diff --git a/.agents/plugins/marketplace.json b/.agents/plugins/marketplace.json
new file mode 100644
index 0000000..9cf4a18
--- /dev/null
+++ b/.agents/plugins/marketplace.json
@@ -0,0 +1,20 @@
+{
+  "name": "looperators-p0",
+  "interface": {
+    "displayName": "Looperators P0"
+  },
+  "plugins": [
+    {
+      "name": "looperators-agent-loop",
+      "source": {
+        "source": "local",
+        "path": "./plugins/looperators-agent-loop"
+      },
+      "policy": {
+        "installation": "AVAILABLE",
+        "authentication": "ON_USE"
+      },
+      "category": "Developer"
+    }
+  ]
+}
diff --git a/.gitignore b/.gitignore
index db17b81..ec7884d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -153,14 +153,15 @@ release
 *.sln
 *.sw?
 
-# Local project vision and design notes
+# Internal project documentation (keep the legacy path blocked)
 design-docs/
 internal_docs/
 
+# Local browser automation state
+.playwright-cli/
+
 # Local verification screenshots
 acceptance-screenshots/
-output/demo-screenshots/
 
-# Headless acceptance run artifacts
-output/acceptance/
-output/ui-acceptance/
+# Generated output and acceptance artifacts
+/output/
diff --git a/.oxlintrc.json b/.oxlintrc.json
index 9b9d6fd..c4e2676 100644
--- a/.oxlintrc.json
+++ b/.oxlintrc.json
@@ -1,6 +1,10 @@
 {
   "$schema": "./node_modules/oxlint/configuration_schema.json",
-  "ignorePatterns": ["dist/**", "dist-electron/**"],
+  "ignorePatterns": [
+    "dist/**",
+    "dist-electron/**",
+    "plugins/looperators-agent-loop/ui/assets/**"
+  ],
   "plugins": ["react", "typescript", "oxc"],
   "rules": {
     "react/rules-of-hooks": "error",
diff --git a/agents.md b/agents.md
index cf7916c..d776b84 100644
--- a/agents.md
+++ b/agents.md
@@ -4,16 +4,12 @@ Branding boundary: the customer-facing product name is `looperators`. `Orrery` /
 remains the internal codename and technical namespace; do not rename code symbols, IPC/MCP
 names, environment variables, storage paths, CLI files, or historical records solely for rebranding.
 
-For project vision and designs, please check the documentation under the `design-docs/`.
+`agents.md` is a protected repository policy file. Modify it only when the user explicitly
+authorizes changes to this file while knowing that `agents.md` itself will be edited; general
+permission to edit code or documentation is not authorization.
 
-- Vision / initial idea: `design-docs/reactive-agent-session-graph.md` — why looperators manages agents as a graph instead of a session list.
-- Design (current source of truth for development): `design-docs/orrery-design.md` — the concrete control model (Skills membrane, Master Agent, scopes/clusters), UI shape, v1 scope, and the §12 Skill API.
-- v1 plan: `design-docs/v1-implementation-plan.md` — phased implementation plan (critical path P0–P3 + parallel workstreams A–C), with goals and acceptance criteria.
-- Internal implementation roadmap / current post-P4 baseline: `design-docs/internal_docs/plans/master-agent-plan-council-implementation-plan.md` — Master-as-Intent-Compiler/Governor/Replanner, Plan Council as the first high-frequency workflow, reliability convergence, correlation/barriers, dynamic topology, and concurrency/safety. Its rationale and discussion replay live in `design-docs/internal_docs/commit-log/2026-07-12-master-agent-plan-council-direction.md`. This roadmap supersedes the old priority of expanding manual canvas authoring first; existing kernel semantics remain governed by `design-docs/session-graph-kernel.md` until each migration phase lands.
-
-- Verification: headless-first, three tiers — `npm run test:kernel` (kernel unit tests, fake providers allowed), `npm run acceptance:headless` (real-scenario acceptance on real providers with the cheap model preset, artifacts in `output/acceptance/`), then final UI acceptance. Commands are documented below; scenario-authoring rules live in `design-docs/AGENTS.md`.
-
-For development and technical planning, follow the design doc and the v1 plan.
+For project vision, design decisions, plans, and other internal context, consult the local,
+Git-ignored `internal_docs/` directory and read only the documents relevant to the current task.
 
 ## Current product surface
 
@@ -126,14 +122,13 @@ npm run acceptance:membrane
 ```
 
 Read the failed run's artifacts before rerunning. Scenario-authoring contracts,
-workspace isolation rules, and evidence requirements are in
-`design-docs/AGENTS.md` and `design-docs/headless-acceptance-harness.md`.
+workspace isolation rules, and evidence requirements are kept in the local internal documentation.
 
 ### 3. Final UI acceptance
 
 UI acceptance is the final, low-frequency tier after kernel and headless
 acceptance pass. Follow the Browser/Computer Use assignment and model rules in
-`design-docs/AGENTS.md`; do not turn UI clicking into the daily test loop.
+the local internal documentation; do not turn UI clicking into the daily test loop.
 
 ## Provider setup notes
 
@@ -169,4 +164,4 @@ npm run cli -- graph
 ```
 
 The full CLI debugging loop, programmatic orchestration client, and browser
-preview setup are documented in `design-docs/AGENTS.md`.
+preview setup are documented in the local internal documentation.
diff --git a/electron/runtime/sessionManager.ts b/electron/runtime/sessionManager.ts
index 4c76166..26daab2 100644
--- a/electron/runtime/sessionManager.ts
+++ b/electron/runtime/sessionManager.ts
@@ -14,41 +14,6 @@
 //      - workflow proposals, wakeups, barriers
 //      - resource policy, run queue, launchRun, provider event stream
 //      - checkpoints/diffs, reports, persistence triggers
-//
-// Split-out knowledge domains (import, don't re-add here):
-//   runtimeCommon.ts                      shared value helpers + validation sets
-//   workspace/gitWorkspace.ts             git/worktree/branch/checkpoint-ref/diff
-//   workspace/workspaceFiles.ts           workspace file tree + open-in-app
-//   workspace/workspaceService.ts         public workspace reads + open facade
-//   providers/providerConfigNormalize.ts  provider instance/runtime config
-//   sessions/sessionInteraction.ts        attachments + request/input normalization
-//   persistence/runtimeStateRecovery.ts   state load/normalize/migrate/repair
-//   terminal/terminalService.ts           embedded terminal subsystem
-//   subscriptionAuthoring.ts              author_subscription input validation
-//   workspace/sessionCheckpoints.ts       per-turn git checkpoints + diffs
-//   providers/providerSetupStatus.ts      provider CLI/model-catalog probing
-//   control/commandRegistry.ts             command kind + handler/policy registry
-//   control/commandExecutor.ts             serialized transaction + effect authority
-//   clusters/clusterControlRuntime.ts      Scope/Master/Loop/freeze topology control
-//   membrane/membraneRequestRuntime.ts     sanctioned agent control-surface dispatch
-//   scheduler/schedulerRuntime.ts           fact -> gate -> activation + timer lifecycle
-//   sessions/sessionRuntimeController.ts    admission + provider turn lifecycle
-//   sessions/sessionCommandRuntime.ts       session commands + channel/interaction adapters
-//   reports/reportFormatting.ts            report/prompt render + payload validation
-//   queries/runtimeQueries.ts               read-only state/kernel projections
-//   external/externalIngestionService.ts    source registry, adapters + ingestion
-//   workflows/workflowKernel.ts           the explicit kernel surface below
-//   workflows/governanceRuntime.ts        wakeup + Barrier state machines
-//   workflows/proposalRuntime.ts          Proposal/Patch authoring + commit
-//   workflows/classicWorkflows.ts         draft/handoff/goal/connect + deployments
-//   workflows/planCouncil.ts              plan council orchestration
-//   workflows/reviewWorkflow.ts           review ring composer
-//   workflows/goalTemplates.ts            goal loop + template library
-//   workflows/workflowShared.ts           workflow resource compensation
-//
-// Growth stopline: new product workflows must not add new knowledge domains
-// to this class; register the domain here and put the implementation in its
-// own module (see design-docs/session-manager-split-plan.md).
 import { randomUUID } from 'node:crypto'
 import fs from 'node:fs'
 import os from 'node:os'
diff --git a/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/cooperative-mcp-checkpoint.md b/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/cooperative-mcp-checkpoint.md
new file mode 100644
index 0000000..3b1cd56
--- /dev/null
+++ b/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/cooperative-mcp-checkpoint.md
@@ -0,0 +1,69 @@
+# Cooperative typed MCP checkpoint
+
+Date: 2026-08-02
+
+## Scope
+
+This checkpoint removes Hooks and native-worker observation from the default Codex Plugin
+surface. The loop is explicitly cooperative: root schedules one logical role at a time and the
+worker reports through a typed, action-scoped MCP capability.
+
+## Product surface
+
+The default MCP server lists exactly eight tools:
+
+1. `looperators_preview_loop`
+2. `looperators_start_loop`
+3. `looperators_pause_loop`
+4. `looperators_resume_loop`
+5. `looperators_cancel_loop`
+6. `looperators_report`
+7. `looperators_get_loop`
+8. `looperators_get_snapshot`
+
+Removed default surfaces include Hook collection/readiness, worker prepare/bind tools, probe
+tools and inline graph rendering. Calling a removed tool by name returns method-not-found.
+
+## Capability boundary
+
+- The token is random and opaque. Its plaintext is never persisted; the shared store contains only
+  its SHA-256 digest and action identity.
+- The durable record binds run, logical role, pending transition and pending action revision, so a
+  native worker's independent MCP process can validate the root-issued token.
+- A token cannot act for the other role or a later action.
+- Cancel and terminal state revoke the action.
+- A new Governor MCP process rotates the current token on root `get_loop`; the Governor must not
+  perform that recovery read while a worker is in flight.
+- Exact cross-process report retries remain idempotent after the transition advances.
+
+This is not cryptographic proof of a native Codex subagent identity. That limitation is deliberate
+in the default no-Hooks mode and is stated in the Plugin README and skill.
+
+## Reproduction
+
+From `/Users/observedobserver/Documents/GitHub/orrery`:
+
+```sh
+node --test --test-concurrency=4 plugins/looperators-agent-loop/tests/*.test.mjs
+npm run test:plugin-agent-loop-ui
+npm run lint
+```
+
+Observed result:
+
+- direct Plugin suite: 60 passed, 0 failed;
+- repository Plugin UI build plus suite: 60 passed, 0 failed;
+- shared graph package typecheck/library/inline/embed builds passed as part of the repository script;
+- lint exited 0 with pre-existing warnings; no new lint error.
+
+The suite covers no-Hook start, logical bindings, token-plaintext non-persistence,
+cross-controller and three-real-MCP-process reporting, implementer-to-reviewer
+and reviewer-to-terminal transitions, wrong-role/stale token rejection, pause/resume, cancel,
+restart rotation, idempotent and conflicting retries, concurrent reports, issues-to-cap,
+verified snapshots, prepared-start crash recovery and real MCP stdio framing/tool dispatch.
+
+## Deferred by design
+
+The existing developer sidecar tests remain green, but the MCP-owned product sidecar and the full
+shared ReactFlow production embed are the next checkpoint. No Desktop UI acceptance or fresh
+Plugin install is claimed here.
diff --git a/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/desktop-interaction-parity.md b/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/desktop-interaction-parity.md
new file mode 100644
index 0000000..7566b2d
--- /dev/null
+++ b/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/desktop-interaction-parity.md
@@ -0,0 +1,92 @@
+# Desktop → shared graph interaction parity
+
+- 日期：2026-08-02
+- Gate：A / shared package independent checkpoint
+- 状态：shared package independent checkpoint passed；Plugin integration pending
+- 规则：`not-applicable` 必须说明 authority 不存在或 fixed review loop 不需要；不能用它
+  掩盖 shared package 缺失。
+
+## Authority sources
+
+- `src/components/session-graph-panel.tsx`：ReactFlow shell、selection、MiniMap、pan/zoom、
+  node/edge routing 与 inspector/loop panel composition。
+- `src/components/canvas.tsx`：Agent node、relationship edge、loop badge 及状态视觉。
+- `src/components/relationship-inspector-panel.tsx`：关系结构、状态、stop action。
+- `src/components/loop-panel.tsx`：lap、issues、recovery、timeline、stop confirmation。
+- `src/hooks/use-canvas.ts`：projection→flow elements、drag、position、selection semantics。
+- `src/lib/graph-view.ts`：portable-ish node/edge/product view model 与 label/routing semantics。
+
+`packages/agent-graph-ui` 已按本矩阵扩展并通过独立验收；Desktop 源文件仍是语义和交互
+authority，Gate A/B 完成前不改 Desktop import。
+
+## Matrix
+
+| Desktop behavior | Classification | Shared/Plugin contract | Acceptance |
+| --- | --- | --- | --- |
+| ReactFlow canvas + dotted background | direct reuse | shared canvas shell | production bundle 可见且无 console error |
+| pan / wheel zoom / zoom buttons / fit view | direct reuse | shared canvas shell | mouse 与 controls 自动化 |
+| MiniMap pannable/zoomable | direct reuse | shared canvas shell | MiniMap 可见并可操作 |
+| node / edge / pane selection | direct reuse | controlled/uncontrolled selection props | click、pane clear、live update 后 selection 稳定 |
+| keyboard node/edge selection | direct reuse | focusable node/edge labels | Enter/Space + focus-visible tests |
+| presentation node dragging | host adapter | shared emits position change；sidecar 保存在当前 Browser session，不写 projection | drag 后位置变化；snapshot 更新不篡改 authority |
+| durable Desktop node positions | not-applicable | Codex Plugin 无 Desktop runtime position authority | sidecar 不调用 store mutation |
+| Agent node card hierarchy | direct reuse | shared portable AgentNode view model | role/identity/state/activity/report variants screenshots |
+| provider/model/vendor identity | host adapter | optional bounded fields；无可信数据时显示 logical role/runtime，不伪造 native provider | present/absent variants |
+| running/master/managed/frozen visual states | direct reuse where modeled | shared state/tone mapping | state fixture matrix |
+| latest verdict / issue count / report summary | direct reuse | typed projection adapter | issues/clean/done fixtures |
+| relationship edge routing/stroke/dash/arrow | direct reuse | shared portable edge model | four review-loop relationships 无交叠/裁剪 |
+| edge label, active/recent/pending, report count | direct reuse | typed relationship status | fixtures + live SSE update |
+| Relationship inspector layout | direct reuse | portable `RelationshipInspectorModel` | From/When/Then/Gate/State/Stop condition visible |
+| relationship stop button | host adapter | injected capability + callback；default review loop maps to pause/cancel preview | enabled/disabled/pending/error tests |
+| Loop badge node | direct reuse | portable loop product summary | headline/lap/status/stop reason visible |
+| Loop panel status summary | direct reuse | portable `LoopPanelModel` | responsible role/verdict/stop reason states |
+| blocking issues list | direct reuse | typed report issues only | file/line/severity and empty states |
+| lap cards + report timeline | direct reuse | bounded typed timeline | issues→clean multiple lap fixture |
+| recovery guidance | direct reuse | interrupted/capped recovery model | restart/cap fixtures |
+| stop confirmation copy/interaction | direct reuse + host adapter | shared confirmation UI + injected cancel callback | confirm/cancel/action-pending tests |
+| open responsible Agent | host adapter | optional callback; hidden with an explicit unavailable explanation when Codex cannot deep-link | capability present/absent tests |
+| open final diff/provider settings/workflow builder | not-applicable | sidecar has no stable Desktop runtime/navigation authority | no fake buttons or shell commands |
+| freeze participants / cluster controls | not-applicable | fixed cooperative review loop has no cluster freeze authority | absent from Plugin bundle |
+| drag-to-connect / create arbitrary Agent | not-applicable | fixed three-role recipe; general graph authoring is out of scope | handles non-connectable; no mutation endpoint |
+| source/clock/cluster synthetic nodes | not-applicable | fixed review loop projection contains root/implementer/reviewer only | no placeholder nodes |
+| kernel/activity overlay | host adapter | bounded typed projection timeline, never transcript/hook tail | SSE updates typed activity only |
+| light/dark theme tokens | direct reuse | shared CSS variables with Desktop-compatible tokens | light/dark screenshots |
+| responsive wide/narrow layout | direct reuse | shared deterministic routing/layout | wide/narrow no overlap/crop |
+| reduced motion | direct reuse | media query disables nonessential animation | browser media emulation |
+
+## Independent checkpoint
+
+Plugin UI may not import the expanded package until 1–5 已通过；第 6 项在 Plugin 接入后、
+Gate A 关闭前执行：
+
+1. portable component/model source with no Electron/runtime/MCP import;
+2. dev server and shipped production bundle;
+3. automated interaction coverage for every `direct reuse` row and every applicable adapter row;
+4. machine-readable result with zero console errors and request inventory;
+5. light/dark + wide/narrow screenshots including MiniMap, Relationship inspector and Loop panel;
+6. static audit proving the Plugin does not ship a second node/edge/inspector/loop-panel implementation.
+
+## Checkpoint result
+
+- 结果：PASS
+- machine-readable evidence：`shared-package-checkpoint.json`
+- production build/test：`npm test -w @looperators/agent-graph-ui`，6/6 pass
+- dev Browser：真实 Chromium 验证 zoom、drag、keyboard selection、edge selection、
+  Relationship inspector、Loop panel/stop confirmation、wide/narrow、dark/light。
+- production Browser：self-contained embed 显示 3 nodes + 4 edges + MiniMap；0 console error，
+  `performance` resource inventory 为空。
+- 初次验收拦截并修复两项真实缺陷：受控节点丢失 measured state 导致节点隐藏/边不渲染；
+  重复 dimension change 导致 `ResizeObserver` warning storm。修复后重启 clean Browser session
+  并重复 panel/resize 操作，dev server 无新增 warning。
+- screenshots：
+  - `output/playwright/agent-graph-ui-shared-checkpoint/graph-wide.png`
+  - `output/playwright/agent-graph-ui-shared-checkpoint/graph-narrow.png`
+  - `output/playwright/agent-graph-ui-shared-checkpoint/graph-light.png`
+  - `output/playwright/agent-graph-ui-shared-checkpoint/loop-panel-wide.png`
+  - `output/playwright/agent-graph-ui-shared-checkpoint/production-embed.png`
+
+## Deferred Desktop migration
+
+During Gate A/B the Desktop authority files remain unchanged. After Plugin acceptance, a separate
+change switches Desktop imports to the accepted shared components and deletes the temporary duplicate
+implementation. That later migration cannot weaken the Plugin checkpoint retroactively.
diff --git a/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/fable-5-desktop-reuse-review.json b/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/fable-5-desktop-reuse-review.json
new file mode 100644
index 0000000..c4d4223
--- /dev/null
+++ b/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/fable-5-desktop-reuse-review.json
@@ -0,0 +1,23 @@
+{
+  "schemaVersion": 1,
+  "reviewedAt": "2026-08-02",
+  "reviewer": {
+    "client": "Claude Code 2.1.218",
+    "model": "claude-fable-5",
+    "mode": "read-only",
+    "subagentsAllowed": false,
+    "webAllowed": false
+  },
+  "initialVerdict": "GO_WITH_AMENDMENTS",
+  "blocking": [],
+  "acceptedAmendments": [
+    "The shared package extraction scope is determined by the Desktop interaction parity matrix, not by the sidecar's current minimum needs.",
+    "The parity matrix is a required artifact with Desktop source references and classification reasons, and the shared package must pass an independent checkpoint before Plugin import."
+  ],
+  "finalReview": {
+    "verdict": "GO",
+    "amendmentsClosed": true,
+    "blocking": [],
+    "consensus": "Desktop graph components and interactions are the authority baseline. Extract and independently accept the shared package first, integrate it into the Plugin second, and change Desktop imports only after Plugin acceptance."
+  }
+}
diff --git a/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/fable-5-plan-review.json b/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/fable-5-plan-review.json
new file mode 100644
index 0000000..36fcbde
--- /dev/null
+++ b/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/fable-5-plan-review.json
@@ -0,0 +1,61 @@
+{
+  "schemaVersion": 1,
+  "reviewedAt": "2026-08-02",
+  "reviewer": {
+    "client": "Claude Code 2.1.218",
+    "model": "claude-fable-5",
+    "mode": "read-only",
+    "tools": [
+      "Read"
+    ],
+    "subagentsAllowed": false,
+    "webAllowed": false
+  },
+  "run": {
+    "result": "completed",
+    "verdict": "GO_WITH_AMENDMENTS",
+    "budgetUsd": 4,
+    "costUsd": 1.721317,
+    "durationApiMs": 118095
+  },
+  "blocking": [],
+  "acceptedAmendments": [
+    "Move interrupted recovery from SessionStart hooks to MCP process/action epochs and root-authorized reconciliation.",
+    "Specify capability validity and revocation across pause, resume, cancel, cap, and restart recovery.",
+    "Bind each browser session cookie to exactly one run instead of all runs served by the MCP process.",
+    "Distinguish host click routing from the ability of the Codex built-in Browser to render the localhost surface.",
+    "Return a safe actionable expiry page for consumed, expired, or old-process login tickets."
+  ],
+  "keep": [
+    "Versioned store, canonical JSON, projection digest, typed reports and transitions.",
+    "Idempotent requestId mutation handling.",
+    "Platform data-root resolution.",
+    "The full ReactFlow agent graph package for the localhost surface.",
+    "The existing loopback, token, cookie, Host and Origin, CSP, bounded SSE, watcher, and backpressure controls.",
+    "Preview, start, report, pause, resume, and cancel domain semantics."
+  ],
+  "removeFromDefaultDistribution": [
+    "All seven plugin hook declarations and hook collector entrypoints.",
+    "Hook readiness and HOOKS_NOT_READY start gates.",
+    "Stop and SubagentStop continuation governor.",
+    "Native agent observation and prepare, poll, and bind tools.",
+    "Identity and shared-root probe tools.",
+    "Inline render tool from the default MCP surface.",
+    "Unpublished-version legacy recovery and quarantine tools."
+  ],
+  "scopeGuards": [
+    "After Gate B, decide whether to delete or retain the existing inline code; do not implement a new inline surface in this plan.",
+    "Treat a self-contained signed cross-platform runtime as a future release gate; this delivery only validates and documents the macOS Node prerequisite."
+  ],
+  "consensusSummary": "The localhost-first, hook-free default architecture is sound and honestly describes cooperative governance. No blocking issue remains after adding MCP-owned restart reconciliation, precise capability revocation, run-scoped browser sessions, Browser acceptance attribution, and expired-ticket behavior.",
+  "finalConsensusReview": {
+    "result": "completed",
+    "verdict": "GO",
+    "costUsd": 0.774847,
+    "durationApiMs": 36835,
+    "allAmendmentsClosed": true,
+    "blocking": [],
+    "scopeDrift": [],
+    "summary": "All five amendments are closed at the specification level. Start implementation with Gate A and Gate B as the only acceptance gates."
+  }
+}
diff --git a/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/gate-a-real-loop.json b/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/gate-a-real-loop.json
new file mode 100644
index 0000000..43cc961
--- /dev/null
+++ b/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/gate-a-real-loop.json
@@ -0,0 +1,92 @@
+{
+  "schemaVersion": 1,
+  "capturedAt": "2026-08-03T07:34:24.000Z",
+  "codex": {
+    "lane": "desktop-bundled-headless",
+    "version": "codex-cli 0.146.0-alpha.9.2",
+    "userConfigLoaded": false,
+    "pluginsFeatureLoaded": false,
+    "multiAgentEnabled": true
+  },
+  "plugin": {
+    "version": "0.3.2+codex.20260803073424",
+    "defaultHooks": false,
+    "protocol": "cooperative-typed-mcp",
+    "reviewSurface": "mcp-owned-127.0.0.1-sidecar"
+  },
+  "run": {
+    "runId": "run_d19f85e9e12f20e88104fdd9e968a42428b385559863ad83402e1137be30a6b6",
+    "status": "succeeded",
+    "revision": 5,
+    "currentLap": 1,
+    "lapCap": 2,
+    "nativeSubagentCount": 2,
+    "rootThreadId": "019fc685-4648-7df3-aee1-b90d46b49745",
+    "nativeSubagents": [
+      {
+        "role": "implementer",
+        "threadId": "019fc685-d665-7351-b9fd-0ad07ec51c4f",
+        "depth": 1,
+        "reportCalls": 2
+      },
+      {
+        "role": "reviewer",
+        "threadId": "019fc686-9fdf-7c31-a6ca-b24d7a4d6828",
+        "depth": 1,
+        "reportCalls": 2
+      }
+    ],
+    "reportSequence": [
+      {
+        "role": "implementer",
+        "type": "info",
+        "status": "done",
+        "fromRevision": 1,
+        "toRevision": 2
+      },
+      {
+        "role": "reviewer",
+        "type": "verdict",
+        "verdict": "issues",
+        "issueCount": 1,
+        "fromRevision": 2,
+        "toRevision": 3
+      },
+      {
+        "role": "implementer",
+        "type": "info",
+        "status": "done",
+        "fromRevision": 3,
+        "toRevision": 4
+      },
+      {
+        "role": "reviewer",
+        "type": "verdict",
+        "verdict": "clean",
+        "issueCount": 0,
+        "fromRevision": 4,
+        "toRevision": 5
+      }
+    ],
+    "fixtureTests": {
+      "passed": 2,
+      "failed": 0
+    },
+    "reviewOrigin": "http://127.0.0.1:58094",
+    "reviewOriginAliveAfterMcpExit": false
+  },
+  "crossProcessCapability": {
+    "originalFailure": "root-issued HMAC token was scoped to one MCP process and worker reports were rejected",
+    "fix": "opaque action token with durable SHA-256 digest and action identity",
+    "plaintextPersisted": false,
+    "threeStdioMcpProcessesPassed": true,
+    "governorRestartRotatesToken": true,
+    "preRotationTokenRejectedAfterRotation": true
+  },
+  "privacy": {
+    "capabilityTokensIncluded": false,
+    "fullPromptsIncluded": false,
+    "rawRolloutsIncluded": false
+  },
+  "passed": true
+}
diff --git a/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/gate-a-real-loop.md b/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/gate-a-real-loop.md
new file mode 100644
index 0000000..52c9724
--- /dev/null
+++ b/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/gate-a-real-loop.md
@@ -0,0 +1,58 @@
+# Gate A real native-agent loop
+
+## Result
+
+Gate A's core real-agent journey passed with Desktop-bundled Codex
+`0.146.0-alpha.9.2`: one root Governor created exactly one native implementer and one native
+reviewer. The same two workers were followed up across lap 1. The authoritative typed sequence was
+`implementer done → reviewer issues → implementer done → reviewer clean`; revision advanced from 1
+to 5 and terminated as `succeeded`. The final fixture contained two passing tests.
+
+The localhost surface opened on a random literal `127.0.0.1` port while the MCP process was alive.
+The origin in the JSON artifact is evidence only and is intentionally no longer reachable after the
+headless MCP process exited.
+
+## Core failure found and fixed
+
+The first real run exposed a genuine architecture bug: root and native workers each receive an
+independent MCP server process. The old HMAC token used a process-local secret/epoch, so the worker
+could never validate the root-issued capability. Re-signing from root only repeated the mismatch.
+
+The replacement is an opaque 48-byte action token. Only its SHA-256 digest plus
+`runId/role/pendingTransitionId/actionRevision` is stored. Independent worker MCP processes validate
+against that durable record; plaintext never enters JSON state. A new Governor MCP process rotates
+the current token during root `get_loop`, so the skill forbids root polling while a worker is in
+flight.
+
+## Reproduction shape
+
+The real run used the Desktop-bundled CLI with user config and the Plugin registry disabled. It
+enabled native multi-agent support and manually registered only the source MCP server against an
+isolated data root:
+
+```sh
+/Applications/ChatGPT.app/Contents/Resources/codex exec \
+  --ignore-user-config --disable plugins --enable multi_agent \
+  --dangerously-bypass-approvals-and-sandbox --json \
+  -C output/acceptance/agent-loop-gate-a-fixture \
+  -c 'mcp_servers.looperators_gate_a.command="/usr/local/bin/node"' \
+  -c 'mcp_servers.looperators_gate_a.args=["<repo>/plugins/looperators-agent-loop/mcp/server.mjs"]' \
+  -c 'mcp_servers.looperators_gate_a.env={ LOOPERATORS_DATA_DIR = "<temporary-data-root>" }' \
+  '<bounded Gate A prompt>'
+```
+
+No Hooks, Personal Plugin, Desktop reload, Node protocol helper, commit, or push was used. Shell was
+available only to the workers for editing the isolated fixture and running its test.
+
+## Evidence boundary
+
+- [gate-a-real-loop.json](./gate-a-real-loop.json) contains sanitized thread lineage, revisions and
+  typed report sequence.
+- Native session metadata confirmed one depth-1 implementer and one depth-1 reviewer under the root.
+- Each child rollout contained two direct `looperators_report` completions, matching the four durable
+  report facts. Rollout text and capability-bearing call arguments were not copied into the repo.
+- Automated tests additionally use three simultaneous real stdio MCP processes and a separate
+  Governor-restart process. They verify token rotation, stale-token rejection and cancel.
+
+This transcript inspection is acceptance evidence, not a product protocol. Runtime authority remains
+the versioned typed store; looperators does not tail transcripts.
diff --git a/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/gate-b-desktop-right-browser.png b/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/gate-b-desktop-right-browser.png
new file mode 100644
index 0000000..274b29d
Binary files /dev/null and b/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/gate-b-desktop-right-browser.png differ
diff --git a/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/gate-b-desktop.json b/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/gate-b-desktop.json
new file mode 100644
index 0000000..1fe56dd
--- /dev/null
+++ b/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/gate-b-desktop.json
@@ -0,0 +1,54 @@
+{
+  "schemaVersion": 1,
+  "gate": "B",
+  "verdict": "GO",
+  "date": "2026-08-03",
+  "environment": {
+    "codexDesktopVersion": "26.727.51351",
+    "codexDesktopBuild": "6119",
+    "codexCliVersion": "0.146.0-alpha.9.2",
+    "pluginVersion": "0.3.2+codex.20260803073424"
+  },
+  "loop": {
+    "threadId": "019fc7b9-aa76-77d1-ac72-e4c3855772a8",
+    "runId": "run_6fc56d7d04232a324a59cd132a18b8246db045adc291eb3a2540f8746f9f22cc",
+    "projectionDigest": "bef9a9a2541d8c3a60dde9bc3170010dbdf4d8e38aa3870564a3cae385e3ef16",
+    "status": "succeeded",
+    "implementerReports": 1,
+    "reviewerReports": 1,
+    "reviewerVerdict": "clean"
+  },
+  "browser": {
+    "surface": "codex-in-app-browser",
+    "verified": true,
+    "live": true,
+    "nodes": ["Governor", "Implementer", "Reviewer"],
+    "relationships": ["governs", "handoff", "feedback", "verdict"],
+    "reactFlowControls": true,
+    "miniMap": true
+  },
+  "controlRoundTrip": {
+    "threadId": "019fc7c0-3a1f-7733-a0c7-88b01d291053",
+    "runId": "run_5b9e832b226b7a2312ef9a6d633ec6b4fcd4f72d18932b18503c3e70f9b79bb4",
+    "projectionDigest": "cee9cc4df8fd12acae291635df4f2f596c4779a9b8e5609fe9192bc63ec11b31",
+    "action": "pause",
+    "source": "localhost-ui",
+    "domStatus": "paused",
+    "mcpStatus": "paused",
+    "subagentCount": 0,
+    "workerReportCount": 0
+  },
+  "artifacts": {
+    "browserScreenshot": {
+      "path": "gate-b-desktop-right-browser.png",
+      "sha256": "5a1cf867ba74795501868100437b77298c6baf14d49affb1205c8c92fb97b4df"
+    }
+  },
+  "security": {
+    "defaultHooks": false,
+    "loopbackOnly": true,
+    "ticketPersisted": false,
+    "capabilityTokenPersisted": false,
+    "transcriptProtocol": false
+  }
+}
diff --git a/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/gate-b-desktop.md b/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/gate-b-desktop.md
new file mode 100644
index 0000000..bece097
--- /dev/null
+++ b/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/gate-b-desktop.md
@@ -0,0 +1,78 @@
+# Gate B：Codex Desktop right Browser 验收
+
+- 日期：2026-08-03
+- verdict：`GO`
+- Codex Desktop：`26.727.51351`（build `6119`）
+- Codex CLI：`0.146.0-alpha.9.2`
+- Plugin：`0.3.2+codex.20260803073424`
+
+## 结论
+
+fresh Desktop task 通过 typed MCP 完成一个真实 root + implementer + reviewer loop，
+Codex 内置右侧 Browser 显示共享 Desktop-derived ReactFlow 图。独立 run 从页面点击
+`Request pause`，DOM 与 authoritative MCP state 均返回 `paused`。没有默认 Hooks、
+没有 shell/Node 脚本代调 MCP、没有仓库修改或 worker transcript 作为协议。
+
+## 实际步骤
+
+1. 使用 Desktop-bundled CLI 安装本地 marketplace Plugin，并核对安装版本为
+   `0.3.2+codex.20260803073424`。
+2. 通过本地 marketplace Plugin detail 确认 Desktop 显示目标版本、1 个 MCP server、
+   1 个启用 Skill；随后创建 fresh Desktop task。
+3. task 调用 `preview → start → report(done) → report(clean) → get_snapshot`；恰好一个
+   implementer 与一个 reviewer 参与。
+4. 调用 `open_review_surface`，只兑换一次短期 ticket；在 Codex 内置 Browser 中读取
+   localhost 页面 DOM，并保存右侧 Browser 页面截图。
+5. 创建独立 control run，start 后不派 worker；从 localhost UI 点击唯一
+   `Request pause`，随后同时检查 DOM 与 `looperators_get_loop`。
+
+## 真实 loop 结果
+
+- Desktop task：`019fc7b9-aa76-77d1-ac72-e4c3855772a8`
+- run：`run_6fc56d7d04232a324a59cd132a18b8246db045adc291eb3a2540f8746f9f22cc`
+- projection digest：
+  `bef9a9a2541d8c3a60dde9bc3170010dbdf4d8e38aa3870564a3cae385e3ef16`
+- status：`succeeded`
+- worker reports：implementer `done`，reviewer `clean`
+- Browser DOM：`verified`、`succeeded`、`live`；Governor、Implementer、Reviewer；
+  governs、handoff、feedback、verdict；Controls、MiniMap。
+
+## Control round-trip
+
+- Desktop task：`019fc7c0-3a1f-7733-a0c7-88b01d291053`
+- run：`run_5b9e832b226b7a2312ef9a6d633ec6b4fcd4f72d18932b18503c3e70f9b79bb4`
+- projection digest：
+  `cee9cc4df8fd12acae291635df4f2f596c4779a9b8e5609fe9192bc63ec11b31`
+- action：右侧 UI 唯一 `Request pause` 按钮点击一次
+- DOM status：`paused`
+- MCP status：`paused`
+- subagent / worker report：0 / 0
+
+## 截图证据
+
+- [右侧 Browser 页面截图](gate-b-desktop-right-browser.png)：完整 localhost graph viewport。
+- 全屏 Codex Desktop 截图不进入公共仓库，因为它包含与本实验无关的本地 task、用户与
+  系统元数据。公开证据只保留裁定 Gate B 所需的右侧 Browser surface。
+
+SHA-256：
+
+- `gate-b-desktop-right-browser.png`：
+  `5a1cf867ba74795501868100437b77298c6baf14d49affb1205c8c92fb97b4df`
+
+## 失败与修正
+
+- 已启动 Desktop task 不会热加载外部 CLI 更新的 dynamic tools；必须在 Desktop 识别目标
+  Plugin detail/version 后创建 fresh task。
+- 旧 `0.2.0` 需要 `LOOPERATORS_DATA_DIR` / `PLUGIN_DATA`，因此出现
+  `DATA_ROOT_UNAVAILABLE`；目标 `0.3.2` 默认使用 looperators-owned platform data path。
+- 同一 one-time ticket 被重复打开时，首次兑换页正常，其余页面显示
+  `Review link unavailable`。最终验收严格 mint 一次、导航一次。
+- 初始验收 prompt 为禁止协议脚本而同时禁止了官方 Browser 控制运行时，导致 Agent 只生成
+  URL 没有实际导航。修正为：继续禁止 shell/独立 Node/MCP 代调，只允许官方 Browser
+  skill 的内部控制运行时。
+
+## 安全与隐私
+
+- 未保存 ticket、cookie、capability token、完整 worker transcript 或私密 prompt。
+- localhost 只监听 `127.0.0.1`；公开截图不含凭据或无关本地 task 元数据。
+- evidence 只记录 run/thread id、projection digest、状态和可复现产品版本。
diff --git a/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/isolated-install.json b/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/isolated-install.json
new file mode 100644
index 0000000..aa98b40
--- /dev/null
+++ b/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/isolated-install.json
@@ -0,0 +1 @@
+{"capturedAt":"2026-08-03T07:35:30.825Z","codex":{"lane":"desktop-bundled","version":"codex-cli 0.146.0-alpha.9.2"},"commands":["env -i <allowlist> CODEX_HOME=<temporary> <desktop-bundled-codex> --version","env -i <allowlist> CODEX_HOME=<temporary> <desktop-bundled-codex> plugin marketplace add <repo>","env -i <allowlist> CODEX_HOME=<temporary> <desktop-bundled-codex> plugin add looperators-agent-loop@looperators-p0 --json","env -i <allowlist> CODEX_HOME=<temporary> <desktop-bundled-codex> plugin list --json","compare canonical source tree with plugins/cache/looperators-p0/looperators-agent-loop/0.3.2+codex.20260803073424"],"desktopRestarted":false,"globalConfigModified":false,"isolation":{"cleanedAfterProbe":true,"codexHomePathRecorded":false,"environmentAllowlist":["CODEX_HOME","LANG","LC_ALL","LC_CTYPE","PATH","TEMP","TERM","TMP","TMPDIR"],"inheritedCredentialVariables":false,"temporaryCodexHome":true},"marketplace":{"added":true,"name":"looperators-p0"},"passed":true,"plugin":{"addMatches":true,"addReturnedJson":true,"enabled":true,"exactListRecordCount":1,"fileCount":87,"installed":true,"installedTreeDigest":"59b77135857193515340769cc46129748e35c24379b14d8e9067490f2740cb15","listReturnedJson":true,"listed":true,"marketplaceSourceMatches":true,"name":"looperators-agent-loop","pluginId":"looperators-agent-loop@looperators-p0","sourceMatches":true,"sourceMatchesInstalledCache":true,"sourceTreeDigest":"59b77135857193515340769cc46129748e35c24379b14d8e9067490f2740cb15","version":"0.3.2+codex.20260803073424","versionMatches":true},"probe":"p1e-isolated-plugin-install","schemaVersion":1}
diff --git a/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/localhost-sidecar-checkpoint.md b/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/localhost-sidecar-checkpoint.md
new file mode 100644
index 0000000..82d5a29
--- /dev/null
+++ b/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/localhost-sidecar-checkpoint.md
@@ -0,0 +1,87 @@
+# MCP-owned localhost live review checkpoint
+
+Date: 2026-08-02
+
+## Result
+
+PASS for the headless localhost product surface. This is not yet the isolated Codex Desktop
+fresh-install Gate B.
+
+The MCP process now owns one sidecar per open run. The sidecar serves the full shared
+Desktop-derived ReactFlow graph and writes pause/resume/cancel to the same authoritative typed
+store used by MCP reports.
+
+## Product protocol
+
+- Bind address: literal `127.0.0.1` only, random OS-assigned port.
+- Route: stable `/runs/<runId>` with run-scoped subordinate routes.
+- Entry: short-lived one-time ticket; redemption redirects to the ticket-free route.
+- Session: independent HttpOnly, SameSite=Strict cookie scoped to the run path.
+- Mutation: exact Origin, JSON content type, session cookie and independent CSRF token.
+- Live state: bounded SSE snapshots with projection digest IDs, Last-Event-ID support, client cap,
+  backpressure close and authoritative replay on store changes.
+- Lifecycle: MCP `open_review_surface` starts/reuses the process-owned sidecar;
+  `close_review_surface` closes it; MCP stdin shutdown closes all remaining sidecars.
+- Expired, consumed or unauthenticated entry renders a bounded safety page instead of exposing the
+  graph.
+
+No Hooks, inline renderer, host-private UI API, external asset server, `0.0.0.0` listener or
+transcript tail is involved.
+
+## Automated reproduction
+
+From `/Users/observedobserver/Documents/GitHub/orrery`:
+
+```sh
+npm test -w @looperators/agent-graph-ui
+npm run test:plugin-agent-loop-ui
+npm run lint
+```
+
+Observed:
+
+- shared graph package: 6 passed, 0 failed;
+- Plugin build and full suite: 58 passed, 0 failed;
+- real stdio MCP test opened the live surface, redeemed its ticket, loaded the page, rejected a
+  replayed ticket and hostile Origin, executed pause/resume, completed the typed loop and closed
+  the listening port;
+- lint exited 0; generated Plugin UI assets are excluded like other build output, while source
+  warnings remain the repository's pre-existing warnings.
+
+## Browser acceptance
+
+The Playwright CLI opened the actual randomized localhost URL in Chromium. Verified DOM state:
+
+- title `looperators Agent Loop live review`;
+- verified/running/live status;
+- 3 role nodes and 4 relationship edges;
+- ReactFlow zoom controls and MiniMap;
+- node selection and inspector state;
+- pause control changed the authoritative projection to `paused` through SSE;
+- resume control changed it back to `running` through SSE;
+- two control POSTs returned HTTP 200;
+- console: 0 errors, 0 warnings.
+
+Evidence:
+
+- [interactive-resumed-live-graph.png](../../../../output/playwright/agent-loop-localhost-checkpoint/interactive-resumed-live-graph.png)
+
+The first browser run exposed a real production-only failure: the bundle referenced the Node
+`process` global and fell back to semantic HTML. The fix defines `process.env.NODE_ENV=production`
+in the Plugin Vite build, which removes the unsafe development branch. The acceptance was then
+repeated from a fresh sidecar/browser session and the full graph rendered with no console error.
+
+The cooperative logical `role:*` bindings are intentionally not projected as native worker IDs;
+the UI no longer makes the false claim that a native worker identity was observed.
+
+## Remaining gates
+
+1. Gate A: a real root task must create native implementer and reviewer subagents, receive typed
+   reports, exercise issues-to-clean or cap, and prove cancel/restart behavior against this live
+   surface.
+2. Gate B: install the packaged Plugin from an isolated source and capture a Codex Desktop system
+   screenshot with this localhost page in the right-side built-in Browser.
+
+The official Codex manual documents that the Desktop built-in Browser can open local web apps,
+share the view beside a task, interact with the page and capture screenshots. That establishes the
+intended host surface, but only Gate B can prove the installed Plugin experience on this machine.
diff --git a/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/shared-package-checkpoint.json b/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/shared-package-checkpoint.json
new file mode 100644
index 0000000..65afd32
--- /dev/null
+++ b/internal_docs/experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/shared-package-checkpoint.json
@@ -0,0 +1,64 @@
+{
+  "schemaVersion": 1,
+  "checkpoint": "desktop-to-shared-agent-graph-ui",
+  "status": "passed",
+  "date": "2026-08-02",
+  "package": "@looperators/agent-graph-ui",
+  "commands": [
+    "npm run typecheck -w @looperators/agent-graph-ui",
+    "npm test -w @looperators/agent-graph-ui",
+    "npm run dev -w @looperators/agent-graph-ui",
+    "npm run preview:embed -w @looperators/agent-graph-ui"
+  ],
+  "automatedTests": {
+    "passed": 6,
+    "failed": 0
+  },
+  "browser": {
+    "engine": "Chromium via Playwright CLI",
+    "dev": {
+      "nodesVisible": 3,
+      "edgesVisible": 4,
+      "miniMapVisible": true,
+      "zoomChangedViewport": true,
+      "dragChangedNodePosition": true,
+      "keyboardSelection": true,
+      "relationshipInspector": true,
+      "loopPanel": true,
+      "stopConfirmation": true,
+      "wideOrientation": "horizontal",
+      "narrowOrientation": "vertical",
+      "darkTheme": true,
+      "lightTheme": true,
+      "consoleErrorsAfterFix": 0,
+      "consoleWarningsAfterFix": 0
+    },
+    "productionEmbed": {
+      "nodesVisible": 3,
+      "edgesVisible": 4,
+      "miniMapVisible": true,
+      "consoleErrors": 0,
+      "consoleWarnings": 0,
+      "externalResourceRequests": 0
+    }
+  },
+  "failuresCaught": [
+    {
+      "code": "CONTROLLED_NODE_MEASUREMENT_DROPPED",
+      "symptom": "React Flow nodes stayed hidden and edges were absent",
+      "resolution": "Persist complete NodeChange state instead of positions only"
+    },
+    {
+      "code": "DUPLICATE_DIMENSION_CHANGE_LOOP",
+      "symptom": "ResizeObserver warning storm after panel and resize interactions",
+      "resolution": "Ignore dimension changes identical to the current measured dimensions"
+    }
+  ],
+  "screenshots": [
+    "output/playwright/agent-graph-ui-shared-checkpoint/graph-wide.png",
+    "output/playwright/agent-graph-ui-shared-checkpoint/graph-narrow.png",
+    "output/playwright/agent-graph-ui-shared-checkpoint/graph-light.png",
+    "output/playwright/agent-graph-ui-shared-checkpoint/loop-panel-wide.png",
+    "output/playwright/agent-graph-ui-shared-checkpoint/production-embed.png"
+  ]
+}
diff --git a/internal_docs/plans/2026-08-02-codex-desktop-agent-loop-localhost-first.md b/internal_docs/plans/2026-08-02-codex-desktop-agent-loop-localhost-first.md
new file mode 100644
index 0000000..64a94b5
--- /dev/null
+++ b/internal_docs/plans/2026-08-02-codex-desktop-agent-loop-localhost-first.md
@@ -0,0 +1,570 @@
+# looperators Codex Agent Loop：localhost-first 轻量 Plugin 计划
+
+- 日期：2026-08-02
+- 分支：`codex/looperators-agent-loop-p1-data-root-fix`
+- 状态：实施完成；Gate A / Gate B 均为 `GO`
+- 目标：把当前研究型 P1 收敛为普通用户可安装、以右侧 live review surface 为主的轻量 Plugin
+
+## 1. 已确认的产品决策
+
+以下是本计划的约束，不在实施中重新讨论或自行改变：
+
+1. **localhost sidecar 是主产品 surface，不是 fallback。** looperators 是重图、实时、
+   可交互功能；主要验收对象是 Codex Desktop 右侧 Browser 中的 live graph。
+2. **默认 Plugin 不携带 Hooks。** 普通安装不能要求用户信任
+   `SessionStart`、`PreToolUse`、`PostToolUse`、`SubagentStart`、`SubagentStop`、`Stop`
+   等命令 hooks。
+3. **默认模式是 cooperative governance。** Governor 与 worker 通过 Skill 和 typed MCP
+   遵守协议；默认模式不宣称可以强制阻止任意 Agent 结束，也不宣称能观察每个原生
+   tool/subagent lifecycle event。
+4. **Hooks 只可能成为未来单独安装的 advanced governance mode。** 本计划不实现该
+   模式，也不允许它阻塞默认模式。
+5. **Inline 退出核心路径。** 本计划不再以 `::codex-inline-vis` 为完成标准，不继续修补
+   inline host。已有 inline 实现只在 localhost 主路径通过后再决定删除或保留为可选
+   静态摘要。
+6. **右侧 surface 的准确名称是 Codex 内置 Browser 中的 localhost Web App。** 当前
+   没有把第三方原生 Artifact 创建能力当作公开稳定依赖；可靠基线是返回可点击 URL，
+   并在能力可用时帮助用户在右侧打开。
+7. **looperators Desktop 现有图 UI 是视觉与交互的权威来源。** localhost surface
+   禁止从零重做一套“相似的图”。必须先从 Desktop 现有实现抽取可移植组件和交互原语，
+   Plugin 只提供 projection adapter、控制 callback 和 host glue。
+
+### 1.1 Desktop UI 复用边界
+
+当前 `@looperators/agent-graph-ui` 是一次简化抽取：它保留 ReactFlow、节点/边选择、
+zoom/fit 和基础详情，但没有完整复用 Desktop 的图产品。以下 Desktop 模块是本次抽取
+的 authority baseline：
+
+```text
+src/components/session-graph-panel.tsx
+src/components/canvas.tsx
+src/components/loop-panel.tsx
+src/components/relationship-inspector-panel.tsx
+src/hooks/use-canvas.ts
+src/lib/graph-view.ts
+```
+
+应最大力度直接复用或提取到共享 package：
+
+- ReactFlow canvas shell、Background、Controls、MiniMap、pan/zoom/fit；
+- Agent node 的角色、provider/model、状态、报告/verdict、选中与 activity 视觉；
+- relationship edge 的 routing、label、active/recent/pending 状态和选择交互；
+- node/edge/pane selection 与 keyboard focus；
+- Relationship inspector 的 from/when/then/gate/firing/stop condition 结构；
+- Loop panel 的 lap、当前责任角色、latest verdict、blocking issues、recovery、timeline、
+  stop confirmation 与终止原因；
+- light/dark theme tokens、responsive layout 和 presentation-level node dragging。
+
+只有依赖 Desktop runtime authority 的行为允许通过 adapter 替换：
+
+- `runtimeApi` mutation；
+- 打开 Desktop chat、diff、provider settings 或 workflow builder；
+- 新建/连接任意 Agent、修改通用拓扑、freeze cluster；
+- Desktop 持久化 node position。
+
+这些行为不得在共享组件内部硬编码。共享组件暴露 typed callbacks 和 capability flags：
+Plugin sidecar 有等价 authority 时接入；没有 authority 时明确隐藏/禁用并解释，不创建
+假的本地行为。节点拖拽可以作为当前 Browser session 的 presentation state，但不能
+改写 authoritative loop projection。
+
+实施顺序仍遵守此前约定：
+
+1. 从 Desktop 现有实现抽取/扩充共享组件并独立验收；
+2. Plugin localhost surface 使用共享组件并完成 Gate A / Gate B；
+3. Plugin 验收通过前，不修改 Desktop 的 import；Desktop 后续切换到共享 package 是
+   单独工作，不阻塞本次 Plugin 交付。
+
+## 2. 为什么改线
+
+当前 P1 已证明 typed report、有限 loop、projection、共享图组件、sidecar 安全边界和
+真实 subagents 都能工作，但它作为普通用户 Plugin 是 **NO-GO**：
+
+- 七个默认 Hooks 带来项目/定义信任、hash 变化后重新信任和跨版本字段耦合；
+- Hook readiness、native agent identity binding、prepare/poll/bind 与 continuation
+  governor 把核心流程变成一条脆弱的宿主生命周期链；
+- Plugin source、安装 cache、已启动 MCP process 和 task capability 可能同时处于不同
+  版本；
+- inline 是非公开宿主协议上的只读快照，却占用了大量兼容与验收成本；
+- 当前 Plugin 暴露 15 个 MCP tools，包含 probe、legacy recovery、worker binding 和
+  inline render，普通 Agent 很难稳定选择正确路径。
+
+现有成果并非全部推倒重来。继续复用：
+
+- versioned store、canonical JSON、projection digest 与 typed report schema；
+- `@looperators/agent-graph-ui` 的 package/build/test 基础，并用 Desktop authority
+  baseline 补齐其节点、边、inspector、loop panel 和交互，而不是保留当前简化版作为
+  最终设计；
+- sidecar 已有的 `127.0.0.1`、随机 secret、HttpOnly cookie、Host/Origin 校验、CSP、
+  bounded SSE、watcher 和 backpressure；
+- preview/start/report/pause/resume/cancel 的领域语义。
+
+## 3. 目标架构
+
+```text
+Codex root task (Governor)
+  │
+  ├─ Skill：规定 cooperative review-until-clean 流程
+  ├─ typed MCP：唯一 mutation/query 接口
+  │    ├─ preview/start/report/control
+  │    ├─ durable store + verified projection
+  │    └─ review-surface lifecycle manager
+  │
+  ├─ native implementer/reviewer subagents
+  │    └─ role-scoped capability → typed report
+  │
+  └─ http://127.0.0.1:<random>/runs/<run-id>
+       ├─ Desktop-derived full ReactFlow graph
+       ├─ live SSE projection
+       └─ authenticated pause/resume/cancel intents
+```
+
+核心 authority 规则：
+
+- store 和 typed MCP 是业务事实源；Browser UI 不从 transcript 推断状态；
+- sidecar 只展示 verified projection，mutation 复用与 MCP 相同的 controller；
+- UI 不直接调用 Codex collaboration tools，也不伪装成能唤醒或强制终止原生 Agent；
+- native `agent_id` 不再是默认模式的授权基础；默认模式使用 role/run/transition-scoped
+  capability，store 只保存 capability digest；
+- lap cap 在 typed report transition 中结算，不依赖 `Stop`/`SubagentStop` hook；
+- pause/cancel 对 looperators 状态和后续 report/transition 立即生效，但不能强杀已经运行
+  的 Codex worker。Governor 在每次 worker 返回后重新读取 authoritative state，禁止继续
+  调度已暂停或取消的 run；
+- 每个 pending action 使用随机 opaque capability；共享 data root 只保存 SHA-256 digest
+  与 run/role/transition/revision 身份，不保存明文。这样 root 与原生 worker 各自的 MCP
+  进程可以跨进程验证同一个 action。Governor MCP 重启后，root `get_loop` 会旋转当前
+  token；因此 Governor 不得在 worker in-flight 时轮询 `get_loop`。该恢复路径不依赖
+  `SessionStart`、Hooks 或 transcript。
+
+## 4. 用户旅程
+
+### 4.1 Preview
+
+1. 用户选择 looperators Plugin 并请求 `review-until-clean`。
+2. Governor 调用 `looperators_preview_loop`；只创建 draft，不启动 subagent。
+3. MCP 同时确保 review surface 已启动，并返回一个短摘要和一次性登录 URL。
+4. 用户点击 URL，在右侧 Browser 看到 draft 图、角色、lap cap 和待确认状态。
+
+### 4.2 Confirm and run
+
+1. 用户在 task 中明确确认；Governor 调用 `looperators_start_loop`。
+2. start 返回 authoritative `nextAction` 和 implementer 的 role-scoped report capability。
+3. Governor 创建原生 implementer，把 bounded work packet 与 capability 交给 worker。
+4. implementer 调用 `looperators_report(done)`；controller 原子消费当前 transition，激活
+   reviewer 并签发 reviewer capability。
+5. reviewer 调用 `looperators_report(issues|clean)`：
+   - `issues` 且未到 cap：产生下一次 implementer action；
+   - `clean`：进入 `succeeded`；
+   - `issues` 且到 cap：进入 `capped`，不再签发 worker action。
+6. 每次 report/control 后，sidecar 通过 SSE 更新同一张图。
+
+### 4.3 Sidecar controls
+
+- `pause`：立即把 run 设为 paused，拒绝 report 和新的 worker action；in-flight worker
+  可能仍会返回，但其 report 会明确失败。UI 必须显示这一限制。普通 resume 后，尚未
+  被 root recovery read 旋转的当前 capability 可继续使用。
+- `cancel`：立即终止 looperators run，后续 report 明确失败且不得重新激活角色。
+- `resume`：恢复 durable run 状态。普通 pause/resume 不旋转未消费 capability；Governor
+  MCP 重启后的 root `get_loop` 必须旋转并返回新 capability。localhost 页面不能主动
+  唤醒 Codex task；UI 显示“已恢复，返回 task
+  继续”，并提供可复制的短 follow-up。
+- `start`：仍要求在 Codex task 中明确确认；sidecar 不绕过对话中的确认门。
+
+## 5. MCP surface 收敛
+
+默认用户可见 tools 收敛为：
+
+```text
+looperators_preview_loop
+looperators_start_loop
+looperators_report
+looperators_get_loop
+looperators_get_snapshot
+looperators_pause_loop
+looperators_resume_loop
+looperators_cancel_loop
+looperators_open_review_surface
+looperators_close_review_surface
+```
+
+从默认 MCP tool list 移除：
+
+- identity/shared-root probes；
+- prepare worker spawn、poll observed worker、native agent bind；
+- inline render；
+- unpublished-version legacy recovery/quarantine。
+
+开发 probe 可以保留在测试目录，但不能继续污染普通 Agent 的 tool selection。
+
+`start`/`report` 协议调整：
+
+- `start` 不再读取 `UserPromptSubmit` hook readiness；显式 user confirmation 由 Skill 与
+  Governor 当前 turn 负责；
+- capability 至少绑定 `runId + role + pendingTransitionId + action revision`；
+- mutation 继续要求 stable `requestId`，重复调用返回同一结果；
+- report token 只返回一次或按当前 action 重新签发，durable store 只保存 digest；
+- cancel、cap 和 terminal state 立即拒绝全部未消费 capability；旧 capability report
+  返回 bounded error 且不改变 run。pause 期间 report 同样被拒绝；普通 resume 后当前
+  token 仍可使用，Governor restart recovery read 则旋转 token；
+- 默认模式接受“持有 capability 即代表该 role”的安全模型，并在文档中明确 root 理论上
+  也能代 worker 调用 report；这不是强身份证明。
+
+## 6. Localhost review surface 产品化
+
+当前 `scripts/sidecar-server.mjs` 从 developer script 升级为 MCP 管理的 product service：
+
+1. MCP process 内维护一个 idempotent sidecar manager；同一进程只启动一个
+   `127.0.0.1` listener，多个 run 使用稳定路由 `/runs/<run-id>`。
+2. 端口由 OS 随机分配；每次 `open` 签发短时、一次性 login ticket，兑换为独立
+   `HttpOnly; SameSite=Strict` session cookie。每个 browser session 只授权 ticket
+   指定的 run，cookie path 绑定 `/runs/<run-id>`；不能枚举或读取同一 MCP process 的
+   其他 run。ticket 不写 store、不进日志。
+3. 保留 exact Host/Origin、CSP、no-store、nosniff、no-referrer、client/backpressure
+   上限；所有 mutation 只接受 authenticated same-origin POST，并要求 idempotent
+   `requestId` 与 CSRF token。
+4. SSE 继续传 verified projection + digest；重连使用 `Last-Event-ID`，projection 不一致
+   时全量重发。
+5. 页面使用从 Desktop authority baseline 抽取的完整
+   `@looperators/agent-graph-ui` ReactFlow bundle，不使用 inline 专用 DOM/SVG
+   renderer，也不另写 Plugin-only node/edge/inspector。
+6. 开发时可以使用独立 Vite dev server/HMR；分发时 sidecar 提供静态 production
+   bundle，业务更新协议只能是 typed store + SSE，不能把 Vite HMR 当产品协议。
+7. MCP process 退出时 listener 干净关闭；进程重启后 `open` 返回新 URL。旧 Browser
+   页面必须显示断线状态，而不是假装仍然 live。已消费、过期或属于旧进程的 ticket
+   返回安全的失效页：“会话已失效，请回到 task 重新打开”，不得只显示裸 401，也不得
+   泄露 run、token 或本地路径。
+
+借鉴 Lottie 的是：稳定资源路由、文件/状态事实源、live preview、浏览器与 Agent 都能
+观察当前状态。不会照搬它的未鉴权 dev server、Vite HMR 产品依赖、shell/npm 启动或
+通用文件删除接口。
+
+## 7. 实施顺序：一个交付，两个 Gate
+
+本计划不拆成大量独立阶段。所有代码工作围绕一个交付版本完成，只设置两个必须关闭的
+验收 Gate。
+
+### Gate A：source-level lean loop + live surface
+
+实施：
+
+- 先建立 Desktop → shared package 的 interaction parity matrix；逐项标记 direct reuse、
+  host adapter 或明确不适用，禁止用新做的简化替代品冒充复用。matrix 是 Gate A 必交
+  artifact；每项必须链接 Desktop authority 源文件并说明分类理由，“不适用”不能只写
+  结论；
+- 从 Desktop authority baseline 抽取 canvas/node/edge/relationship inspector/loop panel
+  和交互原语，保持 portable props + typed callbacks；独立 package build、dev server 和
+  browser interaction tests 通过后，Plugin 才能接入；
+- 从默认 Plugin 分发物中物理移除 hooks 声明；不能只加 runtime flag；
+- 把 Hook/native-agent binding 改为 role capability 协议；
+- 收敛 MCP tool list 和 `review-until-clean` Skill；
+- 将 sidecar manager 接入 MCP，完成稳定 run route、ticket/session、SSE 和 controls；
+- Plugin sidecar 改用完整 ReactFlow graph；inline 不进入该 Gate；
+- 保留 store/projection 数据的版本化与幂等性，必要时为开发中 schema 直接升版，不做
+  未发布版本兼容层。
+
+自动验收：
+
+- **Shared package 独立 checkpoint（先于 Plugin import）**：package build、dev server、
+  production bundle 与 parity matrix 中所有 direct reuse/adapter interaction tests 全绿，
+  保存 matrix、机器可读结果和关键截图；未通过时 Plugin 禁止 import 新组件；
+- Plugin manifest/安装内容中没有默认 hooks；全新 task 不出现 hooks trust UI；
+- preview 自动返回 review URL，且不启动 subagent；
+- role capability 的合法、错误角色、错误 transition、重复、过期和泄漏日志检查通过；
+- real root + implementer + reviewer 完成 `done → issues → done → clean`；
+- cap、pause、resume、cancel、被拒绝的 late report 和 MCP restart recovery 通过；
+- Browser production bundle 显示三节点四关系，并通过 Desktop parity matrix 中适用的
+  selection、keyboard、pan/zoom/fit、MiniMap、node drag、relationship inspector、
+  loop/lap/issues/recovery/timeline/details；
+- Plugin bundle 不包含第二套 Plugin-only node/edge/inspector/loop panel 实现；
+- SSE 实时更新 status/lap/active edge/report；断线和重连状态准确；
+- sidecar 只监听 `127.0.0.1`，未认证、错误 Host/Origin、CSRF、重复 control 和慢客户端
+  测试通过；
+- 一个 browser session 只能访问其 ticket 指定的 run；跨 run 请求与 cookie 复用被拒绝；
+- 已消费、过期、旧进程 ticket 显示明确失效页；
+- ordinary Codex task 不触发 looperators 命令、不写 store、不出现 hook failure。
+
+Gate A 失败时不安装到用户 Personal Plugins，不请求 Desktop reload。
+
+### Gate B：fresh-install + Desktop right-side acceptance
+
+前置：Gate A 全部通过，source cleanly packaged。
+
+验收：
+
+1. 临时 `CODEX_HOME` 执行 isolated plugin install，安装包中无 hooks、无重复 Plugin、
+   source/cache digest 一致；
+2. 最小环境启动 MCP，验证 data root、Node runtime prerequisite 和清晰失败信息；
+3. fresh headless Codex task 只使用 Plugin typed tools 跑通真实 cooperative loop；
+4. 更新当前 Personal Plugin 前先核对已安装版本/cache/process，不通过连续 reload 猜测；
+5. 如运行中 Desktop registry 无法加载新分发物，只在所有自动 Gate 完成后请求一次 reload；
+6. 新 Desktop root task 创建 preview，用户通过点击 URL 或手动把 URL 打开到 Codex 内置
+   Browser，右侧显示 live graph。宿主把普通点击路由到外部浏览器不归因于 Plugin
+   failure，但 Gate B 仍未通过；只有“Codex 内置 Browser 无法呈现该 localhost 页面”
+   才判定 Plugin surface NO-GO；
+7. 公开验收截图只保留裁剪或脱敏后的右侧 Browser surface，必须显示三节点关系图；
+   pause/cancel 至少验证一个真实控制 round-trip；不得提交无关 task、用户或系统元数据；
+8. Inline 不属于 Gate B，不得因 inline 未渲染而判定本版本失败。
+
+Gate B 完成后，才清理默认 Plugin 中已经没有调用者的 hook/inline/legacy 实现与测试；
+清理必须单独验证，不与首次 live surface 跑通混在一起。
+
+## 8. 测试层级
+
+### 每次改动
+
+- contracts/store/controller unit tests；
+- sidecar HTTP/security/SSE tests；
+- shared graph model/component tests，以及 Desktop interaction parity regression；
+- MCP protocol tests；
+- schema validation、syntax、lint、`git diff --check`。
+
+### Gate A 验收
+
+- production sidecar bundle browser automation；
+- isolated data root 下的真实 typed MCP server；
+- 真实 Codex root + 两个 native subagents；
+- restart/cap/cancel 故障旅程。
+
+### Gate B 最终验收
+
+- isolated install；
+- fresh Desktop task；
+- 右侧 Browser live graph 与一次 interactive control；
+- 裁剪或脱敏后的右侧 Browser surface 截图。
+
+不使用 transcript tail 作为协议或通过依据。原始 prompt、完整 worker transcript、token、
+cookie 和 capability 不写入仓库 artifacts。
+
+## 9. 明确风险与非承诺
+
+### 9.1 无 Hooks 的能力代价
+
+默认模式不能保证：
+
+- 拦截任意 root/worker 的 Stop；
+- 观察全部工具调用或 native subagent lifecycle；
+- 把 native `agent_id` 强绑定到 logical role；
+- 强杀已经在运行的 Codex worker；
+- 在用户只操作 sidecar 时主动唤醒空闲 Codex task。
+
+这些限制必须出现在 README 和 UI 状态文案中，不能只藏在内部文档。
+
+### 9.2 Browser 打开方式
+
+支持目标是：返回明确可点击 URL，并在当前 Codex capability 可用时协助打开到右侧
+Browser。Plugin 不承诺第三方原生 Artifact API，也不把自动打开作为数据正确性的
+前提。
+
+### 9.3 Node runtime
+
+当前 `.mcp.json` 以 `node ./mcp/server.mjs` 启动。Codex Plugin 安装本身不等于目标
+机器一定具备可用 Node。Gate B 必须记录真实 prerequisite 行为；在对外发布前，必须
+二选一：
+
+1. 未来分发自包含、签名/校验的跨平台 runtime；或
+2. 把 Node 版本作为明确 prerequisite，并提供安装前检查与可操作错误。
+
+这不是 sidecar 架构问题，但它是普通用户“一次安装成功”的独立 release gate，不能
+继续隐去。本交付只验证当前 macOS/Node 环境的 prerequisite 与清晰错误，不设计跨平台
+runtime 打包/签名；后者进入对外发布前的独立 release plan。本交付不冒充已经完成
+跨平台分发。
+
+## 10. 预计修改边界
+
+主要修改：
+
+```text
+plugins/looperators-agent-loop/.codex-plugin/plugin.json
+plugins/looperators-agent-loop/hooks/**          # 从默认分发移除
+plugins/looperators-agent-loop/lib/control.mjs
+plugins/looperators-agent-loop/lib/store.mjs
+plugins/looperators-agent-loop/lib/projection.mjs
+plugins/looperators-agent-loop/lib/identity.mjs   # 收缩为 role capability
+plugins/looperators-agent-loop/mcp/server.mjs
+plugins/looperators-agent-loop/scripts/sidecar-server.mjs
+plugins/looperators-agent-loop/skills/review-until-clean/**
+plugins/looperators-agent-loop/ui/**
+plugins/looperators-agent-loop/tests/**
+packages/agent-graph-ui/**                       # 按 §1.1 parity matrix 抽取/扩充；不以 sidecar 当前最小需求为上限
+internal_docs/**
+```
+
+Plugin Gate A / Gate B 期间不修改：
+
+```text
+electron/**
+src/components/session-graph-panel.tsx
+src/components/canvas.tsx
+src/components/loop-panel.tsx
+src/components/relationship-inspector-panel.tsx
+src/hooks/use-canvas.ts
+src/lib/graph-view.ts
+shared/graph-state.ts
+plugins/looperators-agent-loop-p0/**
+/Users/observedobserver/Documents/GitHub/lottie/**
+```
+
+Desktop authority files 在本计划中只作为权威来源；把可移植实现提取/复制到 shared
+package，但不修改 Desktop import 或 Desktop 行为。这会产生一段有意、短期的重复代码。
+只有 Plugin 完成 Gate B 后，才另行把 Desktop import 切到已验收的 shared package 并
+删除重复实现。
+
+不移植 Desktop sessionManager/workflowKernel/provider adapters，不迁移 package manager，
+不开发 MCP App iframe，不创建通用 Canvas editor。
+
+## 11. 完成定义
+
+本版本只有在以下结果同时成立时才是 GO：
+
+1. 新用户默认安装不出现 looperators Hooks 信任流程；
+2. fresh task 可以 preview，并在右侧 Browser 打开受保护的 live graph；
+3. root + implementer + reviewer 通过 typed MCP 完成至少一次 issues→clean；
+4. cap、pause、cancel 和 restart 不会产生新的错误 transition；
+5. UI 实时反映 verified projection，并至少完成一次 interactive control；
+6. 普通非 looperators task 零 hook、零写入、零干扰；
+7. 裁剪或脱敏后的 Browser surface 截图证明右侧图真实显示；
+8. README 清楚说明 cooperative mode 的能力代价、Browser 打开方式和 runtime prerequisite。
+9. Desktop interaction parity matrix 中所有适用于 fixed review loop 的项目均由共享
+   package 提供；Plugin 没有并行维护第二套图组件。
+
+若第 2、3 或 7 项失败，本版本 NO-GO；不得用 inline、普通浏览器静态 HTML、mock graph
+或单元测试代替。
+
+Gate B 后只决定 inline 代码是删除还是保留为可选静态摘要；本计划不实现新的 inline
+能力，也不重新打开 inline host 兼容工作。
+
+## 12. Fable 5 评审问题
+
+请只评审以下高价值问题，不扩展到 Desktop UI、MCP App、Yarn、通用 Canvas 或未来
+advanced Hooks 实现：
+
+1. 默认无 Hooks 后，role capability + typed transition 是否足以形成诚实、可恢复的
+   cooperative loop；是否有被忽略的 authority 混淆？
+2. MCP-owned sidecar manager、一次性 ticket、cookie、CSRF、SSE 与 control mutation
+   的边界是否足够安全和可测试？
+3. 两个 Gate 是否聚焦核心交付，是否仍混入会分散注意力的工作？
+4. 哪些现有模块应直接复用，哪些必须从默认分发物中物理移除？
+5. Node runtime、Browser 无法唤醒 task、不能强停 in-flight worker 是否已被足够明确地
+   表达为 release/product boundary？
+
+## 13. Fable 5 评审与最终共识
+
+- Claude Code：`2.1.218`
+- 模型：`claude-fable-5`
+- 模式：只读 `Read`，无 Bash/edit/web/subagent
+- verdict：`GO_WITH_AMENDMENTS`
+- blocking：无
+- scope drift：无新增实现范围；明确阻止重新实现 inline 和在本交付设计跨平台 runtime
+- accepted amendments：
+  1. 初始建议由 MCP/action epoch 接管无 Hook 的 interrupted recovery；
+  2. 固定 pause/cancel/cap/restart 下的 capability 失效语义；
+  3. browser session cookie 绑定单个 run；
+  4. 区分“点击被宿主路由到外部浏览器”和“内置 Browser 无法呈现页面”；
+  5. 为已消费、过期和旧进程 ticket 提供明确安全失效页。
+
+评审证据：
+[fable-5-plan-review.json](../experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/fable-5-plan-review.json)。
+
+Gate A 真实原生 subagent 验收随后证明：root 与 worker 使用不同 MCP 进程，进程内签名
+epoch 会误拒绝合法 worker report。实现因此改为“opaque token + shared digest”，并用
+三真实 MCP 进程、Governor restart rotation 和真实 issues→clean loop 重新验收。该修订
+保持 Fable 要求的失效语义，但移除了不成立的同进程假设。
+
+修订后由 Fable 5 再次只读复核，最终 verdict 为 **GO**：五项 amendment 均已在规范
+层面关闭，无 blocker、无新增 scope drift。双方共识是：按当前计划开始实施，只使用
+Gate A / Gate B 两个验收门；不得在实施中重新加入 inline、默认 Hooks、Desktop 改造
+或跨平台 runtime 打包。
+
+2026-08-02 用户进一步明确：localhost 图必须最大力度复用最早的 looperators Desktop
+图组件和交互，不能把当前简化的 shared graph 当成最终设计。本约束已补入 §1.1、§2、
+§6、Gate A 和 DoD。Fable 5 聚焦复核先给出两项措辞修订：shared package 的范围不得
+被 sidecar 当前最小需求限制；parity matrix 必须是带 Desktop 源文件与分类理由的 Gate A
+artifact，并在 Plugin import 前设置独立 checkpoint。两项均已合入，最终复核为 **GO**，
+无 blocker。
+
+## 14. 实施检查点
+
+### Checkpoint 1：Desktop 图交互抽取（完成）
+
+- commit：`b524f481 feat: extract desktop agent graph interactions`
+- shared package build、unit test、dev/prod browser acceptance 均通过；
+- production embed 显示 3 个节点、4 条边，无 console error/warning、无外部资源请求；
+- Desktop authority 源文件保持不变，Plugin 验收前不切换 Desktop import。
+
+### Checkpoint 2：无 Hooks cooperative typed MCP（完成）
+
+- 默认 Plugin 不再携带 `hooks/hooks.json`、hook collector 或 hook readiness gate；
+- 默认 MCP surface 收敛为 preview/start/pause/resume/cancel/report/get loop/get snapshot；
+- start 返回绑定当前 pending action 的短期 role capability，明文 token 不持久化；
+- wrong-role、stale-action 和 cancel/terminal token 均拒绝；
+- pause/resume、cancel、restart rotation、跨 MCP 进程 report、并发 report、幂等重试和
+  lap cap 均有自动化覆盖；
+- 验证记录：
+  [cooperative-mcp-checkpoint.md](../experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/cooperative-mcp-checkpoint.md)。
+
+下一检查点只做 MCP-owned localhost live review surface，不恢复 inline 或默认 Hooks。
+
+### Checkpoint 3：MCP-owned localhost live review surface（完成）
+
+- MCP 新增 open/close review surface 两个 typed product tools；
+- 每个 run 使用 `127.0.0.1` 随机端口、短期一次性 ticket、HttpOnly/SameSite/run-scoped
+  cookie、同源 + CSRF control；
+- 页面直接打包 shared Desktop-derived ReactFlow 组件，不维护第二套 Plugin graph；
+- verified projection 通过 SSE 更新，pause/resume/cancel 写回同一个 typed store；
+- MCP stdio 集成测试验证 open、ticket redemption、page load、pause/resume、close；
+- Playwright 真实浏览器验证 3 节点、4 关系、node selection、pause→SSE paused、
+  resume→SSE running，console 0 error / 0 warning；
+- 验证记录：
+  [localhost-sidecar-checkpoint.md](../experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/localhost-sidecar-checkpoint.md)。
+
+下一步进入 Gate A 的真实 root + implementer + reviewer loop。Codex Desktop 右侧 Browser
+隐私安全的 Browser surface 截图与 isolated fresh install 仍属于 Gate B，不能由本
+checkpoint 代替。
+
+### Checkpoint 4：Gate A 真实 native-agent loop（完成）
+
+- 首次真实 run 发现并修复跨 MCP 进程 capability bug；进程内 HMAC/epoch 改为 opaque token
+  + durable digest，明文仍不落盘；
+- 三个真实 stdio MCP 进程分别承担 Governor/implementer/reviewer，typed report 通过；
+- 新 Governor MCP 进程会旋转当前 token，旧 token 被拒绝；
+- Desktop-bundled headless Codex 创建恰好一个 implementer 和一个 reviewer，并复用两者跑通
+  `done → issues → done → clean`，revision 5、lap 1、terminal `succeeded`、2/2 tests；
+- 全程未加载默认 Hooks、未使用 Personal Plugin、未 reload Desktop、未用 Node 脚本模拟
+  协议；
+- 验证记录：
+  [gate-a-real-loop.md](../experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/gate-a-real-loop.md) / [gate-a-real-loop.json](../experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/gate-a-real-loop.json)。
+
+下一步只进入 Gate B：重新执行 isolated install probe，然后更新 Personal Plugin；只有自动
+安装、版本/cache/digest 核对完成后才允许一次 Desktop reload 与右侧 Browser 验收截图。
+
+Gate B isolated preflight 已通过：Desktop-bundled Codex `0.146.0-alpha.9.2` 在临时
+`CODEX_HOME` 中安装 `0.3.2+codex.20260803073424`，只出现一个 looperators record，87 个
+文件，source/cache digest 同为
+`59b77135857193515340769cc46129748e35c24379b14d8e9067490f2740cb15`。临时 HOME 已清理，
+未修改全局配置。证据：
+[isolated-install.json](../experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/isolated-install.json)。
+
+### Checkpoint 5：Gate B Desktop right Browser（完成）
+
+- Personal Plugin 最终加载版本：`0.3.2+codex.20260803073424`；Desktop 插件详情显示
+  1 个 MCP server、1 个启用 Skill、无默认 Hooks；
+- fresh Desktop task 使用 typed MCP 跑通真实只读 loop：恰好一个 implementer 与一个
+  reviewer，reviewer 返回 `clean`，run 进入 `succeeded`；
+- 成功 run：
+  `run_6fc56d7d04232a324a59cd132a18b8246db045adc291eb3a2540f8746f9f22cc`，
+  projection digest：
+  `bef9a9a2541d8c3a60dde9bc3170010dbdf4d8e38aa3870564a3cae385e3ef16`；
+- Codex 内置 Browser 的 DOM 与实际截图均确认 `verified / succeeded / live`，并显示
+  Governor、Implementer、Reviewer 三节点、governs/handoff/feedback/verdict 四关系、
+  ReactFlow Controls 与 MiniMap；
+- 独立 control run 从右侧 localhost UI 点击唯一 `Request pause` 按钮；DOM 与
+  `looperators_get_loop` 均确认 `paused`。该 run 未创建 subagent、未提交 worker report；
+- 公开证据保留裁剪后的右侧 Browser live graph，不包含无关 Codex task、用户或系统元数据；
+- 安装调试确认：外部 CLI 更新不会热刷新已启动 task 的 dynamic tool registry。可靠开发
+  路径是安装后打开本地 marketplace 的 Plugin detail，确认目标 version/MCP/Skill，再创建
+  fresh task。一次性 review ticket 只能导航一次；重复打开应显示安全失效页。
+
+证据：
+
+- [Gate B 记录](../experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/gate-b-desktop.md)
+- [机器可读结果](../experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/gate-b-desktop.json)
+- [右侧 Browser 页面截图](../experiments/artifacts/2026-08-02-codex-desktop-agent-loop-localhost-first/gate-b-desktop-right-browser.png)
diff --git a/output/playwright/agent-graph-ui-shared-checkpoint/graph-light.png b/output/playwright/agent-graph-ui-shared-checkpoint/graph-light.png
new file mode 100644
index 0000000..b3606b0
Binary files /dev/null and b/output/playwright/agent-graph-ui-shared-checkpoint/graph-light.png differ
diff --git a/output/playwright/agent-graph-ui-shared-checkpoint/graph-narrow.png b/output/playwright/agent-graph-ui-shared-checkpoint/graph-narrow.png
new file mode 100644
index 0000000..77ad23e
Binary files /dev/null and b/output/playwright/agent-graph-ui-shared-checkpoint/graph-narrow.png differ
diff --git a/output/playwright/agent-graph-ui-shared-checkpoint/graph-wide.png b/output/playwright/agent-graph-ui-shared-checkpoint/graph-wide.png
new file mode 100644
index 0000000..cdc6127
Binary files /dev/null and b/output/playwright/agent-graph-ui-shared-checkpoint/graph-wide.png differ
diff --git a/output/playwright/agent-graph-ui-shared-checkpoint/loop-panel-wide.png b/output/playwright/agent-graph-ui-shared-checkpoint/loop-panel-wide.png
new file mode 100644
index 0000000..ad66da3
Binary files /dev/null and b/output/playwright/agent-graph-ui-shared-checkpoint/loop-panel-wide.png differ
diff --git a/output/playwright/agent-graph-ui-shared-checkpoint/production-embed.png b/output/playwright/agent-graph-ui-shared-checkpoint/production-embed.png
new file mode 100644
index 0000000..8ff7afa
Binary files /dev/null and b/output/playwright/agent-graph-ui-shared-checkpoint/production-embed.png differ
diff --git a/output/playwright/agent-loop-localhost-checkpoint/interactive-resumed-live-graph.png b/output/playwright/agent-loop-localhost-checkpoint/interactive-resumed-live-graph.png
new file mode 100644
index 0000000..2cc03ed
Binary files /dev/null and b/output/playwright/agent-loop-localhost-checkpoint/interactive-resumed-live-graph.png differ
diff --git a/package-lock.json b/package-lock.json
index 3ba6f62..0e11933 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -7,6 +7,9 @@
     "": {
       "name": "orrery",
       "version": "0.2.0",
+      "workspaces": [
+        "packages/*"
+      ],
       "dependencies": {
         "@anthropic-ai/claude-agent-sdk": "^0.3.191",
         "@fontsource-variable/geist": "^5.2.9",
@@ -1164,22 +1167,35 @@
       }
     },
     "node_modules/@emnapi/core": {
-      "version": "1.11.2",
-      "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.11.2.tgz",
-      "integrity": "sha512-TC8MkTuZUtcTSiFeuC0ksCh9QIJ5+F21MvZ4Wn4ORfYaFJ/0dsiudv5tVkejgwZlwQ39jL9WWDe2lz8x0WglOA==",
+      "version": "1.11.3",
+      "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.11.3.tgz",
+      "integrity": "sha512-zLpS5asjEb7lq8jYLq37N6XKaE41DIexlY1rF/z4/tIl3wo13Sqm28fRyfIsKZD+NZ8mM5RoKkpW/rBcuoSZSg==",
       "license": "MIT",
       "optional": true,
+      "peer": true,
+      "dependencies": {
+        "@emnapi/wasi-threads": "1.2.3",
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@emnapi/core/node_modules/@emnapi/wasi-threads": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.2.3.tgz",
+      "integrity": "sha512-ELEBe8PsLvvJ6QMr0zLt8ffvOHW/dc1m3CEzNMg7aJUv3bMaoDtw2TXyDAwkYBuroxxuHEwhRTLJSe5sya547g==",
+      "license": "MIT",
+      "optional": true,
+      "peer": true,
       "dependencies": {
-        "@emnapi/wasi-threads": "1.2.2",
         "tslib": "^2.4.0"
       }
     },
     "node_modules/@emnapi/runtime": {
-      "version": "1.11.2",
-      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.11.2.tgz",
-      "integrity": "sha512-kyOl3X0DuTiT1h2ft8r2fYO8JYtU9a9Xis/zBSiGArNaagCOWx90N1k2wxp18czFDH+OgcWGb5ZP/XMt3dcyPA==",
+      "version": "1.11.3",
+      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.11.3.tgz",
+      "integrity": "sha512-Xz4Tpyki7XyrpbUK1jR1AhdAdaXyhhY4lZ3neLodmhpuWfy2PAQN5B46sAiU4liOXGLkHypn/qU+jvfWSCYYLA==",
       "license": "MIT",
       "optional": true,
+      "peer": true,
       "dependencies": {
         "tslib": "^2.4.0"
       }
@@ -1381,6 +1397,10 @@
         "@jridgewell/sourcemap-codec": "^1.4.14"
       }
     },
+    "node_modules/@looperators/agent-graph-ui": {
+      "resolved": "packages/agent-graph-ui",
+      "link": true
+    },
     "node_modules/@malept/cross-spawn-promise": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/@malept/cross-spawn-promise/-/cross-spawn-promise-2.0.0.tgz",
@@ -4137,6 +4157,66 @@
         "node": ">=14.0.0"
       }
     },
+    "node_modules/@tailwindcss/oxide-wasm32-wasi/node_modules/@emnapi/core": {
+      "version": "1.10.0",
+      "inBundle": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/wasi-threads": "1.2.1",
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-wasm32-wasi/node_modules/@emnapi/runtime": {
+      "version": "1.10.0",
+      "inBundle": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-wasm32-wasi/node_modules/@emnapi/wasi-threads": {
+      "version": "1.2.1",
+      "inBundle": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-wasm32-wasi/node_modules/@napi-rs/wasm-runtime": {
+      "version": "1.1.4",
+      "inBundle": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@tybys/wasm-util": "^0.10.1"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      },
+      "peerDependencies": {
+        "@emnapi/core": "^1.7.1",
+        "@emnapi/runtime": "^1.7.1"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-wasm32-wasi/node_modules/@tybys/wasm-util": {
+      "version": "0.10.2",
+      "inBundle": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-wasm32-wasi/node_modules/tslib": {
+      "version": "2.8.1",
+      "inBundle": true,
+      "license": "0BSD",
+      "optional": true
+    },
     "node_modules/@tailwindcss/oxide-win32-arm64-msvc": {
       "version": "4.3.1",
       "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-win32-arm64-msvc/-/oxide-win32-arm64-msvc-4.3.1.tgz",
@@ -13256,6 +13336,25 @@
         "type": "github",
         "url": "https://github.com/sponsors/wooorm"
       }
+    },
+    "packages/agent-graph-ui": {
+      "name": "@looperators/agent-graph-ui",
+      "version": "0.1.0",
+      "devDependencies": {
+        "@types/react": "^19.2.17",
+        "@types/react-dom": "^19.2.3",
+        "@vitejs/plugin-react": "^6.0.2",
+        "@xyflow/react": "^12.11.1",
+        "react": "^19.2.7",
+        "react-dom": "^19.2.7",
+        "typescript": "~6.0.2",
+        "vite": "^8.1.0"
+      },
+      "peerDependencies": {
+        "@xyflow/react": "^12.11.1",
+        "react": "^19.2.7",
+        "react-dom": "^19.2.7"
+      }
     }
   }
 }
diff --git a/package.json b/package.json
index ff40a95..0cdac6b 100644
--- a/package.json
+++ b/package.json
@@ -2,6 +2,9 @@
   "name": "orrery",
   "private": true,
   "version": "0.2.0",
+  "workspaces": [
+    "packages/*"
+  ],
   "description": "A loop-native desktop tool for agent workflows.",
   "author": "ObservedObserver",
   "type": "module",
@@ -14,6 +17,11 @@
     "dev:app": "npm run build:electron && concurrently -k \"vite --host 127.0.0.1 --port 48273 --strictPort\" \"tsc -p tsconfig.electron.json --watch --preserveWatchOutput\" \"wait-on http://127.0.0.1:48273 dist-electron/electron/main.js && cross-env VITE_DEV_SERVER_URL=http://127.0.0.1:48273 electron .\"",
     "dev:web": "vite --host 127.0.0.1 --port 48273 --strictPort",
     "dev:web:real": "npm run build:electron && concurrently -k \"tsc -p tsconfig.electron.json --watch --preserveWatchOutput\" \"node dist-electron/electron/runtimeHttpServerCli.js\" \"wait-on http://127.0.0.1:48274/api/runtime/config && cross-env VITE_ORRERY_RUNTIME_URL=http://127.0.0.1:48274 vite --host 127.0.0.1 --port 48273 --strictPort\"",
+    "dev:graph-ui": "npm run dev -w @looperators/agent-graph-ui",
+    "build:graph-ui": "npm run build -w @looperators/agent-graph-ui",
+    "test:graph-ui": "npm run test -w @looperators/agent-graph-ui",
+    "build:plugin-agent-loop-ui": "npm run build:graph-ui && tsc -p plugins/looperators-agent-loop/ui/tsconfig.json --noEmit && vite build --config plugins/looperators-agent-loop/ui/vite.config.ts",
+    "test:plugin-agent-loop-ui": "npm run build:plugin-agent-loop-ui && node --test --test-concurrency=4 plugins/looperators-agent-loop/tests/*.test.mjs",
     "build": "npm run build:electron && tsc -b && vite build",
     "build:electron": "tsc -p tsconfig.electron.json && node scripts/prune-electron-output.mjs",
     "check:electron": "tsc -p tsconfig.electron.json --noEmit",
diff --git a/packages/agent-graph-ui/index.html b/packages/agent-graph-ui/index.html
new file mode 100644
index 0000000..c2cb773
--- /dev/null
+++ b/packages/agent-graph-ui/index.html
@@ -0,0 +1,14 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="color-scheme" content="light dark" />
+    <link rel="icon" href="data:," />
+    <title>looperators Agent Graph UI</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/demo.tsx"></script>
+  </body>
+</html>
diff --git a/packages/agent-graph-ui/package.json b/packages/agent-graph-ui/package.json
new file mode 100644
index 0000000..d4887a4
--- /dev/null
+++ b/packages/agent-graph-ui/package.json
@@ -0,0 +1,59 @@
+{
+  "name": "@looperators/agent-graph-ui",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "sideEffects": [
+    "*.css"
+  ],
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/library/agent-graph-ui.js",
+  "module": "./dist/library/agent-graph-ui.js",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/library/agent-graph-ui.js"
+    },
+    "./styles.css": "./dist/library/agent-graph-ui.css",
+    "./inline": {
+      "types": "./dist/types/inline.d.ts",
+      "import": "./dist/inline/agent-graph-ui-inline.js"
+    },
+    "./inline.css": "./dist/inline/agent-graph-ui-inline.css",
+    "./fixtures": {
+      "types": "./dist/types/fixtures.d.ts",
+      "import": "./dist/library/agent-graph-ui.js"
+    }
+  },
+  "scripts": {
+    "dev": "vite --host 127.0.0.1 --port 48311 --strictPort",
+    "build": "npm run clean && npm run typecheck && npm run build:types && npm run build:library && npm run build:inline && npm run build:embed",
+    "clean": "node scripts/clean.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "build:types": "tsc -p tsconfig.build.json",
+    "build:library": "vite build --config vite.library.config.ts",
+    "build:inline": "vite build --config vite.inline.config.ts",
+    "build:embed": "vite build --config vite.embed.config.ts && node scripts/build-embed-harness.mjs",
+    "preview:embed": "vite preview --host 127.0.0.1 --port 48312 --strictPort --outDir dist/embed",
+    "preview": "vite preview --host 127.0.0.1 --port 48312 --strictPort",
+    "test": "npm run build && node --test tests/*.test.mjs"
+  },
+  "peerDependencies": {
+    "@xyflow/react": "^12.11.1",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7"
+  },
+  "devDependencies": {
+    "@types/react": "^19.2.17",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^6.0.2",
+    "@xyflow/react": "^12.11.1",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7",
+    "typescript": "~6.0.2",
+    "vite": "^8.1.0"
+  }
+}
diff --git a/packages/agent-graph-ui/scripts/build-embed-harness.mjs b/packages/agent-graph-ui/scripts/build-embed-harness.mjs
new file mode 100644
index 0000000..1634052
--- /dev/null
+++ b/packages/agent-graph-ui/scripts/build-embed-harness.mjs
@@ -0,0 +1,51 @@
+import { readFile, writeFile } from 'node:fs/promises';
+
+const outputRoot = new URL('../dist/embed/', import.meta.url);
+const libraryUrl = new URL(
+  '../dist/library/agent-graph-ui.js',
+  import.meta.url,
+);
+const { desktopParityModel } = await import(libraryUrl.href);
+
+const [style, script] = await Promise.all([
+  readFile(new URL('agent-graph-ui.css', outputRoot), 'utf8'),
+  readFile(new URL('agent-graph-ui.iife.js', outputRoot), 'utf8'),
+]);
+const envelope = JSON.stringify({
+  model: desktopParityModel,
+  mode: 'snapshot',
+  followUpAvailable: false,
+}).replaceAll('<', '\\u003c');
+const safeScript = script.replaceAll('</script', '<\\/script');
+const document = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta
+      http-equiv="Content-Security-Policy"
+      content="default-src 'none'; img-src data:; style-src 'unsafe-inline'; script-src 'unsafe-inline'; connect-src 'none'"
+    />
+    <link rel="icon" href="data:," />
+    <title>looperators Agent Graph production embed</title>
+    <style>
+      :root { color-scheme: light dark; }
+      body { margin: 0; padding: 16px; background: #f8fafc; }
+      @media (prefers-color-scheme: dark) {
+        body { background: #07090a; }
+      }
+      ${style}
+    </style>
+  </head>
+  <body>
+    <div id="looperators-agent-graph-root"></div>
+    <script id="looperators-agent-graph-data" type="application/json">${envelope}</script>
+    <script>${safeScript}</script>
+  </body>
+</html>
+`;
+
+await writeFile(new URL('index.html', outputRoot), document, {
+  encoding: 'utf8',
+  mode: 0o600,
+});
diff --git a/packages/agent-graph-ui/scripts/clean.mjs b/packages/agent-graph-ui/scripts/clean.mjs
new file mode 100644
index 0000000..8e089a3
--- /dev/null
+++ b/packages/agent-graph-ui/scripts/clean.mjs
@@ -0,0 +1,6 @@
+import { rm } from 'node:fs/promises';
+
+await rm(new URL('../dist', import.meta.url), {
+  recursive: true,
+  force: true,
+});
diff --git a/packages/agent-graph-ui/src/agent-loop-graph.tsx b/packages/agent-graph-ui/src/agent-loop-graph.tsx
new file mode 100644
index 0000000..a43687b
--- /dev/null
+++ b/packages/agent-graph-ui/src/agent-loop-graph.tsx
@@ -0,0 +1,396 @@
+import {
+  applyNodeChanges,
+  Background,
+  BackgroundVariant,
+  Controls,
+  MiniMap,
+  ReactFlow,
+  type Edge,
+  type EdgeMouseHandler,
+  type Node,
+  type NodeMouseHandler,
+  type OnSelectionChangeParams,
+  type NodeChange,
+} from '@xyflow/react';
+import {
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+  type KeyboardEvent,
+} from 'react';
+import { AgentRoleNode } from './agent-node';
+import { AgentRelationshipEdge } from './relationship-edge';
+import { LoopBadge } from './loop-badge';
+import { LoopPanel } from './loop-panel';
+import { RelationshipInspector } from './relationship-inspector';
+import { LoopStatus } from './loop-status';
+import {
+  assertAgentGraphModel,
+  createAgentLoopFlowElements,
+  orientationForWidth,
+  type AgentEdgeData,
+  type AgentGraphFollowUpIntent,
+  type AgentGraphModel,
+  type AgentGraphSelection,
+  type AgentNodeData,
+} from './graph-model';
+
+const nodeTypes = {
+  'agent-role': AgentRoleNode,
+};
+
+const edgeTypes = {
+  'agent-relationship': AgentRelationshipEdge,
+};
+
+export type AgentLoopGraphProps = {
+  model: AgentGraphModel;
+  mode?: 'snapshot' | 'live';
+  liveState?: 'connecting' | 'live' | 'retrying';
+  followUpAvailable?: boolean;
+  explainAvailable?: boolean;
+  controlAvailable?: boolean;
+  onFollowUp?: (intent: AgentGraphFollowUpIntent) => void | Promise<void>;
+  className?: string;
+};
+
+function joinClassNames(...values: Array<string | undefined | false>) {
+  return values.filter(Boolean).join(' ');
+}
+
+function controlKind(model: AgentGraphModel) {
+  if (model.status === 'paused' || model.status === 'interrupted') {
+    return 'resume' as const;
+  }
+  return 'pause' as const;
+}
+
+export function AgentLoopGraph({
+  model: modelValue,
+  mode = 'snapshot',
+  liveState,
+  followUpAvailable = false,
+  explainAvailable = followUpAvailable,
+  controlAvailable = followUpAvailable,
+  onFollowUp,
+  className,
+}: AgentLoopGraphProps) {
+  const model = assertAgentGraphModel(modelValue);
+  const containerRef = useRef<HTMLDivElement>(null);
+  const [width, setWidth] = useState(960);
+  const [selection, setSelection] = useState<AgentGraphSelection>();
+  const [followUpStatus, setFollowUpStatus] = useState('');
+  const [loopPanelOpen, setLoopPanelOpen] = useState(false);
+  const [stopConfirming, setStopConfirming] = useState(false);
+  const orientation = orientationForWidth(width);
+  const flow = useMemo(
+    () => createAgentLoopFlowElements(model, orientation),
+    [model, orientation],
+  );
+  const [presentationNodes, setPresentationNodes] = useState(flow.nodes);
+  const nodes = presentationNodes.map((node) => ({
+    ...node,
+    draggable: true,
+    selected: selection?.kind === 'node' && selection.id === node.id,
+  }));
+  const edges: Edge<AgentEdgeData>[] = flow.edges.map((edge) => ({
+    ...edge,
+    selected: selection?.kind === 'edge' && selection.id === edge.id,
+    data: {
+      ...(edge.data as AgentEdgeData),
+      onSelect: (edgeId: string) => setSelection({ kind: 'edge', id: edgeId }),
+    },
+  }));
+
+  useEffect(() => {
+    const container = containerRef.current;
+    if (!container) return;
+    const updateWidth = () => {
+      const nextWidth = Math.round(container.getBoundingClientRect().width);
+      setWidth((currentWidth) =>
+        currentWidth === nextWidth ? currentWidth : nextWidth,
+      );
+    };
+    updateWidth();
+    if (typeof window === 'undefined') return;
+    window.addEventListener('resize', updateWidth);
+    return () => window.removeEventListener('resize', updateWidth);
+  }, []);
+
+  useEffect(() => {
+    setPresentationNodes(flow.nodes);
+  }, [flow.nodes]);
+
+  useEffect(() => {
+    if (
+      selection?.kind === 'node' &&
+      !model.nodes.some((node) => node.id === selection.id)
+    ) {
+      setSelection(undefined);
+    }
+    if (
+      selection?.kind === 'edge' &&
+      !model.edges.some((edge) => edge.id === selection.id)
+    ) {
+      setSelection(undefined);
+    }
+  }, [model.edges, model.nodes, selection]);
+
+  const selectedNode =
+    selection?.kind === 'node'
+      ? model.nodes.find((node) => node.id === selection.id)
+      : undefined;
+  const selectedEdge =
+    selection?.kind === 'edge'
+      ? model.edges.find((edge) => edge.id === selection.id)
+      : undefined;
+
+  const onNodeClick: NodeMouseHandler = (_event, node) => {
+    setSelection({ kind: 'node', id: node.id });
+  };
+  const onEdgeClick: EdgeMouseHandler = (_event, edge) => {
+    setSelection({ kind: 'edge', id: edge.id });
+  };
+  const onSelectionChange = useCallback(
+    ({
+      nodes: selectedNodes,
+      edges: selectedEdges,
+    }: OnSelectionChangeParams<Node<AgentNodeData>, Edge<AgentEdgeData>>) => {
+      const selectedNodeValue = selectedNodes.at(-1);
+      if (selectedNodeValue) {
+        setSelection({ kind: 'node', id: selectedNodeValue.id });
+        return;
+      }
+      const selectedEdgeValue = selectedEdges.at(-1);
+      if (selectedEdgeValue) {
+        setSelection({ kind: 'edge', id: selectedEdgeValue.id });
+        return;
+      }
+      setSelection(undefined);
+    },
+    [],
+  );
+  const onNodesChange = useCallback(
+    (changes: NodeChange<Node<AgentNodeData>>[]) => {
+      setPresentationNodes((currentNodes) => {
+        const meaningfulChanges = changes.filter((change) => {
+          if (change.type !== 'dimensions' || !change.dimensions) return true;
+          const currentNode = currentNodes.find((node) => node.id === change.id);
+          return (
+            currentNode?.measured?.width !== change.dimensions.width ||
+            currentNode?.measured?.height !== change.dimensions.height
+          );
+        });
+        return meaningfulChanges.length === 0
+          ? currentNodes
+          : applyNodeChanges(meaningfulChanges, currentNodes);
+      });
+    },
+    [],
+  );
+  const onGraphKeyDownCapture = (event: KeyboardEvent<HTMLElement>) => {
+    if (event.key !== 'Enter' && event.key !== ' ') return;
+    const target = event.target;
+    if (!(target instanceof Element)) return;
+    const edgeElement = target.closest<SVGElement>('.react-flow__edge');
+    const nodeElement = target.closest<HTMLElement>('.react-flow__node');
+    if (edgeElement?.dataset.id) {
+      setSelection({ kind: 'edge', id: edgeElement.dataset.id });
+    } else if (nodeElement?.dataset.id) {
+      setSelection({ kind: 'node', id: nodeElement.dataset.id });
+    }
+  };
+
+  const requestFollowUp = async (
+    kind: AgentGraphFollowUpIntent['kind'],
+  ) => {
+    const available = kind === 'explain' ? explainAvailable : controlAvailable;
+    if (!available || !onFollowUp) {
+      setFollowUpStatus('Host follow-up is unavailable.');
+      return;
+    }
+    try {
+      setFollowUpStatus('Requesting follow-up…');
+      await onFollowUp({
+        kind,
+        runId: model.identity.runId,
+        ...(selection ? { selection } : {}),
+      });
+      setFollowUpStatus('Follow-up requested.');
+    } catch {
+      setFollowUpStatus('Follow-up cancelled or failed.');
+    }
+  };
+
+  const terminal = ['succeeded', 'capped', 'cancelled', 'failed'].includes(
+    model.status,
+  );
+  const control = controlKind(model);
+  const requestStopConfirmation = () => {
+    setStopConfirming(true);
+    setLoopPanelOpen(true);
+  };
+  const closeLoopPanel = () => {
+    setStopConfirming(false);
+    setLoopPanelOpen(false);
+  };
+  return (
+    <section
+      ref={containerRef}
+      className={joinClassNames('looperators-agent-graph', className)}
+      data-orientation={orientation}
+      data-status={model.status}
+      data-testid="agent-loop-graph"
+      onKeyDownCapture={onGraphKeyDownCapture}
+    >
+      <LoopStatus model={model} mode={mode} liveState={liveState} />
+      {model.needsHuman || model.cancelRequested || model.recovery ? (
+        <div className="lag-alert" role="status">
+          {model.recovery
+            ? `Recovery: ${model.recovery.reason}`
+            : model.cancelRequested
+              ? 'Cancellation requested.'
+              : 'Human attention is required.'}
+        </div>
+      ) : null}
+      <div
+        className="lag-workspace"
+        data-panel-open={loopPanelOpen || Boolean(selectedEdge)}
+      >
+        <div className="lag-canvas-stack">
+          <LoopBadge model={model} onOpen={() => setLoopPanelOpen(true)} />
+          <div
+            className="lag-flow"
+            data-testid="graph-viewport"
+            data-orientation={orientation}
+          >
+            <ReactFlow<Node<AgentNodeData>, Edge<AgentEdgeData>>
+              key={orientation}
+              nodes={nodes}
+              edges={edges}
+              nodeTypes={nodeTypes}
+              edgeTypes={edgeTypes}
+              nodesDraggable
+              nodesConnectable={false}
+              elementsSelectable
+              elevateEdgesOnSelect
+              minZoom={0.45}
+              maxZoom={1.5}
+              fitView
+              fitViewOptions={{ padding: 0.24, maxZoom: 1.05 }}
+              onNodesChange={onNodesChange}
+              onNodeClick={onNodeClick}
+              onEdgeClick={onEdgeClick}
+              onSelectionChange={onSelectionChange}
+              onPaneClick={() => setSelection(undefined)}
+              aria-label="Agent Loop relationship graph"
+            >
+              <Background variant={BackgroundVariant.Dots} gap={24} size={1.2} />
+              <Controls position="bottom-right" />
+              <MiniMap
+                pannable
+                zoomable
+                position="bottom-left"
+                bgColor="var(--lag-card)"
+                maskColor="color-mix(in srgb, var(--lag-background) 55%, transparent)"
+                nodeColor="var(--lag-card-muted)"
+                nodeStrokeColor="var(--lag-border)"
+              />
+            </ReactFlow>
+          </div>
+        </div>
+        {selectedEdge && !loopPanelOpen ? (
+          <RelationshipInspector
+            edge={selectedEdge}
+            nodes={model.nodes}
+            onClose={() => setSelection(undefined)}
+            stopAvailable={controlAvailable && !terminal}
+            onRequestStop={requestStopConfirmation}
+          />
+        ) : null}
+        {loopPanelOpen ? (
+          <LoopPanel
+            model={model}
+            onClose={closeLoopPanel}
+            controlAvailable={controlAvailable}
+            onControl={onFollowUp}
+            confirming={stopConfirming}
+            onConfirmingChange={setStopConfirming}
+          />
+        ) : null}
+      </div>
+      <section className="lag-inspector" aria-live="polite">
+        <div className="lag-inspector-copy">
+          <p className="lag-eyebrow">
+            {selectedNode
+              ? 'Selected node'
+              : selectedEdge
+                ? 'Selected relationship'
+                : 'Verified snapshot'}
+          </p>
+          <h3>
+            {selectedNode?.label ??
+              (selectedEdge
+                ? `${selectedEdge.source} → ${selectedEdge.target}`
+                : 'Select a node or relationship')}
+          </h3>
+          <p>
+            {selectedNode
+              ? `${selectedNode.role} · ${selectedNode.state}${selectedNode.nativeAgentId ? ' · native worker bound' : ''}`
+              : selectedEdge
+                ? `${selectedEdge.kind} · ${selectedEdge.reportCount} reports${selectedEdge.active ? ' · active' : ''}`
+                : `revision ${model.identity.revision} · digest ${model.identity.projectionDigest.slice(0, 12)}`}
+          </p>
+        </div>
+        <div className="lag-actions">
+          <button
+            type="button"
+            disabled={!selection || !explainAvailable}
+            onClick={() => void requestFollowUp('explain')}
+          >
+            Explain selection
+          </button>
+          <button
+            type="button"
+            disabled={terminal || !controlAvailable}
+            onClick={() => void requestFollowUp(control)}
+          >
+            Request {control}
+          </button>
+          <button
+            type="button"
+            disabled={terminal || !controlAvailable}
+            onClick={requestStopConfirmation}
+          >
+            Review stop…
+          </button>
+        </div>
+        {followUpStatus ? (
+          <p className="lag-follow-up-status" role="status">
+            {followUpStatus}
+          </p>
+        ) : null}
+      </section>
+      <details className="lag-timeline">
+        <summary>
+          Bounded timeline <span>{model.timeline.length}</span>
+        </summary>
+        <ol>
+          {model.timeline.length > 0 ? (
+            model.timeline.map((item) => (
+              <li key={item.id}>
+                <time dateTime={item.at}>{item.at}</time>
+                <span>{item.label}</span>
+                {item.role ? <small>{item.role}</small> : null}
+              </li>
+            ))
+          ) : (
+            <li>No authoritative timeline entries.</li>
+          )}
+        </ol>
+      </details>
+    </section>
+  );
+}
diff --git a/packages/agent-graph-ui/src/agent-node.tsx b/packages/agent-graph-ui/src/agent-node.tsx
new file mode 100644
index 0000000..78e1218
--- /dev/null
+++ b/packages/agent-graph-ui/src/agent-node.tsx
@@ -0,0 +1,101 @@
+import { memo } from 'react';
+import { Handle, Position, type Node, type NodeProps } from '@xyflow/react';
+import type { AgentNodeData } from './graph-model';
+
+const ports = [
+  ['left-in-upper', 'target', Position.Left, 'upper'],
+  ['left-in-lower', 'target', Position.Left, 'lower'],
+  ['left-out-upper', 'source', Position.Left, 'upper'],
+  ['left-out-lower', 'source', Position.Left, 'lower'],
+  ['right-in-upper', 'target', Position.Right, 'upper'],
+  ['right-in-lower', 'target', Position.Right, 'lower'],
+  ['right-out-upper', 'source', Position.Right, 'upper'],
+  ['right-out-lower', 'source', Position.Right, 'lower'],
+  ['top-in', 'target', Position.Top, 'center'],
+  ['top-out', 'source', Position.Top, 'center'],
+  ['bottom-in', 'target', Position.Bottom, 'center'],
+  ['bottom-out', 'source', Position.Bottom, 'center'],
+] as const;
+
+function roleGlyph(role: AgentNodeData['node']['role']) {
+  if (role === 'root') return '◆';
+  if (role === 'implementer') return '⌘';
+  return '✓';
+}
+
+function activityTime(value?: string) {
+  if (!value) return undefined;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? value : date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+}
+
+export const AgentRoleNode = memo(function AgentRoleNode({
+  data,
+  selected,
+}: NodeProps<Node<AgentNodeData>>) {
+  const { node, latestReport, pending } = data;
+  const runtimeLabel = node.runtimeLabel ?? (node.role === 'root' ? 'Governor' : 'Codex worker role');
+  const stateLabel = pending ? 'pending' : node.role === 'root' ? 'master' : node.state;
+  return (
+    <article
+      className="lag-node"
+      data-role={node.role}
+      data-state={node.state}
+      data-selected={selected ? 'true' : 'false'}
+      data-testid={`graph-node-${node.role}`}
+      aria-label={`${node.label}, ${node.state}`}
+    >
+      {ports.map(([id, type, position, lane]) => (
+        <Handle
+          key={id}
+          id={id}
+          type={type}
+          position={position}
+          isConnectable={false}
+          className={`lag-handle lag-handle-${lane} lag-handle-${type}`}
+          aria-label={`${type} ${id} for ${node.label}`}
+        />
+      ))}
+      <header className="lag-node-header">
+        <span className="lag-node-glyph" aria-hidden="true">{roleGlyph(node.role)}</span>
+        <span className="lag-node-heading">
+          <strong title={node.label}>{node.label}</strong>
+          <small title={node.model}>{node.model ?? runtimeLabel}</small>
+        </span>
+        <span className="lag-state-pill">{stateLabel}</span>
+      </header>
+
+      <div className="lag-node-body">
+        {latestReport ? (
+          <>
+            <div className="lag-verdict" data-verdict={latestReport.verdict ?? latestReport.type}>
+              <strong>
+                {latestReport.verdict === 'clean'
+                  ? '✓ clean'
+                  : latestReport.verdict === 'issues'
+                    ? `! ${latestReport.issueCount} issue${latestReport.issueCount === 1 ? '' : 's'}`
+                    : 'done'}
+              </strong>
+              <span>{latestReport.type}</span>
+            </div>
+            {latestReport.summary ? <p className="lag-report-summary" title={latestReport.summary}>{latestReport.summary}</p> : null}
+          </>
+        ) : (
+          <p className="lag-node-description">
+            {node.description ??
+              (node.role === 'root'
+                ? 'Owns the cooperative transition decision.'
+                : node.state === 'unbound'
+                  ? 'Waiting for a role capability.'
+                  : 'Participates through typed reports.')}
+          </p>
+        )}
+      </div>
+
+      <footer className="lag-node-footer">
+        <span className="lag-node-activity"><b>{node.activityCount ?? 0}</b> events</span>
+        <span title={node.lastActivityAt}>{activityTime(node.lastActivityAt) ?? node.id}</span>
+      </footer>
+    </article>
+  );
+});
diff --git a/packages/agent-graph-ui/src/demo.css b/packages/agent-graph-ui/src/demo.css
new file mode 100644
index 0000000..46fb03f
--- /dev/null
+++ b/packages/agent-graph-ui/src/demo.css
@@ -0,0 +1,60 @@
+:root {
+  color-scheme: light dark;
+}
+
+* {
+  box-sizing: border-box;
+}
+
+body {
+  margin: 0;
+}
+
+.lag-demo {
+  min-height: 100vh;
+  background: #f8fafc;
+  padding: 24px;
+}
+
+.lag-demo[data-mode="dark"] {
+  --background: #07090a;
+  --foreground: #e5e7eb;
+  --card: #0d120e;
+  --muted: #0f1511;
+  --muted-foreground: #9ca3af;
+  --border: rgba(255, 255, 255, 0.11);
+  --term-accent-hi: #a3e635;
+  --term-emerald: #6ee7b7;
+  --term-cyan: #67e8f9;
+  --term-amber: #fcd34d;
+  --term-rose: #fb7185;
+  background: #07090a;
+}
+
+.lag-demo-toolbar {
+  display: flex;
+  align-items: center;
+  gap: 14px;
+  flex-wrap: wrap;
+  max-width: 1120px;
+  margin: 0 auto 14px;
+  color: var(--foreground, #171a1f);
+  font: 12px/1.4 ui-sans-serif, system-ui, sans-serif;
+}
+
+.lag-demo-toolbar label {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+}
+
+.lag-demo > .looperators-agent-graph {
+  max-width: 1120px;
+  margin: 0 auto;
+}
+
+@media (max-width: 719px) {
+  .lag-demo {
+    padding: 12px;
+  }
+}
diff --git a/packages/agent-graph-ui/src/demo.tsx b/packages/agent-graph-ui/src/demo.tsx
new file mode 100644
index 0000000..8384179
--- /dev/null
+++ b/packages/agent-graph-ui/src/demo.tsx
@@ -0,0 +1,74 @@
+/* oxlint-disable react/only-export-components -- standalone Vite entrypoint */
+import { StrictMode, useState } from 'react';
+import { createRoot } from 'react-dom/client';
+import { AgentLoopGraph } from './agent-loop-graph';
+import { agentGraphScenarios, desktopParityModel } from './fixtures';
+import type { AgentGraphFollowUpIntent } from './graph-model';
+import '@xyflow/react/dist/style.css';
+import './styles.css';
+import './demo.css';
+
+function Demo() {
+  const [scenarioName, setScenarioName] = useState('desktop-parity');
+  const [dark, setDark] = useState(true);
+  const [followUpAvailable, setFollowUpAvailable] = useState(true);
+  const [lastIntent, setLastIntent] = useState<AgentGraphFollowUpIntent>();
+  const model =
+    scenarioName === 'desktop-parity'
+      ? desktopParityModel
+      : (agentGraphScenarios.find(
+          (candidate) => candidate.name === scenarioName,
+        )?.expectedModel ?? agentGraphScenarios[0].expectedModel);
+  return (
+    <main className="lag-demo" data-mode={dark ? 'dark' : 'light'}>
+      <div className="lag-demo-toolbar">
+        <label>
+          Scenario
+          <select
+            value={scenarioName}
+            onChange={(event) => setScenarioName(event.target.value)}
+          >
+            <option value="desktop-parity">desktop-parity</option>
+            {agentGraphScenarios.map((candidate) => (
+              <option key={candidate.name} value={candidate.name}>
+                {candidate.name}
+              </option>
+            ))}
+          </select>
+        </label>
+        <label>
+          <input
+            type="checkbox"
+            checked={dark}
+            onChange={(event) => setDark(event.target.checked)}
+          />
+          Dark
+        </label>
+        <label>
+          <input
+            type="checkbox"
+            checked={followUpAvailable}
+            onChange={(event) => setFollowUpAvailable(event.target.checked)}
+          />
+          Follow-up host
+        </label>
+        <output data-testid="follow-up-output">
+          {lastIntent
+            ? `${lastIntent.kind}:${lastIntent.selection?.id ?? 'run'}`
+            : 'No follow-up'}
+        </output>
+      </div>
+      <AgentLoopGraph
+        model={model}
+        followUpAvailable={followUpAvailable}
+        onFollowUp={(intent) => setLastIntent(intent)}
+      />
+    </main>
+  );
+}
+
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <Demo />
+  </StrictMode>,
+);
diff --git a/packages/agent-graph-ui/src/embed.tsx b/packages/agent-graph-ui/src/embed.tsx
new file mode 100644
index 0000000..ab02f1b
--- /dev/null
+++ b/packages/agent-graph-ui/src/embed.tsx
@@ -0,0 +1,97 @@
+/* oxlint-disable react/only-export-components -- self-mounting plugin entrypoint */
+import { useState } from 'react';
+import { createRoot } from 'react-dom/client';
+import { AgentLoopGraph } from './agent-loop-graph';
+import {
+  assertAgentGraphModel,
+  type AgentGraphFollowUpIntent,
+  type AgentGraphModel,
+} from './graph-model';
+import '@xyflow/react/dist/style.css';
+import './styles.css';
+
+type EmbedEnvelope = {
+  model: AgentGraphModel;
+  mode?: 'snapshot' | 'live';
+  followUpAvailable?: boolean;
+};
+
+type OpenAIHost = {
+  sendFollowUpMessage?: (input: {
+    prompt: string;
+    title?: string;
+  }) => Promise<void>;
+};
+
+declare global {
+  interface Window {
+    openai?: OpenAIHost;
+    looperatorsAgentGraphView?: {
+      update: (nextModel: unknown) => void;
+      integrityError: (code: string) => void;
+    };
+  }
+}
+
+const rootElement = document.getElementById('looperators-agent-graph-root');
+const dataElement = document.getElementById('looperators-agent-graph-data');
+
+function promptFor(intent: AgentGraphFollowUpIntent) {
+  const selected = intent.selection?.id;
+  if (intent.kind === 'explain') {
+    return `Explain ${selected ? `the selected Agent Loop item ${selected}` : 'this Agent Loop'} for run ${intent.runId}. Separate authoritative projection facts from inference.`;
+  }
+  return `Please preview ${intent.kind} for looperators Agent Loop run ${intent.runId}. Do not mutate it until I confirm.`;
+}
+
+if (rootElement && dataElement) {
+  const envelope = JSON.parse(dataElement.textContent ?? '{}') as EmbedEnvelope;
+  const initialModel = assertAgentGraphModel(envelope.model);
+  let setExternalModel: ((next: AgentGraphModel) => void) | undefined;
+  let setIntegrityError: ((code: string | undefined) => void) | undefined;
+
+  function EmbeddedGraph() {
+    const [model, setModel] = useState(initialModel);
+    const [error, setError] = useState<string>();
+    setExternalModel = setModel;
+    setIntegrityError = setError;
+    const hostAvailable =
+      envelope.followUpAvailable === true &&
+      typeof window.openai?.sendFollowUpMessage === 'function';
+    return (
+      <>
+        {error ? (
+          <p className="lag-embed-error" role="status">
+            Snapshot unavailable: {error}
+          </p>
+        ) : null}
+        <AgentLoopGraph
+          model={model}
+          mode={envelope.mode ?? 'snapshot'}
+          liveState={envelope.mode === 'live' ? 'live' : undefined}
+          followUpAvailable={hostAvailable}
+          onFollowUp={
+            hostAvailable
+              ? (intent) =>
+                  window.openai?.sendFollowUpMessage?.({
+                    prompt: promptFor(intent),
+                    title: `looperators Agent Loop ${intent.kind}`,
+                  })
+              : undefined
+          }
+        />
+      </>
+    );
+  }
+
+  createRoot(rootElement).render(<EmbeddedGraph />);
+  window.looperatorsAgentGraphView = Object.freeze({
+    update(nextModel) {
+      setIntegrityError?.(undefined);
+      setExternalModel?.(assertAgentGraphModel(nextModel));
+    },
+    integrityError(code) {
+      setIntegrityError?.(String(code).slice(0, 80));
+    },
+  });
+}
diff --git a/packages/agent-graph-ui/src/fixtures.ts b/packages/agent-graph-ui/src/fixtures.ts
new file mode 100644
index 0000000..31dc2bd
--- /dev/null
+++ b/packages/agent-graph-ui/src/fixtures.ts
@@ -0,0 +1,434 @@
+import type {
+  AgentGraphEdge,
+  AgentGraphModel,
+  AgentGraphNode,
+  AgentGraphNodeState,
+  AgentGraphReport,
+  AgentGraphStatus,
+} from './graph-model';
+
+type RawProjection = Record<string, unknown>;
+
+export type AgentGraphScenario = {
+  name: string;
+  projection: RawProjection;
+  expectedModel: AgentGraphModel;
+};
+
+const edgeDefinitions = [
+  {
+    id: 'root-governs-implementer',
+    source: 'root',
+    target: 'role:implementer',
+    kind: 'governs',
+  },
+  {
+    id: 'implementer-handoff-reviewer',
+    source: 'role:implementer',
+    target: 'role:reviewer',
+    kind: 'handoff',
+  },
+  {
+    id: 'reviewer-feedback-implementer',
+    source: 'role:reviewer',
+    target: 'role:implementer',
+    kind: 'feedback',
+  },
+  {
+    id: 'reviewer-verdict-root',
+    source: 'role:reviewer',
+    target: 'root',
+    kind: 'verdict',
+  },
+] as const;
+
+function makeNodes(
+  states: [AgentGraphNodeState, AgentGraphNodeState, AgentGraphNodeState],
+  bound = true,
+): AgentGraphNode[] {
+  return [
+    {
+      id: 'root',
+      kind: 'root',
+      role: 'root',
+      label: 'Governor',
+      state: states[0],
+    },
+    {
+      id: 'role:implementer',
+      kind: 'worker-role',
+      role: 'implementer',
+      label: 'Implementer',
+      state: states[1],
+      ...(bound
+        ? {
+            nativeAgentId: 'native-implementer-fixture',
+            nativeAgentType: 'worker',
+          }
+        : {}),
+    },
+    {
+      id: 'role:reviewer',
+      kind: 'worker-role',
+      role: 'reviewer',
+      label: 'Reviewer',
+      state: states[2],
+      ...(bound
+        ? {
+            nativeAgentId: 'native-reviewer-fixture',
+            nativeAgentType: 'worker',
+          }
+        : {}),
+    },
+  ];
+}
+
+function makeEdges(
+  activeKind?: AgentGraphEdge['kind'],
+  reports: Partial<Record<AgentGraphEdge['kind'], number>> = {},
+): AgentGraphEdge[] {
+  return edgeDefinitions.map((edge) => ({
+    ...edge,
+    active: edge.kind === activeKind,
+    reportCount: reports[edge.kind] ?? 0,
+  }));
+}
+
+function rawNodes(nodes: AgentGraphNode[]) {
+  return nodes.map(({ role, ...node }) =>
+    node.kind === 'root' ? node : { ...node, role },
+  );
+}
+
+function scenario(options: {
+  name: string;
+  digestCharacter: string;
+  status: AgentGraphStatus;
+  revision: number;
+  currentLap: number;
+  lapCap?: number;
+  lease?: { granted: number; consumed: number };
+  states: [AgentGraphNodeState, AgentGraphNodeState, AgentGraphNodeState];
+  bound?: boolean;
+  activeKind?: AgentGraphEdge['kind'];
+  reports?: Partial<Record<AgentGraphEdge['kind'], number>>;
+  latestReport?: AgentGraphReport;
+  pendingRole?: 'implementer' | 'reviewer';
+  needsHuman?: boolean;
+  cancelRequested?: boolean;
+  recovery?: { reason: string };
+}): AgentGraphScenario {
+  const nodes = makeNodes(options.states, options.bound);
+  const edges = makeEdges(options.activeKind, options.reports);
+  const digest = options.digestCharacter.repeat(64);
+  const timeline =
+    options.revision === 0
+      ? []
+      : [
+          {
+            id: `transition-${options.name}`,
+            at: '2026-07-28T18:00:00.000Z',
+            label: options.activeKind
+              ? `activate-${options.pendingRole ?? options.activeKind}`
+              : options.status,
+            kind: 'transition' as const,
+            ...(options.pendingRole ? { role: options.pendingRole } : {}),
+          },
+          ...(options.latestReport
+            ? [
+                {
+                  id: `report-${options.name}`,
+                  at: '2026-07-28T18:00:01.000Z',
+                  label:
+                    options.latestReport.verdict === 'issues'
+                      ? 'reviewer verdict: issues'
+                      : options.latestReport.verdict === 'clean'
+                        ? 'reviewer verdict: clean'
+                        : 'implementer info: done',
+                  kind: 'report' as const,
+                  role: options.latestReport.fromRole,
+                },
+              ]
+            : []),
+        ];
+  const model: AgentGraphModel = {
+    identity: {
+      runId: `run-${options.name}`,
+      revision: options.revision,
+      projectionDigest: digest,
+      integrity: 'verified',
+    },
+    status: options.status,
+    currentLap: options.currentLap,
+    lapCap: options.lapCap ?? 3,
+    lease: options.lease ?? { granted: 3, consumed: 0 },
+    cancelRequested: options.cancelRequested ?? false,
+    needsHuman: options.needsHuman ?? false,
+    nodes,
+    edges,
+    ...(options.pendingRole
+      ? {
+          pending: {
+            role: options.pendingRole,
+            kind:
+              options.pendingRole === 'implementer'
+                ? ('activate-implementer' as const)
+                : ('activate-reviewer' as const),
+            lap: options.currentLap,
+          },
+        }
+      : {}),
+    ...(options.latestReport ? { latestReport: options.latestReport } : {}),
+    ...(options.recovery ? { recovery: options.recovery } : {}),
+    timeline,
+  };
+  return {
+    name: options.name,
+    expectedModel: model,
+    projection: {
+      schemaVersion: 1,
+      storeVersion: 1,
+      projectionVersion: 3,
+      runId: model.identity.runId,
+      revision: model.identity.revision,
+      status: model.status,
+      recipe: 'review-until-clean',
+      currentLap: model.currentLap,
+      lapCap: model.lapCap,
+      continuationLease: model.lease,
+      cancelRequested: model.cancelRequested,
+      needsHuman: model.needsHuman,
+      integrity: {
+        status: 'verified',
+        verifiedRevision: model.identity.revision,
+      },
+      eventWatermark: {
+        eventCount: 0,
+      },
+      nodes: rawNodes(nodes),
+      edges,
+      ...(model.pending
+        ? {
+            pending: {
+              transitionId: `transition-${options.name}`,
+              ...model.pending,
+            },
+          }
+        : {}),
+      ...(model.latestReport
+        ? {
+            latestReport: {
+              reportId: `report-${options.name}`,
+              ...model.latestReport,
+            },
+          }
+        : {}),
+      ...(model.recovery
+        ? {
+            recovery: {
+              recoveryId: `recovery_${'d'.repeat(64)}`,
+              ...model.recovery,
+            },
+          }
+        : {}),
+      counts: {
+        events: 0,
+        reports: model.latestReport ? 1 : 0,
+        transitions: model.identity.revision > 0 ? 1 : 0,
+        operations: model.identity.revision,
+        governorDecisions: 0,
+        recoveries: model.recovery ? 1 : 0,
+        diagnostics: 0,
+        conflicts: 0,
+        corrupt: 0,
+      },
+      timeline,
+      projectionDigest: digest,
+    },
+  };
+}
+
+export const agentGraphScenarios: AgentGraphScenario[] = [
+  scenario({
+    name: 'draft',
+    digestCharacter: 'a',
+    status: 'draft',
+    revision: 0,
+    currentLap: 0,
+    states: ['active', 'unbound', 'unbound'],
+    bound: false,
+  }),
+  scenario({
+    name: 'implementer-active',
+    digestCharacter: 'b',
+    status: 'running',
+    revision: 1,
+    currentLap: 0,
+    states: ['waiting', 'active', 'unbound'],
+    activeKind: 'governs',
+    pendingRole: 'implementer',
+  }),
+  scenario({
+    name: 'reviewer-issues',
+    digestCharacter: 'c',
+    status: 'running',
+    revision: 4,
+    currentLap: 1,
+    lease: { granted: 3, consumed: 1 },
+    states: ['waiting', 'waiting', 'active'],
+    activeKind: 'feedback',
+    reports: { handoff: 1, feedback: 1 },
+    pendingRole: 'implementer',
+    latestReport: {
+      fromRole: 'reviewer',
+      type: 'verdict',
+      verdict: 'issues',
+      issueCount: 2,
+    },
+  }),
+  scenario({
+    name: 'paused-needs-human',
+    digestCharacter: 'd',
+    status: 'paused',
+    revision: 5,
+    currentLap: 1,
+    lease: { granted: 3, consumed: 2 },
+    states: ['active', 'bound', 'bound'],
+    reports: { handoff: 1, feedback: 1 },
+    needsHuman: true,
+  }),
+  scenario({
+    name: 'succeeded-clean',
+    digestCharacter: 'e',
+    status: 'succeeded',
+    revision: 7,
+    currentLap: 2,
+    lease: { granted: 3, consumed: 2 },
+    states: ['terminal', 'terminal', 'terminal'],
+    activeKind: 'verdict',
+    reports: { handoff: 2, feedback: 1, verdict: 1 },
+    latestReport: {
+      fromRole: 'reviewer',
+      type: 'verdict',
+      verdict: 'clean',
+      issueCount: 0,
+    },
+  }),
+  scenario({
+    name: 'capped',
+    digestCharacter: 'f',
+    status: 'capped',
+    revision: 6,
+    currentLap: 3,
+    lease: { granted: 3, consumed: 3 },
+    states: ['terminal', 'terminal', 'terminal'],
+    reports: { handoff: 2, feedback: 2 },
+    needsHuman: true,
+  }),
+  scenario({
+    name: 'cancelled',
+    digestCharacter: '1',
+    status: 'cancelled',
+    revision: 2,
+    currentLap: 0,
+    lease: { granted: 3, consumed: 0 },
+    states: ['terminal', 'terminal', 'terminal'],
+    cancelRequested: true,
+  }),
+];
+
+const reviewerIssuesScenario = agentGraphScenarios.find(
+  (candidate) => candidate.name === 'reviewer-issues',
+);
+
+if (!reviewerIssuesScenario) {
+  throw new Error('reviewer-issues fixture is unavailable');
+}
+
+/**
+ * A UI-only acceptance model derived from the paired projection fixture.
+ *
+ * Keep this outside `agentGraphScenarios`: those fixtures prove the Plugin
+ * projection adapter is lossless, while this model exercises the richer
+ * Desktop-derived interaction surface before the Plugin imports it.
+ */
+export const desktopParityModel: AgentGraphModel = {
+  ...reviewerIssuesScenario.expectedModel,
+  responsibleRole: 'implementer',
+  nodes: reviewerIssuesScenario.expectedModel.nodes.map((node) => ({
+    ...node,
+    runtimeLabel: node.role === 'root' ? 'Codex task' : 'Native subagent',
+    model: node.role === 'root' ? 'Governor' : 'worker',
+    description:
+      node.role === 'root'
+        ? 'Owns the bounded review policy and approves every transition.'
+        : node.role === 'implementer'
+          ? 'Addresses the latest blocking findings and reports completion.'
+          : 'Reviews the implementation and returns a typed verdict.',
+    activityCount: node.role === 'root' ? 4 : node.role === 'implementer' ? 7 : 5,
+    lastActivityAt: '2026-08-02T18:00:04.000Z',
+  })),
+  edges: reviewerIssuesScenario.expectedModel.edges.map((edge) => ({
+    ...edge,
+    label:
+      edge.kind === 'governs'
+        ? 'Governed activation'
+        : edge.kind === 'handoff'
+          ? 'Implementation ready'
+          : edge.kind === 'feedback'
+            ? 'Blocking feedback'
+            : 'Clean verdict',
+    summary:
+      edge.kind === 'feedback'
+        ? 'Reviewer found blocking issues, so the Governor grants one bounded implementer continuation.'
+        : `Typed ${edge.kind} report advances the run only after Governor validation.`,
+    recent: edge.kind === 'handoff',
+    pending: edge.kind === 'feedback',
+    gate: 'Governor validates typed report and lease',
+    firings: edge.reportCount,
+    maxFirings: edge.kind === 'governs' ? 1 : 3,
+    stopWhen: edge.kind === 'feedback' ? 'clean verdict, cancellation, or lap cap' : 'terminal run state',
+  })),
+  latestReport: {
+    ...reviewerIssuesScenario.expectedModel.latestReport!,
+    summary: 'Two blocking findings remain before the run can finish cleanly.',
+    issues: [
+      {
+        severity: 'error',
+        message: 'Cancel must revoke every unconsumed continuation capability.',
+        file: 'plugins/looperators-agent-loop/mcp/governor.mjs',
+        line: 214,
+      },
+      {
+        severity: 'warn',
+        message: 'Recovery must reject actions issued before the current process epoch.',
+        file: 'plugins/looperators-agent-loop/mcp/store.mjs',
+        line: 91,
+      },
+    ],
+  },
+  laps: [
+    {
+      index: 0,
+      status: 'issues',
+      at: '2026-08-02T18:00:02.000Z',
+      implementerSummary: 'Added bounded continuation and typed reviewer reports.',
+      reviewerSummary: 'Found cancellation and restart recovery gaps.',
+      verdict: 'issues',
+      issues: [
+        {
+          severity: 'error',
+          message: 'Cancel did not revoke a previously issued continuation.',
+        },
+      ],
+    },
+    {
+      index: 1,
+      status: 'running',
+      at: '2026-08-02T18:00:04.000Z',
+      implementerSummary: 'Applying the two remaining fixes.',
+      reviewerSummary: 'Waiting for a new typed implementation report.',
+      issues: [],
+    },
+  ],
+};
diff --git a/packages/agent-graph-ui/src/graph-model.ts b/packages/agent-graph-ui/src/graph-model.ts
new file mode 100644
index 0000000..1998900
--- /dev/null
+++ b/packages/agent-graph-ui/src/graph-model.ts
@@ -0,0 +1,496 @@
+import { MarkerType, Position, type Edge, type Node } from '@xyflow/react';
+
+export const agentGraphStatuses = [
+  'draft',
+  'running',
+  'paused',
+  'interrupted',
+  'succeeded',
+  'capped',
+  'cancelled',
+  'failed',
+] as const;
+
+export const agentGraphNodeStates = [
+  'active',
+  'waiting',
+  'bound',
+  'unbound',
+  'terminal',
+] as const;
+
+export const agentGraphEdgeKinds = [
+  'governs',
+  'handoff',
+  'feedback',
+  'verdict',
+] as const;
+
+export type AgentGraphStatus = (typeof agentGraphStatuses)[number];
+export type AgentGraphNodeState = (typeof agentGraphNodeStates)[number];
+export type AgentGraphEdgeKind = (typeof agentGraphEdgeKinds)[number];
+export type AgentGraphRole = 'root' | 'implementer' | 'reviewer';
+export type AgentGraphOrientation = 'horizontal' | 'vertical';
+
+export type AgentGraphNode = {
+  id: string;
+  kind: 'root' | 'worker-role';
+  role: AgentGraphRole;
+  label: string;
+  state: AgentGraphNodeState;
+  nativeAgentId?: string;
+  nativeAgentType?: string;
+  runtimeLabel?: string;
+  model?: string;
+  description?: string;
+  activityCount?: number;
+  lastActivityAt?: string;
+};
+
+export type AgentGraphEdge = {
+  id: string;
+  source: string;
+  target: string;
+  kind: AgentGraphEdgeKind;
+  active: boolean;
+  reportCount: number;
+  label?: string;
+  summary?: string;
+  recent?: boolean;
+  pending?: boolean;
+  gate?: string;
+  firings?: number;
+  maxFirings?: number;
+  stopWhen?: string;
+};
+
+export type AgentGraphIssue = {
+  message: string;
+  severity?: 'info' | 'warn' | 'error';
+  file?: string;
+  line?: number;
+};
+
+export type AgentGraphReport = {
+  fromRole: 'implementer' | 'reviewer';
+  type: 'info' | 'verdict';
+  verdict?: 'issues' | 'clean';
+  issueCount: number;
+  summary?: string;
+  issues?: AgentGraphIssue[];
+};
+
+export type AgentGraphPending = {
+  role: 'implementer' | 'reviewer';
+  kind: 'activate-implementer' | 'activate-reviewer';
+  lap: number;
+};
+
+export type AgentGraphTimelineItem = {
+  id: string;
+  at: string;
+  label: string;
+  kind: 'event' | 'report' | 'transition' | 'governor-decision' | 'recovery';
+  role?: 'implementer' | 'reviewer';
+};
+
+export type AgentGraphLap = {
+  index: number;
+  status: 'running' | 'issues' | 'clean' | 'capped' | 'interrupted';
+  at?: string;
+  implementerSummary?: string;
+  reviewerSummary?: string;
+  verdict?: 'issues' | 'clean';
+  issues: AgentGraphIssue[];
+};
+
+export type AgentGraphModel = {
+  identity: {
+    runId: string;
+    revision: number;
+    projectionDigest: string;
+    integrity: 'verified';
+  };
+  status: AgentGraphStatus;
+  currentLap: number;
+  lapCap: number;
+  lease: {
+    granted: number;
+    consumed: number;
+  };
+  cancelRequested: boolean;
+  needsHuman: boolean;
+  nodes: AgentGraphNode[];
+  edges: AgentGraphEdge[];
+  pending?: AgentGraphPending;
+  latestReport?: AgentGraphReport;
+  recovery?: {
+    reason: string;
+    guidance?: string;
+  };
+  responsibleRole?: AgentGraphRole;
+  stopReason?: string;
+  laps?: AgentGraphLap[];
+  timeline: AgentGraphTimelineItem[];
+};
+
+export type AgentGraphSelection =
+  | { kind: 'node'; id: string }
+  | { kind: 'edge'; id: string };
+
+export type AgentGraphFollowUpKind =
+  | 'explain'
+  | 'pause'
+  | 'resume'
+  | 'cancel';
+
+export type AgentGraphFollowUpIntent = {
+  kind: AgentGraphFollowUpKind;
+  runId: string;
+  selection?: AgentGraphSelection;
+};
+
+export type AgentNodeData = {
+  node: AgentGraphNode;
+  latestReport?: AgentGraphReport;
+  pending: boolean;
+} & Record<string, unknown>;
+
+export type AgentEdgeRoute = 'direct' | 'lower' | 'left' | 'right';
+
+export type AgentEdgeData = {
+  edge: AgentGraphEdge;
+  route: AgentEdgeRoute;
+  latestReport?: AgentGraphReport;
+  onSelect?: (edgeId: string) => void;
+} & Record<string, unknown>;
+
+export type LoopSummaryData = {
+  model: AgentGraphModel;
+  onOpen?: () => void;
+} & Record<string, unknown>;
+
+const digestPattern = /^[a-f0-9]{64}$/;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function requireString(
+  value: unknown,
+  path: string,
+  options: { max?: number; pattern?: RegExp } = {},
+) {
+  if (
+    typeof value !== 'string' ||
+    value.length === 0 ||
+    value.length > (options.max ?? 256) ||
+    (options.pattern && !options.pattern.test(value))
+  ) {
+    throw new TypeError(`${path} must be a bounded string`);
+  }
+}
+
+function requireInteger(
+  value: unknown,
+  path: string,
+  options: { min?: number; max?: number } = {},
+) {
+  if (
+    !Number.isSafeInteger(value) ||
+    (options.min !== undefined && Number(value) < options.min) ||
+    (options.max !== undefined && Number(value) > options.max)
+  ) {
+    throw new TypeError(`${path} must be a bounded integer`);
+  }
+}
+
+export function assertAgentGraphModel(value: unknown): AgentGraphModel {
+  if (!isRecord(value)) {
+    throw new TypeError('agent graph model must be an object');
+  }
+  if (!isRecord(value.identity)) {
+    throw new TypeError('agent graph model identity must be an object');
+  }
+  requireString(value.identity.runId, 'identity.runId', { max: 128 });
+  requireInteger(value.identity.revision, 'identity.revision', { min: 0 });
+  requireString(value.identity.projectionDigest, 'identity.projectionDigest', {
+    max: 64,
+    pattern: digestPattern,
+  });
+  if (value.identity.integrity !== 'verified') {
+    throw new TypeError('identity.integrity must be verified');
+  }
+  if (!agentGraphStatuses.includes(value.status as AgentGraphStatus)) {
+    throw new TypeError('agent graph model status is invalid');
+  }
+  requireInteger(value.currentLap, 'currentLap', { min: 0, max: 6 });
+  requireInteger(value.lapCap, 'lapCap', { min: 1, max: 6 });
+  if (Number(value.currentLap) > Number(value.lapCap)) {
+    throw new TypeError('currentLap cannot exceed lapCap');
+  }
+  if (!isRecord(value.lease)) {
+    throw new TypeError('agent graph model lease must be an object');
+  }
+  requireInteger(value.lease.granted, 'lease.granted', { min: 0, max: 6 });
+  requireInteger(value.lease.consumed, 'lease.consumed', { min: 0, max: 6 });
+  if (Number(value.lease.consumed) > Number(value.lease.granted)) {
+    throw new TypeError('lease.consumed cannot exceed lease.granted');
+  }
+  if (
+    typeof value.cancelRequested !== 'boolean' ||
+    typeof value.needsHuman !== 'boolean'
+  ) {
+    throw new TypeError('agent graph model flags must be boolean');
+  }
+  if (
+    !Array.isArray(value.nodes) ||
+    value.nodes.length !== 3 ||
+    !Array.isArray(value.edges) ||
+    value.edges.length !== 4 ||
+    !Array.isArray(value.timeline) ||
+    value.timeline.length > 32
+  ) {
+    throw new TypeError('agent graph model cardinality is invalid');
+  }
+  const nodeIds = new Set<string>();
+  for (const [index, candidate] of value.nodes.entries()) {
+    if (!isRecord(candidate)) {
+      throw new TypeError(`nodes[${index}] must be an object`);
+    }
+    requireString(candidate.id, `nodes[${index}].id`, { max: 96 });
+    requireString(candidate.label, `nodes[${index}].label`, { max: 80 });
+    if (!['root', 'worker-role'].includes(String(candidate.kind))) {
+      throw new TypeError(`nodes[${index}].kind is invalid`);
+    }
+    if (!['root', 'implementer', 'reviewer'].includes(String(candidate.role))) {
+      throw new TypeError(`nodes[${index}].role is invalid`);
+    }
+    if (!agentGraphNodeStates.includes(candidate.state as AgentGraphNodeState)) {
+      throw new TypeError(`nodes[${index}].state is invalid`);
+    }
+    if (nodeIds.has(String(candidate.id))) {
+      throw new TypeError('agent graph node ids must be unique');
+    }
+    nodeIds.add(String(candidate.id));
+    for (const key of ['runtimeLabel', 'model', 'description', 'lastActivityAt'] as const) {
+      if (candidate[key] !== undefined) {
+        requireString(candidate[key], `nodes[${index}].${key}`, { max: 512 });
+      }
+    }
+    if (candidate.activityCount !== undefined) {
+      requireInteger(candidate.activityCount, `nodes[${index}].activityCount`, {
+        min: 0,
+      });
+    }
+  }
+  for (const [index, candidate] of value.edges.entries()) {
+    if (!isRecord(candidate)) {
+      throw new TypeError(`edges[${index}] must be an object`);
+    }
+    requireString(candidate.id, `edges[${index}].id`, { max: 96 });
+    requireString(candidate.source, `edges[${index}].source`, { max: 96 });
+    requireString(candidate.target, `edges[${index}].target`, { max: 96 });
+    if (!agentGraphEdgeKinds.includes(candidate.kind as AgentGraphEdgeKind)) {
+      throw new TypeError(`edges[${index}].kind is invalid`);
+    }
+    if (
+      !nodeIds.has(String(candidate.source)) ||
+      !nodeIds.has(String(candidate.target))
+    ) {
+      throw new TypeError(`edges[${index}] references an unknown node`);
+    }
+    if (typeof candidate.active !== 'boolean') {
+      throw new TypeError(`edges[${index}].active must be boolean`);
+    }
+    requireInteger(candidate.reportCount, `edges[${index}].reportCount`, {
+      min: 0,
+    });
+    for (const key of ['label', 'summary', 'gate', 'stopWhen'] as const) {
+      if (candidate[key] !== undefined) {
+        requireString(candidate[key], `edges[${index}].${key}`, { max: 512 });
+      }
+    }
+    for (const key of ['firings', 'maxFirings'] as const) {
+      if (candidate[key] !== undefined) {
+        requireInteger(candidate[key], `edges[${index}].${key}`, { min: 0 });
+      }
+    }
+    if (
+      (candidate.recent !== undefined && typeof candidate.recent !== 'boolean') ||
+      (candidate.pending !== undefined && typeof candidate.pending !== 'boolean')
+    ) {
+      throw new TypeError(`edges[${index}] flags must be boolean`);
+    }
+  }
+  if (value.latestReport !== undefined) {
+    if (!isRecord(value.latestReport)) {
+      throw new TypeError('latestReport must be an object');
+    }
+    if (value.latestReport.summary !== undefined) {
+      requireString(value.latestReport.summary, 'latestReport.summary', { max: 1024 });
+    }
+    if (value.latestReport.issues !== undefined) {
+      if (!Array.isArray(value.latestReport.issues) || value.latestReport.issues.length > 32) {
+        throw new TypeError('latestReport.issues must be bounded');
+      }
+      for (const [index, issue] of value.latestReport.issues.entries()) {
+        if (!isRecord(issue)) throw new TypeError(`latestReport.issues[${index}] must be an object`);
+        requireString(issue.message, `latestReport.issues[${index}].message`, { max: 1024 });
+      }
+    }
+  }
+  if (value.laps !== undefined) {
+    if (!Array.isArray(value.laps) || value.laps.length > 6) {
+      throw new TypeError('laps must be a bounded array');
+    }
+    for (const [index, lap] of value.laps.entries()) {
+      if (!isRecord(lap)) throw new TypeError(`laps[${index}] must be an object`);
+      requireInteger(lap.index, `laps[${index}].index`, { min: 0, max: 6 });
+      if (!['running', 'issues', 'clean', 'capped', 'interrupted'].includes(String(lap.status))) {
+        throw new TypeError(`laps[${index}].status is invalid`);
+      }
+      if (!Array.isArray(lap.issues) || lap.issues.length > 32) {
+        throw new TypeError(`laps[${index}].issues must be bounded`);
+      }
+    }
+  }
+  return value as AgentGraphModel;
+}
+
+const horizontalPositions: Record<AgentGraphRole, { x: number; y: number }> = {
+  root: { x: 30, y: 82 },
+  implementer: { x: 370, y: 82 },
+  reviewer: { x: 710, y: 82 },
+};
+
+const verticalPositions: Record<AgentGraphRole, { x: number; y: number }> = {
+  root: { x: 130, y: 22 },
+  implementer: { x: 130, y: 232 },
+  reviewer: { x: 130, y: 442 },
+};
+
+const wideHandles: Record<
+  AgentGraphEdgeKind,
+  { sourceHandle: string; targetHandle: string; route: AgentEdgeRoute }
+> = {
+  governs: {
+    sourceHandle: 'right-out-upper',
+    targetHandle: 'left-in-upper',
+    route: 'direct',
+  },
+  handoff: {
+    sourceHandle: 'right-out-upper',
+    targetHandle: 'left-in-upper',
+    route: 'direct',
+  },
+  feedback: {
+    sourceHandle: 'left-out-lower',
+    targetHandle: 'right-in-lower',
+    route: 'lower',
+  },
+  verdict: {
+    sourceHandle: 'bottom-out',
+    targetHandle: 'bottom-in',
+    route: 'lower',
+  },
+};
+
+const narrowHandles: typeof wideHandles = {
+  governs: {
+    sourceHandle: 'bottom-out',
+    targetHandle: 'top-in',
+    route: 'direct',
+  },
+  handoff: {
+    sourceHandle: 'bottom-out',
+    targetHandle: 'top-in',
+    route: 'direct',
+  },
+  feedback: {
+    sourceHandle: 'right-out-lower',
+    targetHandle: 'right-in-lower',
+    route: 'right',
+  },
+  verdict: {
+    sourceHandle: 'left-out-lower',
+    targetHandle: 'left-in-lower',
+    route: 'left',
+  },
+};
+
+export function createAgentLoopFlowElements(
+  modelValue: AgentGraphModel,
+  orientation: AgentGraphOrientation,
+): {
+  nodes: Node<AgentNodeData>[];
+  edges: Edge<AgentEdgeData>[];
+} {
+  const model = assertAgentGraphModel(modelValue);
+  const positions =
+    orientation === 'horizontal' ? horizontalPositions : verticalPositions;
+  const handles = orientation === 'horizontal' ? wideHandles : narrowHandles;
+  return {
+    nodes: model.nodes.map((node) => ({
+      id: node.id,
+      type: 'agent-role',
+      position: positions[node.role],
+      draggable: false,
+      selectable: true,
+      data: {
+        node,
+        pending: model.pending?.role === node.role,
+        ...(model.latestReport?.fromRole === node.role
+          ? { latestReport: model.latestReport }
+          : {}),
+      },
+    })),
+    edges: model.edges.map((edge) => ({
+      id: edge.id,
+      type: 'agent-relationship',
+      source: edge.source,
+      target: edge.target,
+      sourceHandle: handles[edge.kind].sourceHandle,
+      targetHandle: handles[edge.kind].targetHandle,
+      animated: edge.active,
+      focusable: true,
+      markerEnd: {
+        type: MarkerType.ArrowClosed,
+        width: 16,
+        height: 16,
+      },
+      data: {
+        edge,
+        route: handles[edge.kind].route,
+        ...(model.latestReport &&
+        ((edge.kind === 'feedback' &&
+          model.latestReport.verdict === 'issues') ||
+          (edge.kind === 'verdict' &&
+            model.latestReport.verdict === 'clean'))
+          ? { latestReport: model.latestReport }
+          : {}),
+      },
+    })),
+  };
+}
+
+export function orientationForWidth(width: number): AgentGraphOrientation {
+  return width < 720 ? 'vertical' : 'horizontal';
+}
+
+export function statusTone(
+  status: AgentGraphStatus,
+): 'active' | 'success' | 'warning' | 'danger' | 'neutral' {
+  if (status === 'running') return 'active';
+  if (status === 'succeeded') return 'success';
+  if (['paused', 'interrupted', 'capped'].includes(status)) return 'warning';
+  if (['failed', 'cancelled'].includes(status)) return 'danger';
+  return 'neutral';
+}
+
+export function positionForHandle(handleId: string): Position {
+  if (handleId.startsWith('left')) return Position.Left;
+  if (handleId.startsWith('right')) return Position.Right;
+  if (handleId.startsWith('top')) return Position.Top;
+  return Position.Bottom;
+}
diff --git a/packages/agent-graph-ui/src/index.ts b/packages/agent-graph-ui/src/index.ts
new file mode 100644
index 0000000..b888caf
--- /dev/null
+++ b/packages/agent-graph-ui/src/index.ts
@@ -0,0 +1,44 @@
+import '@xyflow/react/dist/style.css';
+import './styles.css';
+
+export { AgentLoopGraph, type AgentLoopGraphProps } from './agent-loop-graph';
+export { AgentRoleNode } from './agent-node';
+export { AgentRelationshipEdge } from './relationship-edge';
+export { LoopBadge } from './loop-badge';
+export { LoopPanel } from './loop-panel';
+export { RelationshipInspector } from './relationship-inspector';
+export { LoopStatus } from './loop-status';
+export {
+  agentGraphEdgeKinds,
+  agentGraphNodeStates,
+  agentGraphStatuses,
+  assertAgentGraphModel,
+  createAgentLoopFlowElements,
+  orientationForWidth,
+  statusTone,
+  type AgentEdgeData,
+  type AgentEdgeRoute,
+  type AgentGraphEdge,
+  type AgentGraphEdgeKind,
+  type AgentGraphFollowUpIntent,
+  type AgentGraphFollowUpKind,
+  type AgentGraphIssue,
+  type AgentGraphLap,
+  type AgentGraphModel,
+  type AgentGraphNode,
+  type AgentGraphNodeState,
+  type AgentGraphOrientation,
+  type AgentGraphPending,
+  type AgentGraphReport,
+  type AgentGraphRole,
+  type AgentGraphSelection,
+  type AgentGraphStatus,
+  type AgentGraphTimelineItem,
+  type AgentNodeData,
+  type LoopSummaryData,
+} from './graph-model';
+export {
+  agentGraphScenarios,
+  desktopParityModel,
+  type AgentGraphScenario,
+} from './fixtures';
diff --git a/packages/agent-graph-ui/src/inline-agent-loop-graph.ts b/packages/agent-graph-ui/src/inline-agent-loop-graph.ts
new file mode 100644
index 0000000..1fd9274
--- /dev/null
+++ b/packages/agent-graph-ui/src/inline-agent-loop-graph.ts
@@ -0,0 +1,466 @@
+import type {
+  AgentGraphFollowUpIntent,
+  AgentGraphModel,
+  AgentGraphSelection,
+} from './graph-model';
+
+export type InlineAgentLoopGraphOptions = {
+  model: AgentGraphModel;
+  mode?: 'snapshot' | 'live';
+  liveState?: 'connecting' | 'live' | 'retrying';
+  driftNote?: string;
+  followUpAvailable?: boolean;
+  onFollowUp?: (intent: AgentGraphFollowUpIntent) => void | Promise<void>;
+};
+
+export type InlineAgentLoopGraphController = {
+  update: (
+    model: AgentGraphModel,
+    options?: Pick<InlineAgentLoopGraphOptions, 'liveState'>,
+  ) => void;
+  integrityError: (code: string) => void;
+  destroy: () => void;
+};
+
+type Point = {
+  x: number;
+  y: number;
+};
+
+const nodePositions: Record<AgentGraphModel['nodes'][number]['role'], Point> = {
+  root: { x: 55, y: 92 },
+  implementer: { x: 375, y: 92 },
+  reviewer: { x: 695, y: 92 },
+};
+
+const edgeGeometry: Record<
+  AgentGraphModel['edges'][number]['kind'],
+  { path: string; label: Point }
+> = {
+  governs: {
+    path: 'M 325 158 C 342 158 358 158 375 158',
+    label: { x: 350, y: 133 },
+  },
+  handoff: {
+    path: 'M 645 158 C 662 158 678 158 695 158',
+    label: { x: 670, y: 133 },
+  },
+  feedback: {
+    path: 'M 695 213 C 670 292 665 292 645 213',
+    label: { x: 670, y: 284 },
+  },
+  verdict: {
+    path: 'M 695 226 C 645 342 375 342 325 226',
+    label: { x: 510, y: 331 },
+  },
+};
+
+function escapeHtml(value: unknown) {
+  return String(value)
+    .replaceAll('&', '&amp;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&#39;');
+}
+
+function compactId(value: string) {
+  return value.length > 28
+    ? `${value.slice(0, 12)}…${value.slice(-9)}`
+    : value;
+}
+
+function statusTone(status: AgentGraphModel['status']) {
+  if (status === 'running') return 'active';
+  if (status === 'succeeded') return 'success';
+  if (['paused', 'interrupted', 'capped'].includes(status)) return 'warning';
+  if (['failed', 'cancelled'].includes(status)) return 'danger';
+  return 'neutral';
+}
+
+function nodeDescription(
+  node: AgentGraphModel['nodes'][number],
+  model: AgentGraphModel,
+) {
+  if (model.latestReport?.fromRole === node.role) {
+    if (model.latestReport.verdict === 'clean') return 'Clean verdict';
+    if (model.latestReport.verdict === 'issues') {
+      return `${model.latestReport.issueCount} issue${
+        model.latestReport.issueCount === 1 ? '' : 's'
+      }`;
+    }
+    return 'Worker report received';
+  }
+  if (node.role === 'root') return 'Owns bounded continuation decisions';
+  if (node.state === 'unbound') return 'Waiting for native worker binding';
+  return 'Bound to the task-scoped worker role';
+}
+
+function renderNode(
+  node: AgentGraphModel['nodes'][number],
+  index: number,
+  model: AgentGraphModel,
+  selection?: AgentGraphSelection,
+) {
+  const { x, y } = nodePositions[node.role];
+  const selected = selection?.kind === 'node' && selection.id === node.id;
+  const pending = model.pending?.role === node.role;
+  const glyph =
+    node.role === 'root' ? 'G' : node.role === 'implementer' ? 'I' : 'R';
+  const subtitle = node.role === 'root' ? 'Governor' : 'Native worker role';
+  return `<g class="lag-inline-node" data-node-index="${index}" data-role="${escapeHtml(
+    node.role,
+  )}" data-state="${escapeHtml(node.state)}" data-selected="${
+    selected ? 'true' : 'false'
+  }" role="button" tabindex="0" aria-label="${escapeHtml(
+    `${node.label}, ${node.state}`,
+  )}" transform="translate(${x} ${y})">
+    <rect class="lag-inline-node-card" width="270" height="146" rx="14"></rect>
+    <rect class="lag-inline-glyph-box" x="14" y="14" width="34" height="34" rx="10"></rect>
+    <text class="lag-inline-glyph" x="31" y="36" text-anchor="middle">${glyph}</text>
+    <text class="lag-inline-node-title" x="60" y="27">${escapeHtml(node.label)}</text>
+    <text class="lag-inline-node-subtitle" x="60" y="43">${subtitle}</text>
+    <rect class="lag-inline-state-box" x="194" y="15" width="62" height="22" rx="11"></rect>
+    <text class="lag-inline-state" x="225" y="30" text-anchor="middle">${escapeHtml(
+      pending ? 'pending' : node.state,
+    )}</text>
+    <rect class="lag-inline-description-box" x="14" y="60" width="242" height="48" rx="9"></rect>
+    <text class="lag-inline-description" x="26" y="82">${escapeHtml(
+      nodeDescription(node, model),
+    )}</text>
+    <line class="lag-inline-node-separator" x1="0" y1="119" x2="270" y2="119"></line>
+    <text class="lag-inline-node-id" x="14" y="136">${escapeHtml(
+      compactId(node.id),
+    )}</text>
+    <text class="lag-inline-node-binding" x="256" y="136" text-anchor="end">${escapeHtml(
+      node.nativeAgentId ? compactId(node.nativeAgentId) : 'not bound',
+    )}</text>
+  </g>`;
+}
+
+function renderEdge(
+  edge: AgentGraphModel['edges'][number],
+  index: number,
+  selection?: AgentGraphSelection,
+) {
+  const geometry = edgeGeometry[edge.kind];
+  const selected = selection?.kind === 'edge' && selection.id === edge.id;
+  const label = `${edge.kind} · ${edge.reportCount}`;
+  const labelWidth = Math.max(78, 21 + label.length * 6.2);
+  const labelX = geometry.label.x - labelWidth / 2;
+  return `<g class="lag-inline-edge" data-edge-index="${index}" data-kind="${escapeHtml(
+    edge.kind,
+  )}" data-active="${edge.active ? 'true' : 'false'}" data-selected="${
+    selected ? 'true' : 'false'
+  }" role="button" tabindex="0" aria-label="${escapeHtml(
+    `${edge.source} to ${edge.target}, ${edge.kind}`,
+  )}">
+    <path class="lag-inline-edge-hit" d="${geometry.path}"></path>
+    <path class="lag-inline-edge-path" d="${geometry.path}" marker-end="url(#lag-arrow)"></path>
+    <rect class="lag-inline-edge-label-box" x="${labelX}" y="${
+      geometry.label.y - 11
+    }" width="${labelWidth}" height="22" rx="11"></rect>
+    <text class="lag-inline-edge-label" x="${geometry.label.x}" y="${
+      geometry.label.y + 3
+    }" text-anchor="middle">${escapeHtml(label)}</text>
+  </g>`;
+}
+
+function selectedCopy(model: AgentGraphModel, selection?: AgentGraphSelection) {
+  const node =
+    selection?.kind === 'node'
+      ? model.nodes.find((candidate) => candidate.id === selection.id)
+      : undefined;
+  const edge =
+    selection?.kind === 'edge'
+      ? model.edges.find((candidate) => candidate.id === selection.id)
+      : undefined;
+  if (node) {
+    return {
+      eyebrow: 'Selected node',
+      title: node.label,
+      detail: `${node.role} · ${node.state}${
+        node.nativeAgentId ? ' · native worker bound' : ''
+      }`,
+    };
+  }
+  if (edge) {
+    return {
+      eyebrow: 'Selected relationship',
+      title: `${edge.source} → ${edge.target}`,
+      detail: `${edge.kind} · ${edge.reportCount} reports${
+        edge.active ? ' · active' : ''
+      }`,
+    };
+  }
+  return {
+    eyebrow: 'Verified snapshot',
+    title: 'Select a node or relationship',
+    detail: `revision ${model.identity.revision} · digest ${model.identity.projectionDigest.slice(
+      0,
+      12,
+    )}`,
+  };
+}
+
+function renderTimeline(model: AgentGraphModel) {
+  const items =
+    model.timeline.length > 0
+      ? model.timeline
+          .map(
+            (item) =>
+              `<li><time datetime="${escapeHtml(item.at)}">${escapeHtml(
+                item.at,
+              )}</time><span>${escapeHtml(item.label)}</span>${
+                item.role ? `<small>${escapeHtml(item.role)}</small>` : ''
+              }</li>`,
+          )
+          .join('')
+      : '<li>No authoritative timeline entries.</li>';
+  return `<details class="lag-inline-timeline">
+    <summary>Bounded timeline <span>${model.timeline.length}</span></summary>
+    <ol>${items}</ol>
+  </details>`;
+}
+
+function renderAlert(
+  model: AgentGraphModel,
+  driftNote: string,
+  integrityError: string,
+) {
+  if (integrityError) {
+    return `<p class="lag-inline-alert lag-inline-error" role="status">Snapshot unavailable: ${escapeHtml(
+      integrityError,
+    )}</p>`;
+  }
+  if (driftNote) {
+    return `<p class="lag-inline-alert" role="status">${escapeHtml(
+      driftNote,
+    )}</p>`;
+  }
+  if (model.recovery) {
+    return `<p class="lag-inline-alert" role="status">Recovery: ${escapeHtml(
+      model.recovery.reason,
+    )}</p>`;
+  }
+  if (model.cancelRequested) {
+    return '<p class="lag-inline-alert" role="status">Cancellation requested.</p>';
+  }
+  if (model.needsHuman) {
+    return '<p class="lag-inline-alert" role="status">Human attention is required.</p>';
+  }
+  return '';
+}
+
+function renderGraph(
+  model: AgentGraphModel,
+  options: InlineAgentLoopGraphOptions,
+  selection: AgentGraphSelection | undefined,
+  integrityError: string,
+  followUpStatus: string,
+) {
+  const selected = selectedCopy(model, selection);
+  const terminal = ['succeeded', 'capped', 'cancelled', 'failed'].includes(
+    model.status,
+  );
+  const control =
+    model.status === 'paused' || model.status === 'interrupted'
+      ? 'resume'
+      : 'pause';
+  const mode = options.mode ?? 'snapshot';
+  const liveLabel =
+    mode === 'live' ? (options.liveState ?? 'connecting') : 'snapshot';
+  return `<section class="looperators-inline-agent-graph" data-status="${escapeHtml(
+    model.status,
+  )}" data-testid="inline-agent-loop-graph">
+    <header class="lag-inline-header">
+      <div><p class="lag-inline-eyebrow">looperators</p><h2>Agent Loop</h2></div>
+      <div class="lag-inline-badges" aria-label="Loop status">
+        <span class="lag-inline-badge lag-inline-verified">verified</span>
+        <span class="lag-inline-badge" data-tone="${statusTone(
+          model.status,
+        )}">${escapeHtml(model.status)}</span>
+        <span class="lag-inline-badge">lap ${model.currentLap}/${
+          model.lapCap
+        }</span>
+        <span class="lag-inline-badge">lease ${model.lease.consumed}/${
+          model.lease.granted
+        }</span>
+        <span class="lag-inline-badge">${escapeHtml(liveLabel)}</span>
+      </div>
+    </header>
+    ${renderAlert(
+      model,
+      options.driftNote ?? '',
+      integrityError,
+    )}
+    <div class="lag-inline-stage">
+      <svg viewBox="0 0 1020 380" preserveAspectRatio="xMidYMid meet" role="img" aria-label="Agent Loop relationship graph">
+        <defs>
+          <pattern id="lag-grid" width="22" height="22" patternUnits="userSpaceOnUse">
+            <circle class="lag-inline-grid-dot" cx="1.5" cy="1.5" r="1.1"></circle>
+          </pattern>
+          <marker id="lag-arrow" markerWidth="9" markerHeight="9" refX="8" refY="4.5" orient="auto" markerUnits="strokeWidth">
+            <path class="lag-inline-arrow" d="M 0 0 L 9 4.5 L 0 9 z"></path>
+          </marker>
+        </defs>
+        <rect class="lag-inline-grid" width="1020" height="380" rx="14"></rect>
+        ${model.edges
+          .map((edge, index) => renderEdge(edge, index, selection))
+          .join('')}
+        ${model.nodes
+          .map((node, index) => renderNode(node, index, model, selection))
+          .join('')}
+      </svg>
+    </div>
+    <section class="lag-inline-inspector" aria-live="polite">
+      <div>
+        <p class="lag-inline-eyebrow">${escapeHtml(selected.eyebrow)}</p>
+        <h3>${escapeHtml(selected.title)}</h3>
+        <p class="lag-inline-detail">${escapeHtml(selected.detail)}</p>
+      </div>
+      <div class="lag-inline-actions">
+        <button type="button" data-action="explain" ${
+          selection ? '' : 'disabled'
+        }>Explain selection</button>
+        <button type="button" data-action="${control}" ${
+          terminal ? 'disabled' : ''
+        }>Request ${control}</button>
+      </div>
+      ${
+        followUpStatus
+          ? `<p class="lag-inline-follow-up" role="status">${escapeHtml(
+              followUpStatus,
+            )}</p>`
+          : ''
+      }
+    </section>
+    ${renderTimeline(model)}
+    <footer class="lag-inline-footer">run ${escapeHtml(
+      compactId(model.identity.runId),
+    )} · revision ${model.identity.revision} · SVG runtime</footer>
+  </section>`;
+}
+
+export function mountInlineAgentLoopGraph(
+  root: HTMLElement,
+  initialOptions: InlineAgentLoopGraphOptions,
+): InlineAgentLoopGraphController {
+  let model = initialOptions.model;
+  let options = { ...initialOptions };
+  let selection: AgentGraphSelection | undefined;
+  let integrityError = '';
+  let followUpStatus = '';
+
+  const render = () => {
+    root.innerHTML = renderGraph(
+      model,
+      options,
+      selection,
+      integrityError,
+      followUpStatus,
+    );
+  };
+
+  const activateSelection = (element: Element) => {
+    const nodeElement = element.closest<SVGGElement>('[data-node-index]');
+    const edgeElement = element.closest<SVGGElement>('[data-edge-index]');
+    if (nodeElement) {
+      const node = model.nodes[Number(nodeElement.dataset.nodeIndex)];
+      if (node) selection = { kind: 'node', id: node.id };
+    } else if (edgeElement) {
+      const edge = model.edges[Number(edgeElement.dataset.edgeIndex)];
+      if (edge) selection = { kind: 'edge', id: edge.id };
+    } else {
+      selection = undefined;
+    }
+    render();
+  };
+
+  const requestFollowUp = async (
+    kind: AgentGraphFollowUpIntent['kind'],
+  ) => {
+    if (!options.followUpAvailable || !options.onFollowUp) {
+      followUpStatus = 'Host follow-up is unavailable.';
+      render();
+      return;
+    }
+    followUpStatus = 'Requesting follow-up…';
+    render();
+    try {
+      await options.onFollowUp({
+        kind,
+        runId: model.identity.runId,
+        ...(selection ? { selection } : {}),
+      });
+      followUpStatus = 'Follow-up requested.';
+    } catch {
+      followUpStatus = 'Follow-up cancelled or failed.';
+    }
+    render();
+  };
+
+  const clickHandler = (event: MouseEvent) => {
+    const target = event.target;
+    if (!(target instanceof Element)) return;
+    const action = target.closest<HTMLButtonElement>('button[data-action]');
+    if (action?.dataset.action) {
+      void requestFollowUp(
+        action.dataset.action as AgentGraphFollowUpIntent['kind'],
+      );
+      return;
+    }
+    if (target.closest('[data-node-index], [data-edge-index]')) {
+      activateSelection(target);
+    }
+  };
+
+  const keyHandler = (event: KeyboardEvent) => {
+    if (event.key !== 'Enter' && event.key !== ' ') return;
+    const target = event.target;
+    if (
+      target instanceof Element &&
+      target.closest('[data-node-index], [data-edge-index]')
+    ) {
+      event.preventDefault();
+      activateSelection(target);
+    }
+  };
+
+  root.addEventListener('click', clickHandler);
+  root.addEventListener('keydown', keyHandler);
+  render();
+
+  return Object.freeze({
+    update(
+      nextModel: AgentGraphModel,
+      nextOptions: Pick<InlineAgentLoopGraphOptions, 'liveState'> = {},
+    ) {
+      model = nextModel;
+      options = { ...options, ...nextOptions };
+      integrityError = '';
+      if (
+        selection?.kind === 'node' &&
+        !model.nodes.some((node) => node.id === selection?.id)
+      ) {
+        selection = undefined;
+      }
+      if (
+        selection?.kind === 'edge' &&
+        !model.edges.some((edge) => edge.id === selection?.id)
+      ) {
+        selection = undefined;
+      }
+      render();
+    },
+    integrityError(code: string) {
+      integrityError = String(code).slice(0, 80);
+      render();
+    },
+    destroy() {
+      root.removeEventListener('click', clickHandler);
+      root.removeEventListener('keydown', keyHandler);
+      root.replaceChildren();
+    },
+  });
+}
diff --git a/packages/agent-graph-ui/src/inline.css b/packages/agent-graph-ui/src/inline.css
new file mode 100644
index 0000000..ff84e88
--- /dev/null
+++ b/packages/agent-graph-ui/src/inline.css
@@ -0,0 +1,407 @@
+.looperators-inline-agent-graph,
+.looperators-inline-agent-graph * {
+  box-sizing: border-box;
+}
+
+.looperators-inline-agent-graph {
+  --lagi-background: var(--background, #f8fafc);
+  --lagi-card: var(--card, #ffffff);
+  --lagi-muted-card: var(--muted, #f1f3f5);
+  --lagi-foreground: var(--foreground, #171a1f);
+  --lagi-muted: var(--muted-foreground, #606772);
+  --lagi-border: var(--border, rgba(23, 26, 31, 0.16));
+  --lagi-accent: var(--term-accent-hi, #65a30d);
+  --lagi-governor: var(--term-amber, #b45309);
+  --lagi-worker: var(--term-cyan, #0e7490);
+  --lagi-success: var(--term-emerald, #047857);
+  --lagi-danger: var(--term-rose, #e11d48);
+  display: grid;
+  gap: 12px;
+  width: 100%;
+  min-width: 0;
+  color: var(--lagi-foreground);
+  font: 14px/1.45 ui-sans-serif, -apple-system, BlinkMacSystemFont, "Segoe UI",
+    sans-serif;
+}
+
+.lag-inline-header,
+.lag-inline-badges,
+.lag-inline-actions {
+  display: flex;
+  align-items: center;
+  gap: 7px;
+  flex-wrap: wrap;
+}
+
+.lag-inline-header {
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 16px;
+}
+
+.lag-inline-header h2,
+.lag-inline-inspector h3 {
+  margin: 0;
+  font-size: 16px;
+  letter-spacing: -0.01em;
+}
+
+.lag-inline-eyebrow {
+  margin: 0 0 2px;
+  color: var(--lagi-muted);
+  font: 10px/1.2 ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas,
+    monospace;
+  letter-spacing: 0.12em;
+  text-transform: uppercase;
+}
+
+.lag-inline-badges {
+  justify-content: flex-end;
+}
+
+.lag-inline-badge {
+  display: inline-flex;
+  align-items: center;
+  min-height: 24px;
+  border: 1px solid var(--lagi-border);
+  border-radius: 999px;
+  background: color-mix(in srgb, var(--lagi-card) 88%, transparent);
+  padding: 2px 8px;
+  color: var(--lagi-muted);
+  font: 10px/1 ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas,
+    monospace;
+  white-space: nowrap;
+}
+
+.lag-inline-badge[data-tone="active"] {
+  border-color: color-mix(in srgb, var(--lagi-accent) 50%, var(--lagi-border));
+  color: var(--lagi-accent);
+}
+
+.lag-inline-badge[data-tone="success"],
+.lag-inline-verified {
+  border-color: color-mix(in srgb, var(--lagi-success) 45%, var(--lagi-border));
+  color: var(--lagi-success);
+}
+
+.lag-inline-badge[data-tone="warning"] {
+  border-color: color-mix(in srgb, var(--lagi-governor) 50%, var(--lagi-border));
+  color: var(--lagi-governor);
+}
+
+.lag-inline-badge[data-tone="danger"] {
+  border-color: color-mix(in srgb, var(--lagi-danger) 45%, var(--lagi-border));
+  color: var(--lagi-danger);
+}
+
+.lag-inline-alert {
+  margin: 0;
+  border: 1px solid
+    color-mix(in srgb, var(--lagi-governor) 45%, var(--lagi-border));
+  border-radius: 10px;
+  background: color-mix(in srgb, var(--lagi-governor) 8%, var(--lagi-card));
+  padding: 8px 10px;
+  color: var(--lagi-governor);
+  font-size: 12px;
+}
+
+.lag-inline-error {
+  border-color: color-mix(in srgb, var(--lagi-danger) 45%, var(--lagi-border));
+  color: var(--lagi-danger);
+}
+
+.lag-inline-stage {
+  width: 100%;
+  overflow: hidden;
+  border: 1px solid var(--lagi-border);
+  border-radius: 14px;
+  background: var(--lagi-background);
+}
+
+.lag-inline-stage svg {
+  display: block;
+  width: 100%;
+  min-width: 620px;
+  height: auto;
+  min-height: 250px;
+  max-height: 420px;
+}
+
+.lag-inline-grid {
+  fill: url("#lag-grid");
+}
+
+.lag-inline-grid-dot {
+  fill: color-mix(in srgb, var(--lagi-muted) 30%, transparent);
+}
+
+.lag-inline-node,
+.lag-inline-edge {
+  cursor: pointer;
+  outline: none;
+}
+
+.lag-inline-node-card {
+  fill: color-mix(in srgb, var(--lagi-card) 96%, transparent);
+  stroke: var(--lagi-border);
+  filter: drop-shadow(0 9px 12px rgba(0, 0, 0, 0.08));
+}
+
+.lag-inline-node[data-role="root"] .lag-inline-node-card {
+  stroke: color-mix(in srgb, var(--lagi-governor) 55%, var(--lagi-border));
+}
+
+.lag-inline-node[data-role="implementer"] .lag-inline-node-card,
+.lag-inline-node[data-role="reviewer"] .lag-inline-node-card {
+  stroke: color-mix(in srgb, var(--lagi-worker) 48%, var(--lagi-border));
+}
+
+.lag-inline-node[data-state="terminal"] {
+  opacity: 0.72;
+}
+
+.lag-inline-node[data-selected="true"] .lag-inline-node-card,
+.lag-inline-node:focus-visible .lag-inline-node-card {
+  stroke: var(--lagi-accent);
+  stroke-width: 3;
+}
+
+.lag-inline-glyph-box,
+.lag-inline-description-box,
+.lag-inline-state-box {
+  fill: color-mix(in srgb, var(--lagi-muted-card) 76%, transparent);
+  stroke: var(--lagi-border);
+}
+
+.lag-inline-glyph,
+.lag-inline-node-title,
+.lag-inline-state,
+.lag-inline-node-subtitle,
+.lag-inline-description,
+.lag-inline-node-id,
+.lag-inline-node-binding,
+.lag-inline-edge-label {
+  dominant-baseline: auto;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+}
+
+.lag-inline-glyph {
+  fill: var(--lagi-worker);
+  font-size: 13px;
+  font-weight: 700;
+}
+
+.lag-inline-node[data-role="root"] .lag-inline-glyph {
+  fill: var(--lagi-governor);
+}
+
+.lag-inline-node-title {
+  fill: var(--lagi-foreground);
+  font-size: 12px;
+  font-weight: 700;
+}
+
+.lag-inline-node-subtitle,
+.lag-inline-state,
+.lag-inline-description,
+.lag-inline-node-id,
+.lag-inline-node-binding,
+.lag-inline-edge-label {
+  fill: var(--lagi-muted);
+}
+
+.lag-inline-node-subtitle,
+.lag-inline-state {
+  font-size: 9px;
+}
+
+.lag-inline-description {
+  font-size: 10px;
+}
+
+.lag-inline-node-id,
+.lag-inline-node-binding,
+.lag-inline-edge-label {
+  font-size: 8.5px;
+}
+
+.lag-inline-node-separator {
+  stroke: var(--lagi-border);
+}
+
+.lag-inline-edge-path {
+  fill: none;
+  stroke: var(--lagi-muted);
+  stroke-width: 2;
+}
+
+.lag-inline-edge-hit {
+  fill: none;
+  stroke: transparent;
+  stroke-width: 18;
+}
+
+.lag-inline-edge[data-kind="governs"] .lag-inline-edge-path {
+  stroke: var(--lagi-governor);
+}
+
+.lag-inline-edge[data-kind="handoff"] .lag-inline-edge-path {
+  stroke: var(--lagi-success);
+}
+
+.lag-inline-edge[data-kind="feedback"] .lag-inline-edge-path {
+  stroke: var(--lagi-governor);
+  stroke-dasharray: 7 5;
+}
+
+.lag-inline-edge[data-kind="verdict"] .lag-inline-edge-path {
+  stroke: var(--lagi-worker);
+  stroke-dasharray: 3 4;
+}
+
+.lag-inline-edge[data-active="false"] {
+  opacity: 0.62;
+}
+
+.lag-inline-edge[data-selected="true"] .lag-inline-edge-path,
+.lag-inline-edge:focus-visible .lag-inline-edge-path {
+  stroke: var(--lagi-accent);
+  stroke-width: 4;
+}
+
+.lag-inline-arrow {
+  fill: var(--lagi-muted);
+}
+
+.lag-inline-edge-label-box {
+  fill: color-mix(in srgb, var(--lagi-card) 94%, transparent);
+  stroke: var(--lagi-border);
+}
+
+.lag-inline-edge[data-active="true"] .lag-inline-edge-label-box {
+  stroke: var(--lagi-accent);
+}
+
+.lag-inline-inspector {
+  display: grid;
+  grid-template-columns: minmax(220px, 1fr) auto;
+  align-items: center;
+  gap: 12px 18px;
+  border: 1px solid var(--lagi-border);
+  border-radius: 12px;
+  background: color-mix(in srgb, var(--lagi-card) 92%, transparent);
+  padding: 11px 12px;
+}
+
+.lag-inline-detail,
+.lag-inline-follow-up {
+  margin: 4px 0 0;
+  color: var(--lagi-muted);
+  font: 10px/1.4 ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas,
+    monospace;
+}
+
+.lag-inline-actions {
+  justify-content: flex-end;
+}
+
+.lag-inline-actions button {
+  min-height: 31px;
+  border: 1px solid var(--lagi-border);
+  border-radius: 9px;
+  background: var(--lagi-card);
+  padding: 5px 9px;
+  color: var(--lagi-foreground);
+  font: 10px/1 ui-sans-serif, -apple-system, BlinkMacSystemFont, "Segoe UI",
+    sans-serif;
+  cursor: pointer;
+}
+
+.lag-inline-actions button:disabled {
+  cursor: not-allowed;
+  opacity: 0.45;
+}
+
+.lag-inline-actions button:focus-visible,
+.lag-inline-timeline summary:focus-visible {
+  outline: 2px solid var(--lagi-accent);
+  outline-offset: 2px;
+}
+
+.lag-inline-follow-up {
+  grid-column: 1 / -1;
+}
+
+.lag-inline-timeline {
+  border: 1px solid var(--lagi-border);
+  border-radius: 12px;
+  background: color-mix(in srgb, var(--lagi-card) 90%, transparent);
+}
+
+.lag-inline-timeline summary {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 10px 12px;
+  color: var(--lagi-foreground);
+  font: 11px/1 ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas,
+    monospace;
+  cursor: pointer;
+}
+
+.lag-inline-timeline ol {
+  display: grid;
+  gap: 6px;
+  margin: 0;
+  padding: 0 12px 12px 32px;
+}
+
+.lag-inline-timeline li,
+.lag-inline-footer {
+  color: var(--lagi-muted);
+  font-size: 10px;
+}
+
+.lag-inline-timeline li time {
+  margin-right: 8px;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+}
+
+.lag-inline-timeline li small {
+  margin-left: 6px;
+  color: var(--lagi-worker);
+}
+
+.lag-inline-footer {
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+}
+
+@media (max-width: 719px) {
+  .lag-inline-stage {
+    overflow-x: auto;
+  }
+
+  .lag-inline-inspector {
+    grid-template-columns: 1fr;
+  }
+
+  .lag-inline-actions {
+    justify-content: flex-start;
+  }
+}
+
+@media (prefers-color-scheme: dark) {
+  .looperators-inline-agent-graph {
+    --lagi-background: var(--background, #07090a);
+    --lagi-card: var(--card, #0d120e);
+    --lagi-muted-card: var(--muted, #0f1511);
+    --lagi-foreground: var(--foreground, #e5e7eb);
+    --lagi-muted: var(--muted-foreground, #9ca3af);
+    --lagi-border: var(--border, rgba(255, 255, 255, 0.12));
+    --lagi-accent: var(--term-accent-hi, #a3e635);
+    --lagi-governor: var(--term-amber, #fcd34d);
+    --lagi-worker: var(--term-cyan, #67e8f9);
+    --lagi-success: var(--term-emerald, #6ee7b7);
+    --lagi-danger: var(--term-rose, #fb7185);
+  }
+}
diff --git a/packages/agent-graph-ui/src/inline.ts b/packages/agent-graph-ui/src/inline.ts
new file mode 100644
index 0000000..b9dafe6
--- /dev/null
+++ b/packages/agent-graph-ui/src/inline.ts
@@ -0,0 +1,12 @@
+import './inline.css';
+
+export {
+  mountInlineAgentLoopGraph,
+  type InlineAgentLoopGraphController,
+  type InlineAgentLoopGraphOptions,
+} from './inline-agent-loop-graph';
+export type {
+  AgentGraphFollowUpIntent,
+  AgentGraphModel,
+  AgentGraphSelection,
+} from './graph-model';
diff --git a/packages/agent-graph-ui/src/loop-badge.tsx b/packages/agent-graph-ui/src/loop-badge.tsx
new file mode 100644
index 0000000..4fd15c9
--- /dev/null
+++ b/packages/agent-graph-ui/src/loop-badge.tsx
@@ -0,0 +1,27 @@
+import type { AgentGraphModel } from './graph-model';
+import { statusTone } from './graph-model';
+
+export function LoopBadge({
+  model,
+  onOpen,
+}: {
+  model: AgentGraphModel;
+  onOpen: () => void;
+}) {
+  return (
+    <button
+      type="button"
+      className="lag-loop-badge"
+      data-tone={statusTone(model.status)}
+      aria-label={`Open Loop details, lap ${model.currentLap} of ${model.lapCap}`}
+      onClick={onOpen}
+    >
+      <span className="lag-loop-badge-icon" aria-hidden="true">↻</span>
+      <span className="lag-loop-badge-copy">
+        <strong>{model.status === 'running' ? 'Review loop active' : `Review loop ${model.status}`}</strong>
+        <small>{model.stopReason ?? `Lap ${model.currentLap}/${model.lapCap}`}</small>
+      </span>
+      <span className="lag-loop-badge-lap">{model.currentLap}/{model.lapCap}</span>
+    </button>
+  );
+}
diff --git a/packages/agent-graph-ui/src/loop-panel.tsx b/packages/agent-graph-ui/src/loop-panel.tsx
new file mode 100644
index 0000000..16969b1
--- /dev/null
+++ b/packages/agent-graph-ui/src/loop-panel.tsx
@@ -0,0 +1,123 @@
+import { useState } from 'react';
+import type { AgentGraphFollowUpIntent, AgentGraphIssue, AgentGraphModel } from './graph-model';
+import { statusTone } from './graph-model';
+
+function IssueList({ issues }: { issues: AgentGraphIssue[] }) {
+  return (
+    <ul className="lag-issue-list">
+      {issues.map((issue, index) => (
+        <li key={`${issue.file ?? ''}:${issue.line ?? ''}:${issue.message}:${index}`}>
+          <strong>{issue.severity ?? 'issue'}</strong>
+          <span>{issue.message}</span>
+          {issue.file ? <small>{issue.file}{issue.line ? `:${issue.line}` : ''}</small> : null}
+        </li>
+      ))}
+    </ul>
+  );
+}
+
+export function LoopPanel({
+  model,
+  onClose,
+  controlAvailable = false,
+  onControl,
+  confirming,
+  onConfirmingChange,
+}: {
+  model: AgentGraphModel;
+  onClose: () => void;
+  controlAvailable?: boolean;
+  onControl?: (intent: AgentGraphFollowUpIntent) => void | Promise<void>;
+  confirming?: boolean;
+  onConfirmingChange?: (confirming: boolean) => void;
+}) {
+  const [internalConfirming, setInternalConfirming] = useState(false);
+  const [pending, setPending] = useState(false);
+  const isConfirming = confirming ?? internalConfirming;
+  const setConfirming = onConfirmingChange ?? setInternalConfirming;
+  const terminal = ['succeeded', 'capped', 'cancelled', 'failed'].includes(model.status);
+  const issues = model.latestReport?.issues ?? [];
+
+  const cancel = async () => {
+    if (!onControl || pending) return;
+    setPending(true);
+    try {
+      await onControl({ kind: 'cancel', runId: model.identity.runId });
+      setConfirming(false);
+    } finally {
+      setPending(false);
+    }
+  };
+
+  return (
+    <aside className="lag-loop-panel" aria-label="Loop details">
+      <header>
+        <span className="lag-panel-icon" data-active={model.status === 'running'} aria-hidden="true">↻</span>
+        <div>
+          <h3>{model.status === 'running' ? 'Review loop active' : `Review loop ${model.status}`}</h3>
+          <p>Lap {model.currentLap}/{model.lapCap}</p>
+        </div>
+        <button type="button" className="lag-icon-button" aria-label="Close loop details" onClick={onClose}>×</button>
+      </header>
+
+      <div className="lag-loop-panel-body">
+        {isConfirming ? (
+          <section className="lag-stop-confirm" aria-label="Confirm Stop loop">
+            <strong>Stop future handoffs?</strong>
+            <p>Work already running may finish, but it cannot activate another lap.</p>
+            <div>
+              <button type="button" disabled={pending} onClick={() => setConfirming(false)}>Keep running</button>
+              <button type="button" disabled={pending} onClick={() => void cancel()}>{pending ? 'Stopping…' : 'Stop handoffs'}</button>
+            </div>
+          </section>
+        ) : null}
+
+        <section className="lag-loop-summary" data-tone={statusTone(model.status)}>
+          <h4>{model.stopReason ?? (terminal ? `Run ${model.status}` : 'Review until clean')}</h4>
+          <p>
+            {model.recovery?.reason ??
+              (model.responsibleRole ? `${model.responsibleRole} is responsible for the next action.` : 'The Governor owns the next transition.')}
+          </p>
+          <dl>
+            <div><dt>Lap</dt><dd>{model.currentLap}/{model.lapCap}</dd></div>
+            <div><dt>Now responsible</dt><dd>{model.responsibleRole ?? (terminal ? 'Complete' : 'Governor')}</dd></div>
+            {model.latestReport?.verdict ? <div><dt>Last verdict</dt><dd>{model.latestReport.verdict}</dd></div> : null}
+            {model.stopReason ? <div><dt>Why it stopped</dt><dd>{model.stopReason}</dd></div> : null}
+          </dl>
+          {!terminal ? (
+            <button type="button" disabled={!controlAvailable || !onControl} onClick={() => setConfirming(true)}>
+              {controlAvailable ? 'Stop loop' : 'Control unavailable'}
+            </button>
+          ) : null}
+          {model.recovery?.guidance ? <small>{model.recovery.guidance}</small> : null}
+        </section>
+
+        {issues.length > 0 ? (
+          <section className="lag-blocking-issues">
+            <h4>Latest blocking issues</h4>
+            <IssueList issues={issues} />
+          </section>
+        ) : null}
+
+        <ol className="lag-lap-list">
+          {[...(model.laps ?? [])].reverse().map((lap) => (
+            <li key={lap.index} className="lag-lap-card" data-status={lap.status}>
+              <header><strong>Lap {lap.index}</strong><span>{lap.verdict ?? lap.status}</span></header>
+              {lap.implementerSummary ? <p><b>Implementer</b>{lap.implementerSummary}</p> : null}
+              {lap.reviewerSummary ? <p><b>Reviewer</b>{lap.reviewerSummary}</p> : null}
+              {lap.issues.length > 0 ? <IssueList issues={lap.issues} /> : null}
+              {lap.at ? <time dateTime={lap.at}>{lap.at}</time> : null}
+            </li>
+          ))}
+        </ol>
+
+        <details className="lag-diagnostics">
+          <summary>Diagnostics & advanced details</summary>
+          <div>runId: {model.identity.runId}</div>
+          <div>revision: {model.identity.revision}</div>
+          <div>digest: {model.identity.projectionDigest}</div>
+        </details>
+      </div>
+    </aside>
+  );
+}
diff --git a/packages/agent-graph-ui/src/loop-status.tsx b/packages/agent-graph-ui/src/loop-status.tsx
new file mode 100644
index 0000000..d3c9c52
--- /dev/null
+++ b/packages/agent-graph-ui/src/loop-status.tsx
@@ -0,0 +1,35 @@
+import { statusTone, type AgentGraphModel } from './graph-model';
+
+export function LoopStatus({
+  model,
+  mode,
+  liveState,
+}: {
+  model: AgentGraphModel;
+  mode: 'snapshot' | 'live';
+  liveState?: 'connecting' | 'live' | 'retrying';
+}) {
+  return (
+    <header className="lag-header">
+      <div>
+        <p className="lag-eyebrow">looperators</p>
+        <h2>Agent Loop</h2>
+      </div>
+      <div className="lag-badges" aria-label="Loop status">
+        <span className="lag-badge lag-verified">verified</span>
+        <span className="lag-badge" data-tone={statusTone(model.status)}>
+          {model.status}
+        </span>
+        <span className="lag-badge">
+          lap {model.currentLap}/{model.lapCap}
+        </span>
+        <span className="lag-badge">
+          lease {model.lease.consumed}/{model.lease.granted}
+        </span>
+        <span className="lag-badge">
+          {mode === 'live' ? (liveState ?? 'connecting') : 'snapshot'}
+        </span>
+      </div>
+    </header>
+  );
+}
diff --git a/packages/agent-graph-ui/src/relationship-edge.tsx b/packages/agent-graph-ui/src/relationship-edge.tsx
new file mode 100644
index 0000000..91f6c3e
--- /dev/null
+++ b/packages/agent-graph-ui/src/relationship-edge.tsx
@@ -0,0 +1,160 @@
+import {
+  BaseEdge,
+  EdgeLabelRenderer,
+  getBezierPath,
+  type Edge,
+  type EdgeProps,
+} from '@xyflow/react';
+import type { AgentEdgeData } from './graph-model';
+
+const edgeLabels = {
+  governs: 'governs',
+  handoff: 'handoff',
+  feedback: 'feedback',
+  verdict: 'verdict',
+} as const;
+
+function routedPath({
+  route,
+  sourceX,
+  sourceY,
+  targetX,
+  targetY,
+  sourcePosition,
+  targetPosition,
+}: {
+  route: AgentEdgeData['route'];
+  sourceX: number;
+  sourceY: number;
+  targetX: number;
+  targetY: number;
+  sourcePosition: EdgeProps['sourcePosition'];
+  targetPosition: EdgeProps['targetPosition'];
+}) {
+  if (route === 'direct') {
+    const [path, labelX, labelY] = getBezierPath({
+      sourceX,
+      sourceY,
+      targetX,
+      targetY,
+      sourcePosition,
+      targetPosition,
+      curvature: 0.32,
+    });
+    return { path, labelX, labelY };
+  }
+  if (route === 'lower') {
+    const depth = Math.max(sourceY, targetY) + 88;
+    return {
+      path: `M ${sourceX} ${sourceY} C ${sourceX} ${depth}, ${targetX} ${depth}, ${targetX} ${targetY}`,
+      labelX: (sourceX + targetX) / 2,
+      labelY: depth - 8,
+    };
+  }
+  const direction = route === 'right' ? 1 : -1;
+  const depth =
+    (route === 'right'
+      ? Math.max(sourceX, targetX)
+      : Math.min(sourceX, targetX)) +
+    direction * 96;
+  return {
+    path: `M ${sourceX} ${sourceY} C ${depth} ${sourceY}, ${depth} ${targetY}, ${targetX} ${targetY}`,
+    labelX:
+      (route === 'right'
+        ? Math.max(sourceX, targetX)
+        : Math.min(sourceX, targetX)) -
+      direction * 28,
+    labelY: (sourceY + targetY) / 2,
+  };
+}
+
+export function AgentRelationshipEdge({
+  id,
+  sourceX,
+  sourceY,
+  targetX,
+  targetY,
+  sourcePosition,
+  targetPosition,
+  markerEnd,
+  selected,
+  data,
+}: EdgeProps<Edge<AgentEdgeData>>) {
+  const edgeData = data as AgentEdgeData;
+  const { edge, route, latestReport } = edgeData;
+  const { path, labelX, labelY } = routedPath({
+    route,
+    sourceX,
+    sourceY,
+    targetX,
+    targetY,
+    sourcePosition,
+    targetPosition,
+  });
+  const reportLabel =
+    latestReport?.verdict === 'issues'
+      ? `${latestReport.issueCount} issues`
+      : latestReport?.verdict === 'clean'
+        ? 'clean'
+        : undefined;
+  const displayLabel = edge.label ?? edgeLabels[edge.kind];
+  const tooltip = [
+    displayLabel,
+    edge.summary,
+    edge.gate ? `gate ${edge.gate}` : undefined,
+    edge.stopWhen,
+    edge.pending ? 'pending' : undefined,
+  ].filter(Boolean).join('\n');
+  return (
+    <>
+      <BaseEdge
+        id={id}
+        path={path}
+        markerEnd={markerEnd}
+        className="lag-edge-path"
+        data-kind={edge.kind}
+        data-active={edge.active ? 'true' : 'false'}
+        data-recent={edge.recent ? 'true' : 'false'}
+        data-pending={edge.pending ? 'true' : 'false'}
+        style={{
+          strokeWidth: selected ? 3 : edge.active ? 2.6 : 1.8,
+        }}
+      />
+      <EdgeLabelRenderer>
+        <div
+          className="lag-edge-label nodrag nopan"
+          data-kind={edge.kind}
+          data-active={edge.active ? 'true' : 'false'}
+          data-selected={selected ? 'true' : 'false'}
+          data-recent={edge.recent ? 'true' : 'false'}
+          data-pending={edge.pending ? 'true' : 'false'}
+          data-testid={`graph-edge-${edge.kind}`}
+          style={{
+            transform: `translate(-50%, -50%) translate(${labelX}px, ${labelY}px)`,
+          }}
+          role="button"
+          tabIndex={0}
+          aria-pressed={selected}
+          aria-label={`Inspect Relationship: ${displayLabel}, ${edge.reportCount} reports`}
+          title={tooltip}
+          onClick={(event) => {
+            event.stopPropagation();
+            edgeData.onSelect?.(id);
+          }}
+          onKeyDown={(event) => {
+            if (event.key !== 'Enter' && event.key !== ' ') return;
+            event.preventDefault();
+            event.stopPropagation();
+            edgeData.onSelect?.(id);
+          }}
+        >
+          <strong>{displayLabel}</strong>
+          {edge.pending ? <span>pending</span> : null}
+          {reportLabel ? <span>{reportLabel}</span> : null}
+          {edge.reportCount > 0 ? <span>{edge.reportCount}</span> : null}
+          {edge.maxFirings !== undefined ? <span>{edge.firings ?? 0}/{edge.maxFirings}</span> : null}
+        </div>
+      </EdgeLabelRenderer>
+    </>
+  );
+}
diff --git a/packages/agent-graph-ui/src/relationship-inspector.tsx b/packages/agent-graph-ui/src/relationship-inspector.tsx
new file mode 100644
index 0000000..0237d45
--- /dev/null
+++ b/packages/agent-graph-ui/src/relationship-inspector.tsx
@@ -0,0 +1,53 @@
+import type { AgentGraphEdge, AgentGraphNode } from './graph-model';
+
+function nodeLabel(nodes: AgentGraphNode[], id: string) {
+  return nodes.find((node) => node.id === id)?.label ?? id;
+}
+
+export function RelationshipInspector({
+  edge,
+  nodes,
+  onClose,
+  onRequestStop,
+  stopAvailable = false,
+}: {
+  edge: AgentGraphEdge;
+  nodes: AgentGraphNode[];
+  onClose: () => void;
+  onRequestStop?: () => void;
+  stopAvailable?: boolean;
+}) {
+  return (
+    <aside className="lag-relationship-inspector" aria-label="Relationship details">
+      <header>
+        <span className="lag-panel-icon" aria-hidden="true">↗</span>
+        <div>
+          <p className="lag-eyebrow">Relationship</p>
+          <h3>{edge.label ?? edge.kind}</h3>
+        </div>
+        <button type="button" className="lag-icon-button" aria-label="Close Relationship inspector" onClick={onClose}>×</button>
+      </header>
+      <dl className="lag-relationship-grid">
+        <dt>From</dt><dd>{nodeLabel(nodes, edge.source)}</dd>
+        <dt>When</dt><dd>{edge.summary ?? edge.kind}</dd>
+        <dt>Then</dt><dd>{nodeLabel(nodes, edge.target)}</dd>
+        <dt>Gate</dt><dd>{edge.gate ?? 'Governor'}</dd>
+        <dt>State</dt>
+        <dd>
+          {edge.active ? 'active' : 'waiting'} · {edge.firings ?? edge.reportCount}
+          {edge.maxFirings !== undefined ? `/${edge.maxFirings}` : ''} firings
+        </dd>
+        <dt>Stop when</dt><dd>{edge.stopWhen ?? 'run reaches a terminal state'}</dd>
+      </dl>
+      {edge.summary ? <p className="lag-panel-note">{edge.summary}</p> : null}
+      <button
+        type="button"
+        className="lag-danger-button"
+        disabled={!stopAvailable || !onRequestStop}
+        onClick={onRequestStop}
+      >
+        {stopAvailable ? 'Stop future handoffs' : 'Control unavailable'}
+      </button>
+    </aside>
+  );
+}
diff --git a/packages/agent-graph-ui/src/styles.css b/packages/agent-graph-ui/src/styles.css
new file mode 100644
index 0000000..88fb150
--- /dev/null
+++ b/packages/agent-graph-ui/src/styles.css
@@ -0,0 +1,813 @@
+.looperators-agent-graph,
+.looperators-agent-graph * {
+  box-sizing: border-box;
+}
+
+.looperators-agent-graph {
+  --lag-background: var(--background, #f8fafc);
+  --lag-card: var(--card, #ffffff);
+  --lag-card-muted: var(--muted, #f1f3f5);
+  --lag-foreground: var(--foreground, #171a1f);
+  --lag-muted: var(--muted-foreground, #606772);
+  --lag-border: var(--border, rgba(23, 26, 31, 0.14));
+  --lag-accent: var(--term-accent-hi, #65a30d);
+  --lag-governor: var(--term-amber, #b45309);
+  --lag-worker: var(--term-cyan, #0e7490);
+  --lag-success: var(--term-emerald, #047857);
+  --lag-danger: var(--term-rose, #e11d48);
+  --lag-font:
+    ui-sans-serif, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+  --lag-mono:
+    ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+  display: grid;
+  gap: 12px;
+  width: 100%;
+  min-width: 0;
+  color: var(--lag-foreground);
+  font: 14px/1.45 var(--lag-font);
+}
+
+.lag-header {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 16px;
+  flex-wrap: wrap;
+}
+
+.lag-header h2,
+.lag-inspector h3 {
+  margin: 0;
+  font-size: 16px;
+  letter-spacing: -0.01em;
+}
+
+.lag-eyebrow {
+  margin: 0 0 2px;
+  color: var(--lag-muted);
+  font: 10px/1.2 var(--lag-mono);
+  letter-spacing: 0.12em;
+  text-transform: uppercase;
+}
+
+.lag-badges {
+  display: flex;
+  align-items: center;
+  justify-content: flex-end;
+  gap: 6px;
+  flex-wrap: wrap;
+}
+
+.lag-badge,
+.lag-state-pill {
+  display: inline-flex;
+  align-items: center;
+  min-height: 24px;
+  border: 1px solid var(--lag-border);
+  border-radius: 999px;
+  background: color-mix(in srgb, var(--lag-card) 88%, transparent);
+  padding: 2px 8px;
+  color: var(--lag-muted);
+  font: 10px/1 var(--lag-mono);
+  white-space: nowrap;
+}
+
+.lag-badge[data-tone="active"] {
+  border-color: color-mix(in srgb, var(--lag-accent) 50%, var(--lag-border));
+  color: var(--lag-accent);
+}
+
+.lag-badge[data-tone="success"],
+.lag-verified {
+  border-color: color-mix(in srgb, var(--lag-success) 45%, var(--lag-border));
+  color: var(--lag-success);
+}
+
+.lag-badge[data-tone="warning"] {
+  border-color: color-mix(in srgb, var(--lag-governor) 50%, var(--lag-border));
+  color: var(--lag-governor);
+}
+
+.lag-badge[data-tone="danger"] {
+  border-color: color-mix(in srgb, var(--lag-danger) 45%, var(--lag-border));
+  color: var(--lag-danger);
+}
+
+.lag-alert,
+.lag-embed-error {
+  margin: 0;
+  border: 1px solid color-mix(in srgb, var(--lag-governor) 45%, var(--lag-border));
+  border-radius: 10px;
+  background: color-mix(in srgb, var(--lag-governor) 8%, var(--lag-card));
+  padding: 8px 10px;
+  color: var(--lag-governor);
+  font-size: 12px;
+}
+
+.lag-embed-error {
+  margin-bottom: 10px;
+  border-color: color-mix(in srgb, var(--lag-danger) 45%, var(--lag-border));
+  color: var(--lag-danger);
+}
+
+.lag-flow {
+  width: 100%;
+  height: 390px;
+  min-height: 320px;
+  overflow: hidden;
+  border: 1px solid var(--lag-border);
+  border-radius: 14px;
+  background:
+    radial-gradient(
+      circle at 15% -10%,
+      color-mix(in srgb, var(--lag-accent) 10%, transparent),
+      transparent 42%
+    ),
+    var(--lag-background);
+}
+
+.lag-workspace {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr);
+  gap: 12px;
+  min-width: 0;
+}
+
+.lag-workspace[data-panel-open="true"] {
+  grid-template-columns: minmax(520px, 1fr) 360px;
+}
+
+.lag-canvas-stack {
+  display: grid;
+  min-width: 0;
+  gap: 8px;
+}
+
+.lag-loop-badge {
+  display: grid;
+  grid-template-columns: auto minmax(0, 1fr) auto;
+  align-items: center;
+  gap: 9px;
+  width: min(360px, 100%);
+  border: 1px solid var(--lag-border);
+  border-radius: 11px;
+  background: color-mix(in srgb, var(--lag-card) 94%, transparent);
+  padding: 8px 10px;
+  color: var(--lag-foreground);
+  font: 10px/1.25 var(--lag-mono);
+  text-align: left;
+  cursor: pointer;
+  box-shadow: 0 4px 14px color-mix(in srgb, #000 7%, transparent);
+}
+
+.lag-loop-badge:hover,
+.lag-loop-badge:focus-visible {
+  border-color: color-mix(in srgb, var(--lag-accent) 55%, var(--lag-border));
+}
+
+.lag-loop-badge[data-tone="active"] { color: var(--lag-accent); }
+.lag-loop-badge[data-tone="success"] { color: var(--lag-success); }
+.lag-loop-badge[data-tone="warning"] { color: var(--lag-governor); }
+.lag-loop-badge[data-tone="danger"] { color: var(--lag-danger); }
+
+.lag-loop-badge-icon {
+  font-size: 17px;
+}
+
+.lag-loop-badge-copy {
+  display: grid;
+  min-width: 0;
+}
+
+.lag-loop-badge-copy strong,
+.lag-loop-badge-copy small {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.lag-loop-badge-copy small {
+  margin-top: 2px;
+  color: var(--lag-muted);
+  font-family: var(--lag-font);
+}
+
+.lag-loop-badge-lap {
+  border: 1px solid currentColor;
+  border-radius: 999px;
+  padding: 3px 7px;
+  font-weight: 700;
+}
+
+.lag-flow[data-orientation="vertical"] {
+  height: 720px;
+}
+
+.lag-flow .react-flow__background {
+  color: color-mix(in srgb, var(--lag-muted) 32%, transparent);
+}
+
+.lag-flow .react-flow__controls {
+  overflow: hidden;
+  border: 1px solid var(--lag-border);
+  border-radius: 10px;
+  box-shadow: none;
+}
+
+.lag-flow .react-flow__controls-button {
+  border-bottom-color: var(--lag-border);
+  background: color-mix(in srgb, var(--lag-card) 94%, transparent);
+  color: var(--lag-foreground);
+}
+
+.lag-flow .react-flow__controls-button:hover {
+  background: var(--lag-card-muted);
+}
+
+.lag-flow .react-flow__controls-button svg {
+  fill: currentColor;
+}
+
+.lag-node {
+  position: relative;
+  display: grid;
+  width: 276px;
+  min-height: 154px;
+  overflow: visible;
+  border: 1px solid var(--lag-border);
+  border-radius: 14px;
+  background: color-mix(in srgb, var(--lag-card) 96%, transparent);
+  box-shadow: 0 10px 24px color-mix(in srgb, #000 7%, transparent);
+  font-family: var(--lag-mono);
+  transition:
+    border-color 140ms ease,
+    box-shadow 140ms ease,
+    opacity 140ms ease;
+}
+
+.lag-node[data-role="root"] {
+  border-color: color-mix(in srgb, var(--lag-governor) 48%, var(--lag-border));
+}
+
+.lag-node[data-role="implementer"],
+.lag-node[data-role="reviewer"] {
+  border-color: color-mix(in srgb, var(--lag-worker) 42%, var(--lag-border));
+}
+
+.lag-node[data-state="active"] {
+  box-shadow:
+    0 0 0 1px color-mix(in srgb, var(--lag-accent) 50%, transparent),
+    0 12px 32px color-mix(in srgb, var(--lag-accent) 14%, transparent);
+}
+
+.lag-node[data-state="terminal"] {
+  opacity: 0.72;
+}
+
+.lag-node[data-selected="true"] {
+  border-color: var(--lag-accent);
+  box-shadow:
+    0 0 0 2px color-mix(in srgb, var(--lag-accent) 32%, transparent),
+    0 12px 32px color-mix(in srgb, var(--lag-accent) 14%, transparent);
+}
+
+.lag-node-header {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 12px 12px 9px;
+}
+
+.lag-node-glyph {
+  display: grid;
+  width: 34px;
+  height: 34px;
+  place-items: center;
+  flex: 0 0 auto;
+  border: 1px solid color-mix(in srgb, currentColor 28%, var(--lag-border));
+  border-radius: 10px;
+  background: color-mix(in srgb, currentColor 8%, var(--lag-card));
+  color: var(--lag-worker);
+  font-size: 13px;
+  font-weight: 700;
+}
+
+.lag-node[data-role="root"] .lag-node-glyph {
+  color: var(--lag-governor);
+}
+
+.lag-node-heading {
+  display: grid;
+  min-width: 0;
+  flex: 1;
+}
+
+.lag-node-heading strong {
+  overflow: hidden;
+  color: var(--lag-foreground);
+  font-size: 12px;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.lag-node-heading small {
+  overflow: hidden;
+  margin-top: 2px;
+  color: var(--lag-muted);
+  font-size: 9px;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.lag-state-pill {
+  min-height: 20px;
+  padding: 2px 7px;
+  font-size: 9px;
+}
+
+.lag-node-body {
+  min-height: 60px;
+  padding: 0 12px 10px;
+}
+
+.lag-node-description {
+  margin: 0;
+  border: 1px solid var(--lag-border);
+  border-radius: 9px;
+  background: color-mix(in srgb, var(--lag-card-muted) 70%, transparent);
+  padding: 8px;
+  color: var(--lag-muted);
+  font: 10px/1.45 var(--lag-font);
+}
+
+.lag-verdict {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+  border: 1px solid var(--lag-border);
+  border-radius: 9px;
+  background: color-mix(in srgb, var(--lag-card-muted) 70%, transparent);
+  padding: 8px;
+  color: var(--lag-muted);
+  font-size: 10px;
+}
+
+.lag-verdict[data-verdict="issues"] {
+  border-color: color-mix(in srgb, var(--lag-governor) 40%, var(--lag-border));
+  color: var(--lag-governor);
+}
+
+.lag-verdict[data-verdict="clean"] {
+  border-color: color-mix(in srgb, var(--lag-success) 40%, var(--lag-border));
+  color: var(--lag-success);
+}
+
+.lag-node-footer {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+  border-top: 1px solid var(--lag-border);
+  padding: 7px 12px;
+  color: var(--lag-muted);
+  font-size: 8.5px;
+}
+
+.lag-node-footer span {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.lag-node-activity {
+  display: inline-flex;
+  gap: 4px;
+}
+
+.lag-report-summary {
+  overflow: hidden;
+  margin: 6px 0 0;
+  color: var(--lag-muted);
+  font: 10px/1.4 var(--lag-font);
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.lag-handle {
+  width: 8px !important;
+  height: 8px !important;
+  border: 2px solid var(--lag-card) !important;
+  background: var(--lag-accent) !important;
+  opacity: 0.86;
+}
+
+.lag-handle-upper:is(.react-flow__handle-left, .react-flow__handle-right) {
+  top: 38% !important;
+}
+
+.lag-handle-lower:is(.react-flow__handle-left, .react-flow__handle-right) {
+  top: 68% !important;
+}
+
+.lag-handle-source {
+  transform: translate(-50%, -50%) scale(0.86);
+}
+
+.lag-edge-path {
+  stroke: var(--lag-muted);
+  transition:
+    stroke 140ms ease,
+    opacity 140ms ease;
+}
+
+.lag-edge-path[data-kind="governs"] {
+  stroke: var(--lag-governor);
+}
+
+.lag-edge-path[data-kind="handoff"] {
+  stroke: var(--lag-success);
+}
+
+.lag-edge-path[data-kind="feedback"] {
+  stroke: var(--lag-governor);
+  stroke-dasharray: 7 5;
+}
+
+.lag-edge-path[data-kind="verdict"] {
+  stroke: var(--lag-worker);
+  stroke-dasharray: 3 4;
+}
+
+.lag-edge-path[data-active="false"] {
+  opacity: 0.58;
+}
+
+.lag-edge-path[data-pending="true"] {
+  animation: lag-edge-pulse 1.8s ease-in-out infinite;
+}
+
+.lag-edge-label[data-recent="true"] {
+  box-shadow:
+    0 0 0 1px color-mix(in srgb, var(--lag-accent) 26%, transparent),
+    0 4px 12px color-mix(in srgb, #000 7%, transparent);
+}
+
+@keyframes lag-edge-pulse {
+  50% { opacity: 0.45; }
+}
+
+.lag-edge-label {
+  position: absolute;
+  z-index: 20;
+  display: flex;
+  align-items: center;
+  gap: 5px;
+  border: 1px solid var(--lag-border);
+  border-radius: 999px;
+  background: color-mix(in srgb, var(--lag-card) 92%, transparent);
+  padding: 4px 7px;
+  color: var(--lag-muted);
+  font: 8.5px/1 var(--lag-mono);
+  box-shadow: 0 4px 12px color-mix(in srgb, #000 7%, transparent);
+  pointer-events: all;
+  white-space: nowrap;
+}
+
+.lag-edge-label[data-active="true"] {
+  border-color: color-mix(in srgb, var(--lag-accent) 50%, var(--lag-border));
+  color: var(--lag-accent);
+}
+
+.lag-edge-label[data-selected="true"] {
+  border-color: var(--lag-accent);
+  box-shadow:
+    0 0 0 2px color-mix(in srgb, var(--lag-accent) 25%, transparent),
+    0 4px 12px color-mix(in srgb, #000 7%, transparent);
+}
+
+.lag-edge-label:focus-visible,
+.lag-actions button:focus-visible,
+.lag-timeline summary:focus-visible {
+  outline: 2px solid var(--lag-accent);
+  outline-offset: 2px;
+}
+
+.lag-inspector {
+  display: grid;
+  grid-template-columns: minmax(220px, 1fr) auto;
+  align-items: center;
+  gap: 12px 18px;
+  border: 1px solid var(--lag-border);
+  border-radius: 12px;
+  background: color-mix(in srgb, var(--lag-card) 92%, transparent);
+  padding: 11px 12px;
+}
+
+.lag-inspector-copy p:last-child {
+  margin: 4px 0 0;
+  color: var(--lag-muted);
+  font: 10px/1.4 var(--lag-mono);
+}
+
+.lag-actions {
+  display: flex;
+  align-items: center;
+  justify-content: flex-end;
+  gap: 7px;
+  flex-wrap: wrap;
+}
+
+.lag-actions button,
+.lag-demo-toolbar select {
+  min-height: 31px;
+  border: 1px solid var(--lag-border);
+  border-radius: 9px;
+  background: var(--lag-card);
+  padding: 5px 9px;
+  color: var(--lag-foreground);
+  font: 10px/1 var(--lag-font);
+  cursor: pointer;
+}
+
+.lag-actions button:disabled {
+  cursor: not-allowed;
+  opacity: 0.45;
+}
+
+.lag-follow-up-status {
+  grid-column: 1 / -1;
+  margin: 0;
+  color: var(--lag-muted);
+  font-size: 10px;
+}
+
+.lag-relationship-inspector,
+.lag-loop-panel {
+  min-width: 0;
+  overflow: hidden;
+  border: 1px solid var(--lag-border);
+  border-radius: 13px;
+  background: color-mix(in srgb, var(--lag-background) 96%, transparent);
+  color: var(--lag-foreground);
+  box-shadow: 0 12px 30px color-mix(in srgb, #000 10%, transparent);
+}
+
+.lag-relationship-inspector > header,
+.lag-loop-panel > header {
+  display: grid;
+  grid-template-columns: auto minmax(0, 1fr) auto;
+  align-items: center;
+  gap: 9px;
+  min-height: 52px;
+  border-bottom: 1px solid var(--lag-border);
+  padding: 8px 10px;
+}
+
+.lag-relationship-inspector h3,
+.lag-loop-panel h3,
+.lag-loop-panel p {
+  margin: 0;
+}
+
+.lag-loop-panel > header p {
+  margin-top: 2px;
+  color: var(--lag-muted);
+  font: 9px/1.2 var(--lag-mono);
+}
+
+.lag-panel-icon {
+  display: grid;
+  width: 28px;
+  height: 28px;
+  place-items: center;
+  border: 1px solid color-mix(in srgb, var(--lag-accent) 35%, var(--lag-border));
+  border-radius: 9px;
+  color: var(--lag-accent);
+}
+
+.lag-panel-icon[data-active="true"] {
+  animation: lag-spin 3s linear infinite;
+}
+
+@keyframes lag-spin { to { transform: rotate(360deg); } }
+
+.lag-icon-button {
+  display: grid;
+  width: 28px;
+  height: 28px;
+  place-items: center;
+  border: 0;
+  border-radius: 8px;
+  background: transparent;
+  color: var(--lag-muted);
+  font-size: 18px;
+  cursor: pointer;
+}
+
+.lag-icon-button:hover { background: var(--lag-card-muted); }
+
+.lag-relationship-grid {
+  display: grid;
+  grid-template-columns: 88px minmax(0, 1fr);
+  gap: 7px 10px;
+  margin: 10px;
+  border: 1px solid var(--lag-border);
+  border-radius: 10px;
+  background: var(--lag-card);
+  padding: 10px;
+  font-size: 10px;
+}
+
+.lag-relationship-grid dt { color: var(--lag-muted); }
+.lag-relationship-grid dd { margin: 0; overflow-wrap: anywhere; }
+
+.lag-panel-note {
+  margin: 0 10px 10px;
+  border: 1px solid var(--lag-border);
+  border-radius: 9px;
+  background: var(--lag-card-muted);
+  padding: 9px;
+  color: var(--lag-muted);
+  font-size: 10px;
+}
+
+.lag-danger-button {
+  width: calc(100% - 20px);
+  margin: 0 10px 10px;
+  border: 1px solid color-mix(in srgb, var(--lag-danger) 45%, var(--lag-border));
+  border-radius: 9px;
+  background: color-mix(in srgb, var(--lag-danger) 8%, var(--lag-card));
+  padding: 8px;
+  color: var(--lag-danger);
+  font-size: 10px;
+  cursor: pointer;
+}
+
+.lag-danger-button:disabled { cursor: not-allowed; opacity: 0.45; }
+
+.lag-loop-panel-body {
+  display: grid;
+  max-height: 640px;
+  gap: 10px;
+  overflow-y: auto;
+  padding: 10px;
+}
+
+.lag-stop-confirm,
+.lag-loop-summary,
+.lag-blocking-issues,
+.lag-lap-card,
+.lag-diagnostics {
+  border: 1px solid var(--lag-border);
+  border-radius: 10px;
+  background: var(--lag-card);
+  padding: 10px;
+}
+
+.lag-stop-confirm {
+  border-color: color-mix(in srgb, var(--lag-governor) 45%, var(--lag-border));
+  background: color-mix(in srgb, var(--lag-governor) 8%, var(--lag-card));
+  color: var(--lag-governor);
+  font-size: 10px;
+}
+
+.lag-stop-confirm p { margin-top: 5px; color: var(--lag-foreground); }
+.lag-stop-confirm > div { display: flex; justify-content: flex-end; gap: 6px; margin-top: 8px; }
+
+.lag-stop-confirm button,
+.lag-loop-summary button {
+  border: 1px solid var(--lag-border);
+  border-radius: 8px;
+  background: var(--lag-card);
+  padding: 6px 8px;
+  color: var(--lag-foreground);
+  font-size: 9px;
+  cursor: pointer;
+}
+
+.lag-loop-summary h4,
+.lag-blocking-issues h4 {
+  margin: 0;
+  font-size: 11px;
+}
+
+.lag-loop-summary > p {
+  margin-top: 5px;
+  color: var(--lag-muted);
+  font-size: 10px;
+}
+
+.lag-loop-summary dl {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 7px;
+  margin: 9px 0;
+  border-top: 1px solid var(--lag-border);
+  padding-top: 8px;
+}
+
+.lag-loop-summary dl div { min-width: 0; }
+.lag-loop-summary dt { color: var(--lag-muted); font-size: 8px; }
+.lag-loop-summary dd { overflow-wrap: anywhere; margin: 2px 0 0; font: 9px/1.3 var(--lag-mono); }
+.lag-loop-summary > small { display: block; margin-top: 8px; color: var(--lag-muted); }
+
+.lag-issue-list,
+.lag-lap-list {
+  display: grid;
+  gap: 7px;
+  margin: 7px 0 0;
+  padding: 0;
+  list-style: none;
+}
+
+.lag-issue-list li { display: grid; gap: 2px; font-size: 9px; }
+.lag-issue-list strong { color: var(--lag-danger); text-transform: uppercase; }
+.lag-issue-list small { color: var(--lag-muted); font-family: var(--lag-mono); }
+
+.lag-lap-card > header { display: flex; justify-content: space-between; gap: 8px; }
+.lag-lap-card p { display: grid; gap: 2px; margin-top: 7px; color: var(--lag-muted); font-size: 9px; }
+.lag-lap-card p b { color: var(--lag-foreground); }
+.lag-lap-card time { display: block; margin-top: 7px; color: var(--lag-muted); font: 8px/1 var(--lag-mono); }
+
+.lag-diagnostics { color: var(--lag-muted); font: 8px/1.45 var(--lag-mono); overflow-wrap: anywhere; }
+.lag-diagnostics summary { color: var(--lag-foreground); cursor: pointer; }
+
+.lag-timeline {
+  border: 1px solid var(--lag-border);
+  border-radius: 12px;
+  background: color-mix(in srgb, var(--lag-card) 90%, transparent);
+}
+
+.lag-timeline summary {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 10px 12px;
+  color: var(--lag-foreground);
+  font: 11px/1 var(--lag-mono);
+  cursor: pointer;
+}
+
+.lag-timeline ol {
+  display: grid;
+  gap: 6px;
+  margin: 0;
+  padding: 0 12px 12px 32px;
+}
+
+.lag-timeline li {
+  color: var(--lag-muted);
+  font-size: 10px;
+}
+
+.lag-timeline li time {
+  margin-right: 8px;
+  font-family: var(--lag-mono);
+}
+
+.lag-timeline li small {
+  margin-left: 6px;
+  color: var(--lag-worker);
+}
+
+@media (max-width: 719px) {
+  .lag-workspace[data-panel-open="true"] {
+    grid-template-columns: 1fr;
+  }
+
+  .lag-inspector {
+    grid-template-columns: 1fr;
+  }
+
+  .lag-actions {
+    justify-content: flex-start;
+  }
+}
+
+@media (prefers-color-scheme: dark) {
+  .looperators-agent-graph {
+    --lag-background: var(--background, #07090a);
+    --lag-card: var(--card, #0d120e);
+    --lag-card-muted: var(--muted, #0f1511);
+    --lag-foreground: var(--foreground, #e5e7eb);
+    --lag-muted: var(--muted-foreground, #9ca3af);
+    --lag-border: var(--border, rgba(255, 255, 255, 0.11));
+    --lag-accent: var(--term-accent-hi, #a3e635);
+    --lag-governor: var(--term-amber, #fcd34d);
+    --lag-worker: var(--term-cyan, #67e8f9);
+    --lag-success: var(--term-emerald, #6ee7b7);
+    --lag-danger: var(--term-rose, #fb7185);
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .looperators-agent-graph *,
+  .looperators-agent-graph *::before,
+  .looperators-agent-graph *::after {
+    scroll-behavior: auto !important;
+    transition-duration: 0.01ms !important;
+    animation-duration: 0.01ms !important;
+    animation-iteration-count: 1 !important;
+  }
+}
diff --git a/packages/agent-graph-ui/tests/embed.test.mjs b/packages/agent-graph-ui/tests/embed.test.mjs
new file mode 100644
index 0000000..69fe8f2
--- /dev/null
+++ b/packages/agent-graph-ui/tests/embed.test.mjs
@@ -0,0 +1,58 @@
+import assert from 'node:assert/strict';
+import { readFile, stat } from 'node:fs/promises';
+import test from 'node:test';
+
+const embedScript = new URL(
+  '../dist/embed/agent-graph-ui.iife.js',
+  import.meta.url,
+);
+const embedStyle = new URL('../dist/embed/agent-graph-ui.css', import.meta.url);
+const libraryScript = new URL(
+  '../dist/library/agent-graph-ui.js',
+  import.meta.url,
+);
+const inlineScript = new URL(
+  '../dist/inline/agent-graph-ui-inline.js',
+  import.meta.url,
+);
+const inlineStyle = new URL(
+  '../dist/inline/agent-graph-ui-inline.css',
+  import.meta.url,
+);
+
+test('plugin-target assets leave at least 512 KiB of inline fragment headroom', async () => {
+  const [scriptStat, styleStat] = await Promise.all([
+    stat(embedScript),
+    stat(embedStyle),
+  ]);
+  const total = scriptStat.size + styleStat.size;
+  assert.ok(total < 1.5 * 1024 * 1024, `embed assets are ${total} bytes`);
+});
+
+test('shipped assets contain no remote or plugin runtime dependency', async () => {
+  const [script, style, library, inline, inlineCss] = await Promise.all([
+    readFile(embedScript, 'utf8'),
+    readFile(embedStyle, 'utf8'),
+    readFile(libraryScript, 'utf8'),
+    readFile(inlineScript, 'utf8'),
+    readFile(inlineStyle, 'utf8'),
+  ]);
+  for (const source of [script, style]) {
+    // Bundled React and SVG metadata contain inert namespace, help, and
+    // attribution URLs. Network isolation is asserted in the browser
+    // acceptance; this static guard rejects executable network primitives.
+    assert.doesNotMatch(source, /\b(?:window|globalThis)\.fetch\s*\(/u);
+    assert.doesNotMatch(source, /\bXMLHttpRequest\b/u);
+    assert.doesNotMatch(source, /\bWebSocket\b/u);
+    assert.doesNotMatch(source, /\bEventSource\b/u);
+  }
+  assert.doesNotMatch(library, /electron|sessionManager|workflowKernel/u);
+  assert.doesNotMatch(library, /from\s*["']@\//u);
+  assert.match(script, /looperatorsAgentGraphView/u);
+  assert.match(inline, /mountInlineAgentLoopGraph/u);
+  assert.match(inline, /Agent Loop relationship graph/u);
+  assert.match(inlineCss, /looperators-inline-agent-graph/u);
+  assert.doesNotMatch(inline, /\bResizeObserver\b/u);
+  assert.doesNotMatch(inline, /\bcreateRoot\b/u);
+  assert.doesNotMatch(inline, /react-flow__node/u);
+});
diff --git a/packages/agent-graph-ui/tests/model.test.mjs b/packages/agent-graph-ui/tests/model.test.mjs
new file mode 100644
index 0000000..179bbdb
--- /dev/null
+++ b/packages/agent-graph-ui/tests/model.test.mjs
@@ -0,0 +1,78 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  agentGraphScenarios,
+  assertAgentGraphModel,
+  createAgentLoopFlowElements,
+  desktopParityModel,
+  orientationForWidth,
+} from '../dist/library/agent-graph-ui.js';
+
+test('all paired fixtures contain an independently valid portable model', () => {
+  assert.equal(agentGraphScenarios.length, 7);
+  for (const fixture of agentGraphScenarios) {
+    assert.equal(
+      assertAgentGraphModel(fixture.expectedModel),
+      fixture.expectedModel,
+    );
+    assert.equal(
+      fixture.projection.projectionDigest,
+      fixture.expectedModel.identity.projectionDigest,
+    );
+    assert.equal(fixture.projection.integrity.status, 'verified');
+  }
+});
+
+test('Desktop parity model exercises the rich shared interaction surface', () => {
+  assert.equal(assertAgentGraphModel(desktopParityModel), desktopParityModel);
+  assert.equal(desktopParityModel.nodes.every((node) => node.description), true);
+  assert.equal(desktopParityModel.edges.some((edge) => edge.pending), true);
+  assert.equal(desktopParityModel.latestReport.issues.length, 2);
+  assert.equal(desktopParityModel.laps.length, 2);
+});
+
+test('wide and narrow layouts keep three stable nodes and four relationships', () => {
+  const model = agentGraphScenarios.find(
+    (fixture) => fixture.name === 'reviewer-issues',
+  ).expectedModel;
+  for (const orientation of ['horizontal', 'vertical']) {
+    const flow = createAgentLoopFlowElements(model, orientation);
+    assert.deepEqual(
+      flow.nodes.map((node) => node.id),
+      ['root', 'role:implementer', 'role:reviewer'],
+    );
+    assert.deepEqual(
+      flow.edges.map((edge) => edge.data.edge.kind),
+      ['governs', 'handoff', 'feedback', 'verdict'],
+    );
+    assert.equal(
+      flow.edges.filter((edge) => edge.animated).map((edge) => edge.id)[0],
+      'reviewer-feedback-implementer',
+    );
+  }
+  assert.equal(orientationForWidth(719), 'vertical');
+  assert.equal(orientationForWidth(720), 'horizontal');
+});
+
+test('model validation rejects unverified, invalid, and unknown-node input', () => {
+  const model = structuredClone(agentGraphScenarios[0].expectedModel);
+  assert.throws(
+    () =>
+      assertAgentGraphModel({
+        ...model,
+        identity: { ...model.identity, integrity: 'unknown' },
+      }),
+    /verified/,
+  );
+  assert.throws(
+    () =>
+      assertAgentGraphModel({
+        ...model,
+        identity: { ...model.identity, projectionDigest: 'short' },
+      }),
+    /bounded string/,
+  );
+  const edges = structuredClone(model.edges);
+  edges[0].target = 'missing';
+  assert.throws(() => assertAgentGraphModel({ ...model, edges }), /unknown node/);
+});
diff --git a/packages/agent-graph-ui/tsconfig.build.json b/packages/agent-graph-ui/tsconfig.build.json
new file mode 100644
index 0000000..03a199c
--- /dev/null
+++ b/packages/agent-graph-ui/tsconfig.build.json
@@ -0,0 +1,22 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": false,
+    "emitDeclarationOnly": true,
+    "declaration": true,
+    "declarationMap": false,
+    "rootDir": "./src",
+    "outDir": "./dist/types"
+  },
+  "include": [
+    "src/index.ts",
+    "src/graph-model.ts",
+    "src/fixtures.ts",
+    "src/agent-node.tsx",
+    "src/relationship-edge.tsx",
+    "src/loop-status.tsx",
+    "src/agent-loop-graph.tsx",
+    "src/inline.ts",
+    "src/inline-agent-loop-graph.ts"
+  ]
+}
diff --git a/packages/agent-graph-ui/tsconfig.json b/packages/agent-graph-ui/tsconfig.json
new file mode 100644
index 0000000..dc70fdb
--- /dev/null
+++ b/packages/agent-graph-ui/tsconfig.json
@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    "target": "ES2023",
+    "lib": [
+      "ES2023",
+      "DOM",
+      "DOM.Iterable"
+    ],
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "jsx": "react-jsx",
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "types": [
+      "vite/client"
+    ]
+  },
+  "include": [
+    "src",
+    "vite.config.ts",
+    "vite.library.config.ts",
+    "vite.embed.config.ts",
+    "vite.inline.config.ts"
+  ]
+}
diff --git a/packages/agent-graph-ui/vite.config.ts b/packages/agent-graph-ui/vite.config.ts
new file mode 100644
index 0000000..c38592b
--- /dev/null
+++ b/packages/agent-graph-ui/vite.config.ts
@@ -0,0 +1,11 @@
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+
+export default defineConfig({
+  plugins: [react()],
+  server: {
+    host: '127.0.0.1',
+    port: 48311,
+    strictPort: true,
+  },
+});
diff --git a/packages/agent-graph-ui/vite.embed.config.ts b/packages/agent-graph-ui/vite.embed.config.ts
new file mode 100644
index 0000000..39166bf
--- /dev/null
+++ b/packages/agent-graph-ui/vite.embed.config.ts
@@ -0,0 +1,26 @@
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+import { resolve } from 'node:path';
+
+export default defineConfig({
+  plugins: [react()],
+  define: {
+    'process.env.NODE_ENV': JSON.stringify('production'),
+  },
+  build: {
+    outDir: 'dist/embed',
+    emptyOutDir: false,
+    cssCodeSplit: false,
+    assetsInlineLimit: Number.MAX_SAFE_INTEGER,
+    target: 'es2022',
+    minify: 'oxc',
+    sourcemap: false,
+    lib: {
+      entry: resolve(import.meta.dirname, 'src/embed.tsx'),
+      name: 'LooperatorsAgentGraphUI',
+      formats: ['iife'],
+      fileName: () => 'agent-graph-ui.iife.js',
+      cssFileName: 'agent-graph-ui',
+    },
+  },
+});
diff --git a/packages/agent-graph-ui/vite.inline.config.ts b/packages/agent-graph-ui/vite.inline.config.ts
new file mode 100644
index 0000000..5914bb7
--- /dev/null
+++ b/packages/agent-graph-ui/vite.inline.config.ts
@@ -0,0 +1,19 @@
+import { defineConfig } from 'vite';
+import { resolve } from 'node:path';
+
+export default defineConfig({
+  build: {
+    outDir: 'dist/inline',
+    emptyOutDir: false,
+    cssCodeSplit: false,
+    target: 'es2022',
+    minify: 'oxc',
+    sourcemap: false,
+    lib: {
+      entry: resolve(import.meta.dirname, 'src/inline.ts'),
+      formats: ['es'],
+      fileName: () => 'agent-graph-ui-inline.js',
+      cssFileName: 'agent-graph-ui-inline',
+    },
+  },
+});
diff --git a/packages/agent-graph-ui/vite.library.config.ts b/packages/agent-graph-ui/vite.library.config.ts
new file mode 100644
index 0000000..c634b35
--- /dev/null
+++ b/packages/agent-graph-ui/vite.library.config.ts
@@ -0,0 +1,21 @@
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+import { resolve } from 'node:path';
+
+export default defineConfig({
+  plugins: [react()],
+  build: {
+    outDir: 'dist/library',
+    emptyOutDir: false,
+    cssCodeSplit: false,
+    lib: {
+      entry: resolve(import.meta.dirname, 'src/index.ts'),
+      formats: ['es'],
+      fileName: () => 'agent-graph-ui.js',
+      cssFileName: 'agent-graph-ui',
+    },
+    rollupOptions: {
+      external: ['react', 'react-dom', 'react/jsx-runtime', '@xyflow/react'],
+    },
+  },
+});
diff --git a/plugins/looperators-agent-loop-p0/.codex-plugin/plugin.json b/plugins/looperators-agent-loop-p0/.codex-plugin/plugin.json
new file mode 100644
index 0000000..e3574f1
--- /dev/null
+++ b/plugins/looperators-agent-loop-p0/.codex-plugin/plugin.json
@@ -0,0 +1,23 @@
+{
+  "name": "looperators-agent-loop-p0",
+  "version": "0.1.0+codex.20260726175228",
+  "description": "P0 compatibility probe for looperators Agent Loop hooks, inline views, and MCP Apps.",
+  "author": {
+    "name": "looperators"
+  },
+  "skills": "./skills/",
+  "interface": {
+    "displayName": "Looperators Agent Loop P0",
+    "shortDescription": "Probe and visualize a local Agent Loop.",
+    "longDescription": "A deliberately small compatibility experiment for collecting Codex hook events, rendering a thread-scoped inline graph, and exposing the same graph through an MCP App.",
+    "developerName": "looperators",
+    "category": "Productivity",
+    "capabilities": [
+      "Agent Loop hook collection",
+      "Thread-scoped inline visualization",
+      "MCP App graph resource"
+    ],
+    "defaultPrompt": "Use $agent-loop-visualization to normalize the local P0 hook log and render the looperators Agent Loop graph."
+  },
+  "mcpServers": "./.mcp.json"
+}
diff --git a/plugins/looperators-agent-loop-p0/.mcp.json b/plugins/looperators-agent-loop-p0/.mcp.json
new file mode 100644
index 0000000..504a3db
--- /dev/null
+++ b/plugins/looperators-agent-loop-p0/.mcp.json
@@ -0,0 +1,14 @@
+{
+  "mcpServers": {
+    "looperators-agent-loop-p0": {
+      "command": "node",
+      "args": [
+        "./mcp/server.mjs"
+      ],
+      "cwd": ".",
+      "env_vars": [
+        "LOOPERATORS_P0_ARTIFACT_DIR"
+      ]
+    }
+  }
+}
diff --git a/plugins/looperators-agent-loop-p0/README.md b/plugins/looperators-agent-loop-p0/README.md
new file mode 100644
index 0000000..43a0789
--- /dev/null
+++ b/plugins/looperators-agent-loop-p0/README.md
@@ -0,0 +1,21 @@
+# looperators Agent Loop P0 plugin
+
+This is a compatibility probe, not a production orchestration runtime. It keeps
+four boundaries intentionally small:
+
+- Codex hook inputs are collected as one atomic file per delivery.
+- `scripts/normalize-events.mjs` derives a deterministic event stream and graph.
+- `scripts/generate-inline-visualization.mjs` projects the real root and
+  subagents into an interactive, thread-scoped native HTML fragment.
+- `mcp/server.mjs` exposes that graph as both structured tool output and an
+  MCP App resource.
+- `scripts/sidecar-server.mjs` is a token-protected, loopback-only SSE fallback.
+
+No looperators Desktop runtime, provider adapter, workflow kernel, or transcript
+tailing is included.
+
+## Local checks
+
+```sh
+node --test plugins/looperators-agent-loop-p0/tests/*.test.mjs
+```
diff --git a/plugins/looperators-agent-loop-p0/hooks/collect-event.mjs b/plugins/looperators-agent-loop-p0/hooks/collect-event.mjs
new file mode 100644
index 0000000..b82c819
--- /dev/null
+++ b/plugins/looperators-agent-loop-p0/hooks/collect-event.mjs
@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+
+import path from "node:path";
+import process from "node:process";
+import {
+  atomicWriteJson,
+  deliveryEventKey,
+  redactHookInput,
+  semanticEventKey,
+  sha256,
+  stableJson,
+} from "../lib/event-utils.mjs";
+
+function argument(name, fallback) {
+  const index = process.argv.indexOf(`--${name}`);
+  return index >= 0 ? process.argv[index + 1] : fallback;
+}
+
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+function continuationOutput(input, stateCreated) {
+  if (!["Stop", "SubagentStop"].includes(input.hook_event_name)) {
+    return null;
+  }
+  if (process.env.LOOPERATORS_P0_CONTINUATION_MODE !== "lap") {
+    return null;
+  }
+  if (input.stop_hook_active === true || !stateCreated) {
+    return { continue: true };
+  }
+  const scope =
+    input.hook_event_name === "SubagentStop"
+      ? `subagent ${input.agent_id ?? "unknown"}`
+      : "root agent";
+  return {
+    decision: "block",
+    reason:
+      `looperators P0 continuation lap 1/1 for ${scope}. ` +
+      "Acknowledge the continuation with the exact marker P0_LAP_CONTINUED, " +
+      "do not call tools, and then stop. The next Stop hook invocation must be allowed.",
+  };
+}
+
+async function main() {
+  const startedWall = new Date().toISOString();
+  const startedMonotonicNs = process.hrtime.bigint();
+  const lane = argument("lane", "primary");
+  const delayMs = Number(argument("delay-ms", "0"));
+  const artifactDir =
+    process.env.LOOPERATORS_P0_ARTIFACT_DIR ??
+    path.join(process.cwd(), "output", "looperators-agent-loop-p0");
+  const rawText = await readStdin();
+  let input;
+  try {
+    input = JSON.parse(rawText);
+  } catch {
+    input = {
+      hook_event_name: "ParseError",
+      malformed_input: {
+        sha256: sha256(rawText),
+        bytes: Buffer.byteLength(rawText),
+      },
+    };
+  }
+
+  const redactedInput = redactHookInput(input);
+  const semanticKey = semanticEventKey(input);
+  const deliveryKey = deliveryEventKey(input, lane);
+  const identityHash = sha256(
+    stableJson({
+      deliveryKey,
+      redactedInput,
+    }),
+  );
+  const stateKey = sha256(
+    stableJson({
+      session_id: input.session_id ?? null,
+      turn_id: input.turn_id ?? null,
+      event: input.hook_event_name ?? null,
+      agent_id: input.agent_id ?? null,
+    }),
+  );
+  const statePath = path.join(artifactDir, "hook-state", `${stateKey}.json`);
+  let stateCreated = false;
+  if (
+    lane === "primary" &&
+    process.env.LOOPERATORS_P0_CONTINUATION_MODE === "lap" &&
+    ["Stop", "SubagentStop"].includes(input.hook_event_name) &&
+    input.stop_hook_active !== true
+  ) {
+    try {
+      await atomicWriteJson(
+        statePath,
+        {
+          semantic_key: semanticKey,
+          first_blocked_at: startedWall,
+          lap_cap: 1,
+        },
+        { exclusive: true },
+      );
+      stateCreated = true;
+    } catch (error) {
+      if (error?.code !== "EEXIST") {
+        throw error;
+      }
+    }
+  }
+
+  if (Number.isFinite(delayMs) && delayMs > 0 && delayMs <= 500) {
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+  }
+
+  const finishedMonotonicNs = process.hrtime.bigint();
+  const record = {
+    schema_version: 1,
+    semantic_key: semanticKey,
+    delivery_key: deliveryKey,
+    identity_hash: identityHash,
+    lane,
+    process_id: process.pid,
+    captured_at: startedWall,
+    started_monotonic_ns: startedMonotonicNs.toString(),
+    finished_monotonic_ns: finishedMonotonicNs.toString(),
+    duration_ms: Number(finishedMonotonicNs - startedMonotonicNs) / 1e6,
+    input: redactedInput,
+  };
+  const eventPath = path.join(
+    artifactDir,
+    "hook-events",
+    `${identityHash}.json`,
+  );
+  try {
+    await atomicWriteJson(eventPath, record, { exclusive: true });
+  } catch (error) {
+    if (error?.code !== "EEXIST") {
+      throw error;
+    }
+  }
+
+  const output = lane === "primary" ? continuationOutput(input, stateCreated) : null;
+  if (output) {
+    process.stdout.write(JSON.stringify(output));
+  }
+}
+
+main().catch(async (error) => {
+  const fallback = {
+    continue: true,
+    systemMessage: `looperators P0 collector failed safely: ${error?.code ?? "error"}`,
+  };
+  process.stdout.write(JSON.stringify(fallback));
+  process.exitCode = 0;
+});
diff --git a/plugins/looperators-agent-loop-p0/hooks/hooks.json b/plugins/looperators-agent-loop-p0/hooks/hooks.json
new file mode 100644
index 0000000..dc43536
--- /dev/null
+++ b/plugins/looperators-agent-loop-p0/hooks/hooks.json
@@ -0,0 +1,90 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${PLUGIN_ROOT}/hooks/collect-event.mjs\" --lane primary",
+            "timeout": 5,
+            "statusMessage": "Recording looperators session start"
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${PLUGIN_ROOT}/hooks/collect-event.mjs\" --lane primary",
+            "timeout": 5,
+            "statusMessage": "Recording looperators prompt boundary"
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${PLUGIN_ROOT}/hooks/collect-event.mjs\" --lane primary",
+            "timeout": 5,
+            "statusMessage": "Recording looperators tool start"
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${PLUGIN_ROOT}/hooks/collect-event.mjs\" --lane primary",
+            "timeout": 5,
+            "statusMessage": "Recording looperators tool result"
+          }
+        ]
+      }
+    ],
+    "SubagentStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${PLUGIN_ROOT}/hooks/collect-event.mjs\" --lane primary",
+            "timeout": 5,
+            "statusMessage": "Recording looperators subagent start"
+          }
+        ]
+      }
+    ],
+    "SubagentStop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${PLUGIN_ROOT}/hooks/collect-event.mjs\" --lane primary",
+            "timeout": 5,
+            "statusMessage": "Applying looperators subagent lap policy"
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${PLUGIN_ROOT}/hooks/collect-event.mjs\" --lane primary",
+            "timeout": 5,
+            "statusMessage": "Applying looperators root lap policy"
+          }
+        ]
+      }
+    ]
+  }
+}
diff --git a/plugins/looperators-agent-loop-p0/lib/event-utils.mjs b/plugins/looperators-agent-loop-p0/lib/event-utils.mjs
new file mode 100644
index 0000000..968f8c2
--- /dev/null
+++ b/plugins/looperators-agent-loop-p0/lib/event-utils.mjs
@@ -0,0 +1,127 @@
+import { createHash, timingSafeEqual } from "node:crypto";
+import {
+  link,
+  mkdir,
+  readFile,
+  rename,
+  unlink,
+  writeFile,
+} from "node:fs/promises";
+import path from "node:path";
+
+export const P0_EVENTS = [
+  "SessionStart",
+  "UserPromptSubmit",
+  "PreToolUse",
+  "PostToolUse",
+  "SubagentStart",
+  "SubagentStop",
+  "Stop",
+];
+
+export function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+
+export function stableJson(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map(stableJson).join(",")}]`;
+  }
+  if (value && typeof value === "object") {
+    return `{${Object.keys(value)
+      .sort()
+      .map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`)
+      .join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+
+function sensitiveSummary(value, label) {
+  const serialized = typeof value === "string" ? value : stableJson(value);
+  return {
+    _redacted: label,
+    sha256: sha256(serialized),
+    bytes: Buffer.byteLength(serialized),
+    ...(value && typeof value === "object" && !Array.isArray(value)
+      ? { keys: Object.keys(value).sort() }
+      : {}),
+  };
+}
+
+export function redactHookInput(input) {
+  const sensitiveKeys = new Set([
+    "prompt",
+    "last_assistant_message",
+    "tool_input",
+    "tool_response",
+  ]);
+  const walk = (value, key = "") => {
+    if (sensitiveKeys.has(key)) {
+      return sensitiveSummary(value, key);
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => walk(item));
+    }
+    if (value && typeof value === "object") {
+      return Object.fromEntries(
+        Object.entries(value).map(([childKey, childValue]) => [
+          childKey,
+          walk(childValue, childKey),
+        ]),
+      );
+    }
+    return value;
+  };
+  return walk(input);
+}
+
+export function semanticEventKey(input) {
+  return [
+    input.session_id ?? "-",
+    input.turn_id ?? "-",
+    input.hook_event_name ?? "-",
+    input.tool_use_id ?? input.agent_id ?? "-",
+    input.stop_hook_active === true ? "continuation" : "initial",
+  ].join(":");
+}
+
+export function deliveryEventKey(input, lane) {
+  return `${semanticEventKey(input)}:${lane}`;
+}
+
+export async function atomicWriteJson(filePath, value, options = {}) {
+  await mkdir(path.dirname(filePath), { recursive: true, mode: 0o700 });
+  const body = `${JSON.stringify(value, null, 2)}\n`;
+  const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  if (options.exclusive) {
+    await writeFile(temporaryPath, body, { flag: "wx", mode: 0o600 });
+    try {
+      await link(temporaryPath, filePath);
+    } finally {
+      await unlink(temporaryPath).catch(() => {});
+    }
+    return;
+  }
+  await writeFile(temporaryPath, body, { mode: 0o600 });
+  await rename(temporaryPath, filePath);
+}
+
+export async function readJsonIfPresent(filePath) {
+  try {
+    return JSON.parse(await readFile(filePath, "utf8"));
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+
+export function safeTokenEqual(actual, expected) {
+  const actualBuffer = Buffer.from(actual ?? "");
+  const expectedBuffer = Buffer.from(expected ?? "");
+  return (
+    actualBuffer.length === expectedBuffer.length &&
+    timingSafeEqual(actualBuffer, expectedBuffer)
+  );
+}
diff --git a/plugins/looperators-agent-loop-p0/mcp/server.mjs b/plugins/looperators-agent-loop-p0/mcp/server.mjs
new file mode 100644
index 0000000..870fdc8
--- /dev/null
+++ b/plugins/looperators-agent-loop-p0/mcp/server.mjs
@@ -0,0 +1,304 @@
+#!/usr/bin/env node
+
+import { createInterface } from "node:readline";
+import path from "node:path";
+import process from "node:process";
+import { atomicWriteJson, sha256, stableJson } from "../lib/event-utils.mjs";
+
+const RESOURCE_URI = "ui://looperators/agent-loop-p0.html";
+const MIME_TYPE = "text/html;profile=mcp-app";
+const artifactDir = process.env.LOOPERATORS_P0_ARTIFACT_DIR;
+let protocolSequence = 0;
+
+const widgetHtml = String.raw`<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width,initial-scale=1" />
+    <title>looperators Agent Loop MCP App</title>
+    <style>
+      :root { color-scheme: light dark; font-family: ui-sans-serif, system-ui, sans-serif; }
+      body { margin: 0; padding: 16px; background: #0b1020; color: #edf1ff; }
+      .top { display: flex; justify-content: space-between; align-items: center; gap: 12px; }
+      h1 { margin: 0; font-size: 18px; }
+      .badge { border: 1px solid #5671bd; border-radius: 999px; padding: 3px 8px; color: #adc0ff; font: 11px ui-monospace, monospace; }
+      #graph { display: flex; gap: 10px; align-items: stretch; margin: 16px 0; }
+      .node { flex: 1; border: 1px solid #4e64a4; border-radius: 10px; padding: 10px; background: #121a33; }
+      .node small { display: block; margin-top: 4px; color: #9faedd; }
+      button { border: 1px solid #7192ee; border-radius: 8px; padding: 7px 10px; background: #26478f; color: white; cursor: pointer; }
+      #status { margin-left: 8px; color: #aab8e5; font: 12px ui-monospace, monospace; }
+    </style>
+  </head>
+  <body>
+    <div class="top"><h1>looperators Agent Loop</h1><span class="badge">MCP App P0</span></div>
+    <div id="graph"><div class="node">Root<small>waiting for structuredContent</small></div></div>
+    <button id="ping">Call component tool</button><span id="status">initializing…</span>
+    <script type="module">
+      const status = document.querySelector("#status");
+      const graph = document.querySelector("#graph");
+      let nextId = 1;
+      const pending = new Map();
+      function send(method, params) {
+        const id = nextId++;
+        parent.postMessage({ jsonrpc: "2.0", id, method, params }, "*");
+        return new Promise((resolve, reject) => pending.set(id, { resolve, reject }));
+      }
+      function render(data) {
+        const nodes = data?.graph?.nodes ?? data?.nodes ?? [];
+        graph.innerHTML = nodes.length
+          ? nodes.map((node) => '<div class="node">' + String(node.label ?? node.id) +
+              '<small>' + String(node.kind ?? "node") + "</small></div>").join("")
+          : '<div class="node">Root<small>no graph rows yet</small></div>';
+      }
+      addEventListener("message", (event) => {
+        const message = event.data;
+        if (!message || message.jsonrpc !== "2.0") return;
+        if (message.id && pending.has(message.id)) {
+          const waiter = pending.get(message.id);
+          pending.delete(message.id);
+          message.error ? waiter.reject(message.error) : waiter.resolve(message.result);
+          return;
+        }
+        if (message.method === "ui/notifications/tool-result") {
+          render(message.params?.structuredContent);
+          status.textContent = "structuredContent received";
+        }
+      });
+      try {
+        await send("ui/initialize", {
+          protocolVersion: "2026-01-26",
+          appInfo: { name: "looperators-agent-loop-p0", version: "0.1.0" },
+          appCapabilities: {}
+        });
+        parent.postMessage({ jsonrpc: "2.0", method: "ui/notifications/initialized" }, "*");
+        status.textContent = "MCP App initialized";
+      } catch {
+        status.textContent = "host did not initialize MCP App";
+      }
+      document.querySelector("#ping").addEventListener("click", async () => {
+        status.textContent = "calling loop_ping…";
+        try {
+          const result = await send("tools/call", {
+            name: "loop_ping",
+            arguments: { message: "component-call" }
+          });
+          status.textContent = result?.structuredContent?.ack ?? "tool returned";
+        } catch {
+          status.textContent = "component tool call rejected";
+        }
+      });
+    </script>
+  </body>
+</html>`;
+
+function graphPayload() {
+  return {
+    graph: {
+      nodes: [
+        { id: "root", kind: "root", label: "Root turn" },
+        { id: "agent-a", kind: "subagent", label: "Subagent A" },
+        { id: "agent-b", kind: "subagent", label: "Subagent B" },
+      ],
+      edges: [
+        { source: "root", target: "agent-a", kind: "spawned" },
+        { source: "root", target: "agent-b", kind: "spawned" },
+      ],
+    },
+    source: "looperators-agent-loop-p0",
+  };
+}
+
+async function logProtocol(direction, message) {
+  if (!artifactDir) {
+    return;
+  }
+  protocolSequence += 1;
+  const redacted = {
+    direction,
+    method: message.method ?? null,
+    id: message.id ?? null,
+    sequence: protocolSequence,
+    captured_at: new Date().toISOString(),
+    payload_sha256: sha256(stableJson(message)),
+  };
+  const fileName = `${String(protocolSequence).padStart(4, "0")}-${direction}-${redacted.method ?? "response"}.json`
+    .replaceAll("/", "-")
+    .replaceAll(":", "-");
+  await atomicWriteJson(path.join(artifactDir, "mcp-protocol", fileName), redacted);
+}
+
+function toolDescriptor(name, description, inputSchema, outputSchema, meta = undefined) {
+  return {
+    name,
+    title: name
+      .split("_")
+      .map((part) => part[0].toUpperCase() + part.slice(1))
+      .join(" "),
+    description,
+    inputSchema,
+    outputSchema,
+    annotations: { readOnlyHint: name !== "loop_ping" },
+    ...(meta ? { _meta: meta } : {}),
+  };
+}
+
+function toolsList() {
+  const outputSchema = {
+    type: "object",
+    properties: {
+      graph: { type: "object" },
+      source: { type: "string" },
+    },
+    required: ["graph", "source"],
+    additionalProperties: true,
+  };
+  return [
+    toolDescriptor(
+      "loop_snapshot",
+      "Return the normalized looperators Agent Loop graph as structured content.",
+      { type: "object", properties: {}, additionalProperties: false },
+      outputSchema,
+    ),
+    toolDescriptor(
+      "loop_widget",
+      "Return the graph and ask a compatible host to render the MCP App.",
+      { type: "object", properties: {}, additionalProperties: false },
+      outputSchema,
+      {
+        ui: { resourceUri: RESOURCE_URI },
+        "ui/resourceUri": RESOURCE_URI,
+        "openai/outputTemplate": RESOURCE_URI,
+      },
+    ),
+    toolDescriptor(
+      "loop_ping",
+      "A deterministic component-to-server tools/call probe.",
+      {
+        type: "object",
+        properties: { message: { type: "string" } },
+        additionalProperties: false,
+      },
+      {
+        type: "object",
+        properties: { ack: { type: "string" } },
+        required: ["ack"],
+        additionalProperties: false,
+      },
+    ),
+  ];
+}
+
+async function dispatch(message) {
+  switch (message.method) {
+    case "initialize":
+      return {
+        protocolVersion: message.params?.protocolVersion ?? "2025-06-18",
+        capabilities: {
+          tools: { listChanged: false },
+          resources: { subscribe: false, listChanged: false },
+        },
+        serverInfo: { name: "looperators-agent-loop-p0", version: "0.1.0" },
+      };
+    case "ping":
+      return {};
+    case "tools/list":
+      return { tools: toolsList() };
+    case "resources/list":
+      return {
+        resources: [
+          {
+            uri: RESOURCE_URI,
+            name: "looperators Agent Loop P0",
+            title: "looperators Agent Loop P0",
+            description: "Minimal MCP App graph for the compatibility probe.",
+            mimeType: MIME_TYPE,
+          },
+        ],
+      };
+    case "resources/templates/list":
+      return { resourceTemplates: [] };
+    case "resources/read":
+      if (message.params?.uri !== RESOURCE_URI) {
+        throw Object.assign(new Error("Unknown resource"), { code: -32002 });
+      }
+      return {
+        contents: [
+          {
+            uri: RESOURCE_URI,
+            mimeType: MIME_TYPE,
+            text: widgetHtml,
+          },
+        ],
+      };
+    case "tools/call": {
+      const name = message.params?.name;
+      if (name === "loop_snapshot" || name === "loop_widget") {
+        const structuredContent = graphPayload();
+        return {
+          content: [
+            {
+              type: "text",
+              text: "looperators Agent Loop graph is available in structuredContent.",
+            },
+          ],
+          structuredContent,
+        };
+      }
+      if (name === "loop_ping") {
+        const messageText = message.params?.arguments?.message ?? "ping";
+        return {
+          content: [{ type: "text", text: `ack:${messageText}` }],
+          structuredContent: { ack: `ack:${messageText}` },
+        };
+      }
+      throw Object.assign(new Error(`Unknown tool: ${name}`), { code: -32602 });
+    }
+    default:
+      if (message.method?.startsWith("notifications/")) {
+        return undefined;
+      }
+      throw Object.assign(new Error(`Method not found: ${message.method}`), {
+        code: -32601,
+      });
+  }
+}
+
+async function handle(message) {
+  await logProtocol("in", message);
+  if (message.id === undefined || message.id === null) {
+    await dispatch(message);
+    return;
+  }
+  let response;
+  try {
+    response = {
+      jsonrpc: "2.0",
+      id: message.id,
+      result: await dispatch(message),
+    };
+  } catch (error) {
+    response = {
+      jsonrpc: "2.0",
+      id: message.id,
+      error: {
+        code: Number.isInteger(error?.code) ? error.code : -32603,
+        message: error?.message ?? "Internal error",
+      },
+    };
+  }
+  await logProtocol("out", response);
+  process.stdout.write(`${JSON.stringify(response)}\n`);
+}
+
+const input = createInterface({ input: process.stdin, crlfDelay: Infinity });
+let chain = Promise.resolve();
+input.on("line", (line) => {
+  if (!line.trim()) {
+    return;
+  }
+  chain = chain
+    .then(() => handle(JSON.parse(line)))
+    .catch((error) => {
+      process.stderr.write(`looperators P0 MCP error: ${error?.message ?? error}\n`);
+    });
+});
diff --git a/plugins/looperators-agent-loop-p0/scripts/capture-environment.mjs b/plugins/looperators-agent-loop-p0/scripts/capture-environment.mjs
new file mode 100644
index 0000000..d01d3b2
--- /dev/null
+++ b/plugins/looperators-agent-loop-p0/scripts/capture-environment.mjs
@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { open, stat } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { atomicWriteJson } from "../lib/event-utils.mjs";
+
+function argument(name, fallback = null) {
+  const index = process.argv.indexOf(`--${name}`);
+  return index >= 0 ? process.argv[index + 1] : fallback;
+}
+
+function run(command, args, cwd = process.cwd()) {
+  const result = spawnSync(command, args, {
+    cwd,
+    encoding: "utf8",
+    timeout: 15_000,
+  });
+  return {
+    command: [command, ...args],
+    status: result.status,
+    stdout: result.stdout.trim(),
+    stderr: result.stderr.trim(),
+  };
+}
+
+async function filePrefixSha256(filePath, prefixBytes) {
+  const handle = await open(filePath, "r");
+  const buffer = Buffer.alloc(prefixBytes);
+  const { bytesRead } = await handle.read(buffer, 0, prefixBytes, 0);
+  await handle.close();
+  const hash = createHash("sha256");
+  hash.update(buffer.subarray(0, bytesRead));
+  return { bytes_read: bytesRead, sha256: hash.digest("hex") };
+}
+
+const outputValue = argument("output");
+if (!outputValue) {
+  throw new Error("--output is required");
+}
+const output = path.resolve(outputValue);
+const repo = process.cwd();
+const appRoot = "/Applications/ChatGPT.app";
+const embeddedCodex = path.join(appRoot, "Contents", "Resources", "codex");
+const infoPlist = path.join(appRoot, "Contents", "Info.plist");
+const appAsar = path.join(appRoot, "Contents", "Resources", "app.asar");
+const appAsarStat = await stat(appAsar);
+const evidence = {
+  schema_version: 1,
+  captured_at: new Date().toISOString(),
+  repo,
+  platform: {
+    arch: process.arch,
+    node: process.version,
+    sw_vers: run("/usr/bin/sw_vers", []),
+  },
+  git: {
+    head: run("/usr/bin/git", ["rev-parse", "HEAD"], repo),
+    status: run("/usr/bin/git", ["status", "--short"], repo),
+  },
+  codex: {
+    path_cli: run("codex", ["--version"], repo),
+    embedded_cli: run(embeddedCodex, ["--version"], repo),
+    embedded_features: run(embeddedCodex, ["features", "list"], repo),
+  },
+  desktop: {
+    bundle_identifier: run("/usr/bin/plutil", [
+      "-extract",
+      "CFBundleIdentifier",
+      "raw",
+      "-o",
+      "-",
+      infoPlist,
+    ]),
+    short_version: run("/usr/bin/plutil", [
+      "-extract",
+      "CFBundleShortVersionString",
+      "raw",
+      "-o",
+      "-",
+      infoPlist,
+    ]),
+    build_version: run("/usr/bin/plutil", [
+      "-extract",
+      "CFBundleVersion",
+      "raw",
+      "-o",
+      "-",
+      infoPlist,
+    ]),
+    app_asar_size_bytes: appAsarStat.size,
+    app_asar_prefix: await filePrefixSha256(appAsar, 65_536),
+  },
+};
+await atomicWriteJson(output, evidence);
+process.stdout.write(`${JSON.stringify({ output, captured_at: evidence.captured_at })}\n`);
diff --git a/plugins/looperators-agent-loop-p0/scripts/create-hook-probe.mjs b/plugins/looperators-agent-loop-p0/scripts/create-hook-probe.mjs
new file mode 100644
index 0000000..cbcaef9
--- /dev/null
+++ b/plugins/looperators-agent-loop-p0/scripts/create-hook-probe.mjs
@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { atomicWriteJson } from "../lib/event-utils.mjs";
+
+function argument(name, fallback = null) {
+  const index = process.argv.indexOf(`--${name}`);
+  return index >= 0 ? process.argv[index + 1] : fallback;
+}
+
+const probeDirValue = argument("probe-dir");
+const artifactDirValue = argument("artifact-dir");
+if (!probeDirValue || !artifactDirValue) {
+  throw new Error("--probe-dir and --artifact-dir are required");
+}
+
+const probeDir = path.resolve(probeDirValue);
+const artifactDir = path.resolve(artifactDirValue);
+const pluginRoot = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "..",
+);
+const collector = path.join(pluginRoot, "hooks", "collect-event.mjs");
+const command = (lane, delayMs = 0) =>
+  [
+    JSON.stringify(process.execPath),
+    JSON.stringify(collector),
+    "--lane",
+    lane,
+    ...(delayMs ? ["--delay-ms", String(delayMs)] : []),
+  ].join(" ");
+const handler = (lane, delayMs = 0, statusMessage) => ({
+  type: "command",
+  command: command(lane, delayMs),
+  timeout: 5,
+  statusMessage,
+});
+const single = (eventName, statusMessage) => ({
+  [eventName]: [
+    {
+      hooks: [handler("primary", 0, statusMessage)],
+    },
+  ],
+});
+const config = {
+  hooks: {
+    ...single("SessionStart", "P0 collecting SessionStart"),
+    ...single("UserPromptSubmit", "P0 collecting UserPromptSubmit"),
+    PreToolUse: [
+      {
+        matcher: "*",
+        hooks: [
+          handler("primary", 120, "P0 PreToolUse lane primary"),
+          handler("parallel", 120, "P0 PreToolUse lane parallel"),
+        ],
+      },
+    ],
+    ...single("PostToolUse", "P0 collecting PostToolUse"),
+    ...single("SubagentStart", "P0 collecting SubagentStart"),
+    ...single("SubagentStop", "P0 applying SubagentStop lap cap"),
+    ...single("Stop", "P0 applying Stop lap cap"),
+  },
+};
+
+await mkdir(path.join(probeDir, ".codex"), { recursive: true, mode: 0o700 });
+await mkdir(artifactDir, { recursive: true, mode: 0o700 });
+await writeFile(
+  path.join(probeDir, ".codex", "hooks.json"),
+  `${JSON.stringify(config, null, 2)}\n`,
+  { mode: 0o600 },
+);
+await atomicWriteJson(path.join(artifactDir, "probe-hooks.json"), config);
+await atomicWriteJson(path.join(artifactDir, "probe-metadata.json"), {
+  schema_version: 1,
+  created_at: new Date().toISOString(),
+  probe_dir: probeDir,
+  plugin_root: pluginRoot,
+  artifact_dir: artifactDir,
+  continuation_mode: "lap",
+  lap_cap: 1,
+  parallel_probe_delay_ms: 120,
+});
+process.stdout.write(
+  `${JSON.stringify({
+    probe_dir: probeDir,
+    hooks_file: path.join(probeDir, ".codex", "hooks.json"),
+    artifact_dir: artifactDir,
+  })}\n`,
+);
diff --git a/plugins/looperators-agent-loop-p0/scripts/create-mcp-probe.mjs b/plugins/looperators-agent-loop-p0/scripts/create-mcp-probe.mjs
new file mode 100644
index 0000000..64af51c
--- /dev/null
+++ b/plugins/looperators-agent-loop-p0/scripts/create-mcp-probe.mjs
@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { atomicWriteJson } from "../lib/event-utils.mjs";
+
+function argument(name, fallback = null) {
+  const index = process.argv.indexOf(`--${name}`);
+  return index >= 0 ? process.argv[index + 1] : fallback;
+}
+
+function tomlString(value) {
+  return JSON.stringify(value);
+}
+
+const probeDirValue = argument("probe-dir");
+const artifactDirValue = argument("artifact-dir");
+if (!probeDirValue || !artifactDirValue) {
+  throw new Error("--probe-dir and --artifact-dir are required");
+}
+const probeDir = path.resolve(probeDirValue);
+const artifactDir = path.resolve(artifactDirValue);
+const pluginRoot = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "..",
+);
+const server = path.join(pluginRoot, "mcp", "server.mjs");
+const config = [
+  "[mcp_servers.looperators_agent_loop_p0]",
+  `command = ${tomlString(process.execPath)}`,
+  `args = [${tomlString(server)}]`,
+  `env = { LOOPERATORS_P0_ARTIFACT_DIR = ${tomlString(artifactDir)} }`,
+  "startup_timeout_sec = 10",
+  "tool_timeout_sec = 10",
+  "",
+].join("\n");
+
+await mkdir(path.join(probeDir, ".codex"), { recursive: true, mode: 0o700 });
+await mkdir(artifactDir, { recursive: true, mode: 0o700 });
+await writeFile(path.join(probeDir, ".codex", "config.toml"), config, {
+  mode: 0o600,
+});
+await writeFile(path.join(artifactDir, "project-config.toml"), config, {
+  mode: 0o600,
+});
+await atomicWriteJson(path.join(artifactDir, "probe-metadata.json"), {
+  schema_version: 1,
+  created_at: new Date().toISOString(),
+  probe_dir: probeDir,
+  plugin_root: pluginRoot,
+  server,
+  resource_uri: "ui://looperators/agent-loop-p0.html",
+  mime_type: "text/html;profile=mcp-app",
+});
+process.stdout.write(
+  `${JSON.stringify({
+    probe_dir: probeDir,
+    config_file: path.join(probeDir, ".codex", "config.toml"),
+    artifact_dir: artifactDir,
+  })}\n`,
+);
diff --git a/plugins/looperators-agent-loop-p0/scripts/extract-desktop-evidence.mjs b/plugins/looperators-agent-loop-p0/scripts/extract-desktop-evidence.mjs
new file mode 100644
index 0000000..d797e81
--- /dev/null
+++ b/plugins/looperators-agent-loop-p0/scripts/extract-desktop-evidence.mjs
@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+
+import { createHash } from "node:crypto";
+import { readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { atomicWriteJson } from "../lib/event-utils.mjs";
+
+function argument(name, fallback = null) {
+  const index = process.argv.indexOf(`--${name}`);
+  return index >= 0 ? process.argv[index + 1] : fallback;
+}
+
+async function filesRecursively(directory) {
+  const entries = await readdir(directory, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const entryPath = path.join(directory, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...(await filesRecursively(entryPath)));
+    } else if (entry.isFile() && entry.name.endsWith(".js")) {
+      files.push(entryPath);
+    }
+  }
+  return files;
+}
+
+const asarDirValue = argument("asar-dir");
+const outputValue = argument("output");
+if (!asarDirValue || !outputValue) {
+  throw new Error("--asar-dir and --output are required");
+}
+const asarDir = path.resolve(asarDirValue);
+const output = path.resolve(outputValue);
+const needles = [
+  "var ige=5e6",
+  "followSymlinks:!1",
+  "/^[a-z0-9]+(?:-[a-z0-9]+)*\\.html$/",
+  "Inline visualization file exceeds the 5 MB limit",
+  "Inline visualizations cannot call tools",
+  "VPa=`codex-inline-vis`",
+  "WPa=/^::codex-(?:inline-vis|live-vis)",
+  "text/html;profile=mcp-app",
+  "t.data.ui?.resourceUri",
+  "method:fl(`tools/call`)",
+];
+const files = await filesRecursively(asarDir);
+const cache = new Map();
+const excerpts = [];
+for (const needle of needles) {
+  let match = null;
+  for (const file of files) {
+    let text = cache.get(file);
+    if (text === undefined) {
+      text = await readFile(file, "utf8");
+      cache.set(file, text);
+    }
+    const index = text.indexOf(needle);
+    if (index >= 0) {
+      match = {
+        needle,
+        relative_file: path.relative(asarDir, file),
+        byte_offset: Buffer.byteLength(text.slice(0, index)),
+        excerpt: text.slice(Math.max(0, index - 420), index + needle.length + 820),
+        source_sha256: createHash("sha256").update(text).digest("hex"),
+      };
+      break;
+    }
+  }
+  excerpts.push(match ?? { needle, missing: true });
+}
+await atomicWriteJson(output, {
+  schema_version: 1,
+  generated_at: new Date().toISOString(),
+  asar_directory: asarDir,
+  excerpts,
+});
+process.stdout.write(
+  `${JSON.stringify({
+    output,
+    matched: excerpts.filter((entry) => !entry.missing).length,
+    missing: excerpts.filter((entry) => entry.missing).map((entry) => entry.needle),
+  })}\n`,
+);
diff --git a/plugins/looperators-agent-loop-p0/scripts/generate-inline-visualization.mjs b/plugins/looperators-agent-loop-p0/scripts/generate-inline-visualization.mjs
new file mode 100644
index 0000000..ad18bf8
--- /dev/null
+++ b/plugins/looperators-agent-loop-p0/scripts/generate-inline-visualization.mjs
@@ -0,0 +1,829 @@
+#!/usr/bin/env node
+
+import {
+  lstat,
+  open,
+  readFile,
+  rename,
+  stat,
+  unlink,
+} from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { pathToFileURL } from "node:url";
+
+const MAX_FRAGMENT_BYTES = 2 * 1024 * 1024;
+const OUTPUT_NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*\.html$/;
+
+function argument(name) {
+  const index = process.argv.indexOf(`--${name}`);
+  return index >= 0 ? process.argv[index + 1] : null;
+}
+
+async function readJsonIfPresent(filePath, fallback) {
+  try {
+    return JSON.parse(await readFile(filePath, "utf8"));
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return fallback;
+    }
+    throw new Error(`Cannot read ${filePath}: ${error.message}`);
+  }
+}
+
+async function readJsonLinesIfPresent(filePath) {
+  let text;
+  try {
+    text = await readFile(filePath, "utf8");
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return [];
+    }
+    throw new Error(`Cannot read ${filePath}: ${error.message}`);
+  }
+  return text
+    .split(/\r?\n/u)
+    .filter(Boolean)
+    .map((line, index) => {
+      try {
+        return JSON.parse(line);
+      } catch (error) {
+        throw new Error(
+          `Cannot parse ${filePath}:${index + 1}: ${error.message}`,
+        );
+      }
+    });
+}
+
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function asObject(value) {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : {};
+}
+
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+
+function asCount(value, fallback = 0) {
+  return Number.isInteger(value) && value >= 0 ? value : fallback;
+}
+
+function shortIdentifier(value) {
+  const identifier = asString(value);
+  if (!identifier) {
+    return "unknown";
+  }
+  return identifier.length <= 14
+    ? identifier
+    : `${identifier.slice(0, 4)}…${identifier.slice(-6)}`;
+}
+
+function semanticEventsFrom(deliveries) {
+  const selected = new Map();
+  for (const [index, event] of deliveries.entries()) {
+    const key =
+      asString(event?.semantic_key) ??
+      `delivery:${asString(event?.delivery_key) ?? index}`;
+    const existing = selected.get(key);
+    if (!existing || (existing.lane !== "primary" && event?.lane === "primary")) {
+      selected.set(key, event);
+    }
+  }
+  return [...selected.values()].sort((left, right) => {
+    const leftSequence = Number.isFinite(left?.sequence)
+      ? left.sequence
+      : Number.MAX_SAFE_INTEGER;
+    const rightSequence = Number.isFinite(right?.sequence)
+      ? right.sequence
+      : Number.MAX_SAFE_INTEGER;
+    if (leftSequence !== rightSequence) {
+      return leftSequence - rightSequence;
+    }
+    return String(left?.captured_at ?? "").localeCompare(
+      String(right?.captured_at ?? ""),
+    );
+  });
+}
+
+function countsByEvent(events) {
+  const counts = new Map();
+  for (const event of events) {
+    const name = asString(event?.event) ?? "Unknown";
+    counts.set(name, (counts.get(name) ?? 0) + 1);
+  }
+  return Object.fromEntries(
+    [...counts.entries()].sort(([left], [right]) => left.localeCompare(right)),
+  );
+}
+
+function stopObservation(kind, events) {
+  const stopEvent = kind === "root" ? "Stop" : "SubagentStop";
+  const stops = events.filter((event) => event?.event === stopEvent);
+  const initialStops = stops.filter(
+    (event) => event?.stop_hook_active === false,
+  ).length;
+  const continuations = stops.filter(
+    (event) => event?.stop_hook_active === true,
+  ).length;
+  let status = "Observed";
+  if (continuations > 0) {
+    status = "Continuation completed";
+  } else if (initialStops > 0) {
+    status = "Initial stop observed";
+  } else if (
+    events.some((event) =>
+      kind === "root"
+        ? ["SessionStart", "UserPromptSubmit"].includes(event?.event)
+        : event?.event === "SubagentStart",
+    )
+  ) {
+    status = "Started";
+  } else if (events.length === 0) {
+    status = "Unknown";
+  }
+  return { status, initialStops, continuations };
+}
+
+function timelineEntry(event) {
+  const details = [];
+  if (asString(event?.tool_name)) {
+    details.push(event.tool_name);
+  }
+  if (event?.stop_hook_active === false) {
+    details.push("initial stop");
+  } else if (event?.stop_hook_active === true) {
+    details.push("continuation stop");
+  }
+  if (asString(event?.turn_id)) {
+    details.push(`turn ${shortIdentifier(event.turn_id)}`);
+  }
+  return {
+    sequence: Number.isFinite(event?.sequence) ? event.sequence : null,
+    event: asString(event?.event) ?? "Unknown",
+    capturedAt: asString(event?.captured_at),
+    details,
+  };
+}
+
+function nodeView(node, semanticEvents) {
+  const kind = node.kind;
+  const rawIdentifier =
+    kind === "root"
+      ? asString(node.session_id) ??
+        asString(node.id)?.replace(/^session:/u, "") ??
+        null
+      : asString(node.agent_id) ??
+        asString(node.id)?.replace(/^agent:/u, "") ??
+        null;
+  const stableIdentifier =
+    asString(node.id) ??
+    (rawIdentifier
+      ? `${kind === "root" ? "session" : "agent"}:${rawIdentifier}`
+      : null);
+  const relatedEvents = semanticEvents.filter((event) => {
+    if (kind === "root") {
+      return (
+        !asString(event?.agent_id) &&
+        (!rawIdentifier || event?.session_id === rawIdentifier)
+      );
+    }
+    return rawIdentifier && event?.agent_id === rawIdentifier;
+  });
+  const stop = stopObservation(kind, relatedEvents);
+  return {
+    id: stableIdentifier,
+    rawId: rawIdentifier,
+    shortId: shortIdentifier(rawIdentifier ?? stableIdentifier),
+    kind,
+    label:
+      asString(node.label) ?? (kind === "root" ? "Root session" : "Subagent"),
+    status: stop.status,
+    eventCount: relatedEvents.length,
+    initialStops: stop.initialStops,
+    continuations: stop.continuations,
+    eventCounts: countsByEvent(relatedEvents),
+    timeline: relatedEvents.map(timelineEntry),
+  };
+}
+
+export async function loadNormalizedArtifactData(artifactDir) {
+  const directory = path.resolve(artifactDir);
+  const metadata = await stat(directory);
+  if (!metadata.isDirectory()) {
+    throw new Error(`Artifact path is not a directory: ${directory}`);
+  }
+  const [graph, events, summary] = await Promise.all([
+    readJsonIfPresent(path.join(directory, "normalized-graph.json"), {
+      nodes: [],
+      edges: [],
+    }),
+    readJsonLinesIfPresent(path.join(directory, "normalized-events.jsonl")),
+    readJsonIfPresent(path.join(directory, "normalized-summary.json"), {}),
+  ]);
+  return { artifactDir: directory, graph, events, summary };
+}
+
+export function buildLoopViewModel({ graph, events, summary }) {
+  const graphObject = asObject(graph);
+  const deliveries = asArray(events).filter(
+    (event) => event && typeof event === "object",
+  );
+  const semanticEvents = semanticEventsFrom(deliveries);
+  const sourceNodes = asArray(graphObject.nodes).filter(
+    (node) =>
+      node &&
+      typeof node === "object" &&
+      ["root", "subagent"].includes(node.kind),
+  );
+  const nodes = sourceNodes.map((node) => nodeView(node, semanticEvents));
+  const nodeIds = new Set(nodes.map((node) => node.id).filter(Boolean));
+  const edges = asArray(graphObject.edges)
+    .filter(
+      (edge) =>
+        edge &&
+        typeof edge === "object" &&
+        edge.kind === "spawned" &&
+        nodeIds.has(edge.source) &&
+        nodeIds.has(edge.target),
+    )
+    .map((edge) => ({
+      id: asString(edge.id),
+      source: asString(edge.source),
+      target: asString(edge.target),
+      kind: "spawned",
+    }));
+  const summaryObject = asObject(summary);
+  const warnings = [];
+  if (asArray(graphObject.nodes).length === 0) {
+    warnings.push("normalized-graph.json has no nodes");
+  }
+  if (deliveries.length === 0) {
+    warnings.push("normalized-events.jsonl has no events");
+  }
+  return {
+    schemaVersion: 1,
+    counts: {
+      deliveries: asCount(summaryObject.total_deliveries, deliveries.length),
+      semanticEvents: asCount(
+        summaryObject.total_semantic_events,
+        semanticEvents.length,
+      ),
+      graphNodes: asArray(graphObject.nodes).length,
+      graphEdges: asArray(graphObject.edges).length,
+      agentNodes: nodes.length,
+      agentEdges: edges.length,
+    },
+    deliveryEventCounts: asObject(summaryObject.deliveries_by_event),
+    semanticEventCounts: countsByEvent(semanticEvents),
+    nodes,
+    edges,
+    warnings,
+  };
+}
+
+function jsonForHtml(value) {
+  return JSON.stringify(value)
+    .replaceAll("&", "\\u0026")
+    .replaceAll("<", "\\u003c")
+    .replaceAll(">", "\\u003e")
+    .replaceAll("\u2028", "\\u2028")
+    .replaceAll("\u2029", "\\u2029");
+}
+
+function htmlEscape(value) {
+  return String(value)
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&#39;");
+}
+
+function nodeButtonMarkup(node) {
+  const identifier = asString(node.id);
+  const dataIdentifier = identifier
+    ? ` data-node-id="${htmlEscape(identifier)}"`
+    : "";
+  const disabled = identifier ? "" : " disabled";
+  const label = `${node.label}, ${node.kind}, ${node.shortId}`;
+  return `<button class="btn viz-tile" type="button"${dataIdentifier} data-kind="${htmlEscape(node.kind)}" aria-label="${htmlEscape(label)}" aria-pressed="false"${disabled}>
+  <span class="loop-node-content">
+    <strong>${node.kind === "root" ? "Root" : "Subagent"}</strong>
+    <code>${htmlEscape(node.shortId)}</code>
+    <span class="text-small">${htmlEscape(node.status)} · ${node.eventCount} events</span>
+  </span>
+</button>`;
+}
+
+export function renderInlineVisualization(viewModel) {
+  const data = jsonForHtml(viewModel);
+  const rootNodes = viewModel.nodes
+    .filter((node) => node.kind === "root")
+    .map(nodeButtonMarkup)
+    .join("\n");
+  const subagentNodes = viewModel.nodes
+    .filter((node) => node.kind === "subagent")
+    .map(nodeButtonMarkup)
+    .join("\n");
+  return `<div id="looperators-agent-loop-p06">
+  <div class="viz-row loop-overview" aria-label="Snapshot totals">
+    <span class="viz-badge" id="loop-delivery-count"></span>
+    <span class="viz-badge" id="loop-semantic-count"></span>
+    <span class="viz-badge" id="loop-agent-count"></span>
+    <span class="viz-badge" id="loop-edge-count"></span>
+  </div>
+
+  <div class="viz-controls" aria-label="Agent Loop controls">
+    <label class="form-label" for="loop-filter">Show
+      <select class="form-select" id="loop-filter" aria-label="Filter Agent Loop nodes">
+        <option value="all">All agents</option>
+        <option value="root">Root only</option>
+        <option value="subagent">Subagents only</option>
+      </select>
+    </label>
+    <div class="viz-row" role="group" aria-label="Zoom controls">
+      <button class="btn" id="loop-zoom-out" type="button" aria-label="Zoom out">Zoom out</button>
+      <output id="loop-zoom-value" aria-live="polite">100%</output>
+      <button class="btn" id="loop-zoom-in" type="button" aria-label="Zoom in">Zoom in</button>
+      <button class="btn btn-ghost" id="loop-zoom-reset" type="button" aria-label="Reset zoom">Reset</button>
+    </div>
+  </div>
+
+  <div class="loop-stage-viewport" id="loop-stage-viewport">
+    <div class="loop-stage" id="loop-stage" role="group" aria-label="Agent Loop graph">
+      <div class="loop-lane" id="loop-root-lane" aria-label="Root agent">
+${rootNodes}
+      </div>
+      <div class="loop-edge" id="loop-edge-label" aria-label="Spawned relationships"></div>
+      <div class="loop-lane loop-subagents" id="loop-subagent-lane" aria-label="Subagents">
+${subagentNodes}
+      </div>
+      <p class="text-muted loop-empty" id="loop-empty" hidden>No matching agent nodes were recorded.</p>
+    </div>
+  </div>
+
+  <section class="card loop-details" id="loop-details" aria-live="polite" aria-label="Selected node details">
+    <div class="viz-row loop-detail-heading">
+      <strong id="loop-detail-label">Select a node</strong>
+      <span class="viz-badge" id="loop-detail-status">No selection</span>
+    </div>
+    <p class="text-small"><code id="loop-detail-id">No stable identifier selected</code></p>
+    <p class="text-small" id="loop-detail-counts">Select a recorded root or subagent to inspect its events.</p>
+    <div id="loop-event-counts"></div>
+    <ol class="loop-timeline" id="loop-timeline"></ol>
+    <div class="viz-row">
+      <button class="btn btn-primary" id="loop-follow-up" type="button" aria-label="Ask Codex about selected node" disabled>Ask Codex about selected node</button>
+      <span class="text-small" id="loop-follow-up-status" role="status">Select a node first.</span>
+    </div>
+  </section>
+
+  <div class="loop-acceptance" aria-label="P0.6 acceptance status">
+    <div class="viz-row">
+      <strong>P0.6 acceptance</strong>
+      <span class="viz-badge" data-check="js">JS ready: pending</span>
+      <span class="viz-badge" data-check="selected">node selected: pending</span>
+      <span class="viz-badge" data-check="details">details updated: pending</span>
+      <span class="viz-badge" data-check="zoom">zoom changed/reset: pending</span>
+      <span class="viz-badge" data-check="filter">filter changed: pending</span>
+      <span class="viz-badge" data-check="followup">follow-up requested: pending</span>
+    </div>
+    <label class="form-label" for="loop-acceptance-summary">Return summary</label>
+    <textarea class="form-control" id="loop-acceptance-summary" rows="2" readonly aria-label="Copyable P0.6 acceptance summary"></textarea>
+  </div>
+
+  <p class="text-small text-muted loop-footer">Interactive snapshot · local controls · no live network/tool calls</p>
+  <p class="text-small text-destructive" id="loop-source-warning" hidden></p>
+</div>
+
+<script type="application/json" id="looperators-agent-loop-p06-data">${data}</script>
+<style>
+  #looperators-agent-loop-p06 {
+    color: var(--foreground);
+    min-width: 0;
+    max-width: 100%;
+    overflow-wrap: anywhere;
+  }
+  #looperators-agent-loop-p06 .loop-overview,
+  #looperators-agent-loop-p06 .viz-controls,
+  #looperators-agent-loop-p06 .loop-acceptance,
+  #looperators-agent-loop-p06 .loop-footer {
+    margin-top: 0.75rem;
+  }
+  #looperators-agent-loop-p06 .loop-stage-viewport {
+    max-width: 100%;
+    overflow: hidden;
+    margin-top: 0.75rem;
+  }
+  #looperators-agent-loop-p06 .loop-stage {
+    width: 100%;
+    transform-origin: top left;
+  }
+  #looperators-agent-loop-p06 .loop-lane {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(min(100%, 11rem), 1fr));
+    gap: 0.5rem;
+    min-width: 0;
+  }
+  #looperators-agent-loop-p06 .loop-node-content {
+    display: grid;
+    gap: 0.25rem;
+    min-width: 0;
+    text-align: left;
+  }
+  #looperators-agent-loop-p06 .loop-node-content code {
+    overflow-wrap: anywhere;
+  }
+  #looperators-agent-loop-p06 .loop-edge {
+    color: var(--muted-foreground);
+    text-align: center;
+    margin: 0.5rem 0;
+  }
+  #looperators-agent-loop-p06 .loop-details {
+    margin-top: 0.75rem;
+    min-width: 0;
+  }
+  #looperators-agent-loop-p06 .loop-detail-heading {
+    justify-content: space-between;
+  }
+  #looperators-agent-loop-p06 .loop-timeline {
+    margin: 0.5rem 0;
+    padding-inline-start: 1.25rem;
+  }
+  #looperators-agent-loop-p06 .loop-timeline li + li {
+    margin-top: 0.25rem;
+  }
+  #looperators-agent-loop-p06 .loop-empty {
+    text-align: center;
+  }
+  #looperators-agent-loop-p06 textarea {
+    max-width: 100%;
+    resize: vertical;
+  }
+  @media (max-width: 420px) {
+    #looperators-agent-loop-p06 .loop-detail-heading {
+      align-items: flex-start;
+    }
+  }
+</style>
+<script>
+(() => {
+  "use strict";
+  const root = document.getElementById("looperators-agent-loop-p06");
+  const dataElement = document.getElementById("looperators-agent-loop-p06-data");
+  if (!root || !dataElement) return;
+
+  const model = JSON.parse(dataElement.textContent);
+  const byId = new Map(model.nodes.filter((node) => node.id).map((node) => [node.id, node]));
+  const checks = {
+    js: "pending",
+    selected: "pending",
+    details: "pending",
+    zoom: "pending",
+    filter: "pending",
+    followup: "pending",
+  };
+  let selectedId = null;
+  let zoom = 1;
+  let zoomChanged = false;
+
+  const elements = {
+    deliveryCount: root.querySelector("#loop-delivery-count"),
+    semanticCount: root.querySelector("#loop-semantic-count"),
+    agentCount: root.querySelector("#loop-agent-count"),
+    edgeCount: root.querySelector("#loop-edge-count"),
+    filter: root.querySelector("#loop-filter"),
+    viewport: root.querySelector("#loop-stage-viewport"),
+    stage: root.querySelector("#loop-stage"),
+    rootLane: root.querySelector("#loop-root-lane"),
+    subagentLane: root.querySelector("#loop-subagent-lane"),
+    edgeLabel: root.querySelector("#loop-edge-label"),
+    empty: root.querySelector("#loop-empty"),
+    detailLabel: root.querySelector("#loop-detail-label"),
+    detailStatus: root.querySelector("#loop-detail-status"),
+    detailId: root.querySelector("#loop-detail-id"),
+    detailCounts: root.querySelector("#loop-detail-counts"),
+    eventCounts: root.querySelector("#loop-event-counts"),
+    timeline: root.querySelector("#loop-timeline"),
+    followUp: root.querySelector("#loop-follow-up"),
+    followUpStatus: root.querySelector("#loop-follow-up-status"),
+    zoomValue: root.querySelector("#loop-zoom-value"),
+    summary: root.querySelector("#loop-acceptance-summary"),
+    warning: root.querySelector("#loop-source-warning"),
+  };
+
+  function setText(element, value) {
+    element.textContent = String(value);
+  }
+
+  function updateAcceptance() {
+    for (const [name, state] of Object.entries(checks)) {
+      const badge = root.querySelector('[data-check="' + name + '"]');
+      badge.textContent =
+        badge.textContent.split(":")[0] + ": " + state;
+    }
+    const labels = {
+      js: "JS ready",
+      selected: "node selected",
+      details: "details updated",
+      zoom: "zoom changed/reset",
+      filter: "filter changed",
+      followup: "follow-up requested",
+    };
+    elements.summary.value =
+      "P0.6 | " +
+      Object.entries(checks)
+        .map(([name, state]) => labels[name] + "=" + state)
+        .join("; ");
+  }
+
+  function appendText(parent, tagName, text, className) {
+    const element = document.createElement(tagName);
+    if (className) element.className = className;
+    element.textContent = text;
+    parent.append(element);
+    return element;
+  }
+
+  function renderNodes() {
+    for (const button of root.querySelectorAll("[data-node-id]")) {
+      button.addEventListener("click", () => selectNode(button.dataset.nodeId));
+    }
+    setText(
+      elements.edgeLabel,
+      model.counts.agentEdges === 1
+        ? "↓ 1 recorded spawned edge"
+        : "↓ " + model.counts.agentEdges + " recorded spawned edges",
+    );
+    applyFilter(false);
+  }
+
+  function eventCountText(node) {
+    const entries = Object.entries(node.eventCounts);
+    return entries.length
+      ? entries.map(([name, count]) => name + " " + count).join(" · ")
+      : "No related semantic events recorded.";
+  }
+
+  function renderDetails(node) {
+    setText(elements.detailLabel, node.label + " · " + node.shortId);
+    setText(elements.detailStatus, node.status);
+    setText(elements.detailId, node.id || "Stable identifier unavailable");
+    setText(
+      elements.detailCounts,
+      node.eventCount +
+        " semantic events · initial stops " +
+        node.initialStops +
+        " · continuations " +
+        node.continuations,
+    );
+    setText(elements.eventCounts, eventCountText(node));
+    elements.timeline.replaceChildren();
+    for (const entry of node.timeline) {
+      const line = document.createElement("li");
+      const time = entry.capturedAt ? entry.capturedAt : "time unavailable";
+      const suffix = entry.details.length ? " · " + entry.details.join(" · ") : "";
+      line.textContent = time + " · " + entry.event + suffix;
+      elements.timeline.append(line);
+    }
+    if (node.timeline.length === 0) {
+      appendText(elements.timeline, "li", "No related timeline entries recorded.");
+    }
+    elements.followUp.disabled = !node.id;
+    setText(
+      elements.followUpStatus,
+      node.id ? "Ready to request a Codex explanation." : "Stable identifier unavailable.",
+    );
+  }
+
+  function selectNode(id) {
+    const node = byId.get(id);
+    if (!node) return;
+    selectedId = id;
+    for (const button of root.querySelectorAll("[data-node-id]")) {
+      button.setAttribute("aria-pressed", String(button.dataset.nodeId === id));
+    }
+    renderDetails(node);
+    checks.selected = "pass";
+    checks.details = "pass";
+    updateAcceptance();
+  }
+
+  function resizeStage() {
+    elements.viewport.style.height = "";
+    requestAnimationFrame(() => {
+      elements.viewport.style.height =
+        Math.ceil(elements.stage.getBoundingClientRect().height) + "px";
+    });
+  }
+
+  function applyZoom(nextZoom, action) {
+    zoom = Math.max(0.8, Math.min(1.25, nextZoom));
+    elements.stage.style.width = 100 / zoom + "%";
+    elements.stage.style.transform = "scale(" + zoom + ")";
+    setText(elements.zoomValue, Math.round(zoom * 100) + "%");
+    if (action === "change") zoomChanged = true;
+    if (action === "reset" && zoomChanged && zoom === 1) checks.zoom = "pass";
+    resizeStage();
+    updateAcceptance();
+  }
+
+  function applyFilter(markChanged = true) {
+    const value = elements.filter.value;
+    let visibleCount = 0;
+    for (const button of root.querySelectorAll("[data-node-id]")) {
+      const visible = value === "all" || button.dataset.kind === value;
+      button.hidden = !visible;
+      button.style.display = visible ? "" : "none";
+      if (visible) visibleCount += 1;
+    }
+    elements.rootLane.hidden = value === "subagent";
+    elements.rootLane.style.display = value === "subagent" ? "none" : "";
+    elements.subagentLane.hidden = value === "root";
+    elements.subagentLane.style.display = value === "root" ? "none" : "";
+    elements.edgeLabel.hidden = value !== "all" || model.counts.agentEdges === 0;
+    elements.edgeLabel.style.display =
+      value !== "all" || model.counts.agentEdges === 0 ? "none" : "";
+    elements.empty.hidden = visibleCount !== 0;
+    elements.empty.style.display = visibleCount === 0 ? "" : "none";
+    if (markChanged) checks.filter = "pass";
+    resizeStage();
+    updateAcceptance();
+  }
+
+  root.querySelector("#loop-zoom-in").addEventListener("click", () => {
+    applyZoom(zoom + 0.1, "change");
+  });
+  root.querySelector("#loop-zoom-out").addEventListener("click", () => {
+    applyZoom(zoom - 0.1, "change");
+  });
+  root.querySelector("#loop-zoom-reset").addEventListener("click", () => {
+    applyZoom(1, "reset");
+  });
+  elements.filter.addEventListener("change", () => applyFilter(true));
+  window.addEventListener("resize", resizeStage);
+  if (typeof ResizeObserver === "function") {
+    const stageObserver = new ResizeObserver(resizeStage);
+    stageObserver.observe(elements.stage);
+  }
+
+  elements.followUp.addEventListener("click", async () => {
+    const node = byId.get(selectedId);
+    if (!node || !node.id) return;
+    elements.followUp.disabled = true;
+    setText(elements.followUpStatus, "Waiting for follow-up confirmation…");
+    const prompt =
+      'Explain the looperators Agent Loop node with stable identifier "' +
+      node.id +
+      '". Its observed kind is "' +
+      node.kind +
+      '", snapshot status is "' +
+      node.status +
+      '", and the snapshot records ' +
+      node.eventCount +
+      " semantic events, " +
+      node.initialStops +
+      " initial stops, and " +
+      node.continuations +
+      " continuation stops. Explain this node's role and state in the loop, separating recorded facts from inference.";
+    const title = "Explain loop node " + node.shortId;
+    try {
+      if (
+        !window.openai ||
+        typeof window.openai.sendFollowUpMessage !== "function"
+      ) {
+        throw new Error("Codex follow-up host API is unavailable");
+      }
+      await window.openai.sendFollowUpMessage({ prompt, title });
+      checks.followup = "pass";
+      setText(elements.followUpStatus, "Follow-up requested.");
+    } catch (error) {
+      checks.followup = "fail";
+      const message =
+        error && typeof error.message === "string"
+          ? error.message
+          : "request canceled or failed";
+      setText(elements.followUpStatus, "Follow-up canceled or failed: " + message);
+    } finally {
+      elements.followUp.disabled = false;
+      updateAcceptance();
+    }
+  });
+
+  setText(elements.deliveryCount, model.counts.deliveries + " deliveries");
+  setText(elements.semanticCount, model.counts.semanticEvents + " semantic events");
+  setText(elements.agentCount, model.counts.agentNodes + " agent nodes");
+  setText(elements.edgeCount, model.counts.agentEdges + " spawned edges");
+  if (model.warnings.length) {
+    elements.warning.hidden = false;
+    setText(elements.warning, model.warnings.join(" · "));
+  }
+  renderNodes();
+  applyZoom(1, "initial");
+  checks.js = "pass";
+  updateAcceptance();
+})();
+</script>
+`;
+}
+
+async function assertSafeOutput(outputPath) {
+  const output = path.resolve(outputPath);
+  if (!OUTPUT_NAME_PATTERN.test(path.basename(output))) {
+    throw new Error(
+      `Output filename must be lowercase ASCII hyphenated HTML: ${output}`,
+    );
+  }
+  const parent = path.dirname(output);
+  const parentMetadata = await lstat(parent);
+  if (parentMetadata.isSymbolicLink()) {
+    throw new Error(`Refusing to write through output directory symlink: ${parent}`);
+  }
+  if (!parentMetadata.isDirectory()) {
+    throw new Error(`Output parent is not a directory: ${parent}`);
+  }
+  let metadata = null;
+  try {
+    metadata = await lstat(output);
+  } catch (error) {
+    if (error?.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  if (metadata?.isSymbolicLink()) {
+    throw new Error(`Refusing to replace output symlink: ${output}`);
+  }
+  if (metadata && !metadata.isFile()) {
+    throw new Error(`Output is not a regular file: ${output}`);
+  }
+  return output;
+}
+
+export async function writeInlineVisualization(outputPath, fragment) {
+  const output = await assertSafeOutput(outputPath);
+  const bytes = Buffer.byteLength(fragment);
+  if (bytes >= MAX_FRAGMENT_BYTES) {
+    throw new Error(
+      `Inline visualization is ${bytes} bytes; limit is ${MAX_FRAGMENT_BYTES - 1}`,
+    );
+  }
+  const temporary = path.join(
+    path.dirname(output),
+    `.${path.basename(output)}.${process.pid}.${Date.now()}.tmp`,
+  );
+  let handle;
+  try {
+    handle = await open(temporary, "wx", 0o600);
+    await handle.writeFile(fragment, "utf8");
+    await handle.sync();
+    await handle.close();
+    handle = null;
+    await rename(temporary, output);
+  } finally {
+    if (handle) {
+      await handle.close();
+    }
+    await unlink(temporary).catch((error) => {
+      if (error?.code !== "ENOENT") throw error;
+    });
+  }
+  return { output, bytes };
+}
+
+export async function generateInlineVisualization({ artifactDir, outputPath }) {
+  const source = await loadNormalizedArtifactData(artifactDir);
+  const viewModel = buildLoopViewModel(source);
+  const fragment = renderInlineVisualization(viewModel);
+  const written = await writeInlineVisualization(outputPath, fragment);
+  return { ...written, viewModel };
+}
+
+async function main() {
+  const artifactDir = argument("artifact-dir");
+  const outputPath = argument("output");
+  if (!artifactDir || !outputPath) {
+    throw new Error(
+      "Usage: generate-inline-visualization.mjs --artifact-dir <directory> --output <looperators-agent-loop.html>",
+    );
+  }
+  const result = await generateInlineVisualization({ artifactDir, outputPath });
+  process.stdout.write(
+    `${JSON.stringify({
+      output: result.output,
+      bytes: result.bytes,
+      counts: result.viewModel.counts,
+      warnings: result.viewModel.warnings,
+    })}\n`,
+  );
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1] ?? "").href) {
+  main().catch((error) => {
+    process.stderr.write(`${error.stack ?? error.message}\n`);
+    process.exitCode = 1;
+  });
+}
diff --git a/plugins/looperators-agent-loop-p0/scripts/normalize-events.mjs b/plugins/looperators-agent-loop-p0/scripts/normalize-events.mjs
new file mode 100644
index 0000000..9a405a6
--- /dev/null
+++ b/plugins/looperators-agent-loop-p0/scripts/normalize-events.mjs
@@ -0,0 +1,310 @@
+#!/usr/bin/env node
+
+import { readdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { pathToFileURL } from "node:url";
+import { atomicWriteJson, P0_EVENTS } from "../lib/event-utils.mjs";
+
+function argument(name, fallback = null) {
+  const index = process.argv.indexOf(`--${name}`);
+  return index >= 0 ? process.argv[index + 1] : fallback;
+}
+
+async function readRecords(directory) {
+  let names = [];
+  try {
+    names = await readdir(directory);
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+  const records = [];
+  for (const name of names.filter((entry) => entry.endsWith(".json")).sort()) {
+    const record = JSON.parse(await readFile(path.join(directory, name), "utf8"));
+    records.push({ ...record, evidence_file: `hook-events/${name}` });
+  }
+  return records.sort((left, right) => {
+    const wall = left.captured_at.localeCompare(right.captured_at);
+    if (wall !== 0) {
+      return wall;
+    }
+    return BigInt(left.started_monotonic_ns) < BigInt(right.started_monotonic_ns)
+      ? -1
+      : 1;
+  });
+}
+
+function normalizedRecord(record, sequence) {
+  const input = record.input ?? {};
+  return {
+    schema_version: 1,
+    sequence,
+    event: input.hook_event_name ?? "Unknown",
+    session_id: input.session_id ?? null,
+    turn_id: input.turn_id ?? null,
+    tool_use_id: input.tool_use_id ?? null,
+    tool_name: input.tool_name ?? null,
+    agent_id: input.agent_id ?? null,
+    agent_type: input.agent_type ?? null,
+    stop_hook_active: input.stop_hook_active ?? null,
+    source: input.source ?? null,
+    lane: record.lane,
+    semantic_key: record.semantic_key,
+    delivery_key: record.delivery_key,
+    captured_at: record.captured_at,
+    duration_ms: record.duration_ms,
+    input_fields: Object.keys(input).sort(),
+    evidence_file: record.evidence_file,
+  };
+}
+
+function buildGraph(events) {
+  const nodeMap = new Map();
+  const edgeMap = new Map();
+  const addNode = (id, kind, label, fields = {}) => {
+    if (!nodeMap.has(id)) {
+      nodeMap.set(id, { id, kind, label, ...fields });
+    }
+  };
+  const addEdge = (source, target, kind, fields = {}) => {
+    const id = `${source}->${target}:${kind}`;
+    if (!edgeMap.has(id)) {
+      edgeMap.set(id, { id, source, target, kind, ...fields });
+    }
+  };
+
+  for (const event of events) {
+    if (!event.session_id) {
+      continue;
+    }
+    const sessionId = `session:${event.session_id}`;
+    addNode(sessionId, "root", "Root session", { session_id: event.session_id });
+    if (event.agent_id) {
+      const agentId = `agent:${event.agent_id}`;
+      addNode(agentId, "subagent", event.agent_type ?? "Subagent", {
+        agent_id: event.agent_id,
+      });
+      addEdge(sessionId, agentId, "spawned");
+    }
+    if (event.tool_use_id) {
+      const toolId = `tool:${event.tool_use_id}`;
+      addNode(toolId, "tool", event.tool_name ?? "Tool", {
+        tool_use_id: event.tool_use_id,
+      });
+      addEdge(sessionId, toolId, "used");
+    }
+  }
+  return {
+    schema_version: 1,
+    nodes: [...nodeMap.values()],
+    edges: [...edgeMap.values()],
+  };
+}
+
+function analyzeConcurrency(records) {
+  const groups = new Map();
+  for (const record of records) {
+    const list = groups.get(record.semantic_key) ?? [];
+    list.push(record);
+    groups.set(record.semantic_key, list);
+  }
+  const probes = [];
+  for (const [semanticKey, group] of groups) {
+    if (new Set(group.map((entry) => entry.lane)).size < 2) {
+      continue;
+    }
+    const intervals = group.map((entry) => ({
+      lane: entry.lane,
+      start: BigInt(entry.started_monotonic_ns),
+      finish: BigInt(entry.finished_monotonic_ns),
+    }));
+    let overlaps = false;
+    for (let left = 0; left < intervals.length; left += 1) {
+      for (let right = left + 1; right < intervals.length; right += 1) {
+        overlaps ||= (
+          intervals[left].start < intervals[right].finish &&
+          intervals[right].start < intervals[left].finish
+        );
+      }
+    }
+    probes.push({
+      semantic_key: semanticKey,
+      lanes: intervals.map((entry) => entry.lane).sort(),
+      overlaps,
+      start_spread_ms:
+        Number(
+          intervals.reduce(
+            (maximum, entry) => (entry.start > maximum ? entry.start : maximum),
+            intervals[0].start,
+          ) -
+            intervals.reduce(
+              (minimum, entry) => (entry.start < minimum ? entry.start : minimum),
+              intervals[0].start,
+            ),
+        ) / 1e6,
+    });
+  }
+  return probes;
+}
+
+function analyzeSubagentOverlap(events) {
+  const lifetimes = new Map();
+  for (const event of events) {
+    if (!event.agent_id) {
+      continue;
+    }
+    const lifetime = lifetimes.get(event.agent_id) ?? {
+      agent_id: event.agent_id,
+      start: null,
+      initial_stop: null,
+      continuation_stop: null,
+    };
+    if (event.event === "SubagentStart") {
+      lifetime.start = Date.parse(event.captured_at);
+    } else if (event.event === "SubagentStop" && event.stop_hook_active === true) {
+      lifetime.continuation_stop = Date.parse(event.captured_at);
+    } else if (event.event === "SubagentStop") {
+      lifetime.initial_stop = Date.parse(event.captured_at);
+    }
+    lifetimes.set(event.agent_id, lifetime);
+  }
+  const completed = [...lifetimes.values()].filter(
+    (entry) => entry.start !== null && (entry.continuation_stop ?? entry.initial_stop) !== null,
+  );
+  const overlaps = [];
+  for (let left = 0; left < completed.length; left += 1) {
+    for (let right = left + 1; right < completed.length; right += 1) {
+      const leftStop =
+        completed[left].continuation_stop ?? completed[left].initial_stop;
+      const rightStop =
+        completed[right].continuation_stop ?? completed[right].initial_stop;
+      const overlapMs =
+        Math.min(leftStop, rightStop) -
+        Math.max(completed[left].start, completed[right].start);
+      overlaps.push({
+        agents: [completed[left].agent_id, completed[right].agent_id].sort(),
+        overlaps: overlapMs > 0,
+        overlap_ms: Math.max(0, overlapMs),
+      });
+    }
+  }
+  return {
+    lifetimes: completed.map((entry) => ({
+      agent_id: entry.agent_id,
+      start: new Date(entry.start).toISOString(),
+      initial_stop: entry.initial_stop
+        ? new Date(entry.initial_stop).toISOString()
+        : null,
+      continuation_stop: entry.continuation_stop
+        ? new Date(entry.continuation_stop).toISOString()
+        : null,
+    })),
+    overlaps,
+  };
+}
+
+export async function normalizeArtifactDirectory(artifactDir) {
+  const records = await readRecords(path.join(artifactDir, "hook-events"));
+  const events = records.map(normalizedRecord);
+  const deliveriesByEvent = Object.fromEntries(
+    [...new Set(events.map((event) => event.event))]
+      .sort()
+      .map((eventName) => [
+        eventName,
+        events.filter((event) => event.event === eventName).length,
+      ]),
+  );
+  const semanticCounts = new Map();
+  for (const event of events) {
+    semanticCounts.set(
+      event.semantic_key,
+      (semanticCounts.get(event.semantic_key) ?? 0) + 1,
+    );
+  }
+  const continuationPairs = events
+    .filter((event) => ["Stop", "SubagentStop"].includes(event.event))
+    .reduce((result, event) => {
+      const key = [
+        event.session_id,
+        event.turn_id,
+        event.event,
+        event.agent_id ?? "-",
+      ].join(":");
+      const current = result[key] ?? { initial: 0, continuation: 0 };
+      current[event.stop_hook_active === true ? "continuation" : "initial"] += 1;
+      result[key] = current;
+      return result;
+    }, {});
+  const summary = {
+    schema_version: 1,
+    generated_at: new Date().toISOString(),
+    total_deliveries: events.length,
+    total_semantic_events: semanticCounts.size,
+    deliveries_by_event: deliveriesByEvent,
+    required_event_coverage: Object.fromEntries(
+      P0_EVENTS.map((eventName) => [
+        eventName,
+        (deliveriesByEvent[eventName] ?? 0) > 0,
+      ]),
+    ),
+    semantic_duplicate_groups: [...semanticCounts.entries()]
+      .filter(([, count]) => count > 1)
+      .map(([semantic_key, count]) => ({ semantic_key, count })),
+    concurrency_probes: analyzeConcurrency(records),
+    subagent_concurrency: analyzeSubagentOverlap(events),
+    continuation_pairs: continuationPairs,
+    transcript_paths: [
+      ...new Set(
+        records
+          .map((record) => record.input?.transcript_path)
+          .filter((entry) => typeof entry === "string"),
+      ),
+    ].sort(),
+    agent_transcript_paths: [
+      ...new Set(
+        records
+          .map((record) => record.input?.agent_transcript_path)
+          .filter((entry) => typeof entry === "string"),
+      ),
+    ].sort(),
+  };
+  const graph = buildGraph(events);
+  await atomicWriteJson(path.join(artifactDir, "normalized-summary.json"), summary);
+  await atomicWriteJson(path.join(artifactDir, "normalized-graph.json"), graph);
+  await writeFile(
+    path.join(artifactDir, "normalized-events.jsonl"),
+    events.map((event) => JSON.stringify(event)).join("\n") +
+      (events.length ? "\n" : ""),
+    { mode: 0o600 },
+  );
+  return { events, graph, summary };
+}
+
+async function main() {
+  const artifactDir = path.resolve(
+    argument(
+      "artifact-dir",
+      process.env.LOOPERATORS_P0_ARTIFACT_DIR ??
+        path.join(process.cwd(), "output", "looperators-agent-loop-p0"),
+    ),
+  );
+  const result = await normalizeArtifactDirectory(artifactDir);
+  process.stdout.write(
+    `${JSON.stringify({
+      artifact_dir: artifactDir,
+      deliveries: result.events.length,
+      semantic_events: result.summary.total_semantic_events,
+      event_coverage: result.summary.required_event_coverage,
+    })}\n`,
+  );
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  main().catch((error) => {
+    console.error(error);
+    process.exitCode = 1;
+  });
+}
diff --git a/plugins/looperators-agent-loop-p0/scripts/probe-mcp-contract.mjs b/plugins/looperators-agent-loop-p0/scripts/probe-mcp-contract.mjs
new file mode 100644
index 0000000..953a9bf
--- /dev/null
+++ b/plugins/looperators-agent-loop-p0/scripts/probe-mcp-contract.mjs
@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { createInterface } from "node:readline";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { atomicWriteJson } from "../lib/event-utils.mjs";
+
+function argument(name, fallback = null) {
+  const index = process.argv.indexOf(`--${name}`);
+  return index >= 0 ? process.argv[index + 1] : fallback;
+}
+
+const outputValue = argument("output");
+if (!outputValue) {
+  throw new Error("--output is required");
+}
+const output = path.resolve(outputValue);
+const pluginRoot = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "..",
+);
+const serverPath = path.join(pluginRoot, "mcp", "server.mjs");
+const child = spawn(process.execPath, [serverPath], {
+  stdio: ["pipe", "pipe", "pipe"],
+});
+let stderr = "";
+child.stderr.on("data", (chunk) => {
+  stderr += chunk;
+});
+const pending = new Map();
+const lines = createInterface({ input: child.stdout, crlfDelay: Infinity });
+lines.on("line", (line) => {
+  const message = JSON.parse(line);
+  pending.get(message.id)?.(message);
+  pending.delete(message.id);
+});
+let nextId = 1;
+const request = (method, params = {}) =>
+  new Promise((resolve, reject) => {
+    const id = nextId++;
+    const timer = setTimeout(
+      () => reject(new Error(`MCP timeout for ${method}: ${stderr}`)),
+      3_000,
+    );
+    pending.set(id, (message) => {
+      clearTimeout(timer);
+      if (message.error) {
+        reject(new Error(message.error.message));
+      } else {
+        resolve(message.result);
+      }
+    });
+    child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}\n`);
+  });
+
+try {
+  const initialize = await request("initialize", {
+    protocolVersion: "2025-06-18",
+    capabilities: {},
+    clientInfo: { name: "looperators-p0-contract-probe", version: "1" },
+  });
+  const toolList = await request("tools/list");
+  const resourceList = await request("resources/list");
+  const resource = await request("resources/read", {
+    uri: "ui://looperators/agent-loop-p0.html",
+  });
+  const widget = await request("tools/call", {
+    name: "loop_widget",
+    arguments: {},
+  });
+  const ping = await request("tools/call", {
+    name: "loop_ping",
+    arguments: { message: "component-call" },
+  });
+  const html = resource.contents[0].text;
+  await atomicWriteJson(output, {
+    schema_version: 1,
+    initialize,
+    tools: toolList.tools,
+    resources: resourceList.resources,
+    resource_read: {
+      uri: resource.contents[0].uri,
+      mimeType: resource.contents[0].mimeType,
+      html_sha256: createHash("sha256").update(html).digest("hex"),
+      html_bytes: Buffer.byteLength(html),
+      contains_ui_initialize: html.includes("ui/initialize"),
+      contains_tool_result_notification: html.includes(
+        "ui/notifications/tool-result",
+      ),
+      contains_component_tools_call: html.includes("tools/call"),
+    },
+    widget_result: widget,
+    component_ping_result: ping,
+  });
+} finally {
+  child.stdin.end();
+}
+process.stdout.write(`${JSON.stringify({ output })}\n`);
diff --git a/plugins/looperators-agent-loop-p0/scripts/run-hook-probe.mjs b/plugins/looperators-agent-loop-p0/scripts/run-hook-probe.mjs
new file mode 100644
index 0000000..a64d896
--- /dev/null
+++ b/plugins/looperators-agent-loop-p0/scripts/run-hook-probe.mjs
@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+
+import { spawn } from "node:child_process";
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { atomicWriteJson } from "../lib/event-utils.mjs";
+
+function argument(name, fallback = null) {
+  const index = process.argv.indexOf(`--${name}`);
+  return index >= 0 ? process.argv[index + 1] : fallback;
+}
+
+const codexBin = path.resolve(argument("codex-bin"));
+const probeDir = path.resolve(argument("probe-dir"));
+const artifactDir = path.resolve(argument("artifact-dir"));
+const runId = argument("run-id", "default");
+const includeUserConfig = process.argv.includes("--include-user-config");
+if (!codexBin || !probeDir || !artifactDir) {
+  throw new Error("--codex-bin, --probe-dir, and --artifact-dir are required");
+}
+
+const lastMessagePath = path.join(
+  artifactDir,
+  `codex-${runId}-last-message.txt`,
+);
+const prompt = [
+  "Run a synthetic looperators Codex hook compatibility probe. Do not inspect",
+  "credentials, user configuration, or files outside this temporary project.",
+  "First call the shell tool exactly once with a harmless command that prints",
+  "P0_TOOL_OK. Then use the Agent/spawn_agent capability to launch exactly two",
+  "independent subagents concurrently. Ask subagent A to return only P0_SUBAGENT_A",
+  "and subagent B to return only P0_SUBAGENT_B; they must not call tools. Wait for",
+  "both. Report P0_TOOL_OK and both markers, then stop. If a Stop or SubagentStop",
+  "hook requests one continuation lap, obey it, output P0_LAP_CONTINUED, call no",
+  "more tools, and stop again.",
+].join(" ");
+const args = [
+  "exec",
+  "--cd",
+  probeDir,
+  "--add-dir",
+  artifactDir,
+  "--skip-git-repo-check",
+  "--sandbox",
+  "workspace-write",
+  "--dangerously-bypass-hook-trust",
+  ...(!includeUserConfig ? ["--ignore-user-config"] : []),
+  "--config",
+  'model_reasoning_effort="high"',
+  "--config",
+  "features.multi_agent=true",
+  "--json",
+  "--output-last-message",
+  lastMessagePath,
+  prompt,
+];
+
+await mkdir(artifactDir, { recursive: true, mode: 0o700 });
+await atomicWriteJson(path.join(artifactDir, `codex-${runId}-command.json`), {
+  executable: codexBin,
+  arguments: args,
+  cwd: probeDir,
+  includes_user_config: includeUserConfig,
+  environment_overrides: {
+    LOOPERATORS_P0_ARTIFACT_DIR: artifactDir,
+    LOOPERATORS_P0_CONTINUATION_MODE: "lap",
+  },
+});
+
+const child = spawn(codexBin, args, {
+  cwd: probeDir,
+  env: {
+    ...process.env,
+    LOOPERATORS_P0_ARTIFACT_DIR: artifactDir,
+    LOOPERATORS_P0_CONTINUATION_MODE: "lap",
+  },
+  stdio: ["ignore", "pipe", "pipe"],
+});
+const stdoutChunks = [];
+const stderrChunks = [];
+child.stdout.on("data", (chunk) => {
+  stdoutChunks.push(chunk);
+  process.stdout.write(chunk);
+});
+child.stderr.on("data", (chunk) => {
+  stderrChunks.push(chunk);
+  process.stderr.write(chunk);
+});
+const exitCode = await new Promise((resolve, reject) => {
+  child.on("error", reject);
+  child.on("close", resolve);
+});
+await writeFile(
+  path.join(artifactDir, `codex-${runId}.jsonl`),
+  Buffer.concat(stdoutChunks),
+  { mode: 0o600 },
+);
+await writeFile(
+  path.join(artifactDir, `codex-${runId}.stderr.txt`),
+  Buffer.concat(stderrChunks),
+  { mode: 0o600 },
+);
+await atomicWriteJson(path.join(artifactDir, `codex-${runId}-result.json`), {
+  exit_code: exitCode,
+  completed_at: new Date().toISOString(),
+});
+process.exitCode = exitCode ?? 1;
diff --git a/plugins/looperators-agent-loop-p0/scripts/run-mcp-host-probe.mjs b/plugins/looperators-agent-loop-p0/scripts/run-mcp-host-probe.mjs
new file mode 100644
index 0000000..6929b82
--- /dev/null
+++ b/plugins/looperators-agent-loop-p0/scripts/run-mcp-host-probe.mjs
@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+
+import { spawn } from "node:child_process";
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { atomicWriteJson } from "../lib/event-utils.mjs";
+
+function argument(name, fallback = null) {
+  const index = process.argv.indexOf(`--${name}`);
+  return index >= 0 ? process.argv[index + 1] : fallback;
+}
+
+const codexBinValue = argument("codex-bin");
+const probeDirValue = argument("probe-dir");
+const artifactDirValue = argument("artifact-dir");
+if (!codexBinValue || !probeDirValue || !artifactDirValue) {
+  throw new Error("--codex-bin, --probe-dir, and --artifact-dir are required");
+}
+const codexBin = path.resolve(codexBinValue);
+const probeDir = path.resolve(probeDirValue);
+const artifactDir = path.resolve(artifactDirValue);
+const runId = argument("run-id", "project-config");
+const injectConfig = process.argv.includes("--inject-config");
+const pluginRoot = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "..",
+);
+const mcpServer = path.join(pluginRoot, "mcp", "server.mjs");
+const prompt = [
+  "Run the synthetic looperators MCP App host probe.",
+  "Call the MCP tool loop_widget from server looperators_agent_loop_p0 exactly once.",
+  "Do not call any other tool and do not inspect local files.",
+  "Report the number of nodes in structuredContent and whether the tool advertises",
+  "the resource ui://looperators/agent-loop-p0.html, then stop.",
+].join(" ");
+const args = [
+  "exec",
+  "--cd",
+  probeDir,
+  "--skip-git-repo-check",
+  "--sandbox",
+  "read-only",
+  "--enable",
+  "enable_mcp_apps",
+  ...(injectConfig
+    ? [
+        "--config",
+        `mcp_servers.looperators_agent_loop_p0.command=${JSON.stringify(process.execPath)}`,
+        "--config",
+        `mcp_servers.looperators_agent_loop_p0.args=${JSON.stringify([mcpServer])}`,
+        "--config",
+        `mcp_servers.looperators_agent_loop_p0.env={ LOOPERATORS_P0_ARTIFACT_DIR = ${JSON.stringify(artifactDir)} }`,
+      ]
+    : []),
+  "--config",
+  'model_reasoning_effort="high"',
+  "--json",
+  "--output-last-message",
+  path.join(artifactDir, `codex-${runId}-last-message.txt`),
+  prompt,
+];
+
+await mkdir(artifactDir, { recursive: true, mode: 0o700 });
+await atomicWriteJson(path.join(artifactDir, `codex-${runId}-command.json`), {
+  executable: codexBin,
+  arguments: args,
+  cwd: probeDir,
+  injected_config: injectConfig,
+});
+const child = spawn(codexBin, args, {
+  cwd: probeDir,
+  env: process.env,
+  stdio: ["ignore", "pipe", "pipe"],
+});
+const stdoutChunks = [];
+const stderrChunks = [];
+child.stdout.on("data", (chunk) => {
+  stdoutChunks.push(chunk);
+  process.stdout.write(chunk);
+});
+child.stderr.on("data", (chunk) => {
+  stderrChunks.push(chunk);
+  process.stderr.write(chunk);
+});
+const exitCode = await new Promise((resolve, reject) => {
+  child.on("error", reject);
+  child.on("close", resolve);
+});
+await writeFile(
+  path.join(artifactDir, `codex-${runId}.jsonl`),
+  Buffer.concat(stdoutChunks),
+  { mode: 0o600 },
+);
+await writeFile(
+  path.join(artifactDir, `codex-${runId}.stderr.txt`),
+  Buffer.concat(stderrChunks),
+  { mode: 0o600 },
+);
+await atomicWriteJson(path.join(artifactDir, `codex-${runId}-result.json`), {
+  exit_code: exitCode,
+  completed_at: new Date().toISOString(),
+});
+process.exitCode = exitCode ?? 1;
diff --git a/plugins/looperators-agent-loop-p0/scripts/sidecar-server.mjs b/plugins/looperators-agent-loop-p0/scripts/sidecar-server.mjs
new file mode 100644
index 0000000..d82cc97
--- /dev/null
+++ b/plugins/looperators-agent-loop-p0/scripts/sidecar-server.mjs
@@ -0,0 +1,271 @@
+#!/usr/bin/env node
+
+import { watch } from "node:fs";
+import { mkdir, readFile, readdir } from "node:fs/promises";
+import http from "node:http";
+import path from "node:path";
+import process from "node:process";
+import { safeTokenEqual } from "../lib/event-utils.mjs";
+
+function argument(name, fallback = null) {
+  const index = process.argv.indexOf(`--${name}`);
+  return index >= 0 ? process.argv[index + 1] : fallback;
+}
+
+const host = argument("host", "127.0.0.1");
+const port = Number(argument("port", "0"));
+const artifactDir = path.resolve(
+  argument(
+    "artifact-dir",
+    process.env.LOOPERATORS_P0_ARTIFACT_DIR ??
+      path.join(process.cwd(), "output", "looperators-agent-loop-p0"),
+  ),
+);
+const token =
+  process.env.LOOPERATORS_P0_SIDECAR_TOKEN ?? argument("token", "");
+
+if (host !== "127.0.0.1") {
+  throw new Error("The P0 sidecar only permits --host 127.0.0.1");
+}
+if (!Number.isInteger(port) || port < 0 || port > 65535) {
+  throw new Error("--port must be an integer from 0 through 65535");
+}
+if (token.length < 16) {
+  throw new Error(
+    "Set LOOPERATORS_P0_SIDECAR_TOKEN to an explicit or random token of at least 16 characters",
+  );
+}
+
+const html = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width,initial-scale=1" />
+    <title>looperators Agent Loop sidecar</title>
+    <style>
+      :root { color-scheme: dark; font-family: ui-sans-serif, system-ui, sans-serif; }
+      body { margin: 0; padding: 20px; background: #0a0f1e; color: #edf1ff; }
+      header { display: flex; align-items: baseline; justify-content: space-between; }
+      h1 { margin: 0; font-size: 20px; }
+      #status { color: #96f0c8; font: 12px ui-monospace, monospace; }
+      #graph { display: grid; grid-template-columns: repeat(auto-fit, minmax(150px, 1fr)); gap: 10px; margin: 18px 0; }
+      .node { border: 1px solid #5068ad; border-radius: 10px; padding: 12px; background: #121a33; }
+      .node small { display: block; margin-top: 5px; color: #9eaddb; }
+      table { width: 100%; border-collapse: collapse; font: 12px ui-monospace, monospace; }
+      th, td { padding: 7px; border-bottom: 1px solid #283454; text-align: left; }
+    </style>
+  </head>
+  <body>
+    <header><h1>looperators Agent Loop</h1><span id="status">connecting…</span></header>
+    <div id="graph"></div>
+    <table>
+      <thead><tr><th>#</th><th>event</th><th>turn</th><th>agent/tool</th></tr></thead>
+      <tbody id="events"></tbody>
+    </table>
+    <script>
+      const status = document.querySelector("#status");
+      const graph = document.querySelector("#graph");
+      const events = document.querySelector("#events");
+      const stream = new EventSource("/events");
+      stream.addEventListener("snapshot", (event) => {
+        const data = JSON.parse(event.data);
+        graph.innerHTML = (data.graph?.nodes ?? []).map((node) =>
+          '<div class="node">' + escapeHtml(node.label ?? node.id) +
+          '<small>' + escapeHtml(node.kind ?? "node") + "</small></div>"
+        ).join("");
+        events.innerHTML = (data.events ?? []).slice(-20).reverse().map((row) =>
+          "<tr><td>" + row.sequence + "</td><td>" + escapeHtml(row.event) +
+          "</td><td>" + escapeHtml(row.turn_id ?? "-") + "</td><td>" +
+          escapeHtml(row.agent_id ?? row.tool_name ?? "-") + "</td></tr>"
+        ).join("");
+        status.textContent = "live · " + new Date().toLocaleTimeString();
+      });
+      stream.onerror = () => { status.textContent = "reconnecting…"; };
+      function escapeHtml(value) {
+        const span = document.createElement("span");
+        span.textContent = String(value);
+        return span.innerHTML;
+      }
+    </script>
+  </body>
+</html>`;
+
+const clients = new Set();
+let watcher;
+let debounceTimer;
+
+async function loadJson(fileName, fallback) {
+  try {
+    return JSON.parse(await readFile(path.join(artifactDir, fileName), "utf8"));
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return fallback;
+    }
+    throw error;
+  }
+}
+
+async function loadEvents() {
+  try {
+    const body = await readFile(
+      path.join(artifactDir, "normalized-events.jsonl"),
+      "utf8",
+    );
+    return body
+      .split("\n")
+      .filter(Boolean)
+      .map((line) => JSON.parse(line));
+  } catch (error) {
+    if (error?.code !== "ENOENT") {
+      throw error;
+    }
+    let names = [];
+    try {
+      names = await readdir(path.join(artifactDir, "hook-events"));
+    } catch (nestedError) {
+      if (nestedError?.code === "ENOENT") {
+        return [];
+      }
+      throw nestedError;
+    }
+    return names
+      .filter((name) => name.endsWith(".json"))
+      .sort()
+      .slice(-20)
+      .map((name, index) => ({
+        sequence: index + 1,
+        event: "un-normalized delivery",
+        turn_id: null,
+        agent_id: null,
+        evidence_file: name,
+      }));
+  }
+}
+
+async function snapshot() {
+  return {
+    generated_at: new Date().toISOString(),
+    graph: await loadJson("normalized-graph.json", { nodes: [], edges: [] }),
+    events: await loadEvents(),
+  };
+}
+
+async function broadcast() {
+  const payload = `event: snapshot\ndata: ${JSON.stringify(await snapshot())}\n\n`;
+  for (const response of clients) {
+    response.write(payload);
+  }
+}
+
+function scheduleBroadcast() {
+  clearTimeout(debounceTimer);
+  debounceTimer = setTimeout(() => {
+    broadcast().catch(() => {});
+  }, 40);
+}
+
+function parseCookies(header) {
+  return Object.fromEntries(
+    String(header ?? "")
+      .split(";")
+      .map((part) => part.trim())
+      .filter(Boolean)
+      .map((part) => {
+        const separator = part.indexOf("=");
+        return [
+          part.slice(0, separator),
+          decodeURIComponent(part.slice(separator + 1)),
+        ];
+      }),
+  );
+}
+
+function authenticated(request) {
+  const bearer = request.headers.authorization?.startsWith("Bearer ")
+    ? request.headers.authorization.slice("Bearer ".length)
+    : "";
+  const cookie = parseCookies(request.headers.cookie).looperators_p0;
+  return safeTokenEqual(bearer || cookie || "", token);
+}
+
+const server = http.createServer(async (request, response) => {
+  const url = new URL(request.url ?? "/", `http://${host}`);
+  const queryToken = url.searchParams.get("token") ?? "";
+  if (queryToken && safeTokenEqual(queryToken, token)) {
+    response.writeHead(303, {
+      Location: url.pathname,
+      "Set-Cookie": `looperators_p0=${encodeURIComponent(token)}; HttpOnly; SameSite=Strict; Path=/`,
+      "Cache-Control": "no-store",
+    });
+    response.end();
+    return;
+  }
+  if (!authenticated(request)) {
+    response.writeHead(401, {
+      "Content-Type": "text/plain; charset=utf-8",
+      "Cache-Control": "no-store",
+    });
+    response.end("Unauthorized\n");
+    return;
+  }
+  if (url.pathname === "/") {
+    response.writeHead(200, {
+      "Content-Type": "text/html; charset=utf-8",
+      "Cache-Control": "no-store",
+      "Content-Security-Policy":
+        "default-src 'self'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; connect-src 'self'; frame-ancestors 'none'",
+      "X-Content-Type-Options": "nosniff",
+      "Referrer-Policy": "no-referrer",
+    });
+    response.end(html);
+    return;
+  }
+  if (url.pathname === "/snapshot") {
+    response.writeHead(200, {
+      "Content-Type": "application/json; charset=utf-8",
+      "Cache-Control": "no-store",
+    });
+    response.end(`${JSON.stringify(await snapshot())}\n`);
+    return;
+  }
+  if (url.pathname === "/events") {
+    response.writeHead(200, {
+      "Content-Type": "text/event-stream; charset=utf-8",
+      "Cache-Control": "no-store",
+      Connection: "keep-alive",
+    });
+    response.write(`event: snapshot\ndata: ${JSON.stringify(await snapshot())}\n\n`);
+    clients.add(response);
+    request.on("close", () => clients.delete(response));
+    return;
+  }
+  response.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
+  response.end("Not found\n");
+});
+
+await mkdir(artifactDir, { recursive: true, mode: 0o700 });
+watcher = watch(artifactDir, { recursive: true }, scheduleBroadcast);
+server.listen(port, host, () => {
+  const address = server.address();
+  process.stdout.write(
+    `${JSON.stringify({
+      status: "ready",
+      host,
+      port: address.port,
+      base_url: `http://${host}:${address.port}/`,
+      token_required: true,
+      artifact_dir: artifactDir,
+    })}\n`,
+  );
+});
+
+function shutdown() {
+  watcher?.close();
+  for (const response of clients) {
+    response.end();
+  }
+  server.close(() => process.exit(0));
+}
+
+process.on("SIGTERM", shutdown);
+process.on("SIGINT", shutdown);
diff --git a/plugins/looperators-agent-loop-p0/skills/agent-loop-visualization/SKILL.md b/plugins/looperators-agent-loop-p0/skills/agent-loop-visualization/SKILL.md
new file mode 100644
index 0000000..1f1446a
--- /dev/null
+++ b/plugins/looperators-agent-loop-p0/skills/agent-loop-visualization/SKILL.md
@@ -0,0 +1,43 @@
+---
+name: agent-loop-visualization
+description: Normalize looperators P0 Codex hook events and render a small thread-scoped Agent Loop graph with the native codex-inline-vis directive. Use only when the user asks for the looperators Agent Loop P0 visualization or compatibility probe.
+---
+
+# looperators Agent Loop visualization
+
+This skill is an explicit P0 compatibility probe. Do not treat it as a durable
+or implicit orchestration protocol.
+
+1. Require the exact experiment artifact directory from the user's request.
+   Resolve it to an absolute path and verify that it is a directory. Do not
+   search other tasks, guess a repository, or infer state by tailing a Codex
+   transcript.
+2. If `<artifact-dir>/hook-events/` exists, run:
+
+   `node "${PLUGIN_ROOT}/scripts/normalize-events.mjs" --artifact-dir "<artifact-dir>"`
+
+   If it does not exist, proceed only when `normalized-graph.json` or
+   `normalized-events.jsonl` already exists. Otherwise report the missing input
+   and stop. Never generate sample nodes or substitute another artifact set.
+3. Use only the thread-scoped visualization directory exposed as a writable
+   root for the current task. Verify that it is an existing directory. Do not
+   guess a `CODEX_HOME` path, create a global fallback, or write through a
+   symlink.
+4. Generate the deterministic fragment from the normalized artifacts:
+
+   `node "${PLUGIN_ROOT}/scripts/generate-inline-visualization.mjs" --artifact-dir "<artifact-dir>" --output "<thread-visualization-dir>/looperators-agent-loop.html"`
+
+   The generator rejects output symlinks, writes atomically with mode `0600`,
+   includes only observed data, and rejects fragments at or above 2 MiB.
+5. Read the generated file back and verify that it is a regular fragment named
+   `looperators-agent-loop.html`, contains no full HTML shell, and reports no
+   source warning unless the input really is partial.
+6. On success, emit only this directive, on its own line and outside a code
+   fence:
+
+   `::codex-inline-vis{file="looperators-agent-loop.html"}`
+
+If the artifact directory, normalized inputs, or writable thread directory is
+unavailable, report that exact limitation and do not emit the directive.
+Presentation controls and `sendFollowUpMessage` stay inside the native card;
+they do not make live network requests or arbitrary tool calls.
diff --git a/plugins/looperators-agent-loop-p0/tests/hooks-and-normalization.test.mjs b/plugins/looperators-agent-loop-p0/tests/hooks-and-normalization.test.mjs
new file mode 100644
index 0000000..6cc7141
--- /dev/null
+++ b/plugins/looperators-agent-loop-p0/tests/hooks-and-normalization.test.mjs
@@ -0,0 +1,129 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { normalizeArtifactDirectory } from "../scripts/normalize-events.mjs";
+
+const pluginRoot = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "..",
+);
+const collector = path.join(pluginRoot, "hooks", "collect-event.mjs");
+
+function runCollector(artifactDir, input, extraArgs = []) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [collector, "--lane", "primary", ...extraArgs], {
+      env: {
+        ...process.env,
+        LOOPERATORS_P0_ARTIFACT_DIR: artifactDir,
+        LOOPERATORS_P0_CONTINUATION_MODE: "lap",
+      },
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(`collector exited ${code}: ${stderr}`));
+        return;
+      }
+      resolve(stdout ? JSON.parse(stdout) : null);
+    });
+    child.stdin.end(JSON.stringify(input));
+  });
+}
+
+test("collector is idempotent and caps Stop continuation at one lap", async () => {
+  const artifactDir = await mkdtemp(
+    path.join(os.tmpdir(), "looperators-p0-hooks-"),
+  );
+  const base = {
+    session_id: "session-test",
+    turn_id: "turn-test",
+    hook_event_name: "Stop",
+    transcript_path: "/tmp/transcript.jsonl",
+    stop_hook_active: false,
+    last_assistant_message: "synthetic private-looking text",
+  };
+  const first = await runCollector(artifactDir, base);
+  const duplicate = await runCollector(artifactDir, base);
+  const continuation = await runCollector(artifactDir, {
+    ...base,
+    stop_hook_active: true,
+    last_assistant_message: "P0_LAP_CONTINUED",
+  });
+  assert.equal(first.decision, "block");
+  assert.equal(duplicate.continue, true);
+  assert.equal(continuation.continue, true);
+
+  const result = await normalizeArtifactDirectory(artifactDir);
+  assert.equal(result.events.length, 2, "duplicate delivery is not written twice");
+  assert.equal(result.summary.continuation_pairs[
+    "session-test:turn-test:Stop:-"
+  ].initial, 1);
+  assert.equal(result.summary.continuation_pairs[
+    "session-test:turn-test:Stop:-"
+  ].continuation, 1);
+
+  const raw = JSON.parse(
+    await readFile(
+      path.join(artifactDir, result.events[0].evidence_file),
+      "utf8",
+    ),
+  );
+  assert.equal(raw.input.last_assistant_message._redacted, "last_assistant_message");
+  assert.equal(raw.input.last_assistant_message.bytes > 0, true);
+});
+
+test("normalizer reports overlap for parallel matching handlers", async () => {
+  const artifactDir = await mkdtemp(
+    path.join(os.tmpdir(), "looperators-p0-concurrency-"),
+  );
+  const input = {
+    session_id: "session-test",
+    turn_id: "turn-test",
+    hook_event_name: "PreToolUse",
+    tool_name: "Bash",
+    tool_use_id: "tool-test",
+    tool_input: { command: "printf synthetic" },
+  };
+  const runLane = (lane) =>
+    new Promise((resolve, reject) => {
+      const child = spawn(
+        process.execPath,
+        [collector, "--lane", lane, "--delay-ms", "100"],
+        {
+          env: {
+            ...process.env,
+            LOOPERATORS_P0_ARTIFACT_DIR: artifactDir,
+          },
+          stdio: ["pipe", "ignore", "pipe"],
+        },
+      );
+      let stderr = "";
+      child.stderr.on("data", (chunk) => {
+        stderr += chunk;
+      });
+      child.on("error", reject);
+      child.on("close", (code) =>
+        code === 0
+          ? resolve()
+          : reject(new Error(`collector exited ${code}: ${stderr}`)),
+      );
+      child.stdin.end(JSON.stringify(input));
+    });
+  await Promise.all([runLane("parallel-a"), runLane("parallel-b")]);
+  const result = await normalizeArtifactDirectory(artifactDir);
+  assert.equal(result.summary.concurrency_probes.length, 1);
+  assert.equal(result.summary.concurrency_probes[0].overlaps, true);
+});
diff --git a/plugins/looperators-agent-loop-p0/tests/inline-browser-contract.test.mjs b/plugins/looperators-agent-loop-p0/tests/inline-browser-contract.test.mjs
new file mode 100644
index 0000000..76c8476
--- /dev/null
+++ b/plugins/looperators-agent-loop-p0/tests/inline-browser-contract.test.mjs
@@ -0,0 +1,282 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import {
+  access,
+  mkdir,
+  mkdtemp,
+  readFile,
+  writeFile,
+} from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import test from "node:test";
+import { pathToFileURL } from "node:url";
+import { generateInlineVisualization } from "../scripts/generate-inline-visualization.mjs";
+import { createRecordedArtifactFixture } from "./recorded-artifact-fixture.mjs";
+
+const execFileAsync = promisify(execFile);
+
+async function loadPlaywright() {
+  const moduleDirectory = process.env.LOOPERATORS_P0_PLAYWRIGHT_MODULE_DIR;
+  if (moduleDirectory) {
+    return import(
+      pathToFileURL(path.join(moduleDirectory, "playwright", "index.mjs")).href
+    );
+  }
+  return import("playwright");
+}
+
+async function findFragmentFrame(page) {
+  for (let attempt = 0; attempt < 100; attempt += 1) {
+    for (const frame of page.frames()) {
+      if (
+        frame !== page.mainFrame() &&
+        (await frame.locator("#looperators-agent-loop-p06").count()) === 1
+      ) {
+        return frame;
+      }
+    }
+    await page.waitForTimeout(25);
+  }
+  throw new Error("Official preview did not expose the inline fragment frame");
+}
+
+test("official preview executes selection, details, zoom, filter, follow-up, and narrow layout", async (t) => {
+  let playwright;
+  try {
+    playwright = await loadPlaywright();
+  } catch (error) {
+    t.skip(`Playwright is unavailable: ${error.message}`);
+    return;
+  }
+  const renderScript = process.env.LOOPERATORS_P0_RENDER_PY;
+  if (!renderScript) {
+    t.skip("LOOPERATORS_P0_RENDER_PY is not set");
+    return;
+  }
+  await access(renderScript);
+
+  const temporary = await mkdtemp(
+    path.join(os.tmpdir(), "looperators-p0-browser-contract-"),
+  );
+  const recordedArtifactDir = await createRecordedArtifactFixture();
+  const fragmentPath = path.join(temporary, "looperators-agent-loop.html");
+  const previewPath = path.join(temporary, "looperators-agent-loop-preview.html");
+  await generateInlineVisualization({
+    artifactDir: recordedArtifactDir,
+    outputPath: fragmentPath,
+  });
+  await execFileAsync(process.env.PYTHON ?? "python3", [
+    renderScript,
+    fragmentPath,
+    previewPath,
+  ]);
+
+  const browser = await playwright.chromium.launch({ headless: true });
+  t.after(() => browser.close());
+  const context = await browser.newContext({
+    viewport: { width: 736, height: 1000 },
+  });
+  await context.addInitScript(() => {
+    window.__looperatorsFollowUps = [];
+    window.openai = {
+      sendFollowUpMessage: async (payload) => {
+        window.__looperatorsFollowUps.push(payload);
+        return { accepted: true };
+      },
+    };
+  });
+  const page = await context.newPage();
+  await page.goto(pathToFileURL(previewPath).href);
+  const frame = await findFragmentFrame(page);
+  const root = frame.locator("#looperators-agent-loop-p06");
+  await root.waitFor();
+
+  const summary = frame.locator("#loop-acceptance-summary");
+  assert.match(await summary.inputValue(), /JS ready=pass/u);
+  const followUp = frame.locator("#loop-follow-up");
+  assert.equal(await followUp.isDisabled(), true);
+
+  const rootButton = frame.locator('[data-kind="root"]');
+  await frame.locator("#loop-zoom-reset").focus();
+  await page.keyboard.press("Tab");
+  assert.equal(
+    await frame.evaluate(
+      () => document.activeElement?.getAttribute("data-kind"),
+    ),
+    "root",
+  );
+  await page.keyboard.press("Enter");
+  assert.equal(await rootButton.getAttribute("aria-pressed"), "true");
+  assert.match(
+    await frame.locator("#loop-detail-id").textContent(),
+    /session:019f9a38-9f26-71d0-b908-df3626a5d40c/u,
+  );
+  assert.match(
+    await frame.locator("#loop-timeline").textContent(),
+    /SessionStart[\s\S]*Stop/u,
+  );
+
+  const subagents = frame.locator('[data-kind="subagent"]');
+  await page.keyboard.press("Tab");
+  assert.equal(
+    await frame.evaluate(
+      () => document.activeElement?.getAttribute("data-node-id"),
+    ),
+    "agent:019f9a39-0485-75f0-b6cf-8beba2cc59cd",
+  );
+  await page.keyboard.press("Enter");
+  await page.keyboard.press("Tab");
+  assert.equal(
+    await frame.evaluate(
+      () => document.activeElement?.getAttribute("data-node-id"),
+    ),
+    "agent:019f9a39-1681-7b90-98e1-55ac153248dd",
+  );
+  await page.keyboard.press("Space");
+  assert.equal(await subagents.nth(1).getAttribute("aria-pressed"), "true");
+  assert.match(
+    await frame.locator("#loop-detail-id").textContent(),
+    /agent:019f9a39-1681-7b90-98e1-55ac153248dd/u,
+  );
+  assert.match(
+    await frame.locator("#loop-detail-counts").textContent(),
+    /3 semantic events · initial stops 1 · continuations 1/u,
+  );
+
+  await frame.locator("#loop-zoom-in").click();
+  assert.equal(await frame.locator("#loop-zoom-value").textContent(), "110%");
+  await frame.locator("#loop-zoom-out").click();
+  await frame.locator("#loop-zoom-out").click();
+  assert.equal(await frame.locator("#loop-zoom-value").textContent(), "90%");
+  await frame.locator("#loop-zoom-reset").click();
+  assert.equal(await frame.locator("#loop-zoom-value").textContent(), "100%");
+
+  const filter = frame.locator("#loop-filter");
+  await filter.selectOption("subagent");
+  assert.equal(await rootButton.isHidden(), true);
+  assert.equal(await subagents.nth(0).isVisible(), true);
+  await filter.selectOption("root");
+  assert.equal(await rootButton.isVisible(), true);
+  assert.equal(await subagents.nth(0).isHidden(), true);
+  await filter.selectOption("all");
+  assert.equal(await rootButton.isVisible(), true);
+  assert.equal(await subagents.nth(1).isVisible(), true);
+
+  await followUp.click();
+  await frame
+    .locator("#loop-follow-up-status")
+    .filter({ hasText: "Follow-up requested." })
+    .waitFor();
+  const followUps = await frame.evaluate(() => window.__looperatorsFollowUps);
+  assert.equal(followUps.length, 1);
+  assert.match(
+    followUps[0].prompt,
+    /stable identifier "agent:019f9a39-1681-7b90-98e1-55ac153248dd"/u,
+  );
+  assert.match(followUps[0].prompt, /separating recorded facts from inference/u);
+  assert.equal(followUps[0].title, "Explain loop node 019f…3248dd");
+
+  const finalSummary = await summary.inputValue();
+  for (const check of [
+    "JS ready=pass",
+    "node selected=pass",
+    "details updated=pass",
+    "zoom changed/reset=pass",
+    "filter changed=pass",
+    "follow-up requested=pass",
+  ]) {
+    assert.match(finalSummary, new RegExp(check.replace("/", "\\/"), "u"));
+  }
+
+  await page.setViewportSize({ width: 320, height: 1600 });
+  await page.waitForTimeout(50);
+  const layout = await frame.evaluate(() => {
+    const visualization = document.getElementById(
+      "looperators-agent-loop-p06",
+    );
+    const rootRect = visualization.getBoundingClientRect();
+    const visibleControls = [...visualization.querySelectorAll("button, select, textarea")]
+      .filter((element) => {
+        const style = getComputedStyle(element);
+        return !element.hidden && style.display !== "none";
+      })
+      .map((element) => {
+        const rect = element.getBoundingClientRect();
+        return {
+          label:
+            element.getAttribute("aria-label") ??
+            element.textContent.trim().slice(0, 40),
+          left: rect.left,
+          right: rect.right,
+        };
+      });
+    return {
+      documentClientWidth: document.documentElement.clientWidth,
+      documentScrollWidth: document.documentElement.scrollWidth,
+      rootClientWidth: visualization.clientWidth,
+      rootScrollWidth: visualization.scrollWidth,
+      rootLeft: rootRect.left,
+      rootRight: rootRect.right,
+      stageHeight: document.getElementById("loop-stage").getBoundingClientRect()
+        .height,
+      stageViewportHeight: document
+        .getElementById("loop-stage-viewport")
+        .getBoundingClientRect().height,
+      visibleControls,
+    };
+  });
+  assert.equal(
+    layout.documentScrollWidth <= layout.documentClientWidth + 1,
+    true,
+    JSON.stringify(layout),
+  );
+  assert.equal(
+    layout.rootScrollWidth <= layout.rootClientWidth + 1,
+    true,
+    JSON.stringify(layout),
+  );
+  assert.equal(
+    layout.stageViewportHeight >= layout.stageHeight - 1,
+    true,
+    JSON.stringify(layout),
+  );
+  for (const control of layout.visibleControls) {
+    assert.equal(
+      control.left >= layout.rootLeft - 1 &&
+        control.right <= layout.rootRight + 1,
+      true,
+      JSON.stringify({ control, layout }),
+    );
+  }
+
+  const evidenceDir = process.env.LOOPERATORS_P0_BROWSER_EVIDENCE_DIR;
+  if (evidenceDir) {
+    await mkdir(evidenceDir, { recursive: true });
+    await root.screenshot({
+      path: path.join(evidenceDir, "headless-inline-320.png"),
+    });
+    await page.setViewportSize({ width: 736, height: 1000 });
+    await page.waitForTimeout(50);
+    await root.screenshot({
+      path: path.join(evidenceDir, "headless-inline-736.png"),
+    });
+    await writeFile(
+      path.join(evidenceDir, "headless-browser-contract.json"),
+      `${JSON.stringify(
+        {
+          officialRenderScript: renderScript,
+          fragmentBytes: (await readFile(fragmentPath)).byteLength,
+          nodeCount: await frame.locator("[data-node-id]").count(),
+          finalSummary,
+          followUps,
+          narrowLayout: layout,
+        },
+        null,
+        2,
+      )}\n`,
+      "utf8",
+    );
+  }
+});
diff --git a/plugins/looperators-agent-loop-p0/tests/inline-visualization.test.mjs b/plugins/looperators-agent-loop-p0/tests/inline-visualization.test.mjs
new file mode 100644
index 0000000..0173336
--- /dev/null
+++ b/plugins/looperators-agent-loop-p0/tests/inline-visualization.test.mjs
@@ -0,0 +1,122 @@
+import assert from "node:assert/strict";
+import {
+  lstat,
+  mkdtemp,
+  mkdir,
+  readFile,
+  symlink,
+} from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import {
+  buildLoopViewModel,
+  generateInlineVisualization,
+  loadNormalizedArtifactData,
+  renderInlineVisualization,
+} from "../scripts/generate-inline-visualization.mjs";
+import { createRecordedArtifactFixture } from "./recorded-artifact-fixture.mjs";
+
+test("generator projects the recorded three agents and two spawned edges", async () => {
+  const recordedArtifactDir = await createRecordedArtifactFixture();
+  const source = await loadNormalizedArtifactData(recordedArtifactDir);
+  const model = buildLoopViewModel(source);
+
+  assert.deepEqual(model.counts, {
+    deliveries: 22,
+    semanticEvents: 18,
+    graphNodes: 7,
+    graphEdges: 6,
+    agentNodes: 3,
+    agentEdges: 2,
+  });
+  assert.deepEqual(
+    model.nodes.map((node) => node.id),
+    [
+      "session:019f9a38-9f26-71d0-b908-df3626a5d40c",
+      "agent:019f9a39-0485-75f0-b6cf-8beba2cc59cd",
+      "agent:019f9a39-1681-7b90-98e1-55ac153248dd",
+    ],
+  );
+  assert.equal(model.edges.every((edge) => edge.kind === "spawned"), true);
+  assert.deepEqual(model.semanticEventCounts, {
+    PostToolUse: 4,
+    PreToolUse: 4,
+    SessionStart: 1,
+    Stop: 2,
+    SubagentStart: 2,
+    SubagentStop: 4,
+    UserPromptSubmit: 1,
+  });
+  for (const node of model.nodes) {
+    assert.equal(node.status, "Continuation completed");
+    assert.equal(node.initialStops, 1);
+    assert.equal(node.continuations, 1);
+  }
+  assert.equal(model.warnings.length, 0);
+});
+
+test("generated output is a deterministic, network-free inline fragment with real data", async () => {
+  const recordedArtifactDir = await createRecordedArtifactFixture();
+  const source = await loadNormalizedArtifactData(recordedArtifactDir);
+  const model = buildLoopViewModel(source);
+  const first = renderInlineVisualization(model);
+  const second = renderInlineVisualization(model);
+
+  assert.equal(first, second);
+  assert.equal(Buffer.byteLength(first) < 2 * 1024 * 1024, true);
+  assert.doesNotMatch(first, /<!doctype|<html(?:\s|>)|<head(?:\s|>)|<body(?:\s|>)/iu);
+  assert.doesNotMatch(first, /\bfetch\s*\(|XMLHttpRequest|WebSocket/);
+  assert.doesNotMatch(first, /expandable|Static thread-scoped|display-only/u);
+  assert.match(
+    first,
+    /Interactive snapshot · local controls · no live network\/tool calls/u,
+  );
+  assert.match(first, /window\.openai\.sendFollowUpMessage/u);
+  assert.match(first, /session:019f9a38-9f26-71d0-b908-df3626a5d40c/u);
+  assert.match(first, /agent:019f9a39-0485-75f0-b6cf-8beba2cc59cd/u);
+  assert.match(first, /agent:019f9a39-1681-7b90-98e1-55ac153248dd/u);
+  assert.match(first, /"PreToolUse":4/u);
+  assert.match(first, /"SubagentStop":4/u);
+  assert.match(first, /<button class="btn viz-tile"/u);
+  assert.match(first, /aria-label="Ask Codex about selected node"/u);
+});
+
+test("generator degrades to an empty observed snapshot and rejects output symlinks", async () => {
+  const artifactDir = await mkdtemp(
+    path.join(os.tmpdir(), "looperators-p0-empty-artifacts-"),
+  );
+  const outputDir = await mkdtemp(
+    path.join(os.tmpdir(), "looperators-p0-inline-output-"),
+  );
+  const output = path.join(outputDir, "looperators-agent-loop.html");
+  const result = await generateInlineVisualization({
+    artifactDir,
+    outputPath: output,
+  });
+  assert.equal(result.viewModel.counts.agentNodes, 0);
+  assert.equal(result.viewModel.counts.agentEdges, 0);
+  assert.deepEqual(result.viewModel.nodes, []);
+  assert.deepEqual(result.viewModel.edges, []);
+  assert.deepEqual(result.viewModel.warnings, [
+    "normalized-graph.json has no nodes",
+    "normalized-events.jsonl has no events",
+  ]);
+  assert.match(
+    await readFile(output, "utf8"),
+    /No matching agent nodes were recorded/u,
+  );
+  assert.equal((await lstat(output)).mode & 0o777, 0o600);
+
+  const targetDir = path.join(outputDir, "target");
+  await mkdir(targetDir);
+  const symlinkOutput = path.join(outputDir, "symlink-output.html");
+  await symlink(path.join(targetDir, "missing.html"), symlinkOutput);
+  await assert.rejects(
+    generateInlineVisualization({
+      artifactDir,
+      outputPath: symlinkOutput,
+    }),
+    /Refusing to replace output symlink/u,
+  );
+});
diff --git a/plugins/looperators-agent-loop-p0/tests/mcp-server.test.mjs b/plugins/looperators-agent-loop-p0/tests/mcp-server.test.mjs
new file mode 100644
index 0000000..13a30b5
--- /dev/null
+++ b/plugins/looperators-agent-loop-p0/tests/mcp-server.test.mjs
@@ -0,0 +1,83 @@
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { createInterface } from "node:readline";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+const pluginRoot = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "..",
+);
+const serverPath = path.join(pluginRoot, "mcp", "server.mjs");
+
+test("MCP server exposes structured content, ui resource, and component tool", async (t) => {
+  const child = spawn(process.execPath, [serverPath], {
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+  t.after(() => child.kill("SIGTERM"));
+  let stderr = "";
+  child.stderr.on("data", (chunk) => {
+    stderr += chunk;
+  });
+  const pending = new Map();
+  const lines = createInterface({ input: child.stdout, crlfDelay: Infinity });
+  lines.on("line", (line) => {
+    const message = JSON.parse(line);
+    pending.get(message.id)?.(message);
+    pending.delete(message.id);
+  });
+  let nextId = 1;
+  const request = (method, params = {}) =>
+    new Promise((resolve, reject) => {
+      const id = nextId++;
+      const timer = setTimeout(
+        () => reject(new Error(`MCP timeout for ${method}; stderr=${stderr}`)),
+        3_000,
+      );
+      pending.set(id, (message) => {
+        clearTimeout(timer);
+        if (message.error) {
+          reject(new Error(message.error.message));
+        } else {
+          resolve(message.result);
+        }
+      });
+      child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}\n`);
+    });
+
+  const initialized = await request("initialize", {
+    protocolVersion: "2025-06-18",
+    capabilities: {},
+    clientInfo: { name: "p0-test", version: "1" },
+  });
+  assert.equal(initialized.serverInfo.name, "looperators-agent-loop-p0");
+
+  const tools = await request("tools/list");
+  const widget = tools.tools.find((tool) => tool.name === "loop_widget");
+  assert.equal(widget._meta.ui.resourceUri, "ui://looperators/agent-loop-p0.html");
+  assert.equal(
+    widget._meta["openai/outputTemplate"],
+    "ui://looperators/agent-loop-p0.html",
+  );
+
+  const resource = await request("resources/read", {
+    uri: "ui://looperators/agent-loop-p0.html",
+  });
+  assert.equal(resource.contents[0].mimeType, "text/html;profile=mcp-app");
+  assert.match(resource.contents[0].text, /ui\/initialize/);
+  assert.match(resource.contents[0].text, /tools\/call/);
+
+  const rendered = await request("tools/call", {
+    name: "loop_widget",
+    arguments: {},
+  });
+  assert.equal(rendered.structuredContent.graph.nodes.length, 3);
+
+  const ping = await request("tools/call", {
+    name: "loop_ping",
+    arguments: { message: "component-call" },
+  });
+  assert.equal(ping.structuredContent.ack, "ack:component-call");
+  child.stdin.end();
+});
diff --git a/plugins/looperators-agent-loop-p0/tests/recorded-artifact-fixture.mjs b/plugins/looperators-agent-loop-p0/tests/recorded-artifact-fixture.mjs
new file mode 100644
index 0000000..0d2871d
--- /dev/null
+++ b/plugins/looperators-agent-loop-p0/tests/recorded-artifact-fixture.mjs
@@ -0,0 +1,150 @@
+import { mkdtemp, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+const rootSessionId = "019f9a38-9f26-71d0-b908-df3626a5d40c";
+const agentIds = [
+  "019f9a39-0485-75f0-b6cf-8beba2cc59cd",
+  "019f9a39-1681-7b90-98e1-55ac153248dd",
+];
+const toolIds = ["bash", "spawn-a", "spawn-b", "wait"];
+
+function fixtureEvents() {
+  const events = [];
+  let semanticSequence = 0;
+  const add = (event, fields = {}, duplicate = false) => {
+    const semanticKey = `fixture:${semanticSequence}:${event}`;
+    const base = {
+      schema_version: 1,
+      event,
+      session_id: rootSessionId,
+      semantic_key: semanticKey,
+      captured_at: `2026-07-25T17:01:${String(semanticSequence).padStart(2, "0")}.000Z`,
+      ...fields,
+    };
+    events.push({
+      ...base,
+      sequence: events.length,
+      lane: "primary",
+      delivery_key: `${semanticKey}:primary`,
+    });
+    if (duplicate) {
+      events.push({
+        ...base,
+        sequence: events.length,
+        lane: "parallel",
+        delivery_key: `${semanticKey}:parallel`,
+      });
+    }
+    semanticSequence += 1;
+  };
+
+  add("SessionStart", { source: "startup" });
+  add("UserPromptSubmit");
+  for (const toolId of toolIds) {
+    add(
+      "PreToolUse",
+      { tool_use_id: `tool-${toolId}`, tool_name: toolId },
+      true,
+    );
+    add("PostToolUse", {
+      tool_use_id: `tool-${toolId}`,
+      tool_name: toolId,
+    });
+  }
+  for (const agentId of agentIds) {
+    add("SubagentStart", { agent_id: agentId, agent_type: "default" });
+  }
+  for (const agentId of agentIds) {
+    add("SubagentStop", { agent_id: agentId, stop_hook_active: false });
+    add("SubagentStop", { agent_id: agentId, stop_hook_active: true });
+  }
+  add("Stop", { stop_hook_active: false });
+  add("Stop", { stop_hook_active: true });
+  return events;
+}
+
+function fixtureGraph() {
+  const rootId = `session:${rootSessionId}`;
+  const toolNodes = toolIds.map((toolId) => ({
+    id: `tool:${toolId}`,
+    kind: "tool",
+    label: toolId,
+    tool_use_id: `tool-${toolId}`,
+  }));
+  const agentNodes = agentIds.map((agentId) => ({
+    id: `agent:${agentId}`,
+    kind: "subagent",
+    label: "default",
+    agent_id: agentId,
+  }));
+  return {
+    schema_version: 1,
+    nodes: [
+      {
+        id: rootId,
+        kind: "root",
+        label: "Root session",
+        session_id: rootSessionId,
+      },
+      ...toolNodes,
+      ...agentNodes,
+    ],
+    edges: [
+      ...toolNodes.map((node) => ({
+        id: `${rootId}->${node.id}:used`,
+        source: rootId,
+        target: node.id,
+        kind: "used",
+      })),
+      ...agentNodes.map((node) => ({
+        id: `${rootId}->${node.id}:spawned`,
+        source: rootId,
+        target: node.id,
+        kind: "spawned",
+      })),
+    ],
+  };
+}
+
+export async function createRecordedArtifactFixture() {
+  const artifactDir = await mkdtemp(
+    path.join(os.tmpdir(), "looperators-p0-recorded-artifacts-"),
+  );
+  const events = fixtureEvents();
+  await Promise.all([
+    writeFile(
+      path.join(artifactDir, "normalized-graph.json"),
+      `${JSON.stringify(fixtureGraph(), null, 2)}\n`,
+      "utf8",
+    ),
+    writeFile(
+      path.join(artifactDir, "normalized-events.jsonl"),
+      `${events.map((event) => JSON.stringify(event)).join("\n")}\n`,
+      "utf8",
+    ),
+    writeFile(
+      path.join(artifactDir, "normalized-summary.json"),
+      `${JSON.stringify(
+        {
+          schema_version: 1,
+          total_deliveries: events.length,
+          total_semantic_events: 18,
+          deliveries_by_event: {
+            PostToolUse: 4,
+            PreToolUse: 8,
+            SessionStart: 1,
+            Stop: 2,
+            SubagentStart: 2,
+            SubagentStop: 4,
+            UserPromptSubmit: 1,
+          },
+        },
+        null,
+        2,
+      )}\n`,
+      "utf8",
+    ),
+  ]);
+  return artifactDir;
+}
diff --git a/plugins/looperators-agent-loop-p0/tests/sidecar-server.test.mjs b/plugins/looperators-agent-loop-p0/tests/sidecar-server.test.mjs
new file mode 100644
index 0000000..0c2e9cc
--- /dev/null
+++ b/plugins/looperators-agent-loop-p0/tests/sidecar-server.test.mjs
@@ -0,0 +1,109 @@
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { mkdtemp, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { createInterface } from "node:readline";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+const pluginRoot = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "..",
+);
+const serverPath = path.join(pluginRoot, "scripts", "sidecar-server.mjs");
+
+test("sidecar binds loopback, requires a token, and streams SSE updates", async (t) => {
+  const artifactDir = await mkdtemp(
+    path.join(os.tmpdir(), "looperators-p0-sidecar-"),
+  );
+  const token = "synthetic-test-token-12345";
+  const child = spawn(
+    process.execPath,
+    [serverPath, "--artifact-dir", artifactDir, "--host", "127.0.0.1", "--port", "0"],
+    {
+      env: { ...process.env, LOOPERATORS_P0_SIDECAR_TOKEN: token },
+      stdio: ["ignore", "pipe", "pipe"],
+    },
+  );
+  t.after(() => child.kill("SIGTERM"));
+  const ready = await new Promise((resolve, reject) => {
+    const lines = createInterface({ input: child.stdout, crlfDelay: Infinity });
+    const timer = setTimeout(() => reject(new Error("sidecar did not start")), 3_000);
+    lines.once("line", (line) => {
+      clearTimeout(timer);
+      resolve(JSON.parse(line));
+    });
+  });
+  assert.equal(ready.host, "127.0.0.1");
+  assert.equal(ready.token_required, true);
+  assert.equal("token" in ready, false);
+
+  const unauthorized = await fetch(ready.base_url, { redirect: "manual" });
+  assert.equal(unauthorized.status, 401);
+
+  const login = await fetch(`${ready.base_url}?token=${encodeURIComponent(token)}`, {
+    redirect: "manual",
+  });
+  assert.equal(login.status, 303);
+  assert.equal(login.headers.get("location"), "/");
+  const cookie = login.headers.get("set-cookie").split(";")[0];
+
+  const page = await fetch(ready.base_url, { headers: { Cookie: cookie } });
+  assert.equal(page.status, 200);
+  assert.match(page.headers.get("content-security-policy"), /frame-ancestors 'none'/);
+  assert.equal(page.headers.get("referrer-policy"), "no-referrer");
+
+  const controller = new AbortController();
+  t.after(() => controller.abort());
+  const stream = await fetch(`${ready.base_url}events`, {
+    headers: { Cookie: cookie },
+    signal: controller.signal,
+  });
+  assert.equal(stream.headers.get("content-type"), "text/event-stream; charset=utf-8");
+  const reader = stream.body.getReader();
+  const decoder = new TextDecoder();
+  let body = decoder.decode((await reader.read()).value);
+  assert.match(body, /event: snapshot/);
+
+  await writeFile(
+    path.join(artifactDir, "normalized-graph.json"),
+    `${JSON.stringify({
+      nodes: [{ id: "root", kind: "root", label: "Root turn" }],
+      edges: [],
+    })}\n`,
+  );
+  const deadline = Date.now() + 3_000;
+  while (!body.includes("Root turn") && Date.now() < deadline) {
+    const chunk = await reader.read();
+    body += decoder.decode(chunk.value);
+  }
+  assert.match(body, /Root turn/);
+  await reader.cancel();
+});
+
+test("sidecar rejects non-loopback binding", async () => {
+  const artifactDir = await mkdtemp(
+    path.join(os.tmpdir(), "looperators-p0-sidecar-bind-"),
+  );
+  const child = spawn(
+    process.execPath,
+    [serverPath, "--artifact-dir", artifactDir, "--host", "0.0.0.0"],
+    {
+      env: {
+        ...process.env,
+        LOOPERATORS_P0_SIDECAR_TOKEN: "synthetic-test-token-12345",
+      },
+      stdio: ["ignore", "ignore", "pipe"],
+    },
+  );
+  const result = await new Promise((resolve) => {
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("close", (code) => resolve({ code, stderr }));
+  });
+  assert.notEqual(result.code, 0);
+  assert.match(result.stderr, /only permits --host 127\.0\.0\.1/);
+});
diff --git a/plugins/looperators-agent-loop/.codex-plugin/plugin.json b/plugins/looperators-agent-loop/.codex-plugin/plugin.json
new file mode 100644
index 0000000..1d712ee
--- /dev/null
+++ b/plugins/looperators-agent-loop/.codex-plugin/plugin.json
@@ -0,0 +1,24 @@
+{
+  "name": "looperators-agent-loop",
+  "version": "0.3.2+codex.20260803073424",
+  "description": "Task-scoped Agent Loop governance for looperators on Codex.",
+  "author": {
+    "name": "looperators"
+  },
+  "interface": {
+    "displayName": "looperators Agent Loop",
+    "shortDescription": "Govern a bounded native Codex agent loop.",
+    "longDescription": "looperators adds a cooperative typed implementer-reviewer loop and an authenticated localhost live review surface without default Hooks.",
+    "developerName": "looperators",
+    "category": "Productivity",
+    "capabilities": [
+      "Task-scoped Agent Loop state",
+      "Typed MCP reports",
+      "Action-scoped role capabilities",
+      "Verified graph snapshots",
+      "Protected localhost live review"
+    ],
+    "defaultPrompt": "Use looperators to preview a bounded review-until-clean loop."
+  },
+  "mcpServers": "./.mcp.json"
+}
diff --git a/plugins/looperators-agent-loop/.mcp.json b/plugins/looperators-agent-loop/.mcp.json
new file mode 100644
index 0000000..dc4b1b2
--- /dev/null
+++ b/plugins/looperators-agent-loop/.mcp.json
@@ -0,0 +1,17 @@
+{
+  "mcpServers": {
+    "looperators-agent-loop": {
+      "command": "node",
+      "args": [
+        "./mcp/server.mjs"
+      ],
+      "cwd": ".",
+      "env_vars": [
+        "LOOPERATORS_DATA_DIR",
+        "HOME",
+        "XDG_DATA_HOME",
+        "LOCALAPPDATA"
+      ]
+    }
+  }
+}
diff --git a/plugins/looperators-agent-loop/README.md b/plugins/looperators-agent-loop/README.md
new file mode 100644
index 0000000..4f04105
--- /dev/null
+++ b/plugins/looperators-agent-loop/README.md
@@ -0,0 +1,93 @@
+# looperators Agent Loop
+
+This directory contains the lean Codex Plugin for one bounded
+`review-until-clean` loop inside a Codex task.
+
+## Runtime prerequisite
+
+The current local-development Plugin requires a PATH-visible Node.js `24.x`
+runtime. It is verified with Node.js `24.11.1`, matching this repository's
+`engines` field and CI. Check the exact Desktop launch environment before
+installing:
+
+```sh
+node --version
+```
+
+An older Node runtime produces an actionable MCP startup error. If `node` is
+absent from PATH entirely, Codex cannot start the MCP process and the Plugin
+itself cannot emit a diagnostic; fix the Desktop launch PATH and reload the
+Plugin. The Plugin does not currently bundle Node, so broad public distribution
+remains gated on either a self-contained runtime or installer-level prerequisite
+validation.
+
+## Default product boundary
+
+- The root task is Governor; 1–2 native Codex subagents are cooperative roles.
+- Typed MCP state and immutable facts are authoritative.
+- The default plugin ships **no Hooks** and needs no Hook trust approval.
+- The plugin does not inspect transcripts or guess native agent ids.
+- Inline visualization is outside the critical path. The primary review surface
+  is the authenticated `127.0.0.1` sidecar managed by MCP.
+- Cooperative mode cannot force a worker to report or force Codex to continue a
+  turn; the Skill makes missing obligations explicit.
+
+## MCP lifecycle
+
+The default tool surface is intentionally small:
+
+```text
+looperators_preview_loop
+looperators_start_loop
+looperators_report
+looperators_get_loop
+looperators_get_snapshot
+looperators_pause_loop
+looperators_resume_loop
+looperators_cancel_loop
+looperators_open_review_surface
+looperators_close_review_surface
+```
+
+`open_review_surface` starts or reuses one MCP-owned server bound to the literal
+`127.0.0.1` on a random OS port. It returns a short-lived, one-time URL that is
+redeemed for an HttpOnly, SameSite, run-scoped cookie. The live page uses the
+shared Desktop-derived ReactFlow graph, verified projection SSE, and same-origin
+CSRF-protected pause/resume/cancel calls. Probe, native-id binding, legacy
+quarantine, and inline render tools are not callable product tools.
+
+`start` and root-only `get_loop` return the current action-scoped
+`roleCapability`. The token binds the run, logical role, pending transition,
+and action revision. Token plaintext is never persisted; the shared data root
+stores only its SHA-256 digest and action identity so independent native-worker
+MCP processes can report. Old-action, wrong-role, and post-cancel tokens are
+rejected. A root read after a Governor MCP restart rotates the current token.
+The Governor must not call `get_loop` while a worker is in flight because that
+restart/recovery read can invalidate the dispatched token.
+
+## Local data
+
+`LOOPERATORS_DATA_DIR` is an optional absolute override for isolated tests and
+advanced setups. Otherwise MCP uses the looperators-owned platform path:
+
+| Platform | Default |
+| --- | --- |
+| macOS | `~/Library/Application Support/looperators/codex-agent-loop/v1` |
+| Linux/Unix | `$XDG_DATA_HOME/looperators/codex-agent-loop/v1`, otherwise `~/.local/share/looperators/codex-agent-loop/v1` |
+| Windows | `%LOCALAPPDATA%\looperators\codex-agent-loop\v1` |
+
+The store never falls back to the repository, worktree, plugin cache, or
+`~/.codex`. POSIX directories are `0700`. The store survives uninstall so an
+unfinished run is not deleted as an installation side effect.
+
+## Verification
+
+```sh
+node --test \
+  plugins/looperators-agent-loop/tests/cooperative-loop.test.mjs \
+  plugins/looperators-agent-loop/tests/cooperative-mcp-server.test.mjs
+npm run build:plugin-agent-loop-ui
+```
+
+The complete Gate A suite additionally covers the sidecar, security controls,
+restart behavior, typed state projection, and the shared graph UI.
diff --git a/plugins/looperators-agent-loop/lib/canonical-json.mjs b/plugins/looperators-agent-loop/lib/canonical-json.mjs
new file mode 100644
index 0000000..91b3fd3
--- /dev/null
+++ b/plugins/looperators-agent-loop/lib/canonical-json.mjs
@@ -0,0 +1,76 @@
+import { createHash, timingSafeEqual } from "node:crypto";
+
+function compareCodePoints(left, right) {
+  const leftPoints = Array.from(left, (character) => character.codePointAt(0));
+  const rightPoints = Array.from(right, (character) => character.codePointAt(0));
+  const length = Math.min(leftPoints.length, rightPoints.length);
+  for (let index = 0; index < length; index += 1) {
+    if (leftPoints[index] !== rightPoints[index]) {
+      return leftPoints[index] - rightPoints[index];
+    }
+  }
+  return leftPoints.length - rightPoints.length;
+}
+
+function serialize(value, seen) {
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "string" || typeof value === "boolean") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new TypeError("canonical JSON rejects non-finite numbers");
+    }
+    return Object.is(value, -0) ? "0" : JSON.stringify(value);
+  }
+  if (typeof value !== "object") {
+    throw new TypeError(`canonical JSON rejects ${typeof value}`);
+  }
+  if (seen.has(value)) {
+    throw new TypeError("canonical JSON rejects circular values");
+  }
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) {
+      return `[${value.map((item) => serialize(item, seen)).join(",")}]`;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+      throw new TypeError("canonical JSON accepts only plain objects");
+    }
+    const keys = Object.keys(value).sort(compareCodePoints);
+    const fields = keys.map(
+      (key) => `${JSON.stringify(key)}:${serialize(value[key], seen)}`,
+    );
+    return `{${fields.join(",")}}`;
+  } finally {
+    seen.delete(value);
+  }
+}
+
+export function canonicalJson(value) {
+  return serialize(value, new Set());
+}
+
+export function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+
+export function digestJson(value) {
+  return sha256(canonicalJson(value));
+}
+
+export function digestEqual(left, right) {
+  if (
+    typeof left !== "string" ||
+    typeof right !== "string" ||
+    left.length !== right.length
+  ) {
+    return false;
+  }
+  return timingSafeEqual(Buffer.from(left), Buffer.from(right));
+}
+
+export { compareCodePoints };
diff --git a/plugins/looperators-agent-loop/lib/contracts.mjs b/plugins/looperators-agent-loop/lib/contracts.mjs
new file mode 100644
index 0000000..a09c21e
--- /dev/null
+++ b/plugins/looperators-agent-loop/lib/contracts.mjs
@@ -0,0 +1,2079 @@
+import { randomUUID } from "node:crypto";
+import {
+  canonicalJson,
+  compareCodePoints,
+  digestJson,
+  sha256,
+} from "./canonical-json.mjs";
+
+export const SCHEMA_VERSION = 1;
+export const SEMANTIC_KEY_VERSION = 1;
+export const STORE_VERSION = 1;
+export const PROJECTION_VERSION = 3;
+export const LEGACY_RECOVERY_VERSION = 1;
+export const LEGACY_EVIDENCE_VERSION = 1;
+export const HOOK_COLLECTOR_PROTOCOL =
+  "looperators-hook-collector-v2";
+export const MAX_LEGACY_NATIVE_TARGET_FACTS = 16;
+
+export const KNOWN_HOOK_EVENTS = new Set([
+  "SessionStart",
+  "UserPromptSubmit",
+  "PreToolUse",
+  "PostToolUse",
+  "SubagentStart",
+  "SubagentStop",
+  "Stop",
+]);
+
+export const RUN_STATUSES = new Set([
+  "draft",
+  "running",
+  "paused",
+  "succeeded",
+  "capped",
+  "cancelled",
+  "failed",
+  "interrupted",
+]);
+
+export const ACTIVE_RUN_STATUSES = new Set([
+  "draft",
+  "running",
+  "paused",
+  "interrupted",
+]);
+
+const SAFE_FILE_ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+const SHA256 = /^[a-f0-9]{64}$/;
+export const WORKER_ROLES = new Set(["implementer", "reviewer"]);
+export const GOVERNOR_ACTIONS = new Set([
+  "block",
+  "cap",
+  "interrupt",
+]);
+
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+function isTimestamp(value) {
+  return (
+    typeof value === "string" &&
+    /^\d{4}-\d{2}-\d{2}T/.test(value) &&
+    Number.isFinite(Date.parse(value))
+  );
+}
+
+function stringField(errors, value, name, options = {}) {
+  const { optional = false, max = 256, pattern = null } = options;
+  if (value === undefined && optional) {
+    return;
+  }
+  if (
+    typeof value !== "string" ||
+    value.length === 0 ||
+    value.length > max ||
+    (pattern && !pattern.test(value))
+  ) {
+    errors.push(`${name} must be a non-empty string up to ${max} characters`);
+  }
+}
+
+function integerField(errors, value, name, options = {}) {
+  const { min = 0, max = Number.MAX_SAFE_INTEGER } = options;
+  if (!Number.isInteger(value) || value < min || value > max) {
+    errors.push(`${name} must be an integer between ${min} and ${max}`);
+  }
+}
+
+function rejectUnknown(errors, value, allowed, name) {
+  if (!isPlainObject(value)) {
+    errors.push(`${name} must be an object`);
+    return;
+  }
+  for (const key of Object.keys(value)) {
+    if (!allowed.has(key)) {
+      errors.push(`${name}.${key} is not allowed`);
+    }
+  }
+}
+
+function utf8StringField(errors, value, name, maxBytes) {
+  if (
+    typeof value !== "string" ||
+    value.length === 0 ||
+    Buffer.byteLength(value, "utf8") > maxBytes
+  ) {
+    errors.push(
+      `${name} must be a non-empty UTF-8 string up to ${maxBytes} bytes`,
+    );
+  }
+}
+
+export function validateNormalizedHookEvent(value) {
+  const errors = [];
+  const allowed = new Set([
+    "schemaVersion",
+    "semanticKeyVersion",
+    "eventId",
+    "semanticKey",
+    "sessionId",
+    "turnId",
+    "event",
+    "agentId",
+    "agentType",
+    "toolUseId",
+    "stopHookActive",
+    "observedAt",
+    "payloadDigest",
+    "payloadSummary",
+    "causeRef",
+    "conflictEligible",
+  ]);
+  rejectUnknown(errors, value, allowed, "event");
+  if (!isPlainObject(value)) {
+    return errors;
+  }
+  if (value.schemaVersion !== SCHEMA_VERSION) {
+    errors.push("event.schemaVersion must be 1");
+  }
+  if (value.semanticKeyVersion !== SEMANTIC_KEY_VERSION) {
+    errors.push("event.semanticKeyVersion must be 1");
+  }
+  stringField(errors, value.eventId, "event.eventId", {
+    max: 68,
+    pattern: /^evt_[a-f0-9]{64}$/,
+  });
+  stringField(errors, value.semanticKey, "event.semanticKey", {
+    max: 71,
+    pattern: /^sem-v1:[a-f0-9]{64}$/,
+  });
+  stringField(errors, value.sessionId, "event.sessionId");
+  stringField(errors, value.turnId, "event.turnId", { optional: true });
+  stringField(errors, value.event, "event.event", { max: 64 });
+  stringField(errors, value.agentId, "event.agentId", { optional: true });
+  stringField(errors, value.agentType, "event.agentType", {
+    optional: true,
+    max: 128,
+  });
+  stringField(errors, value.toolUseId, "event.toolUseId", { optional: true });
+  if (
+    value.stopHookActive !== undefined &&
+    typeof value.stopHookActive !== "boolean"
+  ) {
+    errors.push("event.stopHookActive must be a boolean");
+  }
+  if (!isTimestamp(value.observedAt)) {
+    errors.push("event.observedAt must be an ISO date-time");
+  }
+  stringField(errors, value.payloadDigest, "event.payloadDigest", {
+    max: 64,
+    pattern: SHA256,
+  });
+  if (value.payloadSummary !== undefined && !isPlainObject(value.payloadSummary)) {
+    errors.push("event.payloadSummary must be an object");
+  }
+  stringField(errors, value.causeRef, "event.causeRef", { optional: true });
+  if (typeof value.conflictEligible !== "boolean") {
+    errors.push("event.conflictEligible must be a boolean");
+  }
+  return errors;
+}
+
+export function validateLoopDefinition(value) {
+  const errors = [];
+  const allowed = new Set([
+    "schemaVersion",
+    "definitionId",
+    "runId",
+    "requestId",
+    "requestDigest",
+    "recipe",
+    "goal",
+    "implementerInstructions",
+    "reviewerInstructions",
+    "lapCap",
+    "createdAt",
+  ]);
+  rejectUnknown(errors, value, allowed, "definition");
+  if (!isPlainObject(value)) {
+    return errors;
+  }
+  if (value.schemaVersion !== SCHEMA_VERSION) {
+    errors.push("definition.schemaVersion must be 1");
+  }
+  stringField(errors, value.definitionId, "definition.definitionId", {
+    max: 75,
+    pattern: /^definition_[a-f0-9]{64}$/,
+  });
+  stringField(errors, value.runId, "definition.runId", {
+    max: 68,
+    pattern: /^run_[a-f0-9]{64}$/,
+  });
+  stringField(errors, value.requestId, "definition.requestId", {
+    max: 128,
+    pattern: SAFE_FILE_ID,
+  });
+  stringField(errors, value.requestDigest, "definition.requestDigest", {
+    max: 64,
+    pattern: SHA256,
+  });
+  if (value.recipe !== "review-until-clean") {
+    errors.push("definition.recipe must be review-until-clean");
+  }
+  utf8StringField(errors, value.goal, "definition.goal", 8 * 1024);
+  utf8StringField(
+    errors,
+    value.implementerInstructions,
+    "definition.implementerInstructions",
+    16 * 1024,
+  );
+  utf8StringField(
+    errors,
+    value.reviewerInstructions,
+    "definition.reviewerInstructions",
+    16 * 1024,
+  );
+  integerField(errors, value.lapCap, "definition.lapCap", {
+    min: 1,
+    max: 6,
+  });
+  if (!isTimestamp(value.createdAt)) {
+    errors.push("definition.createdAt must be an ISO date-time");
+  }
+  return errors;
+}
+
+export function validateWorkerObservation(value) {
+  const errors = [];
+  const allowed = new Set([
+    "schemaVersion",
+    "observationId",
+    "runId",
+    "requestId",
+    "requestDigest",
+    "rootSessionId",
+    "role",
+    "spawnToolUseIds",
+    "subagentStartEventIds",
+    "bindingIds",
+    "observationDigest",
+    "createdAt",
+  ]);
+  rejectUnknown(errors, value, allowed, "observation");
+  if (!isPlainObject(value)) {
+    return errors;
+  }
+  if (value.schemaVersion !== SCHEMA_VERSION) {
+    errors.push("observation.schemaVersion must be 1");
+  }
+  stringField(errors, value.observationId, "observation.observationId", {
+    max: 128,
+    pattern: /^observation_[a-f0-9]{64}$/,
+  });
+  stringField(errors, value.runId, "observation.runId", {
+    max: 128,
+  });
+  stringField(errors, value.requestId, "observation.requestId", {
+    max: 128,
+    pattern: SAFE_FILE_ID,
+  });
+  stringField(
+    errors,
+    value.requestDigest,
+    "observation.requestDigest",
+    {
+      max: 64,
+      pattern: SHA256,
+    },
+  );
+  stringField(
+    errors,
+    value.rootSessionId,
+    "observation.rootSessionId",
+  );
+  if (!WORKER_ROLES.has(value.role)) {
+    errors.push("observation.role is invalid");
+  }
+  for (const [field, pattern] of [
+    ["spawnToolUseIds", null],
+    ["subagentStartEventIds", /^evt_[a-f0-9]{64}$/],
+    ["bindingIds", /^binding_[a-f0-9]{64}$/],
+  ]) {
+    const items = value[field];
+    if (
+      !Array.isArray(items) ||
+      items.length > 64 ||
+      new Set(items).size !== items.length
+    ) {
+      errors.push(
+        `observation.${field} must contain at most 64 unique strings`,
+      );
+      continue;
+    }
+    for (const item of items) {
+      if (
+        typeof item !== "string" ||
+        item.length === 0 ||
+        item.length > 256 ||
+        (pattern && !pattern.test(item))
+      ) {
+        errors.push(`observation.${field} contains an invalid id`);
+      }
+    }
+    const sorted = [...items].sort(compareCodePoints);
+    if (canonicalJson(sorted) !== canonicalJson(items)) {
+      errors.push(`observation.${field} must be code-point sorted`);
+    }
+  }
+  stringField(
+    errors,
+    value.observationDigest,
+    "observation.observationDigest",
+    {
+      max: 64,
+      pattern: SHA256,
+    },
+  );
+  if (!isTimestamp(value.createdAt)) {
+    errors.push("observation.createdAt must be an ISO date-time");
+  }
+  return errors;
+}
+
+export function validateLoopOperation(value) {
+  const errors = [];
+  const allowed = new Set([
+    "schemaVersion",
+    "operationId",
+    "runId",
+    "requestId",
+    "requestDigest",
+    "kind",
+    "actorKind",
+    "actorId",
+    "fromRevision",
+    "toRevision",
+    "reportId",
+    "transitionId",
+    "createdAt",
+  ]);
+  rejectUnknown(errors, value, allowed, "operation");
+  if (!isPlainObject(value)) {
+    return errors;
+  }
+  if (value.schemaVersion !== SCHEMA_VERSION) {
+    errors.push("operation.schemaVersion must be 1");
+  }
+  stringField(errors, value.operationId, "operation.operationId", {
+    max: 67,
+    pattern: /^op_[a-f0-9]{64}$/,
+  });
+  stringField(errors, value.runId, "operation.runId", { max: 128 });
+  stringField(errors, value.requestId, "operation.requestId", {
+    max: 128,
+    pattern: SAFE_FILE_ID,
+  });
+  stringField(errors, value.requestDigest, "operation.requestDigest", {
+    max: 64,
+    pattern: SHA256,
+  });
+  if (
+    ![
+      "start",
+      "report",
+      "pause",
+      "resume",
+      "cancel",
+      "interrupt",
+    ].includes(
+      value.kind,
+    )
+  ) {
+    errors.push("operation.kind is invalid");
+  }
+  if (!["root", "worker"].includes(value.actorKind)) {
+    errors.push("operation.actorKind is invalid");
+  }
+  stringField(errors, value.actorId, "operation.actorId");
+  integerField(errors, value.fromRevision, "operation.fromRevision");
+  integerField(errors, value.toRevision, "operation.toRevision");
+  if (
+    Number.isInteger(value.fromRevision) &&
+    Number.isInteger(value.toRevision) &&
+    value.toRevision !== value.fromRevision + 1
+  ) {
+    errors.push("operation.toRevision must equal fromRevision + 1");
+  }
+  stringField(errors, value.reportId, "operation.reportId", {
+    optional: value.kind !== "report",
+    max: 128,
+  });
+  stringField(errors, value.transitionId, "operation.transitionId", {
+    max: 128,
+  });
+  if (!isTimestamp(value.createdAt)) {
+    errors.push("operation.createdAt must be an ISO date-time");
+  }
+  return errors;
+}
+
+export function validateLoopReport(value) {
+  const errors = [];
+  const allowed = new Set([
+    "schemaVersion",
+    "reportId",
+    "runId",
+    "requestId",
+    "requestDigest",
+    "fromRevision",
+    "toRevision",
+    "fromNode",
+    "receiver",
+    "routedToNode",
+    "type",
+    "status",
+    "verdict",
+    "issues",
+    "summary",
+    "originEventId",
+    "createdAt",
+  ]);
+  rejectUnknown(errors, value, allowed, "report");
+  if (!isPlainObject(value)) {
+    return errors;
+  }
+  if (value.schemaVersion !== SCHEMA_VERSION) {
+    errors.push("report.schemaVersion must be 1");
+  }
+  stringField(errors, value.reportId, "report.reportId", { max: 128 });
+  stringField(errors, value.runId, "report.runId", { max: 128 });
+  stringField(errors, value.requestId, "report.requestId", {
+    optional: value.requestDigest === undefined,
+    max: 128,
+    pattern: SAFE_FILE_ID,
+  });
+  stringField(errors, value.requestDigest, "report.requestDigest", {
+    optional: value.requestId === undefined,
+    max: 64,
+    pattern: SHA256,
+  });
+  if (
+    value.requestId !== undefined ||
+    value.requestDigest !== undefined ||
+    value.fromRevision !== undefined ||
+    value.toRevision !== undefined
+  ) {
+    integerField(errors, value.fromRevision, "report.fromRevision");
+    integerField(errors, value.toRevision, "report.toRevision", {
+      min: 1,
+    });
+    if (
+      Number.isInteger(value.fromRevision) &&
+      Number.isInteger(value.toRevision) &&
+      value.toRevision !== value.fromRevision + 1
+    ) {
+      errors.push("report.toRevision must equal fromRevision + 1");
+    }
+    if (
+      value.requestId === undefined ||
+      value.requestDigest === undefined
+    ) {
+      errors.push(
+        "revision-bearing reports require requestId and requestDigest",
+      );
+    }
+  }
+  stringField(errors, value.fromNode, "report.fromNode");
+  if (!["root-master", "human"].includes(value.receiver)) {
+    errors.push("report.receiver is invalid");
+  }
+  stringField(errors, value.routedToNode, "report.routedToNode", {
+    optional: true,
+  });
+  if (!["verdict", "info", "relationship"].includes(value.type)) {
+    errors.push("report.type is invalid");
+  }
+  if (value.status !== undefined && value.status !== "done") {
+    errors.push("report.status is invalid");
+  }
+  if (value.type === "info" && value.status !== undefined && value.status !== "done") {
+    errors.push("info report status must be done");
+  }
+  if (value.verdict !== undefined && !["clean", "issues"].includes(value.verdict)) {
+    errors.push("report.verdict is invalid");
+  }
+  if (value.type === "verdict" && value.verdict === undefined) {
+    errors.push("verdict reports require report.verdict");
+  }
+  if (value.issues !== undefined) {
+    if (!Array.isArray(value.issues) || value.issues.length > 200) {
+      errors.push("report.issues must be an array with at most 200 items");
+    } else {
+      value.issues.forEach((issue, index) => {
+        if (!isPlainObject(issue)) {
+          errors.push(`report.issues[${index}] must be an object`);
+          return;
+        }
+        rejectUnknown(
+          errors,
+          issue,
+          new Set(["message", "file", "line", "severity"]),
+          `report.issues[${index}]`,
+        );
+        stringField(errors, issue.message, `report.issues[${index}].message`, {
+          max: 4000,
+        });
+        stringField(errors, issue.file, `report.issues[${index}].file`, {
+          optional: true,
+          max: 2000,
+        });
+        if (issue.line !== undefined) {
+          integerField(errors, issue.line, `report.issues[${index}].line`, {
+            min: 1,
+          });
+        }
+        if (
+          issue.severity !== undefined &&
+          !["info", "warn", "error"].includes(issue.severity)
+        ) {
+          errors.push(`report.issues[${index}].severity is invalid`);
+        }
+      });
+    }
+  }
+  if (
+    value.type === "verdict" &&
+    value.verdict === "issues" &&
+    (!Array.isArray(value.issues) || value.issues.length === 0)
+  ) {
+    errors.push("issues verdict requires at least one issue");
+  }
+  if (
+    value.type === "verdict" &&
+    value.verdict === "clean" &&
+    Array.isArray(value.issues) &&
+    value.issues.length > 0
+  ) {
+    errors.push("clean verdict cannot contain issues");
+  }
+  stringField(errors, value.summary, "report.summary", {
+    optional: true,
+    max: 8000,
+  });
+  stringField(errors, value.originEventId, "report.originEventId", {
+    optional: true,
+    max: 128,
+  });
+  if (!isTimestamp(value.createdAt)) {
+    errors.push("report.createdAt must be an ISO date-time");
+  }
+  return errors;
+}
+
+export function validateLoopTransition(value) {
+  const errors = [];
+  const allowed = new Set([
+    "schemaVersion",
+    "transitionId",
+    "runId",
+    "requestId",
+    "requestDigest",
+    "kind",
+    "fromNode",
+    "toNode",
+    "originReportId",
+    "originEventId",
+    "lap",
+    "leaseEpoch",
+    "fromRevision",
+    "toRevision",
+    "createdAt",
+  ]);
+  rejectUnknown(errors, value, allowed, "transition");
+  if (!isPlainObject(value)) {
+    return errors;
+  }
+  if (value.schemaVersion !== SCHEMA_VERSION) {
+    errors.push("transition.schemaVersion must be 1");
+  }
+  stringField(errors, value.transitionId, "transition.transitionId", {
+    max: 128,
+  });
+  stringField(errors, value.runId, "transition.runId", { max: 128 });
+  stringField(errors, value.requestId, "transition.requestId", {
+    optional: true,
+    max: 128,
+  });
+  stringField(errors, value.requestDigest, "transition.requestDigest", {
+    optional: value.requestId === undefined,
+    max: 64,
+    pattern: SHA256,
+  });
+  if (
+    ![
+      "activate-reviewer",
+      "activate-implementer",
+      "succeed",
+      "pause",
+      "resume",
+      "cancel",
+      "interrupt",
+      "cap",
+    ].includes(value.kind)
+  ) {
+    errors.push("transition.kind is invalid");
+  }
+  for (const field of [
+    "fromNode",
+    "toNode",
+    "originReportId",
+    "originEventId",
+  ]) {
+    stringField(errors, value[field], `transition.${field}`, {
+      optional: true,
+    });
+  }
+  integerField(errors, value.lap, "transition.lap");
+  if (value.leaseEpoch !== undefined) {
+    integerField(errors, value.leaseEpoch, "transition.leaseEpoch");
+  }
+  if (
+    value.fromRevision !== undefined ||
+    value.toRevision !== undefined
+  ) {
+    integerField(
+      errors,
+      value.fromRevision,
+      "transition.fromRevision",
+    );
+    integerField(errors, value.toRevision, "transition.toRevision");
+    if (
+      Number.isInteger(value.fromRevision) &&
+      Number.isInteger(value.toRevision) &&
+      value.toRevision !== value.fromRevision + 1
+    ) {
+      errors.push(
+        "transition.toRevision must equal fromRevision + 1",
+      );
+    }
+  }
+  if (!isTimestamp(value.createdAt)) {
+    errors.push("transition.createdAt must be an ISO date-time");
+  }
+  return errors;
+}
+
+export function validateGovernorDecision(value) {
+  const errors = [];
+  const allowed = new Set([
+    "schemaVersion",
+    "decisionId",
+    "runId",
+    "obligationId",
+    "originEventId",
+    "hookEvent",
+    "rootSessionId",
+    "turnId",
+    "agentId",
+    "action",
+    "reasonCode",
+    "pendingTransitionId",
+    "fromRevision",
+    "toRevision",
+    "leaseEpoch",
+    "createdAt",
+  ]);
+  rejectUnknown(errors, value, allowed, "governorDecision");
+  if (!isPlainObject(value)) {
+    return errors;
+  }
+  if (value.schemaVersion !== SCHEMA_VERSION) {
+    errors.push("governorDecision.schemaVersion must be 1");
+  }
+  stringField(errors, value.decisionId, "governorDecision.decisionId", {
+    max: 73,
+    pattern: /^decision_[a-f0-9]{64}$/,
+  });
+  stringField(errors, value.runId, "governorDecision.runId", {
+    max: 128,
+  });
+  stringField(
+    errors,
+    value.obligationId,
+    "governorDecision.obligationId",
+    { max: 128 },
+  );
+  stringField(
+    errors,
+    value.originEventId,
+    "governorDecision.originEventId",
+    {
+      max: 68,
+      pattern: /^evt_[a-f0-9]{64}$/,
+    },
+  );
+  if (!["Stop", "SubagentStop", "SessionStart"].includes(value.hookEvent)) {
+    errors.push("governorDecision.hookEvent is invalid");
+  }
+  stringField(
+    errors,
+    value.rootSessionId,
+    "governorDecision.rootSessionId",
+  );
+  stringField(errors, value.turnId, "governorDecision.turnId", {
+    optional: value.hookEvent === "SessionStart",
+  });
+  stringField(errors, value.agentId, "governorDecision.agentId", {
+    optional: true,
+  });
+  if (!GOVERNOR_ACTIONS.has(value.action)) {
+    errors.push("governorDecision.action is invalid");
+  }
+  if (
+    ![
+      "pending-root-transition",
+      "pending-worker-report",
+      "lease-exhausted",
+      "resume-in-flight",
+    ].includes(value.reasonCode)
+  ) {
+    errors.push("governorDecision.reasonCode is invalid");
+  }
+  stringField(
+    errors,
+    value.pendingTransitionId,
+    "governorDecision.pendingTransitionId",
+    { max: 128 },
+  );
+  integerField(
+    errors,
+    value.fromRevision,
+    "governorDecision.fromRevision",
+  );
+  integerField(
+    errors,
+    value.toRevision,
+    "governorDecision.toRevision",
+    { min: 1 },
+  );
+  if (
+    Number.isInteger(value.fromRevision) &&
+    Number.isInteger(value.toRevision) &&
+    value.toRevision !== value.fromRevision + 1
+  ) {
+    errors.push(
+      "governorDecision.toRevision must equal fromRevision + 1",
+    );
+  }
+  if (value.leaseEpoch !== undefined) {
+    integerField(
+      errors,
+      value.leaseEpoch,
+      "governorDecision.leaseEpoch",
+      { min: 1, max: 6 },
+    );
+  }
+  if (!isTimestamp(value.createdAt)) {
+    errors.push("governorDecision.createdAt must be an ISO date-time");
+  }
+
+  if (value.action === "block") {
+    if (!["Stop", "SubagentStop"].includes(value.hookEvent)) {
+      errors.push("block governorDecision requires a stop hook event");
+    }
+    if (value.leaseEpoch === undefined) {
+      errors.push("block governorDecision requires leaseEpoch");
+    }
+    const expectedReason =
+      value.hookEvent === "SubagentStop"
+        ? "pending-worker-report"
+        : "pending-root-transition";
+    if (value.reasonCode !== expectedReason) {
+      errors.push("block governorDecision reasonCode is invalid");
+    }
+  } else if (value.leaseEpoch !== undefined) {
+    errors.push(
+      "non-block governorDecision cannot include leaseEpoch",
+    );
+  }
+  if (
+    value.action === "cap" &&
+    (value.reasonCode !== "lease-exhausted" ||
+      !["Stop", "SubagentStop"].includes(value.hookEvent))
+  ) {
+    errors.push("cap governorDecision fields are invalid");
+  }
+  if (
+    value.action === "interrupt" &&
+    (value.reasonCode !== "resume-in-flight" ||
+      value.hookEvent !== "SessionStart")
+  ) {
+    errors.push("interrupt governorDecision fields are invalid");
+  }
+  if (
+    value.hookEvent === "SubagentStop" &&
+    value.agentId === undefined
+  ) {
+    errors.push("SubagentStop governorDecision requires agentId");
+  }
+  if (
+    value.hookEvent !== "SubagentStop" &&
+    value.agentId !== undefined
+  ) {
+    errors.push(
+      "non-SubagentStop governorDecision cannot include agentId",
+    );
+  }
+  return errors;
+}
+
+export function validateLoopRun(value) {
+  const errors = [];
+  const allowed = new Set([
+    "schemaVersion",
+    "runId",
+    "rootSessionId",
+    "originatingTurnId",
+    "scope",
+    "masterNode",
+    "recipe",
+    "status",
+    "currentLap",
+    "continuationLease",
+    "pendingTransitionId",
+    "cancelRequested",
+    "latestReportId",
+    "latestOperationId",
+    "latestGovernorDecisionId",
+    "latestRecoveryId",
+    "needsHuman",
+    "revision",
+    "createdAt",
+    "updatedAt",
+  ]);
+  rejectUnknown(errors, value, allowed, "run");
+  if (!isPlainObject(value)) {
+    return errors;
+  }
+  if (value.schemaVersion !== SCHEMA_VERSION) {
+    errors.push("run.schemaVersion must be 1");
+  }
+  stringField(errors, value.runId, "run.runId", { max: 128 });
+  stringField(errors, value.rootSessionId, "run.rootSessionId");
+  stringField(errors, value.originatingTurnId, "run.originatingTurnId");
+  if (!isPlainObject(value.scope) || value.scope.kind !== "task") {
+    errors.push("run.scope must equal { kind: \"task\" }");
+  } else {
+    rejectUnknown(errors, value.scope, new Set(["kind"]), "run.scope");
+  }
+  stringField(errors, value.masterNode, "run.masterNode");
+  if (value.recipe !== "review-until-clean") {
+    errors.push("run.recipe must be review-until-clean");
+  }
+  if (!RUN_STATUSES.has(value.status)) {
+    errors.push("run.status is invalid");
+  }
+  integerField(errors, value.currentLap, "run.currentLap");
+  if (!isPlainObject(value.continuationLease)) {
+    errors.push("run.continuationLease must be an object");
+  } else {
+    rejectUnknown(
+      errors,
+      value.continuationLease,
+      new Set(["granted", "consumed"]),
+      "run.continuationLease",
+    );
+    integerField(
+      errors,
+      value.continuationLease.granted,
+      "run.continuationLease.granted",
+      { max: 6 },
+    );
+    integerField(
+      errors,
+      value.continuationLease.consumed,
+      "run.continuationLease.consumed",
+    );
+    if (
+      Number.isInteger(value.continuationLease.granted) &&
+      Number.isInteger(value.continuationLease.consumed) &&
+      value.continuationLease.consumed > value.continuationLease.granted
+    ) {
+      errors.push("run.continuationLease.consumed cannot exceed granted");
+    }
+  }
+  stringField(errors, value.pendingTransitionId, "run.pendingTransitionId", {
+    optional: true,
+    max: 128,
+  });
+  if (typeof value.cancelRequested !== "boolean") {
+    errors.push("run.cancelRequested must be a boolean");
+  }
+  stringField(errors, value.latestReportId, "run.latestReportId", {
+    optional: true,
+    max: 128,
+  });
+  stringField(
+    errors,
+    value.latestOperationId,
+    "run.latestOperationId",
+    {
+      optional: true,
+      max: 128,
+    },
+  );
+  stringField(
+    errors,
+    value.latestGovernorDecisionId,
+    "run.latestGovernorDecisionId",
+    {
+      optional: true,
+      max: 73,
+    },
+  );
+  stringField(
+    errors,
+    value.latestRecoveryId,
+    "run.latestRecoveryId",
+    {
+      optional: true,
+      max: 73,
+      pattern: /^recovery_[a-f0-9]{64}$/,
+    },
+  );
+  if (value.needsHuman !== undefined && typeof value.needsHuman !== "boolean") {
+    errors.push("run.needsHuman must be a boolean");
+  }
+  integerField(errors, value.revision, "run.revision");
+  if (!isTimestamp(value.createdAt)) {
+    errors.push("run.createdAt must be an ISO date-time");
+  }
+  if (!isTimestamp(value.updatedAt)) {
+    errors.push("run.updatedAt must be an ISO date-time");
+  }
+  return errors;
+}
+
+export function validateGraphProjection(value) {
+  const errors = [];
+  const allowed = new Set([
+    "schemaVersion",
+    "storeVersion",
+    "projectionVersion",
+    "runId",
+    "revision",
+    "status",
+    "recipe",
+    "currentLap",
+    "lapCap",
+    "continuationLease",
+    "cancelRequested",
+    "needsHuman",
+    "integrity",
+    "eventWatermark",
+    "nodes",
+    "edges",
+    "pending",
+    "latestReport",
+    "recovery",
+    "counts",
+    "timeline",
+    "projectionDigest",
+  ]);
+  rejectUnknown(errors, value, allowed, "projection");
+  if (!isPlainObject(value)) {
+    return errors;
+  }
+  if (value.schemaVersion !== SCHEMA_VERSION) {
+    errors.push("projection.schemaVersion must be 1");
+  }
+  if (value.storeVersion !== STORE_VERSION) {
+    errors.push("projection.storeVersion must be 1");
+  }
+  if (value.projectionVersion !== PROJECTION_VERSION) {
+    errors.push("projection.projectionVersion must be 3");
+  }
+  stringField(errors, value.runId, "projection.runId", { max: 128 });
+  integerField(errors, value.revision, "projection.revision");
+  if (!RUN_STATUSES.has(value.status)) {
+    errors.push("projection.status is invalid");
+  }
+  if (value.recipe !== "review-until-clean") {
+    errors.push("projection.recipe must be review-until-clean");
+  }
+  integerField(errors, value.currentLap, "projection.currentLap");
+  integerField(errors, value.lapCap, "projection.lapCap", {
+    min: 1,
+    max: 6,
+  });
+  if (!isPlainObject(value.continuationLease)) {
+    errors.push("projection.continuationLease must be an object");
+  } else {
+    rejectUnknown(
+      errors,
+      value.continuationLease,
+      new Set(["granted", "consumed"]),
+      "projection.continuationLease",
+    );
+    integerField(
+      errors,
+      value.continuationLease.granted,
+      "projection.continuationLease.granted",
+      { max: 6 },
+    );
+    integerField(
+      errors,
+      value.continuationLease.consumed,
+      "projection.continuationLease.consumed",
+      { max: 6 },
+    );
+    if (
+      Number.isInteger(value.continuationLease.granted) &&
+      Number.isInteger(value.continuationLease.consumed) &&
+      value.continuationLease.consumed >
+        value.continuationLease.granted
+    ) {
+      errors.push(
+        "projection.continuationLease.consumed cannot exceed granted",
+      );
+    }
+  }
+  if (
+    Number.isInteger(value.currentLap) &&
+    Number.isInteger(value.lapCap) &&
+    value.currentLap > value.lapCap
+  ) {
+    errors.push("projection.currentLap cannot exceed lapCap");
+  }
+  if (typeof value.cancelRequested !== "boolean") {
+    errors.push("projection.cancelRequested must be a boolean");
+  }
+  if (typeof value.needsHuman !== "boolean") {
+    errors.push("projection.needsHuman must be a boolean");
+  }
+  if (!isPlainObject(value.integrity)) {
+    errors.push("projection.integrity must be an object");
+  } else {
+    rejectUnknown(
+      errors,
+      value.integrity,
+      new Set(["status", "verifiedRevision"]),
+      "projection.integrity",
+    );
+    if (value.integrity.status !== "verified") {
+      errors.push("projection.integrity.status must be verified");
+    }
+    integerField(
+      errors,
+      value.integrity.verifiedRevision,
+      "projection.integrity.verifiedRevision",
+    );
+    if (
+      Number.isInteger(value.revision) &&
+      value.integrity.verifiedRevision !== value.revision
+    ) {
+      errors.push(
+        "projection.integrity.verifiedRevision must equal revision",
+      );
+    }
+  }
+  if (!isPlainObject(value.eventWatermark)) {
+    errors.push("projection.eventWatermark must be an object");
+  } else {
+    rejectUnknown(
+      errors,
+      value.eventWatermark,
+      new Set(["eventCount", "lastEventId"]),
+      "projection.eventWatermark",
+    );
+    integerField(
+      errors,
+      value.eventWatermark.eventCount,
+      "projection.eventWatermark.eventCount",
+    );
+    stringField(
+      errors,
+      value.eventWatermark.lastEventId,
+      "projection.eventWatermark.lastEventId",
+      {
+        optional: value.eventWatermark.eventCount === 0,
+        max: 68,
+        pattern: /^evt_[a-f0-9]{64}$/,
+      },
+    );
+    if (
+      value.eventWatermark.eventCount === 0 &&
+      value.eventWatermark.lastEventId !== undefined
+    ) {
+      errors.push(
+        "projection.eventWatermark.lastEventId requires at least one event",
+      );
+    }
+  }
+
+  if (!Array.isArray(value.nodes) || value.nodes.length !== 3) {
+    errors.push("projection.nodes must contain exactly three nodes");
+  } else {
+    const nodeIds = new Set();
+    for (const [index, node] of value.nodes.entries()) {
+      const name = `projection.nodes[${index}]`;
+      rejectUnknown(
+        errors,
+        node,
+        new Set([
+          "id",
+          "kind",
+          "role",
+          "label",
+          "state",
+          "nativeAgentId",
+          "nativeAgentType",
+        ]),
+        name,
+      );
+      if (!isPlainObject(node)) {
+        continue;
+      }
+      if (!["root", "role:implementer", "role:reviewer"].includes(node.id)) {
+        errors.push(`${name}.id is invalid`);
+      }
+      if (nodeIds.has(node.id)) {
+        errors.push(`${name}.id is duplicated`);
+      }
+      nodeIds.add(node.id);
+      if (!["root", "worker-role"].includes(node.kind)) {
+        errors.push(`${name}.kind is invalid`);
+      }
+      if (
+        node.role !== undefined &&
+        !WORKER_ROLES.has(node.role)
+      ) {
+        errors.push(`${name}.role is invalid`);
+      }
+      stringField(errors, node.label, `${name}.label`, { max: 64 });
+      if (
+        !["active", "waiting", "bound", "unbound", "terminal"].includes(
+          node.state,
+        )
+      ) {
+        errors.push(`${name}.state is invalid`);
+      }
+      stringField(errors, node.nativeAgentId, `${name}.nativeAgentId`, {
+        optional: true,
+      });
+      stringField(errors, node.nativeAgentType, `${name}.nativeAgentType`, {
+        optional: true,
+        max: 128,
+      });
+      if (
+        (node.id === "root" &&
+          (node.kind !== "root" ||
+            node.role !== undefined ||
+            node.nativeAgentId !== undefined ||
+            node.nativeAgentType !== undefined)) ||
+        (node.id !== "root" &&
+          (node.kind !== "worker-role" ||
+            node.role !== node.id.slice("role:".length)))
+      ) {
+        errors.push(`${name} has inconsistent root/role fields`);
+      }
+      if (
+        node.nativeAgentType !== undefined &&
+        node.nativeAgentId === undefined
+      ) {
+        errors.push(
+          `${name}.nativeAgentType requires nativeAgentId`,
+        );
+      }
+    }
+    for (const id of ["root", "role:implementer", "role:reviewer"]) {
+      if (!nodeIds.has(id)) {
+        errors.push(`projection.nodes is missing ${id}`);
+      }
+    }
+  }
+
+  if (!Array.isArray(value.edges) || value.edges.length !== 4) {
+    errors.push("projection.edges must contain exactly four edges");
+  } else {
+    const edgeIds = new Set();
+    for (const [index, edge] of value.edges.entries()) {
+      const name = `projection.edges[${index}]`;
+      rejectUnknown(
+        errors,
+        edge,
+        new Set([
+          "id",
+          "source",
+          "target",
+          "kind",
+          "active",
+          "reportCount",
+        ]),
+        name,
+      );
+      if (!isPlainObject(edge)) {
+        continue;
+      }
+      stringField(errors, edge.id, `${name}.id`, { max: 64 });
+      if (edgeIds.has(edge.id)) {
+        errors.push(`${name}.id is duplicated`);
+      }
+      edgeIds.add(edge.id);
+      if (
+        !["root", "role:implementer", "role:reviewer"].includes(
+          edge.source,
+        ) ||
+        !["root", "role:implementer", "role:reviewer"].includes(
+          edge.target,
+        )
+      ) {
+        errors.push(`${name} has an invalid endpoint`);
+      }
+      if (!["governs", "handoff", "feedback", "verdict"].includes(edge.kind)) {
+        errors.push(`${name}.kind is invalid`);
+      }
+      if (typeof edge.active !== "boolean") {
+        errors.push(`${name}.active must be a boolean`);
+      }
+      integerField(errors, edge.reportCount, `${name}.reportCount`);
+    }
+    const expectedEdges = new Map([
+      [
+        "root-governs-implementer",
+        ["root", "role:implementer", "governs"],
+      ],
+      [
+        "implementer-handoff-reviewer",
+        [
+          "role:implementer",
+          "role:reviewer",
+          "handoff",
+        ],
+      ],
+      [
+        "reviewer-feedback-implementer",
+        [
+          "role:reviewer",
+          "role:implementer",
+          "feedback",
+        ],
+      ],
+      [
+        "reviewer-verdict-root",
+        ["role:reviewer", "root", "verdict"],
+      ],
+    ]);
+    for (const edge of value.edges) {
+      const expected = expectedEdges.get(edge.id);
+      if (
+        !expected ||
+        edge.source !== expected[0] ||
+        edge.target !== expected[1] ||
+        edge.kind !== expected[2]
+      ) {
+        errors.push(
+          `projection edge ${edge.id ?? "unknown"} does not match the recipe`,
+        );
+      }
+    }
+  }
+
+  if (value.pending !== undefined) {
+    const pending = value.pending;
+    rejectUnknown(
+      errors,
+      pending,
+      new Set(["transitionId", "kind", "role", "lap"]),
+      "projection.pending",
+    );
+    if (isPlainObject(pending)) {
+      stringField(
+        errors,
+        pending.transitionId,
+        "projection.pending.transitionId",
+        { max: 128 },
+      );
+      if (
+        !["activate-implementer", "activate-reviewer"].includes(
+          pending.kind,
+        )
+      ) {
+        errors.push("projection.pending.kind is invalid");
+      }
+      if (!WORKER_ROLES.has(pending.role)) {
+        errors.push("projection.pending.role is invalid");
+      }
+      if (
+        pending.kind === "activate-implementer" &&
+        pending.role !== "implementer"
+      ) {
+        errors.push("projection.pending role does not match kind");
+      }
+      if (
+        pending.kind === "activate-reviewer" &&
+        pending.role !== "reviewer"
+      ) {
+        errors.push("projection.pending role does not match kind");
+      }
+      integerField(errors, pending.lap, "projection.pending.lap");
+    }
+  }
+
+  if (value.latestReport !== undefined) {
+    const report = value.latestReport;
+    rejectUnknown(
+      errors,
+      report,
+      new Set([
+        "reportId",
+        "fromRole",
+        "type",
+        "verdict",
+        "issueCount",
+      ]),
+      "projection.latestReport",
+    );
+    if (isPlainObject(report)) {
+      stringField(
+        errors,
+        report.reportId,
+        "projection.latestReport.reportId",
+        { max: 128 },
+      );
+      if (!WORKER_ROLES.has(report.fromRole)) {
+        errors.push("projection.latestReport.fromRole is invalid");
+      }
+      if (!["info", "verdict"].includes(report.type)) {
+        errors.push("projection.latestReport.type is invalid");
+      }
+      if (
+        report.verdict !== undefined &&
+        !["issues", "clean"].includes(report.verdict)
+      ) {
+        errors.push("projection.latestReport.verdict is invalid");
+      }
+      integerField(
+        errors,
+        report.issueCount,
+        "projection.latestReport.issueCount",
+        { max: 200 },
+      );
+      if (
+        (report.type === "verdict" &&
+          report.verdict === undefined) ||
+        (report.type === "info" &&
+          report.verdict !== undefined) ||
+        (report.verdict === "clean" &&
+          report.issueCount !== 0) ||
+        (report.verdict === "issues" &&
+          report.issueCount === 0)
+      ) {
+        errors.push(
+          "projection.latestReport type, verdict, and issueCount are inconsistent",
+        );
+      }
+    }
+  }
+
+  const countNames = [
+    "events",
+    "reports",
+    "transitions",
+    "operations",
+    "governorDecisions",
+    "recoveries",
+    "diagnostics",
+    "conflicts",
+    "corrupt",
+  ];
+  if (!isPlainObject(value.counts)) {
+    errors.push("projection.counts must be an object");
+  } else {
+    rejectUnknown(
+      errors,
+      value.counts,
+      new Set(countNames),
+      "projection.counts",
+    );
+    for (const name of countNames) {
+      integerField(
+        errors,
+        value.counts[name],
+        `projection.counts.${name}`,
+      );
+    }
+    if (value.counts.corrupt !== 0) {
+      errors.push("projection.counts.corrupt must be 0");
+    }
+    if (
+      Number.isInteger(value.revision) &&
+      Number.isInteger(value.counts.operations) &&
+      Number.isInteger(value.counts.governorDecisions) &&
+      value.counts.operations +
+        value.counts.governorDecisions +
+        value.counts.recoveries !==
+        value.revision
+    ) {
+      errors.push(
+        "projection applied control receipt counts must equal revision",
+      );
+    }
+    if (
+      Number.isInteger(value.counts.operations) &&
+      Number.isInteger(value.counts.transitions) &&
+      value.counts.operations !== value.counts.transitions
+    ) {
+      errors.push(
+        "projection transition count must equal operation count",
+      );
+    }
+  }
+
+  if (value.recovery !== undefined) {
+    rejectUnknown(
+      errors,
+      value.recovery,
+      new Set(["recoveryId", "reason"]),
+      "projection.recovery",
+    );
+    if (isPlainObject(value.recovery)) {
+      stringField(
+        errors,
+        value.recovery.recoveryId,
+        "projection.recovery.recoveryId",
+        {
+          max: 73,
+          pattern: /^recovery_[a-f0-9]{64}$/,
+        },
+      );
+      if (
+        value.recovery.reason !==
+        "legacy-history-quarantined"
+      ) {
+        errors.push(
+          "projection.recovery.reason must be legacy-history-quarantined",
+        );
+      }
+    }
+  }
+  if (
+    (value.recovery === undefined) !==
+    (value.counts?.recoveries === 0)
+  ) {
+    errors.push(
+      "projection.recovery must exist exactly when one recovery is applied",
+    );
+  }
+
+  if (!Array.isArray(value.timeline) || value.timeline.length > 32) {
+    errors.push("projection.timeline must contain at most 32 items");
+  } else {
+    for (const [index, item] of value.timeline.entries()) {
+      const name = `projection.timeline[${index}]`;
+      rejectUnknown(
+        errors,
+        item,
+        new Set(["kind", "id", "at", "label", "role"]),
+        name,
+      );
+      if (!isPlainObject(item)) {
+        continue;
+      }
+      if (
+        ![
+          "event",
+          "report",
+          "transition",
+          "governor-decision",
+          "recovery",
+        ].includes(item.kind)
+      ) {
+        errors.push(`${name}.kind is invalid`);
+      }
+      stringField(errors, item.id, `${name}.id`, { max: 128 });
+      if (!isTimestamp(item.at)) {
+        errors.push(`${name}.at must be an ISO date-time`);
+      }
+      stringField(errors, item.label, `${name}.label`, { max: 128 });
+      if (item.role !== undefined && !WORKER_ROLES.has(item.role)) {
+        errors.push(`${name}.role is invalid`);
+      }
+    }
+  }
+  stringField(
+    errors,
+    value.projectionDigest,
+    "projection.projectionDigest",
+    { max: 64, pattern: SHA256 },
+  );
+  return errors;
+}
+
+export function validateLegacyNativeTargetEvidence(value) {
+  const errors = [];
+  const allowed = new Set([
+    "schemaVersion",
+    "evidenceVersion",
+    "runId",
+    "stateRevision",
+    "historyDigest",
+    "entries",
+    "evidenceDigest",
+  ]);
+  rejectUnknown(errors, value, allowed, "legacyEvidence");
+  if (!isPlainObject(value)) {
+    return errors;
+  }
+  if (value.schemaVersion !== SCHEMA_VERSION) {
+    errors.push("legacyEvidence.schemaVersion must be 1");
+  }
+  if (value.evidenceVersion !== LEGACY_EVIDENCE_VERSION) {
+    errors.push("legacyEvidence.evidenceVersion must be 1");
+  }
+  stringField(errors, value.runId, "legacyEvidence.runId", {
+    max: 128,
+  });
+  integerField(
+    errors,
+    value.stateRevision,
+    "legacyEvidence.stateRevision",
+  );
+  stringField(
+    errors,
+    value.historyDigest,
+    "legacyEvidence.historyDigest",
+    { max: 64, pattern: SHA256 },
+  );
+  if (
+    !Array.isArray(value.entries) ||
+    value.entries.length < 1 ||
+    value.entries.length > MAX_LEGACY_NATIVE_TARGET_FACTS
+  ) {
+    errors.push(
+      `legacyEvidence.entries must contain 1 to ${MAX_LEGACY_NATIVE_TARGET_FACTS} items`,
+    );
+  } else {
+    const keys = [];
+    for (const [index, entry] of value.entries.entries()) {
+      const name = `legacyEvidence.entries[${index}]`;
+      rejectUnknown(
+        errors,
+        entry,
+        new Set([
+          "factKind",
+          "factId",
+          "factDigest",
+          "field",
+          "role",
+          "bindingId",
+          "bindingDigest",
+        ]),
+        name,
+      );
+      if (!isPlainObject(entry)) {
+        continue;
+      }
+      if (!["transition", "report"].includes(entry.factKind)) {
+        errors.push(`${name}.factKind is invalid`);
+      }
+      stringField(errors, entry.factId, `${name}.factId`, {
+        max: 128,
+      });
+      stringField(
+        errors,
+        entry.factDigest,
+        `${name}.factDigest`,
+        { max: 64, pattern: SHA256 },
+      );
+      const expectedField =
+        entry.factKind === "transition"
+          ? "toNode"
+          : entry.factKind === "report"
+            ? "routedToNode"
+            : null;
+      if (entry.field !== expectedField) {
+        errors.push(`${name}.field does not match factKind`);
+      }
+      if (!WORKER_ROLES.has(entry.role)) {
+        errors.push(`${name}.role is invalid`);
+      }
+      stringField(
+        errors,
+        entry.bindingId,
+        `${name}.bindingId`,
+        {
+          max: 72,
+          pattern: /^binding_[a-f0-9]{64}$/,
+        },
+      );
+      stringField(
+        errors,
+        entry.bindingDigest,
+        `${name}.bindingDigest`,
+        { max: 64, pattern: SHA256 },
+      );
+      keys.push(
+        `${entry.factKind}:${entry.factId}:${entry.field}`,
+      );
+    }
+    if (new Set(keys).size !== keys.length) {
+      errors.push("legacyEvidence.entries must be unique");
+    }
+    const sorted = [...value.entries].sort((left, right) =>
+      compareCodePoints(
+        `${left.factKind}:${left.factId}:${left.field}`,
+        `${right.factKind}:${right.factId}:${right.field}`,
+      ),
+    );
+    if (canonicalJson(sorted) !== canonicalJson(value.entries)) {
+      errors.push(
+        "legacyEvidence.entries must be code-point sorted",
+      );
+    }
+  }
+  stringField(
+    errors,
+    value.evidenceDigest,
+    "legacyEvidence.evidenceDigest",
+    { max: 64, pattern: SHA256 },
+  );
+  if (errors.length === 0) {
+    const { evidenceDigest, ...base } = value;
+    if (evidenceDigest !== digestJson(base)) {
+      errors.push(
+        "legacyEvidence.evidenceDigest must match canonical evidence",
+      );
+    }
+  }
+  return errors;
+}
+
+export function validateLegacyQuarantineReceipt(value) {
+  const errors = [];
+  const allowed = new Set([
+    "schemaVersion",
+    "recoveryVersion",
+    "recoveryId",
+    "runId",
+    "requestId",
+    "requestDigest",
+    "actorKind",
+    "actorId",
+    "reason",
+    "evidenceDigest",
+    "legacyFactCount",
+    "priorStateDigest",
+    "terminalStateDigest",
+    "fromRevision",
+    "toRevision",
+    "createdAt",
+  ]);
+  rejectUnknown(errors, value, allowed, "recovery");
+  if (!isPlainObject(value)) {
+    return errors;
+  }
+  if (value.schemaVersion !== SCHEMA_VERSION) {
+    errors.push("recovery.schemaVersion must be 1");
+  }
+  if (value.recoveryVersion !== LEGACY_RECOVERY_VERSION) {
+    errors.push("recovery.recoveryVersion must be 1");
+  }
+  stringField(errors, value.recoveryId, "recovery.recoveryId", {
+    max: 73,
+    pattern: /^recovery_[a-f0-9]{64}$/,
+  });
+  stringField(errors, value.runId, "recovery.runId", {
+    max: 128,
+  });
+  stringField(errors, value.requestId, "recovery.requestId", {
+    max: 128,
+    pattern: SAFE_FILE_ID,
+  });
+  for (const field of [
+    "requestDigest",
+    "evidenceDigest",
+    "priorStateDigest",
+    "terminalStateDigest",
+  ]) {
+    stringField(errors, value[field], `recovery.${field}`, {
+      max: 64,
+      pattern: SHA256,
+    });
+  }
+  if (value.actorKind !== "root") {
+    errors.push("recovery.actorKind must be root");
+  }
+  stringField(errors, value.actorId, "recovery.actorId");
+  if (
+    value.reason !== "unsupported-native-target-history"
+  ) {
+    errors.push(
+      "recovery.reason must be unsupported-native-target-history",
+    );
+  }
+  integerField(
+    errors,
+    value.legacyFactCount,
+    "recovery.legacyFactCount",
+    { min: 1, max: MAX_LEGACY_NATIVE_TARGET_FACTS },
+  );
+  integerField(
+    errors,
+    value.fromRevision,
+    "recovery.fromRevision",
+  );
+  integerField(
+    errors,
+    value.toRevision,
+    "recovery.toRevision",
+    { min: 1 },
+  );
+  if (
+    Number.isInteger(value.fromRevision) &&
+    Number.isInteger(value.toRevision) &&
+    value.toRevision !== value.fromRevision + 1
+  ) {
+    errors.push(
+      "recovery.toRevision must equal fromRevision + 1",
+    );
+  }
+  if (!isTimestamp(value.createdAt)) {
+    errors.push("recovery.createdAt must be an ISO date-time");
+  }
+  return errors;
+}
+
+export function validateIdentityBinding(value) {
+  const errors = [];
+  const allowed = new Set([
+    "schemaVersion",
+    "bindingId",
+    "runId",
+    "agentId",
+    "rootSessionId",
+    "method",
+    "tokenDigest",
+    "hostIdentityDigest",
+    "role",
+    "requestId",
+    "requestDigest",
+    "observationId",
+    "originEventId",
+    "createdAt",
+    "revokedAt",
+  ]);
+  rejectUnknown(errors, value, allowed, "binding");
+  if (!isPlainObject(value)) {
+    return errors;
+  }
+  if (value.schemaVersion !== SCHEMA_VERSION) {
+    errors.push("binding.schemaVersion must be 1");
+  }
+  stringField(errors, value.bindingId, "binding.bindingId", { max: 128 });
+  stringField(errors, value.runId, "binding.runId", { max: 128 });
+  stringField(errors, value.agentId, "binding.agentId");
+  stringField(errors, value.rootSessionId, "binding.rootSessionId");
+  if (!["host-metadata-v1", "capability-token-v1"].includes(value.method)) {
+    errors.push("binding.method is invalid");
+  }
+  if (
+    value.role !== undefined &&
+    !WORKER_ROLES.has(value.role)
+  ) {
+    errors.push("binding.role is invalid");
+  }
+  stringField(errors, value.requestId, "binding.requestId", {
+    optional: value.requestDigest === undefined,
+    max: 128,
+    pattern: SAFE_FILE_ID,
+  });
+  stringField(errors, value.requestDigest, "binding.requestDigest", {
+    optional: value.requestId === undefined,
+    max: 64,
+    pattern: SHA256,
+  });
+  stringField(errors, value.observationId, "binding.observationId", {
+    optional: true,
+    max: 128,
+    pattern: /^observation_[a-f0-9]{64}$/,
+  });
+  stringField(errors, value.originEventId, "binding.originEventId", {
+    optional: true,
+    max: 68,
+    pattern: /^evt_[a-f0-9]{64}$/,
+  });
+  if (
+    (value.observationId === undefined) !==
+    (value.originEventId === undefined)
+  ) {
+    errors.push(
+      "binding observationId and originEventId must appear together",
+    );
+  }
+  const productFields = [
+    "requestId",
+    "requestDigest",
+    "observationId",
+    "originEventId",
+  ];
+  const productFieldCount = productFields.filter(
+    (field) => value[field] !== undefined,
+  ).length;
+  if (
+    productFieldCount > 0 &&
+    productFieldCount !== productFields.length
+  ) {
+    errors.push(
+      "product identity bindings require role, requestId, requestDigest, observationId, and originEventId together",
+    );
+  }
+  if (
+    productFieldCount > 0 &&
+    value.role === undefined
+  ) {
+    errors.push(
+      "observed identity bindings require a role",
+    );
+  }
+  stringField(errors, value.tokenDigest, "binding.tokenDigest", {
+    optional: value.method !== "capability-token-v1",
+    max: 64,
+    pattern: SHA256,
+  });
+  stringField(errors, value.hostIdentityDigest, "binding.hostIdentityDigest", {
+    optional: value.method !== "host-metadata-v1",
+    max: 64,
+    pattern: SHA256,
+  });
+  if (!isTimestamp(value.createdAt)) {
+    errors.push("binding.createdAt must be an ISO date-time");
+  }
+  if (value.revokedAt !== undefined && !isTimestamp(value.revokedAt)) {
+    errors.push("binding.revokedAt must be an ISO date-time");
+  }
+  return errors;
+}
+
+export function assertContract(name, value, validator) {
+  const errors = validator(value);
+  if (errors.length > 0) {
+    const error = new TypeError(`${name} contract failed: ${errors.join("; ")}`);
+    error.code = "INVALID_CONTRACT";
+    error.details = errors;
+    throw error;
+  }
+  return value;
+}
+
+export function assertSafeFileId(value, name = "id") {
+  if (typeof value !== "string" || !SAFE_FILE_ID.test(value)) {
+    const error = new TypeError(`${name} is not a safe store identifier`);
+    error.code = "INVALID_STORE_ID";
+    throw error;
+  }
+  return value;
+}
+
+function shortString(value, max = 256) {
+  return typeof value === "string" && value.length > 0
+    ? value.slice(0, max)
+    : undefined;
+}
+
+function sortedObjectKeys(value) {
+  return isPlainObject(value)
+    ? Object.keys(value).sort(compareCodePoints)
+    : undefined;
+}
+
+function normalizedToolName(value) {
+  return typeof value === "string"
+    ? value.toLowerCase().replaceAll(/[^a-z0-9]/g, "")
+    : "";
+}
+
+export function isNativeSpawnPreToolUse(event) {
+  if (event?.event !== "PreToolUse") {
+    return false;
+  }
+  const toolName = normalizedToolName(
+    event?.payloadSummary?.toolName,
+  );
+  return [
+    "collaborationspawnagent",
+    "spawnagent",
+  ].includes(toolName);
+}
+
+export function isWorkerObservationEvent(event) {
+  return (
+    event?.event === "SubagentStart" ||
+    isNativeSpawnPreToolUse(event)
+  );
+}
+
+function hasRequiredHookIdentity(event, fields) {
+  if (fields.sessionId === "unknown") {
+    return false;
+  }
+  switch (event) {
+    case "SessionStart":
+      return fields.source !== undefined;
+    case "UserPromptSubmit":
+    case "Stop":
+      return fields.turnId !== undefined;
+    case "PreToolUse":
+    case "PostToolUse":
+      return (
+        fields.turnId !== undefined &&
+        fields.toolUseId !== undefined
+      );
+    case "SubagentStart":
+    case "SubagentStop":
+      return (
+        fields.turnId !== undefined &&
+        fields.agentId !== undefined
+      );
+    default:
+      return false;
+  }
+}
+
+export function normalizeHookEvent(
+  input,
+  options = {},
+) {
+  const observedAt = options.observedAt ?? new Date().toISOString();
+  const event = shortString(input?.hook_event_name, 64) ?? "Unknown";
+  const sessionId = shortString(input?.session_id) ?? "unknown";
+  const turnId = shortString(input?.turn_id);
+  const agentId = shortString(input?.agent_id);
+  const agentType = shortString(input?.agent_type, 128);
+  const toolUseId = shortString(input?.tool_use_id);
+  const stopHookActive =
+    typeof input?.stop_hook_active === "boolean"
+      ? input.stop_hook_active
+      : undefined;
+  const source = shortString(input?.source, 64);
+  const toolName = shortString(input?.tool_name, 128);
+  const hookDefinitionDigest =
+    typeof options.hookDefinitionDigest === "string" &&
+    /^[a-f0-9]{64}$/.test(options.hookDefinitionDigest)
+      ? options.hookDefinitionDigest
+      : undefined;
+  const payloadSummary = {
+    event,
+    ...(event === "UserPromptSubmit" &&
+    options.hookCollectorProtocol ===
+      HOOK_COLLECTOR_PROTOCOL &&
+    hookDefinitionDigest
+      ? {
+          hookCollectorProtocol:
+            options.hookCollectorProtocol,
+          hookDefinitionDigest,
+        }
+      : {}),
+    ...(source ? { source } : {}),
+    ...(toolName ? { toolName } : {}),
+    ...(sortedObjectKeys(input?.tool_input)
+      ? { toolInputKeys: sortedObjectKeys(input.tool_input) }
+      : {}),
+    ...(input?.tool_response === undefined
+      ? {}
+      : { toolResponseType: Array.isArray(input.tool_response)
+          ? "array"
+          : typeof input.tool_response }),
+  };
+  const conflictEligible =
+    KNOWN_HOOK_EVENTS.has(event) &&
+    hasRequiredHookIdentity(event, {
+      sessionId,
+      turnId,
+      agentId,
+      toolUseId,
+      source,
+    });
+  const identity = conflictEligible
+    ? {
+        semanticKeyVersion: SEMANTIC_KEY_VERSION,
+        sessionId,
+        ...(turnId ? { turnId } : {}),
+        event,
+        ...(agentId ? { agentId } : {}),
+        ...(toolUseId ? { toolUseId } : {}),
+        ...(stopHookActive === undefined ? {} : { stopHookActive }),
+        ...(event === "SessionStart" && source ? { source } : {}),
+      }
+    : {
+        semanticKeyVersion: SEMANTIC_KEY_VERSION,
+        unknownDelivery:
+          options.deliveryDigest ??
+          sha256(`${process.pid}:${process.hrtime.bigint()}:${randomUUID()}`),
+      };
+  const semanticKey = `sem-v1:${digestJson(identity)}`;
+  const payloadDigest = digestJson({
+    schemaVersion: SCHEMA_VERSION,
+    semanticKey,
+    sessionId,
+    ...(turnId ? { turnId } : {}),
+    event,
+    ...(agentId ? { agentId } : {}),
+    ...(agentType ? { agentType } : {}),
+    ...(toolUseId ? { toolUseId } : {}),
+    ...(stopHookActive === undefined ? {} : { stopHookActive }),
+    payloadSummary,
+  });
+  const normalized = {
+    schemaVersion: SCHEMA_VERSION,
+    semanticKeyVersion: SEMANTIC_KEY_VERSION,
+    eventId: `evt_${sha256(canonicalJson({ semanticKey, payloadDigest }))}`,
+    semanticKey,
+    sessionId,
+    ...(turnId ? { turnId } : {}),
+    event,
+    ...(agentId ? { agentId } : {}),
+    ...(agentType ? { agentType } : {}),
+    ...(toolUseId ? { toolUseId } : {}),
+    ...(stopHookActive === undefined ? {} : { stopHookActive }),
+    observedAt,
+    payloadDigest,
+    payloadSummary,
+    conflictEligible,
+  };
+  return assertContract(
+    "normalized hook event",
+    normalized,
+    validateNormalizedHookEvent,
+  );
+}
+
+export function createInterruptedRun(runId, event = undefined) {
+  assertSafeFileId(runId, "runId");
+  const now = event?.observedAt ?? new Date(0).toISOString();
+  const sessionId = event?.sessionId ?? "unknown";
+  const turnId = event?.turnId ?? "unknown";
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    runId,
+    rootSessionId: sessionId,
+    originatingTurnId: turnId,
+    scope: { kind: "task" },
+    masterNode: sessionId,
+    recipe: "review-until-clean",
+    status: "interrupted",
+    currentLap: 0,
+    continuationLease: { granted: 0, consumed: 0 },
+    cancelRequested: false,
+    needsHuman: true,
+    revision: 0,
+    createdAt: now,
+    updatedAt: now,
+  };
+}
diff --git a/plugins/looperators-agent-loop/lib/control.mjs b/plugins/looperators-agent-loop/lib/control.mjs
new file mode 100644
index 0000000..260acc5
--- /dev/null
+++ b/plugins/looperators-agent-loop/lib/control.mjs
@@ -0,0 +1,4970 @@
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import {
+  canonicalJson,
+  compareCodePoints,
+  digestJson,
+  sha256,
+} from "./canonical-json.mjs";
+import {
+  ACTIVE_RUN_STATUSES,
+  SCHEMA_VERSION,
+  WORKER_ROLES,
+  assertContract,
+  assertSafeFileId,
+  isNativeSpawnPreToolUse,
+  validateGovernorDecision,
+  validateIdentityBinding,
+  validateLoopDefinition,
+  validateLoopOperation,
+  validateLoopReport,
+  validateLoopTransition,
+  validateWorkerObservation,
+} from "./contracts.mjs";
+import { buildAgentLoopProjection } from "./projection.mjs";
+import {
+  buildLegacyNativeTargetEvidence,
+  collectLegacyNativeTargetEntries,
+  createLegacyQuarantineReceipt,
+  legacyEntryKey,
+  recoveryIdFor,
+  recoveryRequestDigest,
+  terminalStateForRecovery,
+} from "./recovery.mjs";
+
+const NATIVE_SUBAGENT_SOURCE = "subagent";
+const ROOT_METADATA_KEY = "x-codex-turn-metadata";
+const ROOT_CONTROL_STATUSES = new Set([
+  "draft",
+  "running",
+  "paused",
+  "interrupted",
+]);
+
+export class LoopControlError extends Error {
+  constructor(code, message, details = undefined) {
+    super(message);
+    this.name = "LoopControlError";
+    this.code = code;
+    this.details = details;
+  }
+}
+
+function fail(code, message, details = undefined) {
+  throw new LoopControlError(code, message, details);
+}
+
+function boundedString(value, name, max = 256) {
+  if (
+    typeof value !== "string" ||
+    value.length === 0 ||
+    value.length > max
+  ) {
+    fail("INVALID_TOOL_INPUT", `${name} is invalid`);
+  }
+  return value;
+}
+
+function requestId(value) {
+  boundedString(value, "requestId", 128);
+  try {
+    assertSafeFileId(value, "requestId");
+  } catch {
+    fail("INVALID_TOOL_INPUT", "requestId is invalid");
+  }
+  if (value.startsWith("internal-")) {
+    fail(
+      "INVALID_TOOL_INPUT",
+      "requestId uses a reserved internal namespace",
+    );
+  }
+  return value;
+}
+
+function runId(value) {
+  try {
+    return assertSafeFileId(value, "runId");
+  } catch {
+    fail("INVALID_TOOL_INPUT", "runId is invalid");
+  }
+}
+
+function agentId(value) {
+  boundedString(value, "agentId", 256);
+  return value;
+}
+
+function roleAgentId(role) {
+  return `role:${role}`;
+}
+
+function digestsEqual(left, right) {
+  const leftBuffer = Buffer.from(left);
+  const rightBuffer = Buffer.from(right);
+  return (
+    leftBuffer.length === rightBuffer.length &&
+    timingSafeEqual(leftBuffer, rightBuffer)
+  );
+}
+
+function derivedId(prefix, value) {
+  return `${prefix}_${sha256(canonicalJson(value))}`;
+}
+
+function runIdFor(rootSessionId, previewRequestId) {
+  return derivedId("run", {
+    rootSessionId,
+    requestId: previewRequestId,
+  });
+}
+
+function definitionIdFor(value) {
+  return derivedId("definition", {
+    runId: value,
+    kind: "definition",
+  });
+}
+
+function operationIdFor(value, mutationRequestId) {
+  return derivedId("op", {
+    runId: value,
+    requestId: mutationRequestId,
+  });
+}
+
+function reportIdFor(value, mutationRequestId) {
+  return derivedId("report", {
+    runId: value,
+    requestId: mutationRequestId,
+    kind: "report",
+  });
+}
+
+function transitionIdFor(value, mutationRequestId) {
+  return derivedId("transition", {
+    runId: value,
+    requestId: mutationRequestId,
+    kind: "transition",
+  });
+}
+
+function factLimitRequestId(fromRevision) {
+  return `internal-fact-limit-${fromRevision}`;
+}
+
+function reportPayload(report) {
+  return {
+    type: report.type,
+    ...(report.status ? { status: report.status } : {}),
+    ...(report.verdict ? { verdict: report.verdict } : {}),
+    ...(report.issues ? { issues: report.issues } : {}),
+    ...(report.summary ? { summary: report.summary } : {}),
+  };
+}
+
+function bindingRequestDigest(input) {
+  return digestJson({
+    kind: "bind-worker",
+    runId: input.runId,
+    requestId: input.requestId,
+    agentId: input.agentId,
+    role: input.role,
+    observationId: input.observationId,
+    originEventId: input.originEventId,
+  });
+}
+
+function observationIdFor(value, mutationRequestId) {
+  return derivedId("observation", {
+    runId: value,
+    requestId: mutationRequestId,
+    kind: "prepare-worker-spawn",
+  });
+}
+
+function observationRequestDigest(input) {
+  return digestJson({
+    schemaVersion: SCHEMA_VERSION,
+    kind: "prepare-worker-spawn",
+    runId: input.runId,
+    requestId: input.requestId,
+    rootSessionId: input.rootSessionId,
+    role: input.role,
+  });
+}
+
+function mutationRequestDigest(input) {
+  return digestJson({
+    schemaVersion: SCHEMA_VERSION,
+    kind: input.kind,
+    runId: input.runId,
+    requestId: input.requestId,
+    actorKind: input.actorKind,
+    actorId: input.actorId,
+    payload: input.payload ?? {},
+  });
+}
+
+function definitionRequestDigest(input) {
+  return digestJson({
+    schemaVersion: SCHEMA_VERSION,
+    kind: "preview",
+    rootSessionId: input.rootSessionId,
+    requestId: input.requestId,
+    recipe: "review-until-clean",
+    goal: input.goal,
+    implementerInstructions: input.implementerInstructions,
+    reviewerInstructions: input.reviewerInstructions,
+    lapCap: input.lapCap,
+  });
+}
+
+function assertRootContext(context) {
+  if (
+    !context ||
+    typeof context.rootSessionId !== "string" ||
+    typeof context.turnId !== "string"
+  ) {
+    fail(
+      "ROOT_IDENTITY_UNAVAILABLE",
+      "trusted root task metadata is unavailable",
+    );
+  }
+  return context;
+}
+
+export function rootContextFromMcpMessage(message) {
+  const metadata =
+    message?.params?._meta?.[ROOT_METADATA_KEY];
+  if (
+    metadata === null ||
+    typeof metadata !== "object" ||
+    Array.isArray(metadata) ||
+    typeof metadata.session_id !== "string" ||
+    metadata.session_id.length === 0 ||
+    metadata.session_id.length > 512 ||
+    typeof metadata.turn_id !== "string" ||
+    metadata.turn_id.length === 0 ||
+    metadata.turn_id.length > 512 ||
+    typeof metadata.thread_source !== "string" ||
+    metadata.thread_source.length === 0 ||
+    metadata.thread_source.length > 128
+  ) {
+    fail(
+      "ROOT_IDENTITY_UNAVAILABLE",
+      "trusted root task metadata is unavailable",
+    );
+  }
+  const rootSessionId = metadata.session_id;
+  const turnId = metadata.turn_id;
+  const threadSource = metadata.thread_source;
+  const nativeAgentId = metadata.agent_id;
+  if (
+    nativeAgentId !== undefined &&
+    (typeof nativeAgentId !== "string" ||
+      nativeAgentId.length === 0 ||
+      nativeAgentId.length > 512)
+  ) {
+    fail(
+      "ROOT_IDENTITY_UNAVAILABLE",
+      "trusted root task metadata is unavailable",
+    );
+  }
+  if (threadSource === NATIVE_SUBAGENT_SOURCE) {
+    fail(
+      "ROOT_ONLY_TOOL",
+      "this tool may only be called by the root task",
+    );
+  }
+  return Object.freeze({ rootSessionId, turnId, threadSource });
+}
+
+async function maybeRead(reader) {
+  try {
+    return await reader();
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+
+function stateSummary(state, definition, duplicate = false) {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    runId: state.runId,
+    status: state.status,
+    revision: state.revision,
+    currentLap: state.currentLap,
+    lapCap: definition.lapCap,
+    continuationLease: state.continuationLease,
+    cancelRequested: state.cancelRequested,
+    needsHuman: state.needsHuman ?? false,
+    duplicate,
+    ...(state.pendingTransitionId
+      ? { pendingTransitionId: state.pendingTransitionId }
+      : {}),
+    ...(state.latestReportId
+      ? { latestReportId: state.latestReportId }
+      : {}),
+    ...(state.latestGovernorDecisionId
+      ? {
+          latestGovernorDecisionId:
+            state.latestGovernorDecisionId,
+        }
+      : {}),
+    ...(state.latestRecoveryId
+      ? { latestRecoveryId: state.latestRecoveryId }
+      : {}),
+  };
+}
+
+function previewGraph() {
+  return {
+    nodes: [
+      { id: "root-master", role: "root" },
+      { id: "role:implementer", role: "implementer" },
+      { id: "role:reviewer", role: "reviewer" },
+    ],
+    edges: [
+      {
+        from: "role:implementer",
+        to: "role:reviewer",
+        on: "done",
+      },
+      {
+        from: "role:reviewer",
+        to: "role:implementer",
+        on: "issues",
+      },
+      {
+        from: "role:reviewer",
+        to: "root-master",
+        on: "clean",
+      },
+    ],
+  };
+}
+
+function withoutPending(state) {
+  const { pendingTransitionId: _pending, ...rest } = state;
+  return rest;
+}
+
+function governedTransitionRole(transition) {
+  if (transition.kind === "activate-implementer") {
+    return "implementer";
+  }
+  if (transition.kind === "activate-reviewer") {
+    return "reviewer";
+  }
+  return null;
+}
+
+function workerObservationSnapshot(
+  evidence,
+  bindings,
+  rootSessionId,
+) {
+  const spawnToolUseIds = [
+    ...new Set(
+      evidence
+        .filter(
+          (event) =>
+            event.conflictEligible === true &&
+            event.sessionId === rootSessionId &&
+            isNativeSpawnPreToolUse(event) &&
+            typeof event.toolUseId === "string",
+        )
+        .map((event) => event.toolUseId),
+    ),
+  ].sort(compareCodePoints);
+  const starts = evidence
+    .filter(
+      (event) =>
+        event.event === "SubagentStart" &&
+        event.conflictEligible === true &&
+        event.sessionId === rootSessionId &&
+        typeof event.agentId === "string",
+    )
+    .sort((left, right) => {
+      const observedOrder = compareCodePoints(
+        left.observedAt,
+        right.observedAt,
+      );
+      return observedOrder !== 0
+        ? observedOrder
+        : compareCodePoints(left.eventId, right.eventId);
+    });
+  const subagentStartEventIds = starts
+    .map((event) => event.eventId)
+    .sort(compareCodePoints);
+  const bindingIds = bindings
+    .map((binding) => binding.bindingId)
+    .sort(compareCodePoints);
+  const base = {
+    spawnToolUseIds,
+    subagentStartEventIds,
+    bindingIds,
+  };
+  return {
+    ...base,
+    starts,
+    observationDigest: digestJson(base),
+  };
+}
+
+function difference(values, baseline) {
+  const prior = new Set(baseline);
+  return values.filter((value) => !prior.has(value));
+}
+
+export class LoopController {
+  constructor(store, options = {}) {
+    this.store = store;
+    this.now =
+      options.now ?? (() => new Date().toISOString());
+    this.fault = options.fault ?? (async () => {});
+    this.actionTokens = new Map();
+  }
+
+  async preview(contextValue, input) {
+    const context = assertRootContext(contextValue);
+    const previewRequestId = requestId(input?.requestId);
+    const lapCap = input?.lapCap ?? 3;
+    const goal = boundedString(input?.goal, "goal", 8192);
+    const implementerInstructions = boundedString(
+      input?.implementerInstructions,
+      "implementerInstructions",
+      16384,
+    );
+    const reviewerInstructions = boundedString(
+      input?.reviewerInstructions,
+      "reviewerInstructions",
+      16384,
+    );
+    if (!Number.isInteger(lapCap) || lapCap < 1 || lapCap > 6) {
+      fail("INVALID_TOOL_INPUT", "lapCap is invalid");
+    }
+    const desiredRunId = runIdFor(
+      context.rootSessionId,
+      previewRequestId,
+    );
+    const desired = assertContract(
+      "loop definition",
+      {
+        schemaVersion: SCHEMA_VERSION,
+        definitionId: definitionIdFor(desiredRunId),
+        runId: desiredRunId,
+        requestId: previewRequestId,
+        requestDigest: definitionRequestDigest({
+          rootSessionId: context.rootSessionId,
+          requestId: previewRequestId,
+          goal,
+          implementerInstructions,
+          reviewerInstructions,
+          lapCap,
+        }),
+        recipe: "review-until-clean",
+        goal,
+        implementerInstructions,
+        reviewerInstructions,
+        lapCap,
+        createdAt: this.now(),
+      },
+      validateLoopDefinition,
+    );
+
+    const existingDefinition = await maybeRead(() =>
+      this.store.readDefinition(desiredRunId),
+    );
+    if (existingDefinition) {
+      if (
+        existingDefinition.requestDigest !==
+        desired.requestDigest
+      ) {
+        fail(
+          "REQUEST_ID_CONFLICT",
+          "preview request id already has different content",
+        );
+      }
+      const state = await this.#ensurePreviewDraft(
+        context,
+        existingDefinition,
+      );
+      return this.#previewResult(
+        state,
+        existingDefinition,
+        true,
+      );
+    }
+
+    const bound = await this.store.boundRunsForSession(
+      context.rootSessionId,
+    );
+    const occupied = bound.find(
+      ({ state }) =>
+        state === null || ACTIVE_RUN_STATUSES.has(state.status),
+    );
+    if (occupied) {
+      fail(
+        "ACTIVE_RUN_EXISTS",
+        "another non-terminal loop run already exists in this task",
+        { runId: occupied.binding.runId },
+      );
+    }
+
+    const published = await this.store.putDefinition(
+      desiredRunId,
+      desired,
+    );
+    if (published.status === "conflict") {
+      fail(
+        "REQUEST_ID_CONFLICT",
+        "preview request id already has different content",
+      );
+    }
+    await this.fault("afterDefinition", {
+      runId: desiredRunId,
+    });
+    const state = await this.#ensurePreviewDraft(
+      context,
+      desired,
+    );
+    return this.#previewResult(
+      state,
+      desired,
+      published.status === "duplicate",
+    );
+  }
+
+  async #ensurePreviewDraft(context, definition) {
+    try {
+      return await this.#ensureDraftState(context, definition);
+    } catch (error) {
+      if (
+        ![
+          "SESSION_BINDING_CONFLICT",
+          "SESSION_BINDING_RESERVED",
+        ].includes(error?.code)
+      ) {
+        throw error;
+      }
+      const current = await this.store.boundRunsForSession(
+        context.rootSessionId,
+      );
+      fail(
+        "ACTIVE_RUN_EXISTS",
+        "another non-terminal loop run already exists in this task",
+        { runId: current[0]?.binding.runId },
+      );
+    }
+  }
+
+  async #ensureDraftState(context, definition) {
+    const existing = await maybeRead(() =>
+      this.store.readState(definition.runId),
+    );
+    if (existing) {
+      this.#assertRoot(existing, context);
+      if (existing.status !== "draft") {
+        fail(
+          "RUN_ALREADY_STARTED",
+          "preview request already belongs to a started run",
+          { runId: existing.runId, status: existing.status },
+        );
+      }
+      return existing;
+    }
+    const state = {
+      schemaVersion: SCHEMA_VERSION,
+      runId: definition.runId,
+      rootSessionId: context.rootSessionId,
+      originatingTurnId: context.turnId,
+      scope: { kind: "task" },
+      masterNode: context.rootSessionId,
+      recipe: "review-until-clean",
+      status: "draft",
+      currentLap: 0,
+      continuationLease: {
+        granted: definition.lapCap,
+        consumed: 0,
+      },
+      cancelRequested: false,
+      revision: 0,
+      createdAt: definition.createdAt,
+      updatedAt: definition.createdAt,
+    };
+    const result = await this.store.initializeRun(state);
+    return result.existing ?? state;
+  }
+
+  #previewResult(state, definition, duplicate) {
+    return {
+      ...stateSummary(state, definition, duplicate),
+      definition,
+      preview: previewGraph(),
+    };
+  }
+
+  #assertRoot(state, context) {
+    assertRootContext(context);
+    if (state.rootSessionId !== context.rootSessionId) {
+      fail(
+        "ROOT_IDENTITY_MISMATCH",
+        "root task does not own this loop run",
+      );
+    }
+  }
+
+  #assertIdentityBindingTopology(
+    bindingRead,
+    rootSessionId,
+  ) {
+    const bindings = bindingRead.facts;
+    if (
+      bindings.some(
+        (binding) =>
+          binding.rootSessionId !== rootSessionId ||
+          !WORKER_ROLES.has(binding.role),
+      ) ||
+      bindings.length > 2
+    ) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "worker identity bindings do not match the authoritative root and role topology",
+      );
+    }
+    const roleCounts = new Map();
+    for (const binding of bindings) {
+      roleCounts.set(
+        binding.role,
+        (roleCounts.get(binding.role) ?? 0) + 1,
+      );
+    }
+    const topologyIsValid =
+      bindings.length === 0 ||
+      (bindings.length === 1 &&
+        roleCounts.get("implementer") === 1) ||
+      (bindings.length === 2 &&
+        roleCounts.get("implementer") === 1 &&
+        roleCounts.get("reviewer") === 1);
+    if (!topologyIsValid) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "worker identity bindings violate implementer-first topology",
+      );
+    }
+  }
+
+  #assertRequestNamespace(
+    targetRequestId,
+    expectedNamespace,
+    values,
+  ) {
+    const claims = [
+      ...(values.definition.requestId === targetRequestId
+        ? ["definition"]
+        : []),
+      ...values.operations
+        .filter(
+          (operation) =>
+            operation.requestId === targetRequestId,
+        )
+        .map(() => "operations"),
+      ...values.observations
+        .filter(
+          (observation) =>
+            observation.requestId === targetRequestId,
+        )
+        .map(() => "observations"),
+      ...values.bindings
+        .filter(
+          (binding) =>
+            binding.requestId === targetRequestId,
+        )
+        .map(() => "identity"),
+      ...(values.recoveries ?? [])
+        .filter(
+          (recovery) =>
+            recovery.requestId === targetRequestId,
+        )
+        .map(() => "recoveries"),
+    ];
+    if (
+      claims.some(
+        (namespace) => namespace !== expectedNamespace,
+      )
+    ) {
+      fail(
+        "REQUEST_ID_CONFLICT",
+        "request id already belongs to another mutation namespace",
+      );
+    }
+  }
+
+  #assertDurableRequestNamespaces(values) {
+    const claims = new Map();
+    const claim = (request, namespace) => {
+      if (typeof request !== "string") {
+        return;
+      }
+      const namespaces = claims.get(request) ?? new Set();
+      namespaces.add(namespace);
+      claims.set(request, namespaces);
+    };
+    claim(values.definition.requestId, "definition");
+    for (const operation of values.operations) {
+      claim(operation.requestId, "operations");
+    }
+    for (const observation of values.observations) {
+      claim(observation.requestId, "observations");
+    }
+    for (const binding of values.bindings) {
+      claim(binding.requestId, "identity");
+    }
+    for (const recovery of values.recoveries) {
+      claim(recovery.requestId, "recoveries");
+    }
+    const collisions = [...claims.entries()]
+      .filter(([, namespaces]) => namespaces.size > 1)
+      .map(([request, namespaces]) => ({
+        requestIdDigest: sha256(request),
+        namespaces: [...namespaces].sort(compareCodePoints),
+      }))
+      .sort((left, right) =>
+        compareCodePoints(
+          left.requestIdDigest,
+          right.requestIdDigest,
+        ),
+      );
+    if (collisions.length > 0) {
+      fail(
+        "HISTORY_CORRUPT",
+        "durable request ids cross mutation namespaces",
+        { collisions },
+      );
+    }
+  }
+
+  async #readRequestNamespacePlane(targetRunId) {
+    const [
+      definition,
+      operationRead,
+      observationRead,
+      bindingRead,
+      recoveryRead,
+    ] = await Promise.all([
+      this.store.readDefinition(targetRunId),
+      this.store.listOperations(targetRunId),
+      this.store.listWorkerObservations(targetRunId),
+      this.store.listIdentityBindings(targetRunId),
+      this.store.listRecoveries(targetRunId),
+    ]);
+    if (
+      [
+        operationRead,
+        observationRead,
+        bindingRead,
+        recoveryRead,
+      ].some((read) => read.corrupt.length > 0)
+    ) {
+      fail(
+        "HISTORY_CORRUPT",
+        "request namespace history could not be verified",
+      );
+    }
+    this.#assertDurableRequestNamespaces({
+      definition,
+      operations: operationRead.facts,
+      observations: observationRead.facts,
+      bindings: bindingRead.facts,
+      recoveries: recoveryRead.facts,
+    });
+    return {
+      definition,
+      operationRead,
+      observationRead,
+      bindingRead,
+      recoveryRead,
+    };
+  }
+
+  async #readLegacyRecoveryPlane(targetRunId) {
+    const [
+      state,
+      definition,
+      operationRead,
+      governorDecisionRead,
+      recoveryRead,
+      reportRead,
+      transitionRead,
+      bindingRead,
+      observationRead,
+    ] = await Promise.all([
+      this.store.readState(targetRunId),
+      this.store.readDefinition(targetRunId),
+      this.store.listOperations(targetRunId),
+      this.store.listGovernorDecisions(targetRunId),
+      this.store.listRecoveries(targetRunId),
+      this.store.listReports(targetRunId),
+      this.store.listTransitions(targetRunId),
+      this.store.listIdentityBindings(targetRunId),
+      this.store.listWorkerObservations(targetRunId),
+    ]);
+    const reads = [
+      operationRead,
+      governorDecisionRead,
+      recoveryRead,
+      reportRead,
+      transitionRead,
+      bindingRead,
+      observationRead,
+    ];
+    if (reads.some((read) => read.corrupt.length > 0)) {
+      fail(
+        "HISTORY_CORRUPT",
+        "legacy recovery history could not be verified",
+      );
+    }
+    this.#assertIdentityBindingTopology(
+      bindingRead,
+      state.rootSessionId,
+    );
+    this.#assertDurableRequestNamespaces({
+      definition,
+      operations: operationRead.facts,
+      observations: observationRead.facts,
+      bindings: bindingRead.facts,
+      recoveries: recoveryRead.facts,
+    });
+    return {
+      definition,
+      operationRead,
+      governorDecisionRead,
+      recoveryRead,
+      reportRead,
+      transitionRead,
+      bindingRead,
+      observationRead,
+    };
+  }
+
+  #legacyEvidenceFromPlane(state, plane) {
+    return buildLegacyNativeTargetEvidence({
+      state,
+      definition: plane.definition,
+      operations: plane.operationRead.facts,
+      governorDecisions:
+        plane.governorDecisionRead.facts,
+      transitions: plane.transitionRead.facts,
+      reports: plane.reportRead.facts,
+      bindings: plane.bindingRead.facts,
+    });
+  }
+
+  async #verifyLegacyEvidence(state, plane) {
+    const evidence = this.#legacyEvidenceFromPlane(
+      state,
+      plane,
+    );
+    await this.#validateDurableControlHistory(
+      state,
+      plane.operationRead,
+      plane.governorDecisionRead,
+      { facts: [], corrupt: [] },
+      {
+        reportRead: plane.reportRead,
+        transitionRead: plane.transitionRead,
+        ...(evidence ? { legacyEvidence: evidence } : {}),
+      },
+    );
+    return evidence;
+  }
+
+  #assertPreparedRecoveryIdentity(
+    state,
+    receipt,
+    context,
+    input,
+  ) {
+    this.#assertRecoveryReceiptInvariant(state, receipt);
+    if (
+      receipt.requestId !== input.requestId ||
+      receipt.actorId !== context.rootSessionId ||
+      receipt.fromRevision !== input.expectedRevision ||
+      receipt.evidenceDigest !==
+        input.expectedEvidenceDigest
+    ) {
+      fail(
+        "REQUEST_ID_CONFLICT",
+        "legacy recovery request does not match its immutable receipt",
+      );
+    }
+  }
+
+  #assertRecoveryReceiptInvariant(state, receipt) {
+    if (
+      receipt.recoveryId !==
+        recoveryIdFor(
+          receipt.runId,
+          receipt.requestId,
+        ) ||
+      receipt.runId !== state.runId ||
+      receipt.actorKind !== "root" ||
+      receipt.actorId !== state.rootSessionId ||
+      receipt.requestDigest !==
+        recoveryRequestDigest({
+          runId: receipt.runId,
+          requestId: receipt.requestId,
+          actorId: receipt.actorId,
+          expectedRevision: receipt.fromRevision,
+          expectedEvidenceDigest:
+            receipt.evidenceDigest,
+        })
+    ) {
+      fail(
+        "HISTORY_CORRUPT",
+        "legacy recovery receipt identity is invalid",
+      );
+    }
+  }
+
+  #assertPreparedRecoveryBarrier(
+    state,
+    recoveryRead,
+    options = {},
+  ) {
+    if (recoveryRead.corrupt.length > 0) {
+      fail(
+        "HISTORY_CORRUPT",
+        "legacy recovery receipt is corrupt",
+      );
+    }
+    if (recoveryRead.facts.length > 1) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "multiple legacy recovery receipts exist for one run",
+      );
+    }
+    const receipt = recoveryRead.facts[0];
+    if (!receipt) {
+      return;
+    }
+    this.#assertRecoveryReceiptInvariant(state, receipt);
+    if (
+      state.latestRecoveryId === receipt.recoveryId &&
+      state.revision === receipt.toRevision
+    ) {
+      if (
+        digestJson(state) !== receipt.terminalStateDigest
+      ) {
+        fail(
+          "HISTORY_CORRUPT",
+          "quarantined state does not match its recovery receipt",
+        );
+      }
+      return;
+    }
+    if (
+      state.revision !== receipt.fromRevision ||
+      digestJson(state) !== receipt.priorStateDigest
+    ) {
+      fail(
+        "LEGACY_RECOVERY_ORPHANED",
+        "prepared legacy recovery no longer matches durable state",
+      );
+    }
+    if (
+      digestJson(
+        terminalStateForRecovery(state, receipt),
+      ) !== receipt.terminalStateDigest
+    ) {
+      fail(
+        "HISTORY_CORRUPT",
+        "prepared legacy recovery terminal state is invalid",
+      );
+    }
+    if ((options.normalPreparedCount ?? 0) > 0) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "legacy recovery competes with another prepared receipt",
+      );
+    }
+    fail(
+      "LEGACY_RECOVERY_PENDING",
+      "a legacy recovery receipt awaits explicit confirmation",
+    );
+  }
+
+  #legacyRecoveryResult(
+    state,
+    receipt,
+    duplicate,
+    verification,
+  ) {
+    return {
+      schemaVersion: SCHEMA_VERSION,
+      runId: state.runId,
+      status: state.status,
+      revision: state.revision,
+      recoveryId: receipt.recoveryId,
+      duplicate,
+      verification,
+    };
+  }
+
+  async #appliedRecoveryVerification(
+    state,
+    receipt,
+  ) {
+    try {
+      const plane =
+        await this.#readLegacyRecoveryPlane(state.runId);
+      await this.#validateDurableControlHistory(
+        state,
+        plane.operationRead,
+        plane.governorDecisionRead,
+        plane.recoveryRead,
+        {
+          reportRead: plane.reportRead,
+          transitionRead: plane.transitionRead,
+        },
+      );
+      return state.latestRecoveryId === receipt.recoveryId
+        ? "verified"
+        : "quarantined-unverified";
+    } catch {
+      return "quarantined-unverified";
+    }
+  }
+
+  async previewLegacyRecovery(contextValue, input) {
+    const context = assertRootContext(contextValue);
+    const targetRunId = runId(input?.runId);
+    return this.store.withControlLock(
+      targetRunId,
+      async () => {
+        const state = await this.store.readState(targetRunId);
+        this.#assertRoot(state, context);
+        const plane =
+          await this.#readLegacyRecoveryPlane(targetRunId);
+        if (plane.recoveryRead.facts.length > 1) {
+          fail(
+            "RECOVERY_REQUIRED",
+            "multiple legacy recovery receipts exist for one run",
+          );
+        }
+        const receipt = plane.recoveryRead.facts[0];
+        if (receipt) {
+          this.#assertRecoveryReceiptInvariant(
+            state,
+            receipt,
+          );
+          if (
+            state.latestRecoveryId === receipt.recoveryId &&
+            state.revision === receipt.toRevision &&
+            digestJson(state) ===
+              receipt.terminalStateDigest
+          ) {
+            await this.#validateDurableControlHistory(
+              state,
+              plane.operationRead,
+              plane.governorDecisionRead,
+              plane.recoveryRead,
+              {
+                reportRead: plane.reportRead,
+                transitionRead: plane.transitionRead,
+              },
+            );
+            return {
+              schemaVersion: SCHEMA_VERSION,
+              runId: targetRunId,
+              eligible: false,
+              quarantined: true,
+              pendingRecovery: false,
+              revision: state.revision,
+              legacyFactCount:
+                receipt.legacyFactCount,
+              evidenceDigest: receipt.evidenceDigest,
+              terminalStatus: "failed",
+              warningCode:
+                "LEGACY_HISTORY_ALREADY_QUARANTINED",
+            };
+          }
+          if (
+            state.revision !== receipt.fromRevision ||
+            digestJson(state) !== receipt.priorStateDigest
+          ) {
+            fail(
+              "LEGACY_RECOVERY_ORPHANED",
+              "prepared legacy recovery no longer matches durable state",
+            );
+          }
+          if (
+            digestJson(
+              terminalStateForRecovery(state, receipt),
+            ) !== receipt.terminalStateDigest
+          ) {
+            fail(
+              "HISTORY_CORRUPT",
+              "prepared legacy recovery terminal state is invalid",
+            );
+          }
+          let evidenceMatches = false;
+          try {
+            const current =
+              this.#legacyEvidenceFromPlane(state, plane);
+            evidenceMatches =
+              current?.evidenceDigest ===
+                receipt.evidenceDigest &&
+              current.entries.length ===
+                receipt.legacyFactCount;
+          } catch {
+            evidenceMatches = false;
+          }
+          return {
+            schemaVersion: SCHEMA_VERSION,
+            runId: targetRunId,
+            eligible: true,
+            quarantined: false,
+            pendingRecovery: true,
+            revision: state.revision,
+            legacyFactCount: receipt.legacyFactCount,
+            evidenceDigest: receipt.evidenceDigest,
+            evidenceMatches,
+            terminalStatus: "failed",
+            warningCode:
+              "LEGACY_RECOVERY_CONFIRM_REQUIRED",
+          };
+        }
+        if (!ROOT_CONTROL_STATUSES.has(state.status)) {
+          fail(
+            "INVALID_STATE_TRANSITION",
+            "only a non-terminal run can enter legacy quarantine",
+          );
+        }
+        const evidence = await this.#verifyLegacyEvidence(
+          state,
+          plane,
+        );
+        return {
+          schemaVersion: SCHEMA_VERSION,
+          runId: targetRunId,
+          eligible: Boolean(evidence),
+          quarantined: false,
+          pendingRecovery: false,
+          revision: state.revision,
+          legacyFactCount: evidence?.entries.length ?? 0,
+          ...(evidence
+            ? { evidenceDigest: evidence.evidenceDigest }
+            : {}),
+          terminalStatus: "failed",
+          warningCode: evidence
+            ? "LEGACY_HISTORY_QUARANTINE_AVAILABLE"
+            : "NO_LEGACY_NATIVE_TARGET_HISTORY",
+        };
+      },
+    );
+  }
+
+  async quarantineLegacy(contextValue, input) {
+    const context = assertRootContext(contextValue);
+    const targetRunId = runId(input?.runId);
+    const targetRequestId = requestId(input?.requestId);
+    const expectedRevision = input?.expectedRevision;
+    const expectedEvidenceDigest =
+      input?.expectedEvidenceDigest;
+    if (
+      input?.confirm !== true ||
+      !Number.isInteger(expectedRevision) ||
+      expectedRevision < 0 ||
+      typeof expectedEvidenceDigest !== "string" ||
+      !/^[a-f0-9]{64}$/.test(expectedEvidenceDigest)
+    ) {
+      fail(
+        "INVALID_TOOL_INPUT",
+        "legacy quarantine confirmation is invalid",
+      );
+    }
+    return this.store.withControlLock(
+      targetRunId,
+      async () => {
+        let state = await this.store.readState(targetRunId);
+        this.#assertRoot(state, context);
+        const namespacePlane =
+          await this.#readRequestNamespacePlane(
+            targetRunId,
+          );
+        const { recoveryRead } = namespacePlane;
+        if (recoveryRead.facts.length > 1) {
+          fail(
+            "RECOVERY_REQUIRED",
+            "multiple legacy recovery receipts exist for one run",
+          );
+        }
+        const existing = recoveryRead.facts[0];
+        if (existing) {
+          this.#assertPreparedRecoveryIdentity(
+            state,
+            existing,
+            context,
+            {
+              requestId: targetRequestId,
+              expectedRevision,
+              expectedEvidenceDigest,
+            },
+          );
+          if (
+            state.latestRecoveryId ===
+              existing.recoveryId &&
+            state.revision === existing.toRevision
+          ) {
+            if (
+              digestJson(state) !==
+              existing.terminalStateDigest
+            ) {
+              fail(
+                "HISTORY_CORRUPT",
+                "quarantined state does not match its recovery receipt",
+              );
+            }
+            return this.#legacyRecoveryResult(
+              state,
+              existing,
+              true,
+              await this.#appliedRecoveryVerification(
+                state,
+                existing,
+              ),
+            );
+          }
+          if (
+            state.revision !== existing.fromRevision ||
+            digestJson(state) !==
+              existing.priorStateDigest
+          ) {
+            fail(
+              "LEGACY_RECOVERY_ORPHANED",
+              "prepared legacy recovery no longer matches durable state",
+            );
+          }
+          let verified = false;
+          try {
+            const plane =
+              await this.#readLegacyRecoveryPlane(
+                targetRunId,
+              );
+            const evidence =
+              this.#legacyEvidenceFromPlane(state, plane);
+            verified =
+              evidence?.evidenceDigest ===
+                existing.evidenceDigest &&
+              evidence.entries.length ===
+                existing.legacyFactCount;
+          } catch {
+            verified = false;
+          }
+          const next = terminalStateForRecovery(
+            state,
+            existing,
+          );
+          if (
+            digestJson(next) !==
+              existing.terminalStateDigest
+          ) {
+            fail(
+              "HISTORY_CORRUPT",
+              "prepared recovery terminal state is invalid",
+            );
+          }
+          state = await this.store.compareAndSwapState(
+            targetRunId,
+            state.revision,
+            next,
+          );
+          await this.fault("afterRecoveryCas", {
+            runId: targetRunId,
+            requestId: targetRequestId,
+          });
+          return this.#legacyRecoveryResult(
+            state,
+            existing,
+            false,
+            verified
+              ? "verified"
+              : "quarantined-unverified",
+          );
+        }
+
+        if (
+          state.revision !== expectedRevision ||
+          !ROOT_CONTROL_STATUSES.has(state.status)
+        ) {
+          fail(
+            "STALE_RECOVERY_PREVIEW",
+            "legacy recovery preview no longer matches durable state",
+          );
+        }
+        const plane =
+          await this.#readLegacyRecoveryPlane(targetRunId);
+        this.#assertRequestNamespace(
+          targetRequestId,
+          "recoveries",
+          {
+            definition: plane.definition,
+            operations: plane.operationRead.facts,
+            observations: plane.observationRead.facts,
+            bindings: plane.bindingRead.facts,
+            recoveries: plane.recoveryRead.facts,
+          },
+        );
+        const normalPrepared = [
+          ...plane.operationRead.facts,
+          ...plane.governorDecisionRead.facts,
+        ].filter(
+          (receipt) =>
+            receipt.fromRevision === state.revision,
+        );
+        if (normalPrepared.length > 0) {
+          fail(
+            "RECOVERY_REQUIRED",
+            "legacy recovery competes with a prepared control receipt",
+          );
+        }
+        const evidence = await this.#verifyLegacyEvidence(
+          state,
+          plane,
+        );
+        if (!evidence) {
+          fail(
+            "NO_LEGACY_NATIVE_TARGET_HISTORY",
+            "run has no eligible legacy native-target history",
+          );
+        }
+        if (
+          evidence.evidenceDigest !==
+          expectedEvidenceDigest
+        ) {
+          fail(
+            "STALE_RECOVERY_PREVIEW",
+            "legacy recovery evidence changed after preview",
+          );
+        }
+        const receipt = createLegacyQuarantineReceipt({
+          state,
+          requestId: targetRequestId,
+          actorId: context.rootSessionId,
+          evidence,
+          createdAt: this.now(),
+        });
+        const published = await this.store.putRecovery(
+          targetRunId,
+          receipt,
+        );
+        if (published.status === "conflict") {
+          fail(
+            "REQUEST_ID_CONFLICT",
+            "legacy recovery receipt conflicts with this request",
+          );
+        }
+        if (published.status === "limit") {
+          fail(
+            "FACT_LIMIT_REACHED",
+            "legacy recovery receipt capacity was reached before publication",
+          );
+        }
+        if (
+          !["created", "duplicate"].includes(
+            published.status,
+          )
+        ) {
+          fail(
+            "RECOVERY_REQUIRED",
+            "legacy recovery receipt could not be published",
+          );
+        }
+        await this.fault("afterRecoveryReceipt", {
+          runId: targetRunId,
+          requestId: targetRequestId,
+        });
+        const next = terminalStateForRecovery(
+          state,
+          receipt,
+        );
+        state = await this.store.compareAndSwapState(
+          targetRunId,
+          state.revision,
+          next,
+        );
+        await this.fault("afterRecoveryCas", {
+          runId: targetRunId,
+          requestId: targetRequestId,
+        });
+        return this.#legacyRecoveryResult(
+          state,
+          receipt,
+          false,
+          "verified",
+        );
+      },
+    );
+  }
+
+  async getLoop(contextValue, input) {
+    const context = assertRootContext(contextValue);
+    const targetRunId = runId(input?.runId);
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      const before = await this.snapshotForRun(targetRunId, {
+        rootContext: context,
+      });
+      const state = await this.store.readState(targetRunId);
+      this.#assertRoot(state, context);
+      const definition =
+        await this.store.readDefinition(targetRunId);
+      const roleCapability =
+        await this.#currentRoleCapability(state);
+      const identityPlane =
+        await this.store.withWorkerObservationSnapshotLock(
+          targetRunId,
+          () =>
+            this.#readIdentityPlane(
+              targetRunId,
+              context.rootSessionId,
+            ),
+        );
+      const { bindingRead, observedRead, snapshot } =
+        identityPlane;
+      const roleByAgentId = new Map(
+        bindingRead.facts.map((binding) => [
+          binding.agentId,
+          binding.role,
+        ]),
+      );
+      const pendingTransition = state.pendingTransitionId
+        ? await maybeRead(() =>
+            this.store.readTransition(
+              targetRunId,
+              state.pendingTransitionId,
+            ),
+          )
+        : null;
+      const latestReport = state.latestReportId
+        ? await maybeRead(() =>
+            this.store.readReport(
+              targetRunId,
+              state.latestReportId,
+            ),
+          )
+        : null;
+      const after = await this.snapshotForRun(targetRunId, {
+        rootContext: context,
+      });
+      const coherentState =
+        canonicalJson({
+          runId: state.runId,
+          revision: state.revision,
+          status: state.status,
+          currentLap: state.currentLap,
+          lapCap: definition.lapCap,
+          continuationLease: state.continuationLease,
+          cancelRequested: state.cancelRequested,
+          needsHuman: state.needsHuman ?? false,
+          pendingTransitionId:
+            state.pendingTransitionId ?? null,
+          latestReportId:
+            state.latestReportId ?? null,
+          latestRecoveryId:
+            state.latestRecoveryId ?? null,
+        }) ===
+        canonicalJson({
+          runId: after.runId,
+          revision: after.revision,
+          status: after.status,
+          currentLap: after.currentLap,
+          lapCap: after.lapCap,
+          continuationLease:
+            after.continuationLease,
+          cancelRequested: after.cancelRequested,
+          needsHuman: after.needsHuman,
+          pendingTransitionId:
+            after.pending?.transitionId ?? null,
+          latestReportId:
+            after.latestReport?.reportId ?? null,
+          latestRecoveryId:
+            after.recovery?.recoveryId ?? null,
+        });
+      if (
+        before.projectionDigest !==
+          after.projectionDigest ||
+        !coherentState
+      ) {
+        continue;
+      }
+      return {
+        ...stateSummary(state, definition),
+        definition,
+        bindings: bindingRead.facts
+          .map((binding) => ({
+            agentId: binding.agentId,
+            role: binding.role,
+            method: binding.method,
+            createdAt: binding.createdAt,
+          }))
+          .sort((left, right) =>
+            compareCodePoints(
+              `${left.role}:${left.agentId}`,
+              `${right.role}:${right.agentId}`,
+            ),
+          ),
+        observedWorkers: observedRead.facts.map((event) => ({
+          agentId: event.agentId,
+          agentType: event.agentType ?? "unknown",
+          eventId: event.eventId,
+          observedAt: event.observedAt,
+          ...(roleByAgentId.has(event.agentId)
+            ? {
+                boundRole: roleByAgentId.get(
+                  event.agentId,
+                ),
+              }
+            : {}),
+        })),
+        workerObservation: {
+          observationDigest:
+            snapshot.observationDigest,
+          spawnCount: snapshot.spawnToolUseIds.length,
+          workerStartCount:
+            snapshot.subagentStartEventIds.length,
+          pendingCount: identityPlane.pendingCount,
+          balanced:
+            snapshot.spawnToolUseIds.length ===
+            snapshot.subagentStartEventIds.length,
+        },
+        ...(roleCapability ? { roleCapability } : {}),
+        ...(pendingTransition
+          ? { pendingTransition }
+          : {}),
+        ...(latestReport ? { latestReport } : {}),
+        projectionDigest: after.projectionDigest,
+        eventWatermark: after.eventWatermark,
+      };
+    }
+    fail(
+      "SNAPSHOT_BUSY",
+      "authoritative loop changed while it was being read",
+    );
+  }
+
+  async getSnapshot(contextValue, input) {
+    const context = assertRootContext(contextValue);
+    return this.snapshotForRun(runId(input?.runId), {
+      rootContext: context,
+    });
+  }
+
+  async snapshotForRun(targetRunIdValue, options = {}) {
+    const targetRunId = runId(targetRunIdValue);
+    const lockTimeoutMs = options.lockTimeoutMs ?? 250;
+    if (
+      !Number.isInteger(lockTimeoutMs) ||
+      lockTimeoutMs < 1 ||
+      lockTimeoutMs > 5_000
+    ) {
+      fail(
+        "INVALID_SNAPSHOT_OPTIONS",
+        "snapshot lock timeout is invalid",
+      );
+    }
+    try {
+      return await this.store.withControlLock(
+        targetRunId,
+        async () => {
+          const state = await this.store.readState(targetRunId);
+          if (options.rootContext) {
+            this.#assertRoot(state, options.rootContext);
+          }
+          const [
+            operationRead,
+            governorDecisionRead,
+            eventRead,
+            reportRead,
+            transitionRead,
+            bindingRead,
+            observationRead,
+            diagnosticRead,
+            recoveryRead,
+          ] = await Promise.all([
+            this.store.listOperations(targetRunId),
+            this.store.listGovernorDecisions(targetRunId),
+            this.store.listEvents(targetRunId),
+            this.store.listReports(targetRunId),
+            this.store.listTransitions(targetRunId),
+            this.store.listIdentityBindings(targetRunId),
+            this.store.listWorkerObservations(targetRunId),
+            this.store.listDiagnostics(targetRunId),
+            this.store.listRecoveries(targetRunId),
+          ]);
+          const reads = [
+            operationRead,
+            governorDecisionRead,
+            eventRead,
+            reportRead,
+            transitionRead,
+            bindingRead,
+            observationRead,
+            diagnosticRead,
+            recoveryRead,
+          ];
+          if (reads.some((read) => read.corrupt.length > 0)) {
+            fail(
+              "HISTORY_CORRUPT",
+              "authoritative loop history could not be verified",
+            );
+          }
+          const definition =
+            await this.store.readDefinition(targetRunId);
+          this.#assertDurableRequestNamespaces({
+            definition,
+            operations: operationRead.facts,
+            observations: observationRead.facts,
+            bindings: bindingRead.facts,
+            recoveries: recoveryRead.facts,
+          });
+          this.#assertPreparedRecoveryBarrier(
+            state,
+            recoveryRead,
+            {
+              normalPreparedCount: [
+                ...operationRead.facts,
+                ...governorDecisionRead.facts,
+              ].filter(
+                (receipt) =>
+                  receipt.fromRevision ===
+                  state.revision,
+              ).length,
+            },
+          );
+          if (!state.latestRecoveryId) {
+            this.#detectUnsupportedNativeTargets(
+              state,
+              bindingRead,
+              operationRead,
+              reportRead,
+              transitionRead,
+            );
+          }
+          const verified =
+            await this.#validateDurableControlHistory(
+              state,
+              operationRead,
+              governorDecisionRead,
+              recoveryRead,
+              { reportRead, transitionRead },
+            );
+          return buildAgentLoopProjection({
+            state,
+            definition: verified.definition,
+            bindings: verified.bindingRead.facts,
+            events: eventRead.facts,
+            reports: reportRead.facts,
+            transitions: transitionRead.facts,
+            operations: operationRead.facts,
+            governorDecisions: governorDecisionRead.facts,
+            recoveries: verified.appliedRecoveries,
+            diagnostics: diagnosticRead.facts,
+          });
+        },
+        { timeoutMs: lockTimeoutMs },
+      );
+    } catch (error) {
+      if (error?.code === "STORE_LOCK_TIMEOUT") {
+        fail(
+          "SNAPSHOT_BUSY",
+          "authoritative snapshot is temporarily busy",
+        );
+      }
+      if (
+        [
+          "ROOT_ONLY_TOOL",
+          "ROOT_IDENTITY_MISMATCH",
+          "UNSUPPORTED_NATIVE_TARGET_HISTORY",
+          "LEGACY_RECOVERY_PENDING",
+          "LEGACY_RECOVERY_LIMIT",
+          "HISTORY_CORRUPT",
+          "PROJECTION_TOO_LARGE",
+          "INVALID_SNAPSHOT_OPTIONS",
+        ].includes(error?.code)
+      ) {
+        throw error;
+      }
+      fail(
+        "HISTORY_CORRUPT",
+        "authoritative loop history could not be verified",
+      );
+    }
+  }
+
+  async #readIdentityPlane(
+    targetRunId,
+    rootSessionId,
+    options = {},
+  ) {
+    if (options.reconcile === true) {
+      const reconciled =
+        await this.store.reconcilePendingWorkerObservations(
+          targetRunId,
+        );
+      if (
+        reconciled.corrupt.length > 0 ||
+        reconciled.unresolved.length > 0
+      ) {
+        fail(
+          "OBSERVATION_INCOMPLETE",
+          "pending worker observations require recovery",
+        );
+      }
+    }
+    const [bindingRead, evidenceRead] = await Promise.all([
+      this.store.listIdentityBindings(targetRunId),
+      this.store.readWorkerObservationEvidence(targetRunId),
+    ]);
+    if (
+      bindingRead.corrupt.length > 0 ||
+      evidenceRead.corrupt.length > 0 ||
+      evidenceRead.conflicts.length > 0
+    ) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "worker identity evidence is corrupt",
+      );
+    }
+    this.#assertIdentityBindingTopology(
+      bindingRead,
+      rootSessionId,
+    );
+    const observedRead = {
+      facts: evidenceRead.facts
+        .filter(
+          (event) =>
+            event.event === "SubagentStart" &&
+            event.conflictEligible === true &&
+            event.sessionId === rootSessionId &&
+            typeof event.agentId === "string",
+        )
+        .sort((left, right) => {
+          const timeOrder = compareCodePoints(
+            left.observedAt,
+            right.observedAt,
+          );
+          return timeOrder !== 0
+            ? timeOrder
+            : compareCodePoints(left.eventId, right.eventId);
+        }),
+      corrupt: evidenceRead.corrupt,
+    };
+    const snapshot = workerObservationSnapshot(
+      evidenceRead.facts,
+      bindingRead.facts,
+      rootSessionId,
+    );
+    if (
+      observedRead.facts.length > 64 ||
+      snapshot.spawnToolUseIds.length > 64 ||
+      bindingRead.facts.length > 64
+    ) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "worker observation exceeds the bounded identity view",
+      );
+    }
+    return {
+      bindingRead,
+      observedRead,
+      evidenceRead,
+      snapshot,
+      pendingCount: evidenceRead.pendingCount,
+    };
+  }
+
+  async start(contextValue, input) {
+    const context = assertRootContext(contextValue);
+    const targetRunId = runId(input?.runId);
+    const before = await this.store.readState(targetRunId);
+    this.#assertRoot(before, context);
+    await this.#ensureCooperativeRoleBindings(before);
+    const result = await this.#rootMutation(
+      context,
+      input,
+      "start",
+      async (state, definition, createdAt, ids) => {
+        if (state.status !== "draft") {
+          fail(
+            "INVALID_STATE_TRANSITION",
+            "only a draft run can start",
+          );
+        }
+        return {
+          transition: this.#transition({
+            ...ids,
+            kind: "activate-implementer",
+            fromNode: state.masterNode,
+            toNode: await this.#roleNode(
+              state.runId,
+              "implementer",
+            ),
+            lap: 0,
+            createdAt,
+          }),
+        };
+      },
+    );
+    return this.#withCurrentRoleCapability(result);
+  }
+
+  async #ensureCooperativeRoleBindings(state) {
+    const current = await this.store.listIdentityBindings(
+      state.runId,
+    );
+    if (current.corrupt.length > 0) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "cooperative role bindings are corrupt",
+      );
+    }
+    for (const role of ["implementer", "reviewer"]) {
+      const targetAgentId = roleAgentId(role);
+      const existing = current.facts.find(
+        (binding) => binding.role === role,
+      );
+      if (existing) {
+        if (
+          existing.agentId !== targetAgentId ||
+          existing.rootSessionId !== state.rootSessionId ||
+          existing.method !== "capability-token-v1" ||
+          existing.revokedAt !== undefined
+        ) {
+          fail(
+            "RECOVERY_REQUIRED",
+            "cooperative role binding conflicts with the fixed topology",
+          );
+        }
+        continue;
+      }
+      const binding = assertContract(
+        "identity binding",
+        {
+          schemaVersion: SCHEMA_VERSION,
+          bindingId: `binding_${sha256(
+            canonicalJson({
+              runId: state.runId,
+              agentId: targetAgentId,
+            }),
+          )}`,
+          runId: state.runId,
+          agentId: targetAgentId,
+          rootSessionId: state.rootSessionId,
+          method: "capability-token-v1",
+          tokenDigest: sha256(
+            canonicalJson({
+              kind: "cooperative-role-binding",
+              runId: state.runId,
+              role,
+            }),
+          ),
+          role,
+          createdAt: state.createdAt,
+        },
+        validateIdentityBinding,
+      );
+      const published = await this.store.putIdentityBinding(
+        state.runId,
+        binding,
+      );
+      if (!["created", "duplicate"].includes(published.status)) {
+        fail(
+          "RECOVERY_REQUIRED",
+          "cooperative role binding could not be published",
+        );
+      }
+      current.facts.push(binding);
+    }
+  }
+
+  async #currentRoleCapability(state) {
+    if (
+      !["running", "paused", "interrupted"].includes(
+        state.status,
+      ) ||
+      !state.pendingTransitionId
+    ) {
+      return null;
+    }
+    return this.store.withControlLock(state.runId, async () => {
+      const current = await this.store.readState(state.runId);
+      if (
+        !["running", "paused", "interrupted"].includes(
+          current.status,
+        ) ||
+        !current.pendingTransitionId
+      ) {
+        return null;
+      }
+      const transition = await this.store.readTransition(
+        current.runId,
+        current.pendingTransitionId,
+      );
+      const role = governedTransitionRole(transition);
+      if (!role) {
+        fail(
+          "RECOVERY_REQUIRED",
+          "pending transition has no cooperative role",
+        );
+      }
+      const key = canonicalJson({
+        runId: current.runId,
+        role,
+        pendingTransitionId: transition.transitionId,
+        actionRevision: transition.toRevision,
+      });
+      const cachedToken = this.actionTokens.get(key);
+      const existing = await maybeRead(() =>
+        this.store.readActionCapability(
+          current.runId,
+          transition.transitionId,
+        ),
+      );
+      if (
+        cachedToken &&
+        this.#validActionCapabilityRecord(
+          existing,
+          current.runId,
+          role,
+          transition,
+        ) &&
+        digestsEqual(existing.tokenDigest, sha256(cachedToken))
+      ) {
+        return {
+          role,
+          pendingTransitionId: transition.transitionId,
+          actionRevision: transition.toRevision,
+          capabilityToken: cachedToken,
+        };
+      }
+      const capabilityToken = randomBytes(48).toString("base64url");
+      await this.store.replaceActionCapability(
+        current.runId,
+        transition.transitionId,
+        {
+          schemaVersion: SCHEMA_VERSION,
+          runId: current.runId,
+          role,
+          pendingTransitionId: transition.transitionId,
+          actionRevision: transition.toRevision,
+          tokenDigest: sha256(capabilityToken),
+          issuedAt: this.now(),
+        },
+      );
+      this.actionTokens.set(key, capabilityToken);
+      return {
+        role,
+        pendingTransitionId: transition.transitionId,
+        actionRevision: transition.toRevision,
+        capabilityToken,
+      };
+    });
+  }
+
+  async #withCurrentRoleCapability(result) {
+    const state = await this.store.readState(result.runId);
+    const roleCapability =
+      await this.#currentRoleCapability(state);
+    return roleCapability
+      ? { ...result, roleCapability }
+      : result;
+  }
+
+  #validActionCapabilityRecord(
+    record,
+    runIdValue,
+    role,
+    transition,
+  ) {
+    return (
+      record?.schemaVersion === SCHEMA_VERSION &&
+      record.runId === runIdValue &&
+      record.role === role &&
+      record.pendingTransitionId === transition.transitionId &&
+      record.actionRevision === transition.toRevision &&
+      typeof record.tokenDigest === "string" &&
+      /^[a-f0-9]{64}$/.test(record.tokenDigest) &&
+      typeof record.issuedAt === "string"
+    );
+  }
+
+  #assertCapabilityTokenShape(role, token) {
+    if (
+      !WORKER_ROLES.has(role) ||
+      typeof token !== "string" ||
+      token.length < 64 ||
+      token.length > 256 ||
+      !/^[A-Za-z0-9_-]+$/.test(token)
+    ) {
+      fail(
+        "CAPABILITY_REJECTED",
+        "role capability is missing, stale, or invalid",
+      );
+    }
+  }
+
+  async #assertRoleCapability(state, role, token) {
+    this.#assertCapabilityTokenShape(role, token);
+    if (
+      state.status !== "running" ||
+      !state.pendingTransitionId
+    ) {
+      fail(
+        "CAPABILITY_REJECTED",
+        "role capability is missing, stale, or invalid",
+      );
+    }
+    const transition = await this.store.readTransition(
+      state.runId,
+      state.pendingTransitionId,
+    );
+    const record = await maybeRead(() =>
+      this.store.readActionCapability(
+        state.runId,
+        state.pendingTransitionId,
+      ),
+    );
+    if (
+      governedTransitionRole(transition) !== role ||
+      !this.#validActionCapabilityRecord(
+        record,
+        state.runId,
+        role,
+        transition,
+      ) ||
+      !digestsEqual(record.tokenDigest, sha256(token))
+    ) {
+      fail(
+        "CAPABILITY_REJECTED",
+        "role capability is missing, stale, or invalid",
+      );
+    }
+  }
+
+  async #assertConsumedRoleCapability(
+    operation,
+    role,
+    token,
+    operations,
+  ) {
+    this.#assertCapabilityTokenShape(role, token);
+    const anchor = operations.find(
+      (candidate) =>
+        candidate.toRevision === operation.fromRevision,
+    );
+    if (!anchor) {
+      fail(
+        "CAPABILITY_REJECTED",
+        "role capability is missing, stale, or invalid",
+      );
+    }
+    const transition = await this.store.readTransition(
+      operation.runId,
+      anchor.transitionId,
+    );
+    const record = await maybeRead(() =>
+      this.store.readActionCapability(
+        operation.runId,
+        transition.transitionId,
+      ),
+    );
+    if (
+      governedTransitionRole(transition) !== role ||
+      !this.#validActionCapabilityRecord(
+        record,
+        operation.runId,
+        role,
+        transition,
+      ) ||
+      !digestsEqual(record.tokenDigest, sha256(token))
+    ) {
+      fail(
+        "CAPABILITY_REJECTED",
+        "role capability is missing, stale, or invalid",
+      );
+    }
+  }
+
+  async pause(contextValue, input) {
+    return this.#rootMutation(
+      contextValue,
+      input,
+      "pause",
+      async (state, _definition, createdAt, ids) => {
+        if (!["running", "interrupted"].includes(state.status)) {
+          fail(
+            "INVALID_STATE_TRANSITION",
+            "only a running or interrupted run can pause",
+          );
+        }
+        return {
+          transition: this.#transition({
+            ...ids,
+            kind: "pause",
+            fromNode: state.masterNode,
+            toNode: state.masterNode,
+            lap: state.currentLap,
+            createdAt,
+          }),
+        };
+      },
+    );
+  }
+
+  async resume(contextValue, input) {
+    return this.#rootMutation(
+      contextValue,
+      input,
+      "resume",
+      async (state, _definition, createdAt, ids) => {
+        if (!["paused", "interrupted"].includes(state.status)) {
+          fail(
+            "INVALID_STATE_TRANSITION",
+            "only a paused or interrupted run can resume",
+          );
+        }
+        return {
+          transition: this.#transition({
+            ...ids,
+            kind: "resume",
+            fromNode: state.masterNode,
+            toNode: state.masterNode,
+            lap: state.currentLap,
+            createdAt,
+          }),
+        };
+      },
+    );
+  }
+
+  async cancel(contextValue, input) {
+    return this.#rootMutation(
+      contextValue,
+      input,
+      "cancel",
+      async (state, _definition, createdAt, ids) => {
+        if (!ROOT_CONTROL_STATUSES.has(state.status)) {
+          fail(
+            "INVALID_STATE_TRANSITION",
+            "terminal runs cannot be cancelled again",
+          );
+        }
+        return {
+          transition: this.#transition({
+            ...ids,
+            kind: "cancel",
+            fromNode: state.masterNode,
+            toNode: state.masterNode,
+            lap: state.currentLap,
+            createdAt,
+          }),
+        };
+      },
+    );
+  }
+
+  async #rootMutation(
+    contextValue,
+    input,
+    kind,
+    build,
+  ) {
+    const context = assertRootContext(contextValue);
+    const targetRunId = runId(input?.runId);
+    const mutationRequestId = requestId(input?.requestId);
+    const actor = {
+      kind: "root",
+      id: context.rootSessionId,
+    };
+    const digest = mutationRequestDigest({
+      kind,
+      runId: targetRunId,
+      requestId: mutationRequestId,
+      actorKind: actor.kind,
+      actorId: actor.id,
+    });
+    return this.#mutate({
+      runId: targetRunId,
+      requestId: mutationRequestId,
+      requestDigest: digest,
+      kind,
+      actor,
+      authorize: (state) => this.#assertRoot(state, context),
+      build,
+    });
+  }
+
+  async prepareWorkerSpawn(contextValue, input) {
+    const context = assertRootContext(contextValue);
+    const targetRunId = runId(input?.runId);
+    const prepareRequestId = requestId(input?.requestId);
+    const role = input?.role;
+    if (!WORKER_ROLES.has(role)) {
+      fail("INVALID_TOOL_INPUT", "role is invalid");
+    }
+    const desiredObservationId = observationIdFor(
+      targetRunId,
+      prepareRequestId,
+    );
+    const requestDigest = observationRequestDigest({
+      runId: targetRunId,
+      requestId: prepareRequestId,
+      rootSessionId: context.rootSessionId,
+      role,
+    });
+    return this.store.withControlLock(
+      targetRunId,
+      () =>
+        this.store.withWorkerObservationSnapshotLock(
+          targetRunId,
+          async () => {
+            let state =
+              await this.store.readState(targetRunId);
+            this.#assertRoot(state, context);
+            state =
+              await this.#rollForwardPrepared(state);
+            this.#assertRoot(state, context);
+            if (state.status !== "running") {
+              fail(
+                "INVALID_STATE_TRANSITION",
+                "worker spawn can only prepare on a running loop",
+              );
+            }
+            const [
+              plane,
+              observations,
+              operations,
+              recoveries,
+              definition,
+            ] =
+              await Promise.all([
+                this.#readIdentityPlane(
+                  targetRunId,
+                  context.rootSessionId,
+                  { reconcile: true },
+                ),
+                this.store.listWorkerObservations(
+                  targetRunId,
+                ),
+                this.store.listOperations(targetRunId),
+                this.store.listRecoveries(targetRunId),
+                this.store.readDefinition(targetRunId),
+              ]);
+            if (
+              observations.corrupt.length > 0 ||
+              operations.corrupt.length > 0 ||
+              recoveries.corrupt.length > 0
+            ) {
+              fail(
+                "RECOVERY_REQUIRED",
+                "prepare receipts are corrupt",
+              );
+            }
+            this.#assertRequestNamespace(
+              prepareRequestId,
+              "observations",
+              {
+                definition,
+                operations: operations.facts,
+                observations: observations.facts,
+                bindings: plane.bindingRead.facts,
+                recoveries: recoveries.facts,
+              },
+            );
+            const sameRequest = observations.facts.filter(
+              (item) => item.requestId === prepareRequestId,
+            );
+            if (sameRequest.length > 1) {
+              fail(
+                "RECOVERY_REQUIRED",
+                "multiple prepare receipts reuse one request id",
+              );
+            }
+            if (sameRequest.length === 1) {
+              const existing = sameRequest[0];
+              if (
+                existing.observationId ===
+                  desiredObservationId &&
+                existing.requestDigest === requestDigest &&
+                existing.role === role
+              ) {
+                return {
+                  schemaVersion: SCHEMA_VERSION,
+                  runId: targetRunId,
+                  observationId: existing.observationId,
+                  role,
+                  observationDigest:
+                    existing.observationDigest,
+                  duplicate: true,
+                  consumed: plane.bindingRead.facts.some(
+                    (binding) =>
+                      binding.observationId ===
+                      existing.observationId,
+                  ),
+                };
+              }
+              fail(
+                "REQUEST_ID_CONFLICT",
+                "prepare request id already has different content",
+              );
+            }
+            if (
+              definition.requestId === prepareRequestId ||
+              operations.facts.some(
+                (operation) =>
+                  operation.requestId === prepareRequestId,
+              ) ||
+              plane.bindingRead.facts.some(
+                (binding) =>
+                  binding.requestId === prepareRequestId,
+              )
+            ) {
+              fail(
+                "REQUEST_ID_CONFLICT",
+                "request id already belongs to another mutation",
+              );
+            }
+            const consumed = new Set(
+              plane.bindingRead.facts
+                .map((binding) => binding.observationId)
+                .filter(Boolean),
+            );
+            if (
+              observations.facts.some(
+                (item) => !consumed.has(item.observationId),
+              )
+            ) {
+              fail(
+                "SPAWN_ALREADY_PREPARED",
+                "another worker spawn baseline is still unconsumed",
+              );
+            }
+            const roleBindings = new Map(
+              plane.bindingRead.facts
+                .filter((binding) => binding.role)
+                .map((binding) => [binding.role, binding]),
+            );
+            if (roleBindings.has(role)) {
+              fail(
+                "ROLE_ALREADY_BOUND",
+                "worker role is already bound",
+              );
+            }
+            if (
+              (role === "implementer" &&
+                roleBindings.size !== 0) ||
+              (role === "reviewer" &&
+                (!roleBindings.has("implementer") ||
+                  roleBindings.size !== 1))
+            ) {
+              fail(
+                "WORKER_ROLE_ORDER",
+                "workers must prepare implementer then reviewer",
+              );
+            }
+            if (
+              plane.snapshot.spawnToolUseIds.length !==
+              plane.snapshot.subagentStartEventIds.length
+            ) {
+              fail(
+                "OBSERVATION_UNBALANCED",
+                "native spawn and worker-start observations are not balanced",
+              );
+            }
+            const boundAgentIds = new Set(
+              plane.bindingRead.facts.map(
+                (binding) => binding.agentId,
+              ),
+            );
+            if (
+              plane.snapshot.starts.some(
+                (event) => !boundAgentIds.has(event.agentId),
+              )
+            ) {
+              fail(
+                "UNEXPLAINED_WORKER",
+                "an observed worker is not bound to this loop",
+              );
+            }
+            const observation = assertContract(
+              "worker observation",
+              {
+                schemaVersion: SCHEMA_VERSION,
+                observationId: desiredObservationId,
+                runId: targetRunId,
+                requestId: prepareRequestId,
+                requestDigest,
+                rootSessionId: context.rootSessionId,
+                role,
+                spawnToolUseIds:
+                  plane.snapshot.spawnToolUseIds,
+                subagentStartEventIds:
+                  plane.snapshot.subagentStartEventIds,
+                bindingIds: plane.snapshot.bindingIds,
+                observationDigest:
+                  plane.snapshot.observationDigest,
+                createdAt: this.now(),
+              },
+              validateWorkerObservation,
+            );
+            const published =
+              await this.store.putWorkerObservation(
+                targetRunId,
+                observation,
+              );
+            if (
+              !["created", "duplicate"].includes(
+                published.status,
+              )
+            ) {
+              fail(
+                published.status === "limit"
+                  ? "FACT_LIMIT_REACHED"
+                  : "REQUEST_ID_CONFLICT",
+                "worker spawn baseline could not be published",
+              );
+            }
+            return {
+              schemaVersion: SCHEMA_VERSION,
+              runId: targetRunId,
+              observationId: observation.observationId,
+              role,
+              observationDigest:
+                observation.observationDigest,
+              duplicate:
+                published.status === "duplicate",
+              consumed: false,
+            };
+          },
+        ),
+    );
+  }
+
+  async bindWorker(contextValue, input) {
+    const context = assertRootContext(contextValue);
+    const targetRunId = runId(input?.runId);
+    const bindRequestId = requestId(input?.requestId);
+    const targetAgentId = agentId(input?.agentId);
+    const targetObservationId = runId(
+      input?.observationId,
+    );
+    const targetOriginEventId = runId(
+      input?.originEventId,
+    );
+    const role = input?.role;
+    if (!WORKER_ROLES.has(role)) {
+      fail("INVALID_TOOL_INPUT", "role is invalid");
+    }
+    const digest = bindingRequestDigest({
+      runId: targetRunId,
+      requestId: bindRequestId,
+      agentId: targetAgentId,
+      role,
+      observationId: targetObservationId,
+      originEventId: targetOriginEventId,
+    });
+    return this.store.withControlLock(
+      targetRunId,
+      () =>
+        this.store.withWorkerObservationSnapshotLock(
+          targetRunId,
+          async () => {
+        let state = await this.store.readState(targetRunId);
+        this.#assertRoot(state, context);
+        state = await this.#rollForwardPrepared(state);
+        this.#assertRoot(state, context);
+        if (state.status !== "running") {
+          fail(
+            "INVALID_STATE_TRANSITION",
+            "workers can only bind to a running loop",
+          );
+        }
+        const [
+          plane,
+          observations,
+          operations,
+          recoveries,
+          definition,
+        ] =
+          await Promise.all([
+            this.#readIdentityPlane(
+              targetRunId,
+              context.rootSessionId,
+              { reconcile: true },
+            ),
+            this.store.listWorkerObservations(targetRunId),
+            this.store.listOperations(targetRunId),
+            this.store.listRecoveries(targetRunId),
+            this.store.readDefinition(targetRunId),
+          ]);
+        const bindings = plane.bindingRead;
+        if (
+          observations.corrupt.length > 0 ||
+          operations.corrupt.length > 0 ||
+          recoveries.corrupt.length > 0
+        ) {
+          fail(
+            "RECOVERY_REQUIRED",
+            "worker bind receipts are corrupt",
+          );
+        }
+        if (bindings.corrupt.length > 0) {
+          fail(
+            "RECOVERY_REQUIRED",
+            "identity bindings are corrupt",
+          );
+        }
+        this.#assertRequestNamespace(
+          bindRequestId,
+          "identity",
+          {
+            definition,
+            operations: operations.facts,
+            observations: observations.facts,
+            bindings: bindings.facts,
+            recoveries: recoveries.facts,
+          },
+        );
+        const sameRequests = bindings.facts.filter(
+          (binding) => binding.requestId === bindRequestId,
+        );
+        if (sameRequests.length > 1) {
+          fail(
+            "RECOVERY_REQUIRED",
+            "multiple worker bindings reuse one request id",
+          );
+        }
+        if (sameRequests.length === 1) {
+          const existing = sameRequests[0];
+          if (
+              existing.agentId === targetAgentId &&
+              existing.role === role &&
+              existing.requestDigest === digest &&
+              existing.observationId ===
+                targetObservationId &&
+              existing.originEventId ===
+                targetOriginEventId
+          ) {
+            return {
+              schemaVersion: SCHEMA_VERSION,
+              runId: targetRunId,
+              agentId: targetAgentId,
+              role,
+              issued: false,
+              duplicate: true,
+              capabilityReissueRequired: true,
+            };
+          }
+          fail(
+            "REQUEST_ID_CONFLICT",
+            "bind request id already has different content",
+          );
+        }
+        if (
+          definition.requestId === bindRequestId ||
+          operations.facts.some(
+            (operation) =>
+              operation.requestId === bindRequestId,
+          ) ||
+          observations.facts.some(
+            (observation) =>
+              observation.requestId === bindRequestId,
+          )
+        ) {
+          fail(
+            "REQUEST_ID_CONFLICT",
+            "request id already belongs to another mutation",
+          );
+        }
+        let baseline;
+        try {
+          baseline =
+            await this.store.readWorkerObservation(
+              targetRunId,
+              targetObservationId,
+            );
+        } catch (error) {
+          if (error?.code === "ENOENT") {
+            fail(
+              "OBSERVATION_BASELINE_MISSING",
+              "worker spawn baseline does not exist",
+            );
+          }
+          throw error;
+        }
+        if (
+          baseline.rootSessionId !== context.rootSessionId ||
+          baseline.role !== role
+        ) {
+          fail(
+            "OBSERVATION_BASELINE_MISMATCH",
+            "worker spawn baseline belongs to another root or role",
+          );
+        }
+        if (
+          bindings.facts.some(
+            (binding) =>
+              binding.observationId ===
+              targetObservationId,
+          )
+        ) {
+          fail(
+            "OBSERVATION_BASELINE_CONSUMED",
+            "worker spawn baseline is already consumed",
+          );
+        }
+        const consumed = new Set(
+          bindings.facts
+            .map((binding) => binding.observationId)
+            .filter(Boolean),
+        );
+        const unconsumed = observations.facts.filter(
+          (observation) =>
+            !consumed.has(observation.observationId),
+        );
+        if (
+          unconsumed.length !== 1 ||
+          unconsumed[0].observationId !==
+            targetObservationId
+        ) {
+          fail(
+            "OBSERVATION_BASELINE_SUPERSEDED",
+            "worker spawn baseline is not the current permit",
+          );
+        }
+        const sameAgent = bindings.facts.find(
+          (binding) => binding.agentId === targetAgentId,
+        );
+        if (sameAgent) {
+          fail(
+            "AGENT_ALREADY_BOUND",
+            "agent is already bound with different intent",
+          );
+        }
+        if (
+          bindings.facts.some(
+            (binding) => binding.role === role,
+          )
+        ) {
+          fail(
+            "ROLE_ALREADY_BOUND",
+            "worker role is already bound",
+          );
+        }
+        if (
+          (bindings.facts.length === 0 &&
+            role !== "implementer") ||
+          (bindings.facts.length === 1 &&
+            role !== "reviewer")
+        ) {
+          fail(
+            "WORKER_ROLE_ORDER",
+            "workers must bind implementer then reviewer",
+          );
+        }
+        const baselineBase = {
+          spawnToolUseIds: baseline.spawnToolUseIds,
+          subagentStartEventIds:
+            baseline.subagentStartEventIds,
+          bindingIds: baseline.bindingIds,
+        };
+        if (
+          digestJson(baselineBase) !==
+          baseline.observationDigest
+        ) {
+          fail(
+            "RECOVERY_REQUIRED",
+            "worker spawn baseline digest is invalid",
+          );
+        }
+        for (const [current, prior] of [
+          [
+            plane.snapshot.spawnToolUseIds,
+            baseline.spawnToolUseIds,
+          ],
+          [
+            plane.snapshot.subagentStartEventIds,
+            baseline.subagentStartEventIds,
+          ],
+          [plane.snapshot.bindingIds, baseline.bindingIds],
+        ]) {
+          if (
+            prior.some((id) => !current.includes(id))
+          ) {
+            fail(
+              "RECOVERY_REQUIRED",
+              "worker observation moved behind its baseline",
+            );
+          }
+        }
+        if (
+          canonicalJson(plane.snapshot.bindingIds) !==
+          canonicalJson(baseline.bindingIds)
+        ) {
+          fail(
+            "OBSERVATION_AMBIGUOUS",
+            "identity bindings changed after worker prepare",
+          );
+        }
+        const newSpawnToolUseIds = difference(
+          plane.snapshot.spawnToolUseIds,
+          baseline.spawnToolUseIds,
+        );
+        const newStartEventIds = difference(
+          plane.snapshot.subagentStartEventIds,
+          baseline.subagentStartEventIds,
+        );
+        if (
+          newSpawnToolUseIds.length !== 1 ||
+          newStartEventIds.length !== 1
+        ) {
+          fail(
+            "OBSERVATION_AMBIGUOUS",
+            "worker bind requires exactly one spawn and one worker-start delta",
+            {
+              spawnDelta: newSpawnToolUseIds.length,
+              workerStartDelta: newStartEventIds.length,
+            },
+          );
+        }
+        if (
+          newStartEventIds[0] !== targetOriginEventId
+        ) {
+          fail(
+            "OBSERVATION_CANDIDATE_CHANGED",
+            "selected worker event is no longer the unique delta",
+          );
+        }
+        const originEvent = plane.snapshot.starts.find(
+          (event) =>
+            event.eventId === targetOriginEventId,
+        );
+        if (
+          !originEvent ||
+          originEvent.agentId !== targetAgentId
+        ) {
+          fail(
+            "OBSERVATION_CANDIDATE_MISMATCH",
+            "selected worker does not match the observed event",
+          );
+        }
+        const boundAgentIds = new Set(
+          bindings.facts.map((binding) => binding.agentId),
+        );
+        const unboundStarts =
+          plane.snapshot.starts.filter(
+            (event) =>
+              !boundAgentIds.has(event.agentId),
+          );
+        if (
+          unboundStarts.length !== 1 ||
+          unboundStarts[0].eventId !==
+            targetOriginEventId
+        ) {
+          fail(
+            "OBSERVATION_AMBIGUOUS",
+            "worker observation contains unexplained unbound workers",
+          );
+        }
+        const issued = await issueRunCapability(this.store, {
+          runId: targetRunId,
+          rootSessionId: context.rootSessionId,
+          agentId: targetAgentId,
+          role,
+          requestId: bindRequestId,
+          requestDigest: digest,
+          observationId: targetObservationId,
+          originEventId: targetOriginEventId,
+          createdAt: this.now(),
+        });
+        return {
+          schemaVersion: SCHEMA_VERSION,
+          runId: targetRunId,
+          agentId: targetAgentId,
+          role,
+          issued: true,
+          duplicate: false,
+          capabilityToken: issued.token,
+        };
+          },
+        ),
+    );
+  }
+
+  async report(input) {
+    const targetRunId = runId(input?.runId);
+    const mutationRequestId = requestId(input?.requestId);
+    const role = input?.role;
+    if (!WORKER_ROLES.has(role)) {
+      fail("INVALID_TOOL_INPUT", "role is invalid");
+    }
+    const targetAgentId = roleAgentId(role);
+    const token = boundedString(
+      input?.capabilityToken,
+      "capabilityToken",
+      2048,
+    );
+    if (!["info", "verdict"].includes(input?.type)) {
+      fail("INVALID_REPORT", "report type is invalid");
+    }
+    const payload = {
+      type: input?.type,
+      ...(input?.status ? { status: input.status } : {}),
+      ...(input?.verdict ? { verdict: input.verdict } : {}),
+      ...(input?.issues ? { issues: input.issues } : {}),
+      ...(input?.summary ? { summary: input.summary } : {}),
+    };
+    const digest = mutationRequestDigest({
+      kind: "report",
+      runId: targetRunId,
+      requestId: mutationRequestId,
+      actorKind: "worker",
+      actorId: targetAgentId,
+      payload,
+    });
+    const [stateBefore, operationRead] = await Promise.all([
+      this.store.readState(targetRunId),
+      this.store.listOperations(targetRunId),
+    ]);
+    if (operationRead.corrupt.length > 0) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "report operation history is corrupt",
+      );
+    }
+    const existingOperation = operationRead.facts.find(
+      (operation) =>
+        operation.operationId ===
+        operationIdFor(targetRunId, mutationRequestId),
+    );
+    if (
+      existingOperation &&
+      stateBefore.revision >= existingOperation.toRevision
+    ) {
+      if (
+        existingOperation.kind !== "report" ||
+        existingOperation.actorId !== targetAgentId ||
+        existingOperation.requestDigest !== digest
+      ) {
+        fail(
+          "REQUEST_ID_CONFLICT",
+          "report request id already has different content",
+        );
+      }
+      await this.#assertConsumedRoleCapability(
+        existingOperation,
+        role,
+        token,
+        operationRead.facts,
+      );
+      return this.#mutationResult(
+        stateBefore,
+        await this.store.readDefinition(targetRunId),
+        existingOperation,
+        true,
+      );
+    }
+    await this.#assertRoleCapability(
+      stateBefore,
+      role,
+      token,
+    );
+    return this.#mutate({
+      runId: targetRunId,
+      requestId: mutationRequestId,
+      requestDigest: digest,
+      kind: "report",
+      actor: { kind: "worker", id: targetAgentId },
+      authorize: (state) =>
+        this.#assertRoleCapability(state, role, token),
+      reportPayload: payload,
+      build: (state, definition, createdAt, ids) =>
+        this.#buildReportMutation(
+          state,
+          definition,
+          createdAt,
+          ids,
+          targetAgentId,
+          payload,
+        ),
+    });
+  }
+
+  async #buildReportMutation(
+    state,
+    definition,
+    createdAt,
+    ids,
+    targetAgentId,
+    payload,
+  ) {
+    if (state.status !== "running") {
+      fail(
+        "REPORT_NOT_ACCEPTED",
+        "run is not accepting worker reports",
+      );
+    }
+    const bindings =
+      await this.store.listIdentityBindings(state.runId);
+    if (bindings.corrupt.length > 0) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "identity bindings are corrupt",
+      );
+    }
+    const binding = bindings.facts.find(
+      (candidate) => candidate.agentId === targetAgentId,
+    );
+    if (!binding?.role) {
+      fail(
+        "AGENT_NOT_BOUND",
+        "worker has no governed role binding",
+      );
+    }
+    if (!state.pendingTransitionId) {
+      fail("REPORT_OUT_OF_TURN", "run has no pending worker action");
+    }
+    const pending = await this.store.readTransition(
+      state.runId,
+      state.pendingTransitionId,
+    );
+    const expectedRole =
+      pending.kind === "activate-implementer"
+        ? "implementer"
+        : pending.kind === "activate-reviewer"
+          ? "reviewer"
+          : null;
+    if (binding.role !== expectedRole) {
+      fail(
+        "REPORT_OUT_OF_TURN",
+        "worker role does not match the pending action",
+      );
+    }
+
+    let transitionKind;
+    let transitionTarget;
+    let transitionLap = state.currentLap;
+    if (binding.role === "implementer") {
+      if (
+        payload.type !== "info" ||
+        payload.status !== "done" ||
+        payload.verdict !== undefined ||
+        payload.issues !== undefined
+      ) {
+        fail(
+          "INVALID_REPORT",
+          "implementer must submit only info/status=done",
+        );
+      }
+      transitionKind = "activate-reviewer";
+      transitionTarget = await this.#roleNode(
+        state.runId,
+        "reviewer",
+      );
+    } else {
+      if (
+        payload.type !== "verdict" ||
+        !["issues", "clean"].includes(payload.verdict) ||
+        payload.status !== undefined
+      ) {
+        fail(
+          "INVALID_REPORT",
+          "reviewer must submit a typed clean/issues verdict",
+        );
+      }
+      if (
+        payload.verdict === "issues" &&
+        (!Array.isArray(payload.issues) ||
+          payload.issues.length === 0)
+      ) {
+        fail(
+          "INVALID_REPORT",
+          "issues verdict requires at least one issue",
+        );
+      }
+      if (
+        payload.verdict === "clean" &&
+        Array.isArray(payload.issues) &&
+        payload.issues.length > 0
+      ) {
+        fail(
+          "INVALID_REPORT",
+          "clean verdict cannot contain issues",
+        );
+      }
+      if (payload.verdict === "clean") {
+        transitionKind = "succeed";
+        transitionTarget = state.masterNode;
+      } else if (state.currentLap + 1 > definition.lapCap) {
+        transitionKind = "cap";
+        transitionTarget = state.masterNode;
+      } else {
+        transitionKind = "activate-implementer";
+        transitionTarget = await this.#roleNode(
+          state.runId,
+          "implementer",
+        );
+        transitionLap = state.currentLap + 1;
+      }
+    }
+
+    const report = assertContract(
+      "loop report",
+      {
+        schemaVersion: SCHEMA_VERSION,
+        reportId: ids.reportId,
+        runId: state.runId,
+        requestId: ids.requestId,
+        requestDigest: ids.requestDigest,
+        fromRevision: ids.fromRevision,
+        toRevision: ids.toRevision,
+        fromNode: targetAgentId,
+        receiver: "root-master",
+        ...(transitionKind.startsWith("activate-")
+          ? { routedToNode: transitionTarget }
+          : {}),
+        type: payload.type,
+        ...(payload.status ? { status: payload.status } : {}),
+        ...(payload.verdict ? { verdict: payload.verdict } : {}),
+        ...(payload.issues ? { issues: payload.issues } : {}),
+        ...(payload.summary ? { summary: payload.summary } : {}),
+        createdAt,
+      },
+      validateLoopReport,
+    );
+    const transition = this.#transition({
+      ...ids,
+      kind: transitionKind,
+      fromNode: targetAgentId,
+      toNode: transitionTarget,
+      originReportId: report.reportId,
+      lap: transitionLap,
+      createdAt,
+    });
+    return { report, transition };
+  }
+
+  async #roleNode(targetRunId, role) {
+    const bindings =
+      await this.store.listIdentityBindings(targetRunId);
+    if (bindings.corrupt.length > 0) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "identity bindings are corrupt",
+      );
+    }
+    const matches = bindings.facts.filter(
+      (binding) => binding.role === role,
+    );
+    if (matches.length > 1) {
+      fail(
+        "IDENTITY_BINDING_CONFLICT",
+        "multiple workers are bound to one role",
+      );
+    }
+    return `role:${role}`;
+  }
+
+  #transition(input) {
+    return assertContract(
+      "loop transition",
+      {
+        schemaVersion: SCHEMA_VERSION,
+        transitionId: input.transitionId,
+        runId: input.runId,
+        requestId: input.requestId,
+        requestDigest: input.requestDigest,
+        kind: input.kind,
+        ...(input.fromNode ? { fromNode: input.fromNode } : {}),
+        ...(input.toNode ? { toNode: input.toNode } : {}),
+        ...(input.originReportId
+          ? { originReportId: input.originReportId }
+          : {}),
+        lap: input.lap,
+        fromRevision: input.fromRevision,
+        toRevision: input.toRevision,
+        createdAt: input.createdAt,
+      },
+      validateLoopTransition,
+    );
+  }
+
+  async #mutate(spec) {
+    return this.store.withControlLock(
+      spec.runId,
+      async () => {
+        let state = await this.store.readState(spec.runId);
+        await spec.authorize(state);
+        state = await this.#rollForwardPrepared(state);
+        await spec.authorize(state);
+        const targetOperationId = operationIdFor(
+          spec.runId,
+          spec.requestId,
+        );
+        const [
+          definition,
+          operationRead,
+          observationRead,
+          bindingRead,
+          recoveryRead,
+        ] = await Promise.all([
+          this.store.readDefinition(spec.runId),
+          this.store.listOperations(spec.runId),
+          this.store.listWorkerObservations(spec.runId),
+          this.store.listIdentityBindings(spec.runId),
+          this.store.listRecoveries(spec.runId),
+        ]);
+        if (
+          operationRead.corrupt.length > 0 ||
+          observationRead.corrupt.length > 0 ||
+          bindingRead.corrupt.length > 0 ||
+          recoveryRead.corrupt.length > 0
+        ) {
+          fail(
+            "RECOVERY_REQUIRED",
+            "request namespace receipts are corrupt",
+          );
+        }
+        this.#assertIdentityBindingTopology(
+          bindingRead,
+          state.rootSessionId,
+        );
+        this.#assertRequestNamespace(
+          spec.requestId,
+          "operations",
+          {
+            definition,
+            operations: operationRead.facts,
+            observations: observationRead.facts,
+            bindings: bindingRead.facts,
+            recoveries: recoveryRead.facts,
+          },
+        );
+        const existingOperation = operationRead.facts.find(
+          (operation) =>
+            operation.operationId === targetOperationId,
+        );
+        if (existingOperation) {
+          if (
+            existingOperation.requestDigest !==
+              spec.requestDigest ||
+            existingOperation.kind !== spec.kind
+          ) {
+            fail(
+              "REQUEST_ID_CONFLICT",
+              "request id already has different content",
+            );
+          }
+          state = await this.#applyOperation(
+            state,
+            existingOperation,
+          );
+          return this.#mutationResult(
+            state,
+            definition,
+            existingOperation,
+            true,
+          );
+        }
+
+        const ids = {
+          runId: spec.runId,
+          requestId: spec.requestId,
+          requestDigest: spec.requestDigest,
+          transitionId: transitionIdFor(
+            spec.runId,
+            spec.requestId,
+          ),
+          ...(spec.kind === "report"
+            ? {
+                reportId: reportIdFor(
+                  spec.runId,
+                  spec.requestId,
+                ),
+              }
+            : {}),
+          fromRevision: state.revision,
+          toRevision: state.revision + 1,
+        };
+        const existingTransition = await maybeRead(() =>
+          this.store.readTransition(
+            spec.runId,
+            ids.transitionId,
+          ),
+        );
+        const existingReport = ids.reportId
+          ? await maybeRead(() =>
+              this.store.readReport(
+                spec.runId,
+                ids.reportId,
+              ),
+            )
+          : null;
+        for (const orphan of [
+          existingTransition,
+          existingReport,
+        ].filter(Boolean)) {
+          if (
+            orphan.requestDigest !== spec.requestDigest ||
+            orphan.requestId !== spec.requestId
+          ) {
+            fail(
+              "REQUEST_ID_CONFLICT",
+              "request id already has different facts",
+            );
+          }
+          if (
+            orphan.fromRevision !== undefined &&
+            orphan.fromRevision !== state.revision
+          ) {
+            fail(
+              "STALE_UNCOMMITTED_REQUEST",
+              "uncommitted request belongs to an older revision",
+            );
+          }
+        }
+        const createdAt =
+          existingTransition?.createdAt ??
+          existingReport?.createdAt ??
+          this.now();
+        if (
+          existingTransition &&
+          existingReport &&
+          existingTransition.createdAt !== existingReport.createdAt
+        ) {
+          fail(
+            "RECOVERY_REQUIRED",
+            "uncommitted request facts disagree",
+          );
+        }
+        const built = await spec.build(
+          state,
+          definition,
+          createdAt,
+          ids,
+        );
+        const transitionResult =
+          await this.store.putTransition(
+            spec.runId,
+            built.transition,
+          );
+        await this.#requireFactPublication(
+          "transitions",
+          transitionResult,
+          spec.runId,
+          "transition fact conflicts with this request",
+        );
+        await this.fault("afterTransitionFact", {
+          runId: spec.runId,
+          requestId: spec.requestId,
+        });
+        if (built.report) {
+          const reportResult = await this.store.putReport(
+            spec.runId,
+            built.report,
+          );
+          await this.#requireFactPublication(
+            "reports",
+            reportResult,
+            spec.runId,
+            "report fact conflicts with this request",
+          );
+          await this.fault("afterReportFact", {
+            runId: spec.runId,
+            requestId: spec.requestId,
+          });
+        }
+        await this.fault("afterFacts", {
+          runId: spec.runId,
+          requestId: spec.requestId,
+        });
+        const operation = assertContract(
+          "loop operation",
+          {
+            schemaVersion: SCHEMA_VERSION,
+            operationId: targetOperationId,
+            runId: spec.runId,
+            requestId: spec.requestId,
+            requestDigest: spec.requestDigest,
+            kind: spec.kind,
+            actorKind: spec.actor.kind,
+            actorId: spec.actor.id,
+            fromRevision: state.revision,
+            toRevision: state.revision + 1,
+            ...(built.report
+              ? { reportId: built.report.reportId }
+              : {}),
+            transitionId: built.transition.transitionId,
+            createdAt,
+          },
+          validateLoopOperation,
+        );
+        const operationResult =
+          await this.store.putOperation(
+            spec.runId,
+            operation,
+          );
+        await this.#requireFactPublication(
+          "operations",
+          operationResult,
+          spec.runId,
+          "operation receipt conflicts with this request",
+        );
+        await this.fault("afterReceipt", {
+          runId: spec.runId,
+          requestId: spec.requestId,
+        });
+        state = await this.#applyOperation(state, operation);
+        await this.fault("afterCas", {
+          runId: spec.runId,
+          requestId: spec.requestId,
+        });
+        return this.#mutationResult(
+          state,
+          definition,
+          operation,
+          false,
+        );
+      },
+    );
+  }
+
+  async #requireFactPublication(
+    factKind,
+    result,
+    targetRunId,
+    conflictMessage,
+  ) {
+    if (["created", "duplicate"].includes(result?.status)) {
+      return;
+    }
+    if (result?.status === "conflict") {
+      fail("REQUEST_ID_CONFLICT", conflictMessage);
+    }
+    if (result?.status === "limit") {
+      let durableState = await maybeRead(() =>
+        this.store.readState(targetRunId),
+      );
+      if (
+        durableState &&
+        ACTIVE_RUN_STATUSES.has(durableState.status) &&
+        !(
+          durableState.status === "interrupted" &&
+          durableState.needsHuman === true
+        )
+      ) {
+        durableState = await this.interruptForFactLimit(
+          durableState,
+          {
+            factKind,
+            limit: result.limit,
+          },
+        );
+      }
+      fail(
+        "FACT_LIMIT_REACHED",
+        `${factKind} capacity was reached; the run requires human recovery`,
+        {
+          factKind,
+          limit: result.limit,
+          status: durableState?.status ?? "unknown",
+          needsHuman: durableState?.needsHuman === true,
+        },
+      );
+    }
+    fail(
+      "RECOVERY_REQUIRED",
+      `${factKind} publication returned an unsupported result`,
+    );
+  }
+
+  async interruptForFactLimit(initialState, details = {}) {
+    let state = await this.store.readState(initialState.runId);
+    if (
+      canonicalJson({
+        runId: state.runId,
+        rootSessionId: state.rootSessionId,
+      }) !==
+      canonicalJson({
+        runId: initialState.runId,
+        rootSessionId: initialState.rootSessionId,
+      })
+    ) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "fact-limit interruption targets a different run identity",
+      );
+    }
+    state = await this.#rollForwardPrepared(state);
+    if (
+      !ACTIVE_RUN_STATUSES.has(state.status) ||
+      (state.status === "interrupted" &&
+        state.needsHuman === true)
+    ) {
+      return state;
+    }
+    await this.#readAndValidateDefinition(state);
+    const internalRequestId = factLimitRequestId(
+      state.revision,
+    );
+    const requestDigest = mutationRequestDigest({
+      kind: "interrupt",
+      runId: state.runId,
+      requestId: internalRequestId,
+      actorKind: "root",
+      actorId: state.rootSessionId,
+    });
+    const ids = {
+      runId: state.runId,
+      requestId: internalRequestId,
+      requestDigest,
+      transitionId: transitionIdFor(
+        state.runId,
+        internalRequestId,
+      ),
+      fromRevision: state.revision,
+      toRevision: state.revision + 1,
+    };
+    const existingTransition = await maybeRead(() =>
+      this.store.readTransition(
+        state.runId,
+        ids.transitionId,
+      ),
+    );
+    const existingOperation = await maybeRead(() =>
+      this.store.readOperation(
+        state.runId,
+        operationIdFor(state.runId, internalRequestId),
+      ),
+    );
+    const createdAt =
+      existingTransition?.createdAt ??
+      existingOperation?.createdAt ??
+      this.now();
+    if (
+      existingTransition &&
+      existingOperation &&
+      existingTransition.createdAt !==
+        existingOperation.createdAt
+    ) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "fact-limit interruption facts disagree",
+      );
+    }
+    const transition = this.#transition({
+      ...ids,
+      kind: "interrupt",
+      fromNode: state.masterNode,
+      toNode: state.masterNode,
+      lap: state.currentLap,
+      createdAt,
+    });
+    const transitionResult =
+      await this.store.putTransition(
+        state.runId,
+        transition,
+        { allowSafetyReserve: true },
+      );
+    if (
+      !["created", "duplicate"].includes(
+        transitionResult?.status,
+      )
+    ) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "fact-limit interruption transition could not be published",
+        {
+          factKind: details.factKind ?? "unknown",
+          limit: details.limit ?? null,
+          status: transitionResult?.status ?? "unknown",
+        },
+      );
+    }
+    await this.fault("afterSafetyTransition", {
+      runId: state.runId,
+      requestId: internalRequestId,
+    });
+    const operation = assertContract(
+      "loop operation",
+      {
+        schemaVersion: SCHEMA_VERSION,
+        operationId: operationIdFor(
+          state.runId,
+          internalRequestId,
+        ),
+        runId: state.runId,
+        requestId: internalRequestId,
+        requestDigest,
+        kind: "interrupt",
+        actorKind: "root",
+        actorId: state.rootSessionId,
+        fromRevision: state.revision,
+        toRevision: state.revision + 1,
+        transitionId: transition.transitionId,
+        createdAt,
+      },
+      validateLoopOperation,
+    );
+    const operationResult =
+      await this.store.putOperation(
+        state.runId,
+        operation,
+        { allowSafetyReserve: true },
+      );
+    if (
+      !["created", "duplicate"].includes(
+        operationResult?.status,
+      )
+    ) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "fact-limit interruption receipt could not be published",
+        {
+          factKind: details.factKind ?? "unknown",
+          limit: details.limit ?? null,
+          status: operationResult?.status ?? "unknown",
+        },
+      );
+    }
+    await this.fault("afterSafetyReceipt", {
+      runId: state.runId,
+      requestId: internalRequestId,
+    });
+    state = await this.#applyOperation(state, operation);
+    await this.fault("afterSafetyCas", {
+      runId: state.runId,
+      requestId: internalRequestId,
+    });
+    return state;
+  }
+
+  async #readAndValidateDefinition(state) {
+    let definition;
+    try {
+      definition = await this.store.readDefinition(state.runId);
+    } catch (error) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "run definition is missing or unreadable",
+        { code: error?.code ?? "READ_ERROR" },
+      );
+    }
+    const expectedDigest = definitionRequestDigest({
+      rootSessionId: state.rootSessionId,
+      requestId: definition.requestId,
+      goal: definition.goal,
+      implementerInstructions:
+        definition.implementerInstructions,
+      reviewerInstructions:
+        definition.reviewerInstructions,
+      lapCap: definition.lapCap,
+    });
+    if (
+      definition.runId !== state.runId ||
+      definition.definitionId !==
+        definitionIdFor(state.runId) ||
+      definition.requestDigest !== expectedDigest ||
+      definition.recipe !== state.recipe ||
+      definition.createdAt !== state.createdAt ||
+      state.masterNode !== state.rootSessionId ||
+      definition.lapCap !==
+        state.continuationLease.granted
+    ) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "run definition conflicts with durable loop state",
+      );
+    }
+    return definition;
+  }
+
+  async #readAndValidateOperation(operation, state) {
+    let durable;
+    try {
+      durable = await this.store.readOperation(
+        operation.runId,
+        operation.operationId,
+      );
+    } catch (error) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "operation receipt is missing or unreadable",
+        { code: error?.code ?? "READ_ERROR" },
+      );
+    }
+    const expectsReport = operation.kind === "report";
+    if (
+      canonicalJson(durable) !== canonicalJson(operation) ||
+      operation.runId !== state.runId ||
+      operation.operationId !==
+        operationIdFor(operation.runId, operation.requestId) ||
+      operation.transitionId !==
+        transitionIdFor(operation.runId, operation.requestId) ||
+      (expectsReport &&
+        operation.reportId !==
+          reportIdFor(operation.runId, operation.requestId)) ||
+      (!expectsReport && operation.reportId !== undefined) ||
+      (expectsReport &&
+        (operation.actorKind !== "worker" ||
+          operation.actorId === state.rootSessionId)) ||
+      (!expectsReport &&
+        (operation.actorKind !== "root" ||
+          operation.actorId !== state.rootSessionId))
+    ) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "operation receipt identity or actor is invalid",
+      );
+    }
+    return this.#readOperationFacts(operation);
+  }
+
+  async #readGovernorDecisionReferences(
+    state,
+    decision,
+    appliedOperations,
+  ) {
+    let event;
+    let transition;
+    try {
+      [event, transition] = await Promise.all([
+        this.store.readEvent(
+          decision.runId,
+          decision.originEventId,
+        ),
+        this.store.readTransition(
+          decision.runId,
+          decision.pendingTransitionId,
+        ),
+      ]);
+    } catch (error) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "governor receipt references missing or unreadable facts",
+        { code: error?.code ?? "READ_ERROR" },
+      );
+    }
+    const role = governedTransitionRole(transition);
+    const eventTurnId = event.turnId;
+    const decisionTurnId = decision.turnId;
+    const anchor = appliedOperations.find(
+      (operation) =>
+        operation.transitionId === transition.transitionId &&
+        operation.toRevision <= decision.fromRevision,
+    );
+    if (
+      decision.runId !== state.runId ||
+      decision.rootSessionId !== state.rootSessionId ||
+      decision.obligationId !==
+        decision.pendingTransitionId ||
+      event.eventId !== decision.originEventId ||
+      event.conflictEligible !== true ||
+      event.event !== decision.hookEvent ||
+      event.sessionId !== decision.rootSessionId ||
+      eventTurnId !== decisionTurnId ||
+      transition.runId !== state.runId ||
+      transition.transitionId !==
+        decision.pendingTransitionId ||
+      transition.toRevision === undefined ||
+      transition.toRevision > decision.fromRevision ||
+      role === null ||
+      !anchor
+    ) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "governor receipt conflicts with its durable event or obligation",
+      );
+    }
+    if (
+      decision.hookEvent === "SessionStart" &&
+      event.payloadSummary?.source !== "resume"
+    ) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "resume interruption receipt lacks a durable resume event",
+      );
+    }
+    if (decision.hookEvent === "SubagentStop") {
+      const bindingRead =
+        await this.store.listIdentityBindings(state.runId);
+      if (bindingRead.corrupt.length > 0) {
+        fail(
+          "RECOVERY_REQUIRED",
+          "worker identity bindings are corrupt",
+        );
+      }
+      const matches = bindingRead.facts.filter(
+        (binding) =>
+          binding.agentId === decision.agentId &&
+          event.agentId === decision.agentId &&
+          binding.role === role &&
+          binding.rootSessionId === state.rootSessionId &&
+          binding.method === "capability-token-v1" &&
+          binding.revokedAt === undefined,
+      );
+      if (matches.length !== 1) {
+        fail(
+          "RECOVERY_REQUIRED",
+          "SubagentStop receipt lacks one authoritative worker binding",
+        );
+      }
+    } else if (
+      event.agentId !== undefined ||
+      decision.agentId !== undefined
+    ) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "root governor receipt contains worker identity",
+      );
+    }
+    return { event, transition, role };
+  }
+
+  async #readValidatedBindings(state) {
+    const bindingRead =
+      await this.store.listIdentityBindings(state.runId);
+    if (bindingRead.corrupt.length > 0) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "worker identity bindings are corrupt",
+      );
+    }
+    this.#assertIdentityBindingTopology(
+      bindingRead,
+      state.rootSessionId,
+    );
+    return bindingRead;
+  }
+
+  #roleTargetMatches(
+    role,
+    nodeId,
+    compatibilityKey,
+    compatibilityKeys,
+  ) {
+    return (
+      nodeId === `role:${role}` ||
+      compatibilityKeys?.has(compatibilityKey) === true
+    );
+  }
+
+  #detectUnsupportedNativeTargets(
+    state,
+    bindingRead,
+    operationRead,
+    reportRead,
+    transitionRead,
+  ) {
+    const entries = collectLegacyNativeTargetEntries({
+      state,
+      operations: operationRead.facts,
+      reports: reportRead.facts,
+      transitions: transitionRead.facts,
+      bindings: bindingRead.facts,
+    });
+    if (entries.length > 0) {
+      fail(
+        "UNSUPPORTED_NATIVE_TARGET_HISTORY",
+        "loop history uses an unsupported native worker target shape",
+      );
+    }
+  }
+
+  #bindingForAgent(bindingRead, state, targetAgentId) {
+    const matches = bindingRead.facts.filter(
+      (binding) =>
+        binding.agentId === targetAgentId &&
+        binding.rootSessionId === state.rootSessionId &&
+        binding.method === "capability-token-v1" &&
+        binding.revokedAt === undefined,
+    );
+    if (matches.length !== 1) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "operation actor lacks one authoritative worker binding",
+      );
+    }
+    return matches[0];
+  }
+
+  #initialReplayState(state, definition) {
+    return {
+      schemaVersion: state.schemaVersion,
+      runId: state.runId,
+      rootSessionId: state.rootSessionId,
+      originatingTurnId: state.originatingTurnId,
+      scope: state.scope,
+      masterNode: state.masterNode,
+      recipe: state.recipe,
+      status: "draft",
+      currentLap: 0,
+      continuationLease: {
+        granted: definition.lapCap,
+        consumed: 0,
+      },
+      cancelRequested: false,
+      revision: 0,
+      createdAt: definition.createdAt,
+      updatedAt: definition.createdAt,
+    };
+  }
+
+  async #nextStateForOperation(
+    state,
+    operation,
+    facts,
+    definition,
+    bindingRead,
+    options = {},
+  ) {
+    const { transition, report } = facts;
+    if (
+      state.runId !== operation.runId ||
+      state.revision !== operation.fromRevision ||
+      operation.toRevision !== state.revision + 1
+    ) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "operation revision does not match replay state",
+      );
+    }
+    const expectedDigest = mutationRequestDigest({
+      kind: operation.kind,
+      runId: operation.runId,
+      requestId: operation.requestId,
+      actorKind: operation.actorKind,
+      actorId: operation.actorId,
+      payload: report ? reportPayload(report) : {},
+    });
+    if (operation.requestDigest !== expectedDigest) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "operation request digest is not reproducible",
+      );
+    }
+    const transitionMatches = (expected) =>
+      transition.kind === expected.kind &&
+      transition.fromNode === expected.fromNode &&
+      transition.lap === expected.lap &&
+      (expected.toRole
+        ? this.#roleTargetMatches(
+            expected.toRole,
+            transition.toNode,
+            `transition:${transition.transitionId}:toNode`,
+            options.compatibilityKeys,
+          )
+        : transition.toNode === expected.toNode);
+    const reportRouteMatches = (expectedRole = null) =>
+      report?.fromNode === operation.actorId &&
+      report?.receiver === "root-master" &&
+      (expectedRole
+        ? report.routedToNode === transition.toNode &&
+          this.#roleTargetMatches(
+            expectedRole,
+            report.routedToNode,
+            `report:${report.reportId}:routedToNode`,
+            options.compatibilityKeys,
+          )
+        : report?.routedToNode === undefined);
+    let next = {
+      ...state,
+      revision: operation.toRevision,
+      updatedAt: operation.createdAt,
+      latestOperationId: operation.operationId,
+    };
+
+    if (operation.kind === "start") {
+      if (
+        state.status !== "draft" ||
+        state.currentLap !== 0 ||
+        report !== null ||
+        !transitionMatches({
+          kind: "activate-implementer",
+          fromNode: state.masterNode,
+          toRole: "implementer",
+          lap: 0,
+        })
+      ) {
+        fail(
+          "RECOVERY_REQUIRED",
+          "start receipt has invalid transition semantics",
+        );
+      }
+      return {
+        ...next,
+        status: "running",
+        pendingTransitionId: transition.transitionId,
+      };
+    }
+
+    if (operation.kind === "report") {
+      if (
+        state.status !== "running" ||
+        !state.pendingTransitionId ||
+        report === null
+      ) {
+        fail(
+          "RECOVERY_REQUIRED",
+          "report receipt does not match an active obligation",
+        );
+      }
+      let pending;
+      try {
+        pending = await this.store.readTransition(
+          state.runId,
+          state.pendingTransitionId,
+        );
+      } catch (error) {
+        fail(
+          "RECOVERY_REQUIRED",
+          "report receipt references an unreadable prior obligation",
+          { code: error?.code ?? "READ_ERROR" },
+        );
+      }
+      const binding = this.#bindingForAgent(
+        bindingRead,
+        state,
+        operation.actorId,
+      );
+      const pendingRole = governedTransitionRole(pending);
+      if (
+        pendingRole === null ||
+        binding.role !== pendingRole
+      ) {
+        fail(
+          "RECOVERY_REQUIRED",
+          "report actor does not own the replayed obligation",
+        );
+      }
+      if (binding.role === "implementer") {
+        if (
+          report.type !== "info" ||
+          report.status !== "done" ||
+          report.verdict !== undefined ||
+          report.issues !== undefined ||
+          !transitionMatches({
+            kind: "activate-reviewer",
+            fromNode: operation.actorId,
+            toRole: "reviewer",
+            lap: state.currentLap,
+          }) ||
+          !reportRouteMatches("reviewer")
+        ) {
+          fail(
+            "RECOVERY_REQUIRED",
+            "implementer report has invalid transition semantics",
+          );
+        }
+        return {
+          ...next,
+          currentLap: transition.lap,
+          pendingTransitionId: transition.transitionId,
+          latestReportId: report.reportId,
+        };
+      }
+
+      if (
+        report.type !== "verdict" ||
+        !["clean", "issues"].includes(report.verdict) ||
+        report.status !== undefined
+      ) {
+        fail(
+          "RECOVERY_REQUIRED",
+          "reviewer report has invalid typed semantics",
+        );
+      }
+      if (report.verdict === "clean") {
+        if (
+          !transitionMatches({
+            kind: "succeed",
+            fromNode: operation.actorId,
+            toNode: state.masterNode,
+            lap: state.currentLap,
+          }) ||
+          !reportRouteMatches()
+        ) {
+          fail(
+            "RECOVERY_REQUIRED",
+            "clean verdict has invalid transition semantics",
+          );
+        }
+        return {
+          ...withoutPending(next),
+          status: "succeeded",
+          latestReportId: report.reportId,
+        };
+      }
+      if (
+        !Array.isArray(report.issues) ||
+        report.issues.length === 0
+      ) {
+        fail(
+          "RECOVERY_REQUIRED",
+          "issues verdict lacks typed issues",
+        );
+      }
+      if (state.currentLap + 1 > definition.lapCap) {
+        if (
+          !transitionMatches({
+            kind: "cap",
+            fromNode: operation.actorId,
+            toNode: state.masterNode,
+            lap: state.currentLap,
+          }) ||
+          !reportRouteMatches()
+        ) {
+          fail(
+            "RECOVERY_REQUIRED",
+            "lap-cap verdict has invalid transition semantics",
+          );
+        }
+        return {
+          ...withoutPending(next),
+          status: "capped",
+          latestReportId: report.reportId,
+        };
+      }
+      if (
+        !transitionMatches({
+          kind: "activate-implementer",
+          fromNode: operation.actorId,
+          toRole: "implementer",
+          lap: state.currentLap + 1,
+        }) ||
+        !reportRouteMatches("implementer")
+      ) {
+        fail(
+          "RECOVERY_REQUIRED",
+          "issues verdict has invalid transition semantics",
+        );
+      }
+      return {
+        ...next,
+        currentLap: transition.lap,
+        pendingTransitionId: transition.transitionId,
+        latestReportId: report.reportId,
+      };
+    }
+
+    if (report !== null) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "non-report operation unexpectedly references a report",
+      );
+    }
+    const rootTransitionMatches = (kind) =>
+      transitionMatches({
+        kind,
+        fromNode: state.masterNode,
+        toNode: state.masterNode,
+        lap: state.currentLap,
+      });
+    switch (operation.kind) {
+      case "pause":
+        if (
+          !["running", "interrupted"].includes(state.status) ||
+          !rootTransitionMatches("pause")
+        ) {
+          fail(
+            "RECOVERY_REQUIRED",
+            "pause receipt has invalid transition semantics",
+          );
+        }
+        return { ...next, status: "paused" };
+      case "resume":
+        if (
+          !["paused", "interrupted"].includes(state.status) ||
+          !rootTransitionMatches("resume")
+        ) {
+          fail(
+            "RECOVERY_REQUIRED",
+            "resume receipt has invalid transition semantics",
+          );
+        }
+        return {
+          ...next,
+          status: "running",
+          needsHuman: false,
+        };
+      case "cancel":
+        if (
+          !ROOT_CONTROL_STATUSES.has(state.status) ||
+          !rootTransitionMatches("cancel")
+        ) {
+          fail(
+            "RECOVERY_REQUIRED",
+            "cancel receipt has invalid transition semantics",
+          );
+        }
+        return {
+          ...withoutPending(next),
+          status: "cancelled",
+          cancelRequested: true,
+        };
+      case "interrupt":
+        if (
+          operation.requestId !==
+            factLimitRequestId(operation.fromRevision) ||
+          !ACTIVE_RUN_STATUSES.has(state.status) ||
+          (state.status === "interrupted" &&
+            state.needsHuman === true) ||
+          !rootTransitionMatches("interrupt")
+        ) {
+          fail(
+            "RECOVERY_REQUIRED",
+            "fact-limit interruption receipt has invalid semantics",
+          );
+        }
+        return {
+          ...next,
+          status: "interrupted",
+          needsHuman: true,
+        };
+      default:
+        fail(
+          "RECOVERY_REQUIRED",
+          "operation kind is unsupported during replay",
+        );
+    }
+  }
+
+  #nextStateForGovernorDecision(state, decision) {
+    if (
+      state.runId !== decision.runId ||
+      state.rootSessionId !== decision.rootSessionId ||
+      state.revision !== decision.fromRevision ||
+      decision.toRevision !== state.revision + 1 ||
+      state.pendingTransitionId !==
+        decision.pendingTransitionId ||
+      decision.obligationId !==
+        decision.pendingTransitionId
+    ) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "governor receipt does not match replay state",
+      );
+    }
+    let next = {
+      ...state,
+      revision: decision.toRevision,
+      updatedAt: decision.createdAt,
+      latestGovernorDecisionId: decision.decisionId,
+    };
+    switch (decision.action) {
+      case "block":
+        if (
+          state.status !== "running" ||
+          decision.leaseEpoch !==
+            state.continuationLease.consumed + 1 ||
+          decision.leaseEpoch >
+            state.continuationLease.granted
+        ) {
+          fail(
+            "RECOVERY_REQUIRED",
+            "continuation receipt has an invalid lease epoch",
+          );
+        }
+        return {
+          ...next,
+          continuationLease: {
+            ...state.continuationLease,
+            consumed: decision.leaseEpoch,
+          },
+        };
+      case "cap":
+        if (
+          state.status !== "running" ||
+          state.continuationLease.consumed <
+            state.continuationLease.granted
+        ) {
+          fail(
+            "RECOVERY_REQUIRED",
+            "cap receipt does not match an exhausted lease",
+          );
+        }
+        return {
+          ...withoutPending(next),
+          status: "capped",
+          needsHuman: true,
+        };
+      case "interrupt":
+        if (state.status !== "running") {
+          fail(
+            "RECOVERY_REQUIRED",
+            "interrupt receipt does not match a running state",
+          );
+        }
+        return {
+          ...next,
+          status: "interrupted",
+          needsHuman: true,
+        };
+      default:
+        fail(
+          "RECOVERY_REQUIRED",
+          "governor receipt action is unsupported",
+        );
+    }
+  }
+
+  #nextStateForRecovery(state, receipt, context) {
+    if (
+      state.runId !== receipt.runId ||
+      state.rootSessionId !== receipt.actorId ||
+      state.revision !== receipt.fromRevision ||
+      receipt.toRevision !== state.revision + 1 ||
+      receipt.recoveryId !==
+        recoveryIdFor(receipt.runId, receipt.requestId) ||
+      receipt.requestDigest !==
+        recoveryRequestDigest({
+          runId: receipt.runId,
+          requestId: receipt.requestId,
+          actorId: receipt.actorId,
+          expectedRevision: receipt.fromRevision,
+          expectedEvidenceDigest:
+            receipt.evidenceDigest,
+        }) ||
+      !ROOT_CONTROL_STATUSES.has(state.status) ||
+      digestJson(state) !== receipt.priorStateDigest
+    ) {
+      fail(
+        "HISTORY_CORRUPT",
+        "legacy recovery receipt does not match its prior state",
+      );
+    }
+    const evidence = buildLegacyNativeTargetEvidence({
+      state,
+      definition: context.definition,
+      operations: context.operations,
+      governorDecisions: context.governorDecisions,
+      transitions: context.transitions,
+      reports: context.reports,
+      bindings: context.bindings,
+      entries: context.entries,
+    });
+    if (
+      !evidence ||
+      evidence.evidenceDigest !== receipt.evidenceDigest ||
+      evidence.entries.length !== receipt.legacyFactCount
+    ) {
+      fail(
+        "HISTORY_CORRUPT",
+        "legacy recovery evidence no longer matches its immutable receipt",
+      );
+    }
+    const next = terminalStateForRecovery(state, receipt);
+    if (
+      digestJson(next) !== receipt.terminalStateDigest
+    ) {
+      fail(
+        "HISTORY_CORRUPT",
+        "legacy recovery terminal state digest is invalid",
+      );
+    }
+    return next;
+  }
+
+  async #validateDurableControlHistory(
+    state,
+    operationRead,
+    governorDecisionRead,
+    recoveryRead = { facts: [], corrupt: [] },
+    options = {},
+  ) {
+    const definition =
+      await this.#readAndValidateDefinition(state);
+    const bindingRead =
+      await this.#readValidatedBindings(state);
+    const observationRead =
+      options.observationRead ??
+      (await this.store.listWorkerObservations(
+        state.runId,
+      ));
+    if (observationRead.corrupt.length > 0) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "worker observation receipts are corrupt",
+      );
+    }
+    if (recoveryRead.corrupt.length > 0) {
+      fail(
+        "HISTORY_CORRUPT",
+        "legacy recovery receipts are corrupt",
+      );
+    }
+    if (recoveryRead.facts.length > 1) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "multiple legacy recovery receipts exist for one run",
+      );
+    }
+    this.#assertDurableRequestNamespaces({
+      definition,
+      operations: operationRead.facts,
+      observations: observationRead.facts,
+      bindings: bindingRead.facts,
+      recoveries: recoveryRead.facts,
+    });
+    this.#assertPreparedRecoveryBarrier(
+      state,
+      recoveryRead,
+      {
+        normalPreparedCount: [
+          ...operationRead.facts,
+          ...governorDecisionRead.facts,
+        ].filter(
+          (receipt) =>
+            receipt.fromRevision === state.revision,
+        ).length,
+      },
+    );
+    for (const receipt of recoveryRead.facts) {
+      let durable;
+      try {
+        durable = await this.store.readRecovery(
+          state.runId,
+          receipt.recoveryId,
+        );
+      } catch (error) {
+        fail(
+          "HISTORY_CORRUPT",
+          "legacy recovery receipt is missing or unreadable",
+          { code: error?.code ?? "READ_ERROR" },
+        );
+      }
+      if (
+        canonicalJson(durable) !== canonicalJson(receipt) ||
+        receipt.runId !== state.runId ||
+        receipt.actorKind !== "root" ||
+        receipt.fromRevision > state.revision
+      ) {
+        fail(
+          "HISTORY_CORRUPT",
+          "legacy recovery receipt identity is unstable",
+        );
+      }
+    }
+    const operationFacts = new Map();
+    for (const operation of operationRead.facts) {
+      if (operation.fromRevision > state.revision) {
+        fail(
+          "RECOVERY_REQUIRED",
+          "operation receipt is ahead of durable state",
+        );
+      }
+      operationFacts.set(
+        operation.operationId,
+        await this.#readAndValidateOperation(operation, state),
+      );
+    }
+    const appliedOperationReceipts =
+      operationRead.facts.filter(
+        (operation) =>
+          operation.toRevision <= state.revision,
+      );
+    for (const decision of governorDecisionRead.facts) {
+      if (decision.fromRevision > state.revision) {
+        fail(
+          "RECOVERY_REQUIRED",
+          "governor receipt is ahead of durable state",
+        );
+      }
+      let durable;
+      try {
+        durable = await this.store.readGovernorDecision(
+          state.runId,
+          decision.decisionId,
+        );
+      } catch (error) {
+        fail(
+          "RECOVERY_REQUIRED",
+          "governor receipt is missing or unreadable",
+          { code: error?.code ?? "READ_ERROR" },
+        );
+      }
+      if (canonicalJson(durable) !== canonicalJson(decision)) {
+        fail(
+          "RECOVERY_REQUIRED",
+          "governor receipt identity is unstable",
+        );
+      }
+      await this.#readGovernorDecisionReferences(
+        state,
+        decision,
+        appliedOperationReceipts,
+      );
+    }
+
+    const receipts = [
+      ...operationRead.facts.map((receipt) => ({
+        kind: "operation",
+        id: receipt.operationId,
+        receipt,
+      })),
+      ...governorDecisionRead.facts.map((receipt) => ({
+        kind: "governor-decision",
+        id: receipt.decisionId,
+        receipt,
+      })),
+      ...recoveryRead.facts.map((receipt) => ({
+        kind: "recovery",
+        id: receipt.recoveryId,
+        receipt,
+      })),
+    ];
+    const applied = receipts.filter(
+      ({ receipt }) => receipt.toRevision <= state.revision,
+    );
+    const appliedByRevision = new Map();
+    for (const item of applied) {
+      const revision = item.receipt.fromRevision;
+      const values = appliedByRevision.get(revision) ?? [];
+      values.push(item);
+      appliedByRevision.set(revision, values);
+    }
+    for (
+      let revision = 0;
+      revision < state.revision;
+      revision += 1
+    ) {
+      const matches = (
+        appliedByRevision.get(revision) ?? []
+      ).filter(
+        ({ receipt }) =>
+          receipt.toRevision === revision + 1,
+      );
+      if (matches.length !== 1) {
+        fail(
+          "RECOVERY_REQUIRED",
+          "durable control receipt history has a gap or collision",
+          { revision, receipts: matches.length },
+        );
+      }
+    }
+
+    let replay = this.#initialReplayState(
+      state,
+      definition,
+    );
+    const transitionFacts =
+      options.transitionRead?.facts ??
+      [...operationFacts.values()].map(
+        ({ transition }) => transition,
+      );
+    const reportFacts =
+      options.reportRead?.facts ??
+      [...operationFacts.values()]
+        .map(({ report }) => report)
+        .filter(Boolean);
+    const appliedRecovery = recoveryRead.facts.find(
+      (receipt) => receipt.toRevision <= state.revision,
+    );
+    const compatibilityEntries =
+      options.legacyEvidence?.entries ??
+      (appliedRecovery
+        ? collectLegacyNativeTargetEntries({
+            state,
+            operations: operationRead.facts,
+            transitions: transitionFacts,
+            reports: reportFacts,
+            bindings: bindingRead.facts,
+          })
+        : []);
+    const compatibilityKeys =
+      options.legacyEvidence || appliedRecovery
+        ? new Set(
+            compatibilityEntries.map(legacyEntryKey),
+          )
+        : undefined;
+    for (
+      let revision = 0;
+      revision < state.revision;
+      revision += 1
+    ) {
+      const [item] = (
+        appliedByRevision.get(revision) ?? []
+      ).filter(
+        ({ receipt }) =>
+          receipt.toRevision === revision + 1,
+      );
+      if (item.kind === "operation") {
+        replay = await this.#nextStateForOperation(
+              replay,
+              item.receipt,
+              operationFacts.get(item.receipt.operationId),
+              definition,
+              bindingRead,
+              { compatibilityKeys },
+            );
+      } else if (item.kind === "governor-decision") {
+        replay = this.#nextStateForGovernorDecision(
+              replay,
+              item.receipt,
+            );
+      } else {
+        replay = this.#nextStateForRecovery(
+          replay,
+          item.receipt,
+          {
+            definition,
+            operations: operationRead.facts,
+            governorDecisions:
+              governorDecisionRead.facts,
+            transitions: transitionFacts,
+            reports: reportFacts,
+            bindings: bindingRead.facts,
+            entries: compatibilityEntries,
+          },
+        );
+      }
+    }
+    if (canonicalJson(replay) !== canonicalJson(state)) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "durable state does not equal deterministic receipt replay",
+      );
+    }
+    const prepared = receipts.filter(
+      ({ receipt }) =>
+        receipt.fromRevision === state.revision,
+    );
+    if (prepared.length > 1) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "durable control history has competing prepared receipts",
+      );
+    }
+    for (const item of prepared) {
+      if (item.receipt.toRevision !== state.revision + 1) {
+        fail(
+          "RECOVERY_REQUIRED",
+          "prepared receipt has an invalid target revision",
+        );
+      }
+      if (item.kind === "operation") {
+        await this.#nextStateForOperation(
+          replay,
+          item.receipt,
+          operationFacts.get(item.receipt.operationId),
+          definition,
+          bindingRead,
+          { compatibilityKeys },
+        );
+      } else if (item.kind === "governor-decision") {
+        this.#nextStateForGovernorDecision(
+          replay,
+          item.receipt,
+        );
+      } else {
+        fail(
+          "LEGACY_RECOVERY_PENDING",
+          "a legacy recovery receipt awaits explicit confirmation",
+        );
+      }
+    }
+
+    const appliedOperations = appliedOperationReceipts
+      .sort(
+        (left, right) =>
+          left.toRevision - right.toRevision ||
+          compareCodePoints(
+            left.operationId,
+            right.operationId,
+          ),
+      );
+    const appliedDecisions = governorDecisionRead.facts
+      .filter(
+        (decision) =>
+          decision.toRevision <= state.revision,
+      )
+      .sort(
+        (left, right) =>
+          left.toRevision - right.toRevision ||
+          compareCodePoints(
+            left.decisionId,
+            right.decisionId,
+          ),
+      );
+    const expectedOperationId =
+      appliedOperations.at(-1)?.operationId;
+    const expectedDecisionId =
+      appliedDecisions.at(-1)?.decisionId;
+    const appliedRecoveries = recoveryRead.facts
+      .filter(
+        (receipt) =>
+          receipt.toRevision <= state.revision,
+      )
+      .sort(
+        (left, right) =>
+          left.toRevision - right.toRevision ||
+          compareCodePoints(
+            left.recoveryId,
+            right.recoveryId,
+          ),
+      );
+    const expectedRecoveryId =
+      appliedRecoveries.at(-1)?.recoveryId;
+    if (
+      state.latestOperationId !== expectedOperationId ||
+      state.latestGovernorDecisionId !== expectedDecisionId ||
+      state.latestRecoveryId !== expectedRecoveryId
+    ) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "durable state points to missing or stale control receipts",
+      );
+    }
+    const expectedReportId = [...appliedOperations]
+      .reverse()
+      .find((operation) => operation.reportId)?.reportId;
+    if (state.latestReportId !== expectedReportId) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "durable state points to a missing or stale report",
+      );
+    }
+
+    const blocks = appliedDecisions
+      .filter((decision) => decision.action === "block")
+      .sort(
+        (left, right) =>
+          left.leaseEpoch - right.leaseEpoch ||
+          compareCodePoints(
+            left.decisionId,
+            right.decisionId,
+          ),
+      );
+    if (
+      blocks.length !== state.continuationLease.consumed ||
+      blocks.some(
+        (decision, index) =>
+          decision.leaseEpoch !== index + 1,
+      )
+    ) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "continuation lease does not match applied decision receipts",
+      );
+    }
+
+    if (state.pendingTransitionId) {
+      const anchors = appliedOperations.filter(
+        (operation) =>
+          operation.transitionId ===
+          state.pendingTransitionId,
+      );
+      const transition =
+        anchors.length === 1
+          ? operationFacts.get(anchors[0].operationId)
+              ?.transition
+          : null;
+      if (
+        !transition ||
+        governedTransitionRole(transition) === null ||
+        transition.lap !== state.currentLap
+      ) {
+        fail(
+          "RECOVERY_REQUIRED",
+          "pending transition is not anchored in applied operation history",
+        );
+      }
+    }
+    return {
+      definition,
+      bindingRead,
+      operationFacts,
+      appliedOperations,
+      appliedDecisions,
+      appliedRecoveries,
+    };
+  }
+
+  async rollForwardPrepared(initialState) {
+    return this.#rollForwardPrepared(initialState);
+  }
+
+  async applyGovernorDecision(state, decision) {
+    return this.#applyGovernorDecision(state, decision);
+  }
+
+  async #rollForwardPrepared(initialState) {
+    let state = initialState;
+    for (let attempt = 0; attempt < 32; attempt += 1) {
+      const [
+        operationRead,
+        governorDecisionRead,
+        recoveryRead,
+        reportRead,
+        transitionRead,
+      ] =
+        await Promise.all([
+          this.store.listOperations(state.runId),
+          this.store.listGovernorDecisions(state.runId),
+          this.store.listRecoveries(state.runId),
+          this.store.listReports(state.runId),
+          this.store.listTransitions(state.runId),
+        ]);
+      if (
+        operationRead.corrupt.length > 0 ||
+        governorDecisionRead.corrupt.length > 0 ||
+        reportRead.corrupt.length > 0 ||
+        transitionRead.corrupt.length > 0
+      ) {
+        fail(
+          "RECOVERY_REQUIRED",
+          "prepared receipts are corrupt",
+        );
+      }
+      if (recoveryRead.corrupt.length > 0) {
+        fail(
+          "HISTORY_CORRUPT",
+          "legacy recovery receipt is corrupt",
+        );
+      }
+      await this.#validateDurableControlHistory(
+        state,
+        operationRead,
+        governorDecisionRead,
+        recoveryRead,
+        { reportRead, transitionRead },
+      );
+      const prepared = [
+        ...operationRead.facts.map((receipt) => ({
+          kind: "operation",
+          id: receipt.operationId,
+          receipt,
+        })),
+        ...governorDecisionRead.facts.map((receipt) => ({
+          kind: "governor-decision",
+          id: receipt.decisionId,
+          receipt,
+        })),
+      ]
+        .filter(
+          ({ receipt }) =>
+            receipt.fromRevision === state.revision,
+        )
+        .sort((left, right) =>
+          compareCodePoints(left.id, right.id),
+        );
+      if (prepared.length === 0) {
+        return state;
+      }
+      if (prepared.length > 1) {
+        fail(
+          "RECOVERY_REQUIRED",
+          "multiple prepared receipts target the same revision",
+        );
+      }
+      const [next] = prepared;
+      state =
+        next.kind === "operation"
+          ? await this.#applyOperation(
+              state,
+              next.receipt,
+            )
+          : await this.#applyGovernorDecision(
+              state,
+              next.receipt,
+            );
+    }
+    fail(
+      "RECOVERY_REQUIRED",
+      "prepared receipt chain exceeds the recovery bound",
+    );
+  }
+
+  async #applyOperation(state, operation) {
+    if (state.runId !== operation.runId) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "operation receipt belongs to a different run",
+      );
+    }
+    const facts = await this.#readAndValidateOperation(
+      operation,
+      state,
+    );
+    if (state.revision >= operation.toRevision) {
+      return state;
+    }
+    const [
+      definition,
+      bindingRead,
+    ] = await Promise.all([
+      this.#readAndValidateDefinition(state),
+      this.#readValidatedBindings(state),
+    ]);
+    const next = await this.#nextStateForOperation(
+      state,
+      operation,
+      facts,
+      definition,
+      bindingRead,
+    );
+    return this.store.compareAndSwapState(
+      state.runId,
+      state.revision,
+      next,
+    );
+  }
+
+  async #applyGovernorDecision(state, decisionValue) {
+    const decision = assertContract(
+      "governor decision",
+      decisionValue,
+      validateGovernorDecision,
+    );
+    let durable;
+    try {
+      durable = await this.store.readGovernorDecision(
+        decision.runId,
+        decision.decisionId,
+      );
+    } catch (error) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "governor receipt is missing or unreadable",
+        { code: error?.code ?? "READ_ERROR" },
+      );
+    }
+    if (canonicalJson(durable) !== canonicalJson(decision)) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "governor receipt conflicts with the prepared decision",
+      );
+    }
+    await this.#readAndValidateDefinition(state);
+    const operationRead =
+      await this.store.listOperations(state.runId);
+    if (operationRead.corrupt.length > 0) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "operation receipts are corrupt",
+      );
+    }
+    await this.#readGovernorDecisionReferences(
+      state,
+      decision,
+      operationRead.facts.filter(
+        (operation) =>
+          operation.toRevision <= state.revision,
+      ),
+    );
+    if (
+      state.runId !== decision.runId ||
+      state.rootSessionId !== decision.rootSessionId ||
+      decision.obligationId !==
+        decision.pendingTransitionId
+    ) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "governor receipt belongs to a different run or root",
+      );
+    }
+    if (state.revision >= decision.toRevision) {
+      return state;
+    }
+    if (
+      state.revision !== decision.fromRevision ||
+      state.pendingTransitionId !==
+        decision.pendingTransitionId
+    ) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "governor receipt does not match durable state",
+      );
+    }
+    const next = this.#nextStateForGovernorDecision(
+      state,
+      decision,
+    );
+    return this.store.compareAndSwapState(
+      state.runId,
+      state.revision,
+      next,
+    );
+  }
+
+  async #readOperationFacts(operation) {
+    let transition;
+    let report = null;
+    try {
+      transition = await this.store.readTransition(
+        operation.runId,
+        operation.transitionId,
+      );
+      if (operation.reportId) {
+        report = await this.store.readReport(
+          operation.runId,
+          operation.reportId,
+        );
+      }
+    } catch (error) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "operation receipt references missing or unreadable facts",
+        { code: error?.code ?? "READ_ERROR" },
+      );
+    }
+    const expectsReport = operation.kind === "report";
+    if (
+      Boolean(operation.reportId) !== expectsReport ||
+      Boolean(report) !== expectsReport ||
+      transition.transitionId !== operation.transitionId ||
+      transition.runId !== operation.runId ||
+      transition.requestId !== operation.requestId ||
+      transition.requestDigest !== operation.requestDigest ||
+      transition.fromRevision !== operation.fromRevision ||
+      transition.toRevision !== operation.toRevision ||
+      transition.createdAt !== operation.createdAt ||
+      (expectsReport &&
+        (report.reportId !== operation.reportId ||
+          report.runId !== operation.runId ||
+          report.requestId !== operation.requestId ||
+          report.requestDigest !== operation.requestDigest ||
+          report.fromRevision !== operation.fromRevision ||
+          report.toRevision !== operation.toRevision ||
+          report.createdAt !== operation.createdAt ||
+          transition.originReportId !== operation.reportId)) ||
+      (!expectsReport && transition.originReportId !== undefined)
+    ) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "operation receipt references missing or conflicting facts",
+      );
+    }
+    return { transition, report };
+  }
+
+  async #mutationResult(
+    state,
+    definition,
+    operation,
+    duplicate,
+  ) {
+    const { transition, report } =
+      await this.#readOperationFacts(operation);
+    return {
+      ...stateSummary(state, definition, duplicate),
+      operationId: operation.operationId,
+      transition,
+      ...(report ? { report } : {}),
+    };
+  }
+}
diff --git a/plugins/looperators-agent-loop/lib/data-root.mjs b/plugins/looperators-agent-loop/lib/data-root.mjs
new file mode 100644
index 0000000..6bcae6e
--- /dev/null
+++ b/plugins/looperators-agent-loop/lib/data-root.mjs
@@ -0,0 +1,273 @@
+import { randomUUID } from "node:crypto";
+import {
+  chmod,
+  lstat,
+  mkdir,
+  realpath,
+} from "node:fs/promises";
+import { homedir as systemHomeDirectory } from "node:os";
+import path from "node:path";
+import { digestJson } from "./canonical-json.mjs";
+import { atomicCreateJson, readJsonFile } from "./fs-utils.mjs";
+
+const MARKER_FILE = ".looperators-store-v1.json";
+const PRODUCT_DIRECTORY = [
+  "looperators",
+  "codex-agent-loop",
+  "v1",
+];
+
+export class DataRootUnavailableError extends Error {
+  constructor(message = "no supported looperators data root is available") {
+    super(message);
+    this.name = "DataRootUnavailableError";
+    this.code = "DATA_ROOT_UNAVAILABLE";
+  }
+}
+
+export class DataRootSplitError extends Error {
+  constructor(message = "hook and MCP data roots do not agree") {
+    super(message);
+    this.name = "DataRootSplitError";
+    this.code = "DATA_ROOT_SPLIT";
+  }
+}
+
+export class InvalidDataRootError extends Error {
+  constructor(message = "looperators data root is invalid") {
+    super(message);
+    this.name = "InvalidDataRootError";
+    this.code = "INVALID_DATA_ROOT";
+  }
+}
+
+function requireAbsolute(value, name) {
+  if (!path.isAbsolute(value)) {
+    throw new InvalidDataRootError(`${name} must be an absolute path`);
+  }
+}
+
+function requirePlatformBase(value, pathImplementation) {
+  if (
+    typeof value !== "string" ||
+    value.length === 0 ||
+    !pathImplementation.isAbsolute(value)
+  ) {
+    throw new DataRootUnavailableError(
+      "no absolute platform data directory is available",
+    );
+  }
+  return value;
+}
+
+function resolveHomeDirectory(options, env) {
+  const configured = options.homeDirectory ?? env.HOME;
+  if (configured) {
+    return configured;
+  }
+  try {
+    return (
+      options.systemHomeDirectory?.() ??
+      systemHomeDirectory()
+    );
+  } catch {
+    return undefined;
+  }
+}
+
+export function defaultDataRoot(options = {}) {
+  const env = options.env ?? process.env;
+  const platform = options.platform ?? process.platform;
+  const pathImplementation =
+    options.pathImplementation ??
+    (platform === "win32" ? path.win32 : path);
+  let base;
+  if (platform === "darwin") {
+    base = pathImplementation.join(
+      requirePlatformBase(
+        resolveHomeDirectory(options, env),
+        pathImplementation,
+      ),
+      "Library",
+      "Application Support",
+    );
+  } else if (platform === "win32") {
+    base = requirePlatformBase(
+      options.localAppData ?? env.LOCALAPPDATA,
+      pathImplementation,
+    );
+  } else {
+    const xdgDataHome =
+      options.xdgDataHome ?? env.XDG_DATA_HOME;
+    base = xdgDataHome
+      ? requirePlatformBase(xdgDataHome, pathImplementation)
+      : pathImplementation.join(
+          requirePlatformBase(
+            resolveHomeDirectory(options, env),
+            pathImplementation,
+          ),
+          ".local",
+          "share",
+        );
+  }
+  return pathImplementation.join(base, ...PRODUCT_DIRECTORY);
+}
+
+function validateMarker(marker) {
+  if (
+    marker?.schemaVersion !== 1 ||
+    marker?.storeVersion !== 1 ||
+    typeof marker?.instanceId !== "string" ||
+    marker.instanceId.length < 16
+  ) {
+    throw new InvalidDataRootError("data-root marker is malformed");
+  }
+  return marker;
+}
+
+async function writeDataRootSplitDiagnostic(root, details) {
+  const fingerprint = digestJson({
+    kind: "data_root_split",
+    details,
+  });
+  const diagnostic = {
+    schemaVersion: 1,
+    diagnosticId: `data_root_split_${fingerprint}`,
+    kind: "data_root_split",
+    severity: "error",
+    details,
+    createdAt: new Date().toISOString(),
+  };
+  try {
+    await atomicCreateJson(
+      path.join(
+        root,
+        "diagnostics",
+        "data-root-split",
+        `${fingerprint}.json`,
+      ),
+      diagnostic,
+      {
+        equivalent: (left) =>
+          left?.diagnosticId === diagnostic.diagnosticId,
+        root,
+      },
+    );
+  } catch {
+    // The resolver must still reject a split root when the best-effort
+    // diagnostic cannot be persisted.
+  }
+}
+
+export async function resolveDataRoot(options = {}) {
+  const {
+    env = process.env,
+    expectedInstanceId,
+    create = true,
+    platform = process.platform,
+  } = options;
+  const explicit = env.LOOPERATORS_DATA_DIR;
+  if (explicit) {
+    requireAbsolute(explicit, "LOOPERATORS_DATA_DIR");
+  }
+  const selectedValue =
+    explicit ??
+    defaultDataRoot({
+      ...options,
+      env,
+      platform,
+    });
+  const source = explicit
+    ? "LOOPERATORS_DATA_DIR"
+    : "looperators-platform-data";
+  let createdDirectory;
+  if (create) {
+    createdDirectory = await mkdir(selectedValue, {
+      recursive: true,
+      mode: 0o700,
+    });
+  }
+  let root;
+  try {
+    root = await realpath(selectedValue);
+  } catch (error) {
+    if (error?.code === "ENOENT" && !create) {
+      throw new DataRootUnavailableError(
+        "looperators data root has not been initialized",
+      );
+    }
+    throw error;
+  }
+  const rootMetadata = await lstat(root);
+  if (!rootMetadata.isDirectory()) {
+    throw new InvalidDataRootError("data root must be a directory");
+  }
+  if (
+    create &&
+    createdDirectory &&
+    !explicit &&
+    platform !== "win32"
+  ) {
+    await chmod(root, 0o700);
+  }
+  const markerPath = path.join(root, MARKER_FILE);
+  let marker;
+  if (create) {
+    const candidate = {
+      schemaVersion: 1,
+      storeVersion: 1,
+      instanceId: randomUUID(),
+      createdAt: new Date().toISOString(),
+    };
+    const published = await atomicCreateJson(markerPath, candidate, {
+      equivalent: (left) =>
+        left?.schemaVersion === 1 &&
+        left?.storeVersion === 1 &&
+        typeof left?.instanceId === "string",
+      root,
+    });
+    marker =
+      published.status === "created"
+        ? candidate
+        : validateMarker(await readJsonFile(markerPath, { root }));
+  } else {
+    try {
+      marker = validateMarker(
+        await readJsonFile(markerPath, { root }),
+      );
+    } catch (error) {
+      if (error?.code === "ENOENT") {
+        throw new DataRootUnavailableError(
+          "looperators data root marker is unavailable",
+        );
+      }
+      throw error;
+    }
+  }
+  validateMarker(marker);
+  if (expectedInstanceId && marker.instanceId !== expectedInstanceId) {
+    await writeDataRootSplitDiagnostic(root, {
+      reason: "instance-marker-mismatch",
+      expectedInstanceIdDigest: digestJson({
+        instanceId: expectedInstanceId,
+      }),
+      actualInstanceIdDigest: digestJson({
+        instanceId: marker.instanceId,
+      }),
+    });
+    throw new DataRootSplitError("data-root instance marker does not match");
+  }
+  return {
+    path: root,
+    source,
+    marker,
+    instanceIdDigest: digestJson({ instanceId: marker.instanceId }),
+  };
+}
+
+export function dataRootEnvironmentSummary(env = process.env) {
+  return {
+    explicitPresent: Boolean(env.LOOPERATORS_DATA_DIR),
+    pluginDataPresent: Boolean(env.PLUGIN_DATA),
+  };
+}
diff --git a/plugins/looperators-agent-loop/lib/fs-utils.mjs b/plugins/looperators-agent-loop/lib/fs-utils.mjs
new file mode 100644
index 0000000..e256be3
--- /dev/null
+++ b/plugins/looperators-agent-loop/lib/fs-utils.mjs
@@ -0,0 +1,576 @@
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import {
+  chmod,
+  link,
+  lstat,
+  mkdir,
+  open,
+  readdir,
+  rename,
+  unlink,
+} from "node:fs/promises";
+import path from "node:path";
+import { canonicalJson, compareCodePoints } from "./canonical-json.mjs";
+
+export const MAX_STORE_JSON_BYTES = 2 * 1024 * 1024;
+
+export class UnsafeStoreFileError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UnsafeStoreFileError";
+    this.code = "UNSAFE_STORE_FILE";
+  }
+}
+
+export class LockTimeoutError extends Error {
+  constructor(message = "store lock timed out") {
+    super(message);
+    this.name = "LockTimeoutError";
+    this.code = "STORE_LOCK_TIMEOUT";
+  }
+}
+
+async function syncDirectory(directory) {
+  let handle;
+  try {
+    handle = await open(directory, "r");
+    await handle.sync();
+  } catch (error) {
+    if (!["EINVAL", "ENOTSUP", "EBADF", "EISDIR"].includes(error?.code)) {
+      throw error;
+    }
+  } finally {
+    await handle?.close();
+  }
+}
+
+function assertContainedPath(root, candidate) {
+  const rootPath = path.resolve(root);
+  const candidatePath = path.resolve(candidate);
+  const relative = path.relative(rootPath, candidatePath);
+  if (
+    relative === ".." ||
+    relative.startsWith(`..${path.sep}`) ||
+    path.isAbsolute(relative)
+  ) {
+    throw new UnsafeStoreFileError("store path escapes its data root");
+  }
+  return { rootPath, candidatePath, relative };
+}
+
+export async function ensureSafeDirectory(
+  root,
+  directory,
+  options = {},
+) {
+  const { create = false } = options;
+  const { rootPath, candidatePath, relative } = assertContainedPath(
+    root,
+    directory,
+  );
+  const rootMetadata = await lstat(rootPath);
+  if (rootMetadata.isSymbolicLink() || !rootMetadata.isDirectory()) {
+    throw new UnsafeStoreFileError(
+      "store root must be a canonical directory",
+    );
+  }
+  let current = rootPath;
+  const segments = relative ? relative.split(path.sep) : [];
+  for (const segment of segments) {
+    current = path.join(current, segment);
+    if (create) {
+      try {
+        await mkdir(current, { mode: 0o700 });
+      } catch (error) {
+        if (error?.code !== "EEXIST") {
+          throw error;
+        }
+      }
+    }
+    const metadata = await lstat(current);
+    if (metadata.isSymbolicLink() || !metadata.isDirectory()) {
+      throw new UnsafeStoreFileError(
+        "store path components must be real directories",
+      );
+    }
+  }
+  return candidatePath;
+}
+
+async function prepareParent(target, options = {}) {
+  const directory = path.dirname(target);
+  if (options.root) {
+    await ensureSafeDirectory(options.root, directory, { create: true });
+  } else {
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+  }
+  return directory;
+}
+
+function encodeJson(value, maxBytes) {
+  const encoded = `${canonicalJson(value)}\n`;
+  if (Buffer.byteLength(encoded, "utf8") > maxBytes) {
+    const error = new RangeError("store JSON file exceeds the write limit");
+    error.code = "STORE_FILE_TOO_LARGE";
+    throw error;
+  }
+  return encoded;
+}
+
+async function writeTempJson(target, value, options = {}) {
+  const {
+    durable = true,
+    maxBytes = MAX_STORE_JSON_BYTES,
+  } = options;
+  const encoded = encodeJson(value, maxBytes);
+  const directory = await prepareParent(target, options);
+  const temporary = path.join(
+    directory,
+    `.${path.basename(target)}.tmp-${process.pid}-${randomUUID()}`,
+  );
+  const handle = await open(temporary, "wx", 0o600);
+  try {
+    await handle.writeFile(encoded, "utf8");
+    if (durable) {
+      await handle.sync();
+    }
+  } finally {
+    await handle.close();
+  }
+  return temporary;
+}
+
+async function publishExclusiveJson(target, value, options = {}) {
+  try {
+    await lstat(target);
+    return false;
+  } catch (error) {
+    if (error?.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  const temporary = await writeTempJson(target, value, {
+    ...options,
+    durable: false,
+  });
+  try {
+    try {
+      await link(temporary, target);
+      return true;
+    } catch (error) {
+      if (error?.code === "EEXIST") {
+        return false;
+      }
+      throw error;
+    }
+  } finally {
+    await unlink(temporary).catch((error) => {
+      if (error?.code !== "ENOENT") {
+        throw error;
+      }
+    });
+  }
+}
+
+export async function readBoundedFile(file, options = {}) {
+  const {
+    maxBytes = MAX_STORE_JSON_BYTES,
+    root,
+  } = options;
+  if (root) {
+    await ensureSafeDirectory(root, path.dirname(file));
+  }
+  const noFollow = constants.O_NOFOLLOW ?? 0;
+  const handle = await open(file, constants.O_RDONLY | noFollow);
+  try {
+    const metadata = await handle.stat();
+    if (!metadata.isFile()) {
+      throw new UnsafeStoreFileError(
+        "store JSON path must be a regular file",
+      );
+    }
+    if (metadata.size > maxBytes) {
+      const error = new RangeError(
+        "store JSON file exceeds the read limit",
+      );
+      error.code = "STORE_FILE_TOO_LARGE";
+      throw error;
+    }
+    return await handle.readFile();
+  } finally {
+    await handle.close();
+  }
+}
+
+export async function readJsonFile(file, options = {}) {
+  const buffer = await readBoundedFile(file, options);
+  return JSON.parse(buffer.toString("utf8"));
+}
+
+export async function atomicCreateJson(target, value, options = {}) {
+  const {
+    equivalent = (left, right) =>
+      canonicalJson(left) === canonicalJson(right),
+    root,
+  } = options;
+  const temporary = await writeTempJson(target, value, options);
+  try {
+    try {
+      await link(temporary, target);
+      await syncDirectory(path.dirname(target));
+      return { status: "created", path: target };
+    } catch (error) {
+      if (error?.code !== "EEXIST") {
+        throw error;
+      }
+      const existing = await readJsonFile(target, { root });
+      if (equivalent(existing, value)) {
+        return { status: "duplicate", path: target, existing };
+      }
+      return { status: "conflict", path: target, existing };
+    }
+  } finally {
+    await unlink(temporary).catch((error) => {
+      if (error?.code !== "ENOENT") {
+        throw error;
+      }
+    });
+  }
+}
+
+export async function atomicReplaceJson(target, value, options = {}) {
+  const temporary = await writeTempJson(target, value, options);
+  try {
+    await rename(temporary, target);
+    await chmod(target, 0o600);
+    await syncDirectory(path.dirname(target));
+    return { status: "replaced", path: target };
+  } catch (error) {
+    await unlink(temporary).catch(() => {});
+    throw error;
+  }
+}
+
+export async function listJsonFiles(directory, options = {}) {
+  let entries;
+  try {
+    if (options.root) {
+      await ensureSafeDirectory(options.root, directory);
+    }
+    entries = await readdir(directory, { withFileTypes: true });
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+  return entries
+    .filter(
+      (entry) =>
+        entry.isFile() &&
+        !entry.isSymbolicLink() &&
+        !entry.name.startsWith(".") &&
+        entry.name.endsWith(".json"),
+    )
+    .map((entry) => path.join(directory, entry.name))
+    .sort(compareCodePoints);
+}
+
+function wait(delayMs) {
+  return new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+
+function processIsAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code === "EPERM";
+  }
+}
+
+async function restoreMovedGuard(quarantinePath, guardPath) {
+  try {
+    await link(quarantinePath, guardPath);
+  } catch (error) {
+    if (error?.code !== "EEXIST") {
+      throw error;
+    }
+  } finally {
+    await unlink(quarantinePath).catch((error) => {
+      if (error?.code !== "ENOENT") {
+        throw error;
+      }
+    });
+  }
+}
+
+async function tryReclaimStaleGuard(guardPath, observed, options) {
+  if (Date.now() - observed.mtimeMs <= options.staleMs) {
+    return false;
+  }
+  let observedGuard = null;
+  try {
+    observedGuard = await readJsonFile(guardPath, {
+      root: options.root,
+    });
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return true;
+    }
+  }
+  if (processIsAlive(observedGuard?.pid)) {
+    return false;
+  }
+  const quarantinePath =
+    `${guardPath}.stale-${process.pid}-${randomUUID()}`;
+  try {
+    await rename(guardPath, quarantinePath);
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return true;
+    }
+    throw error;
+  }
+  let moved;
+  let movedGuard = null;
+  try {
+    moved = await lstat(quarantinePath);
+    try {
+      movedGuard = await readJsonFile(quarantinePath, {
+        root: options.root,
+      });
+    } catch {
+      movedGuard = null;
+    }
+    const sameObservedGuard =
+      moved.dev === observed.dev &&
+      moved.ino === observed.ino &&
+      (observedGuard?.token === undefined ||
+        movedGuard?.token === observedGuard.token);
+    if (!sameObservedGuard) {
+      await restoreMovedGuard(quarantinePath, guardPath);
+      return false;
+    }
+    await unlink(quarantinePath);
+    return true;
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return true;
+    }
+    throw error;
+  }
+}
+
+async function tryReclaimStaleLock(
+  lockPath,
+  observed,
+  options,
+) {
+  const guardPath = `${lockPath}.reclaim`;
+  const guardToken = randomUUID();
+  let ownsGuard = false;
+  for (
+    let attempt = 0;
+    attempt < 2 && !ownsGuard;
+    attempt += 1
+  ) {
+    ownsGuard = await publishExclusiveJson(
+      guardPath,
+      {
+        schemaVersion: 1,
+        token: guardToken,
+        pid: process.pid,
+        acquiredAt: new Date().toISOString(),
+      },
+      { root: options.root },
+    );
+    if (!ownsGuard) {
+      let guardMetadata;
+      try {
+        guardMetadata = await lstat(guardPath);
+      } catch (error) {
+        if (error?.code === "ENOENT") {
+          continue;
+        }
+        throw error;
+      }
+      if (
+        await tryReclaimStaleGuard(
+          guardPath,
+          guardMetadata,
+          options,
+        )
+      ) {
+        continue;
+      }
+      return false;
+    }
+  }
+  if (!ownsGuard) {
+    return false;
+  }
+
+  let reclaimed;
+  let reclaimError;
+  try {
+    reclaimed = await (async () => {
+      let current;
+      try {
+        current = await lstat(lockPath);
+      } catch (error) {
+        return error?.code === "ENOENT";
+      }
+      if (
+        current.dev !== observed.dev ||
+        current.ino !== observed.ino ||
+        Date.now() - current.mtimeMs <= options.staleMs
+      ) {
+        return false;
+      }
+      let ownerAlive = false;
+      try {
+        const lock = await readJsonFile(lockPath, { root: options.root });
+        ownerAlive = processIsAlive(lock.pid);
+      } catch (error) {
+        if (error?.code === "ENOENT") {
+          return true;
+        }
+      }
+      if (ownerAlive) {
+        return false;
+      }
+      let currentGuard;
+      try {
+        currentGuard = await readJsonFile(guardPath, {
+          root: options.root,
+        });
+      } catch {
+        return false;
+      }
+      if (
+        currentGuard.token !== guardToken ||
+        currentGuard.pid !== process.pid
+      ) {
+        return false;
+      }
+      const finalCurrent = await lstat(lockPath);
+      if (
+        finalCurrent.dev !== observed.dev ||
+        finalCurrent.ino !== observed.ino
+      ) {
+        return false;
+      }
+      await unlink(lockPath);
+      return true;
+    })();
+  } catch (error) {
+    reclaimError = error;
+  }
+
+  let cleanupError;
+  try {
+    const currentGuard = await readJsonFile(guardPath, {
+      root: options.root,
+    });
+    if (currentGuard.token === guardToken) {
+      await unlink(guardPath);
+    }
+  } catch (error) {
+    if (error?.code !== "ENOENT" && cleanupError === undefined) {
+      cleanupError = error;
+    }
+  }
+  if (reclaimError !== undefined) {
+    throw reclaimError;
+  }
+  if (cleanupError !== undefined) {
+    throw cleanupError;
+  }
+  return reclaimed;
+}
+
+export async function withFileLock(lockPath, callback, options = {}) {
+  const {
+    timeoutMs = 250,
+    staleMs = 5_000,
+    retryMs = 5,
+    root,
+  } = options;
+  await prepareParent(lockPath, { root });
+  const started = Date.now();
+  const token = randomUUID();
+  let acquired = false;
+  while (!acquired) {
+    acquired = await publishExclusiveJson(
+      lockPath,
+      {
+        schemaVersion: 1,
+        token,
+        pid: process.pid,
+        acquiredAt: new Date().toISOString(),
+      },
+      { root },
+    );
+    if (!acquired) {
+      try {
+        const metadata = await lstat(lockPath);
+        if (metadata.isSymbolicLink() || !metadata.isFile()) {
+          throw new UnsafeStoreFileError(
+            "store lock path must be a regular file",
+          );
+        }
+        if (Date.now() - metadata.mtimeMs > staleMs) {
+          const reclaimed = await tryReclaimStaleLock(
+            lockPath,
+            metadata,
+            { staleMs, root },
+          );
+          if (reclaimed) {
+            continue;
+          }
+        }
+      } catch (statError) {
+        if (statError?.code === "ENOENT") {
+          continue;
+        }
+        throw statError;
+      }
+      if (Date.now() - started >= timeoutMs) {
+        throw new LockTimeoutError();
+      }
+      await wait(retryMs);
+    }
+  }
+  let result;
+  let callbackError;
+  try {
+    result = await callback();
+  } catch (error) {
+    callbackError = error;
+  }
+
+  let cleanupError;
+  try {
+    const current = await readJsonFile(lockPath, { root });
+    if (current.token === token) {
+      await unlink(lockPath);
+    }
+  } catch (error) {
+    if (error?.code !== "ENOENT" && cleanupError === undefined) {
+      cleanupError = error;
+    }
+  }
+
+  if (callbackError !== undefined) {
+    throw callbackError;
+  }
+  if (cleanupError !== undefined) {
+    throw cleanupError;
+  }
+  return result;
+}
diff --git a/plugins/looperators-agent-loop/lib/governor.mjs b/plugins/looperators-agent-loop/lib/governor.mjs
new file mode 100644
index 0000000..76f56fd
--- /dev/null
+++ b/plugins/looperators-agent-loop/lib/governor.mjs
@@ -0,0 +1,584 @@
+import {
+  canonicalJson,
+  sha256,
+} from "./canonical-json.mjs";
+import {
+  SCHEMA_VERSION,
+  assertContract,
+  assertSafeFileId,
+  validateGovernorDecision,
+  validateNormalizedHookEvent,
+} from "./contracts.mjs";
+import { LoopController } from "./control.mjs";
+
+const TERMINAL_STATUSES = new Set([
+  "succeeded",
+  "capped",
+  "cancelled",
+  "failed",
+]);
+
+const NON_BLOCKING_STATUSES = new Set([
+  "draft",
+  "paused",
+  "interrupted",
+]);
+
+export class GovernorError extends Error {
+  constructor(code, message, details = undefined) {
+    super(message);
+    this.name = "GovernorError";
+    this.code = code;
+    this.details = details;
+  }
+}
+
+function fail(code, message, details = undefined) {
+  throw new GovernorError(code, message, details);
+}
+
+function expectedRole(transition) {
+  if (transition.kind === "activate-implementer") {
+    return "implementer";
+  }
+  if (transition.kind === "activate-reviewer") {
+    return "reviewer";
+  }
+  return null;
+}
+
+function decisionIdentity(input) {
+  if (input.action === "block") {
+    return {
+      runId: input.runId,
+      obligationId: input.obligationId,
+      kind: "continuation-block",
+    };
+  }
+  if (input.action === "cap") {
+    return {
+      runId: input.runId,
+      obligationId: input.obligationId,
+      kind: "continuation-cap",
+    };
+  }
+  return {
+    runId: input.runId,
+    sessionStartEventId: input.originEventId,
+    stateRevision: input.fromRevision,
+    kind: "resume-interrupt",
+  };
+}
+
+export function governorDecisionId(input) {
+  return `decision_${sha256(
+    canonicalJson(decisionIdentity(input)),
+  )}`;
+}
+
+function allow(reasonCode, options = {}) {
+  return {
+    decision: "allow",
+    reasonCode,
+    ...(options.systemMessage
+      ? { systemMessage: options.systemMessage }
+      : {}),
+    ...(options.state ? { state: options.state } : {}),
+  };
+}
+
+function continuationCommittedMessage(runId, obligationId) {
+  return (
+    `looperators already committed the bounded continuation for run ${runId} ` +
+    `obligation ${obligationId}; it will not be sent again. ` +
+    "Read authoritative loop state, then explicitly complete, resume, or cancel."
+  ).slice(0, 960);
+}
+
+function blockReason(runId, transition, role = undefined) {
+  if (role) {
+    return (
+      `looperators run ${runId} still requires the bound ${role} typed report ` +
+      `for ${transition.transitionId}. Use the capability already provided to ` +
+      "call looperators_report; do not infer completion from prose."
+    ).slice(0, 960);
+  }
+  return (
+    `looperators run ${runId} still has pending ${transition.kind} ` +
+    `${transition.transitionId}. Read looperators_get_loop, perform only that ` +
+    "native worker action, and stop when authoritative state is terminal, " +
+    "paused, or cancelled."
+  ).slice(0, 960);
+}
+
+async function maybeRead(reader) {
+  try {
+    return await reader();
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+
+export class ContinuationGovernor {
+  constructor(store, options = {}) {
+    this.store = store;
+    this.now =
+      options.now ?? (() => new Date().toISOString());
+    this.fault = options.fault ?? (async () => {});
+    this.controller =
+      options.controller ??
+      new LoopController(store, {
+        now: this.now,
+      });
+  }
+
+  async evaluate(runIdValue, eventValue) {
+    if (!runIdValue) {
+      return allow("no-active-run");
+    }
+    const runId = assertSafeFileId(runIdValue, "runId");
+    const event = assertContract(
+      "normalized hook event",
+      eventValue,
+      validateNormalizedHookEvent,
+    );
+    if (
+      !["Stop", "SubagentStop"].includes(event.event) ||
+      event.conflictEligible !== true
+    ) {
+      return allow("unsupported-or-incomplete-event");
+    }
+    return this.store.withControlLock(runId, async () => {
+      let state = await this.store.readState(runId);
+      if (state.rootSessionId !== event.sessionId) {
+        fail(
+          "ROOT_IDENTITY_MISMATCH",
+          "hook session does not own this loop run",
+        );
+      }
+      state =
+        await this.controller.rollForwardPrepared(state);
+      if (
+        state.cancelRequested ||
+        TERMINAL_STATUSES.has(state.status)
+      ) {
+        return allow("terminal-or-cancelled", { state });
+      }
+      if (NON_BLOCKING_STATUSES.has(state.status)) {
+        await this.#diagnose(runId, "governor_state_allows_stop", {
+          eventId: event.eventId,
+          status: state.status,
+        });
+        return allow("non-blocking-state", { state });
+      }
+      if (
+        state.status !== "running" ||
+        !state.pendingTransitionId
+      ) {
+        await this.#diagnose(runId, "governor_missing_obligation", {
+          eventId: event.eventId,
+          status: state.status,
+        });
+        return allow("missing-obligation", { state });
+      }
+      await this.#readDurableHookEvent(runId, event);
+
+      const transition = await this.store.readTransition(
+        runId,
+        state.pendingTransitionId,
+      );
+      if (
+        transition.runId !== runId ||
+        transition.transitionId !==
+          state.pendingTransitionId
+      ) {
+        fail(
+          "RECOVERY_REQUIRED",
+          "pending transition identity is invalid",
+        );
+      }
+      const role = expectedRole(transition);
+      if (!role) {
+        await this.#diagnose(
+          runId,
+          "governor_terminal_transition_pending",
+          {
+            eventId: event.eventId,
+            transitionId: transition.transitionId,
+            transitionKind: transition.kind,
+          },
+        );
+        return allow("non-actionable-transition", { state });
+      }
+      if (event.event === "SubagentStop") {
+        const bindingRead =
+          await this.store.listIdentityBindings(runId);
+        if (bindingRead.corrupt.length > 0) {
+          fail(
+            "RECOVERY_REQUIRED",
+            "worker identity bindings are corrupt",
+          );
+        }
+        const agentMatches = bindingRead.facts.filter(
+          (binding) =>
+            binding.agentId === event.agentId &&
+            binding.rootSessionId === state.rootSessionId &&
+            binding.method === "capability-token-v1" &&
+            binding.revokedAt === undefined,
+        );
+        if (
+          agentMatches.length === 1 &&
+          agentMatches[0].role !== role
+        ) {
+          return allow("stale-bound-worker", { state });
+        }
+        if (
+          agentMatches.length !== 1 ||
+          agentMatches[0].role !== role
+        ) {
+          await this.#diagnose(
+            runId,
+            "governor_worker_not_authorized",
+            {
+              eventId: event.eventId,
+              agentId: event.agentId,
+              expectedRole: role,
+            },
+          );
+          return allow("worker-not-authorized", { state });
+        }
+      }
+
+      const obligationId = state.pendingTransitionId;
+      const existingBlockId = governorDecisionId({
+        action: "block",
+        runId,
+        obligationId,
+      });
+      const existingBlock = await maybeRead(() =>
+        this.store.readGovernorDecision(
+          runId,
+          existingBlockId,
+        ),
+      );
+      if (existingBlock) {
+        if (
+          existingBlock.action !== "block" ||
+          existingBlock.obligationId !== obligationId
+        ) {
+          fail(
+            "RECOVERY_REQUIRED",
+            "continuation receipt conflicts with its obligation",
+          );
+        }
+        await this.#diagnose(
+          runId,
+          "continuation_no_progress",
+          {
+            eventId: event.eventId,
+            obligationId,
+            decisionId: existingBlock.decisionId,
+          },
+        );
+        return allow("continuation-already-committed", {
+          state,
+          systemMessage: continuationCommittedMessage(
+            runId,
+            obligationId,
+          ),
+        });
+      }
+
+      if (
+        state.continuationLease.consumed >=
+        state.continuationLease.granted
+      ) {
+        const decision = this.#buildDecision({
+          action: "cap",
+          event,
+          runId,
+          state,
+          obligationId,
+          reasonCode: "lease-exhausted",
+        });
+        const published =
+          await this.store.putGovernorDecision(
+            runId,
+            decision,
+          );
+        await this.#requirePublished(
+          published,
+          "cap",
+          runId,
+        );
+        await this.fault("afterGovernorReceipt", {
+          runId,
+          decisionId: decision.decisionId,
+        });
+        state = await this.controller.applyGovernorDecision(
+          state,
+          decision,
+        );
+        await this.fault("afterGovernorCas", {
+          runId,
+          decisionId: decision.decisionId,
+        });
+        return allow("lease-exhausted", { state });
+      }
+
+      const decision = this.#buildDecision({
+        action: "block",
+        event,
+        runId,
+        state,
+        obligationId,
+        reasonCode:
+          event.event === "SubagentStop"
+            ? "pending-worker-report"
+            : "pending-root-transition",
+        leaseEpoch:
+          state.continuationLease.consumed + 1,
+      });
+      const published =
+        await this.store.putGovernorDecision(runId, decision);
+      await this.#requirePublished(
+        published,
+        "block",
+        runId,
+      );
+      await this.fault("afterGovernorReceipt", {
+        runId,
+        decisionId: decision.decisionId,
+      });
+      state = await this.controller.applyGovernorDecision(
+        state,
+        decision,
+      );
+      await this.fault("afterGovernorCas", {
+        runId,
+        decisionId: decision.decisionId,
+      });
+      await this.fault("beforeGovernorOutput", {
+        runId,
+        decisionId: decision.decisionId,
+      });
+      return {
+        decision: "block",
+        reasonCode: decision.reasonCode,
+        reason: blockReason(
+          runId,
+          transition,
+          event.event === "SubagentStop" ? role : undefined,
+        ),
+        state,
+        decisionReceipt: decision,
+      };
+    });
+  }
+
+  async recover(runIdValue, eventValue) {
+    if (!runIdValue) {
+      return allow("no-active-run");
+    }
+    const runId = assertSafeFileId(runIdValue, "runId");
+    const event = assertContract(
+      "normalized hook event",
+      eventValue,
+      validateNormalizedHookEvent,
+    );
+    if (
+      event.event !== "SessionStart" ||
+      event.payloadSummary?.source !== "resume"
+    ) {
+      return allow("session-start-does-not-recover");
+    }
+    return this.store.withControlLock(runId, async () => {
+      let state = await this.store.readState(runId);
+      if (state.rootSessionId !== event.sessionId) {
+        fail(
+          "ROOT_IDENTITY_MISMATCH",
+          "resumed session does not own this loop run",
+        );
+      }
+      state =
+        await this.controller.rollForwardPrepared(state);
+      if (
+        state.status !== "running" ||
+        !state.pendingTransitionId
+      ) {
+        if (
+          state.status === "running" &&
+          !state.pendingTransitionId
+        ) {
+          await this.#diagnose(
+            runId,
+            "resume_running_without_obligation",
+            { eventId: event.eventId },
+          );
+        }
+        return allow("resume-needs-no-recovery", { state });
+      }
+      await this.#readDurableHookEvent(runId, event);
+      const decision = this.#buildDecision({
+        action: "interrupt",
+        event,
+        runId,
+        state,
+        obligationId: state.pendingTransitionId,
+        reasonCode: "resume-in-flight",
+      });
+      const existing = await maybeRead(() =>
+        this.store.readGovernorDecision(
+          runId,
+          decision.decisionId,
+        ),
+      );
+      if (existing) {
+        return allow("resume-already-recovered", { state });
+      }
+      const published =
+        await this.store.putGovernorDecision(
+          runId,
+          decision,
+        );
+      await this.#requirePublished(
+        published,
+        "interrupt",
+        runId,
+      );
+      await this.fault("afterGovernorReceipt", {
+        runId,
+        decisionId: decision.decisionId,
+      });
+      state = await this.controller.applyGovernorDecision(
+        state,
+        decision,
+      );
+      await this.fault("afterGovernorCas", {
+        runId,
+        decisionId: decision.decisionId,
+      });
+      return allow("resume-interrupted", { state });
+    });
+  }
+
+  async #readDurableHookEvent(runId, event) {
+    let durable;
+    try {
+      durable = await this.store.readEvent(
+        runId,
+        event.eventId,
+      );
+    } catch (error) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "governor hook event is not durably recorded",
+        { code: error?.code ?? "READ_ERROR" },
+      );
+    }
+    if (
+      durable.eventId !== event.eventId ||
+      durable.semanticKey !== event.semanticKey ||
+      durable.payloadDigest !== event.payloadDigest ||
+      durable.sessionId !== event.sessionId ||
+      durable.turnId !== event.turnId ||
+      durable.event !== event.event ||
+      durable.agentId !== event.agentId ||
+      durable.conflictEligible !== true
+    ) {
+      fail(
+        "RECOVERY_REQUIRED",
+        "governor hook event conflicts with durable evidence",
+      );
+    }
+    return durable;
+  }
+
+  #buildDecision(input) {
+    const value = {
+      schemaVersion: SCHEMA_VERSION,
+      decisionId: governorDecisionId({
+        action: input.action,
+        runId: input.runId,
+        obligationId: input.obligationId,
+        originEventId: input.event.eventId,
+        fromRevision: input.state.revision,
+      }),
+      runId: input.runId,
+      obligationId: input.obligationId,
+      originEventId: input.event.eventId,
+      hookEvent: input.event.event,
+      rootSessionId: input.state.rootSessionId,
+      ...(input.event.turnId
+        ? { turnId: input.event.turnId }
+        : {}),
+      ...(input.event.event === "SubagentStop"
+        ? { agentId: input.event.agentId }
+        : {}),
+      action: input.action,
+      reasonCode: input.reasonCode,
+      pendingTransitionId: input.obligationId,
+      fromRevision: input.state.revision,
+      toRevision: input.state.revision + 1,
+      ...(input.leaseEpoch
+        ? { leaseEpoch: input.leaseEpoch }
+        : {}),
+      createdAt: this.now(),
+    };
+    return assertContract(
+      "governor decision",
+      value,
+      validateGovernorDecision,
+    );
+  }
+
+  async #requirePublished(result, action, runId) {
+    if (result?.status === "created") {
+      return;
+    }
+    if (result?.status === "duplicate") {
+      fail(
+        "DELIVERY_UNCERTAIN",
+        `${action} receipt was already committed`,
+      );
+    }
+    if (result?.status === "limit") {
+      const interrupted =
+        await this.controller.interruptForFactLimit(
+          await this.store.readState(runId),
+          {
+            factKind: "governor-decisions",
+            limit: result.limit,
+          },
+        );
+      fail(
+        "FACT_LIMIT_REACHED",
+        "governor receipt capacity was reached",
+        {
+          status: interrupted.status,
+          needsHuman: interrupted.needsHuman === true,
+        },
+      );
+    }
+    fail(
+      "RECOVERY_REQUIRED",
+      "governor receipt could not be published",
+    );
+  }
+
+  async #diagnose(runId, kind, details) {
+    try {
+      await this.store.writeDiagnostic(
+        runId,
+        kind,
+        details,
+      );
+    } catch {
+      // Diagnostics are observational. Their failure must never turn an allow
+      // decision into a continuation block.
+    }
+  }
+}
diff --git a/plugins/looperators-agent-loop/lib/graph-view.mjs b/plugins/looperators-agent-loop/lib/graph-view.mjs
new file mode 100644
index 0000000..81af573
--- /dev/null
+++ b/plugins/looperators-agent-loop/lib/graph-view.mjs
@@ -0,0 +1,145 @@
+import { readFileSync } from "node:fs";
+import { assertGraphProjectionIntegrity } from "./projection.mjs";
+
+function readUiAsset(name) {
+  const value = readFileSync(
+    new URL(`../ui/assets/${name}`, import.meta.url),
+    "utf8",
+  );
+  if (/<\/(?:script|style)\b/iu.test(value)) {
+    throw new Error(`unsafe graph UI asset: ${name}`);
+  }
+  return value;
+}
+
+const UI_STYLE = readUiAsset("agent-loop-ui.css");
+const UI_SCRIPT = readUiAsset("agent-loop-ui.iife.js");
+
+function jsonForScript(value) {
+  return JSON.stringify(value)
+    .replaceAll("&", "\\u0026")
+    .replaceAll("<", "\\u003c")
+    .replaceAll(">", "\\u003e")
+    .replaceAll("\u2028", "\\u2028")
+    .replaceAll("\u2029", "\\u2029");
+}
+
+function escapeHtml(value) {
+  return String(value)
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&#39;");
+}
+
+function semanticFallback(projection) {
+  const nodes = projection.nodes
+    .map(
+      (node) =>
+        `<li><strong>${escapeHtml(node.label)}</strong>: ` +
+        `${escapeHtml(node.state)}</li>`,
+    )
+    .join("");
+  const edges = projection.edges
+    .map(
+      (edge) =>
+        `<li>${escapeHtml(edge.source)} &rarr; ` +
+        `${escapeHtml(edge.target)}: ${escapeHtml(edge.kind)}</li>`,
+    )
+    .join("");
+  return `<section id="looperators-agent-loop-fallback" class="looperators-agent-loop-fallback" role="status">
+  <h2>looperators Agent Loop</h2>
+  <p>Verified ${escapeHtml(projection.status)} snapshot, lap ${projection.currentLap}/${projection.lapCap}.</p>
+  <ul>${nodes}</ul>
+  <ul>${edges}</ul>
+  <p>revision ${projection.revision} &middot; digest ${projection.projectionDigest.slice(0, 12)}</p>
+</section>`;
+}
+
+const FALLBACK_STYLE = `<style>
+  .looperators-agent-loop-fallback {
+    box-sizing: border-box;
+    display: grid;
+    gap: .5rem;
+    width: 100%;
+    min-width: 0;
+    border: 1px solid color-mix(in srgb, var(--foreground, #172033) 20%, transparent);
+    border-radius: .75rem;
+    background: color-mix(in srgb, var(--background, #fff) 94%, var(--foreground, #172033));
+    padding: .75rem;
+    color: var(--foreground, #172033);
+    font: 13px/1.45 ui-sans-serif, system-ui, sans-serif;
+  }
+  .looperators-agent-loop-fallback[hidden] { display: none !important; }
+  .looperators-agent-loop-fallback h2,
+  .looperators-agent-loop-fallback p,
+  .looperators-agent-loop-fallback ul { margin: 0; }
+</style>`;
+
+export function renderGraphFragment(
+  projectionValue,
+  options = {},
+) {
+  const projection = assertGraphProjectionIntegrity(
+    projectionValue,
+  );
+  const mode = options.mode ?? "inline";
+  if (!["inline", "sidecar"].includes(mode)) {
+    throw new TypeError("graph view mode is invalid");
+  }
+  const driftNote =
+    typeof options.driftNote === "string" &&
+    options.driftNote.length <= 160
+      ? options.driftNote
+      : "";
+  const envelope = jsonForScript({
+    projection,
+    expectedProjectionDigest: projection.projectionDigest,
+    runId: projection.runId,
+    mode,
+    ...(driftNote ? { driftNote } : {}),
+    ...(mode === "sidecar" && options.eventsUrl
+      ? { eventsUrl: options.eventsUrl }
+      : {}),
+    ...(mode === "sidecar" && options.controlUrl
+      ? { controlUrl: options.controlUrl }
+      : {}),
+    ...(mode === "sidecar" && options.csrfToken
+      ? { csrfToken: options.csrfToken }
+      : {}),
+  });
+  return `<div id="looperators-agent-loop-root"></div>
+${semanticFallback(projection)}
+<script type="application/json" id="looperators-agent-loop-data">${envelope}</script>
+${FALLBACK_STYLE}
+<style>${UI_STYLE}</style>
+<script>${UI_SCRIPT}</script>`;
+}
+
+export function renderSidecarDocument(projection, options = {}) {
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  <meta name="color-scheme" content="light dark">
+  <title>looperators Agent Loop live review</title>
+  <link rel="icon" href="data:,">
+  <style>
+    body {
+      margin: 0;
+      padding: 16px;
+      background: var(--background, Canvas);
+      color: var(--foreground, CanvasText);
+    }
+  </style>
+</head>
+<body>
+${renderGraphFragment(projection, {
+    ...options,
+    mode: "sidecar",
+  })}
+</body>
+</html>`;
+}
diff --git a/plugins/looperators-agent-loop/lib/identity.mjs b/plugins/looperators-agent-loop/lib/identity.mjs
new file mode 100644
index 0000000..d14c42b
--- /dev/null
+++ b/plugins/looperators-agent-loop/lib/identity.mjs
@@ -0,0 +1,392 @@
+import { randomBytes } from "node:crypto";
+import {
+  canonicalJson,
+  compareCodePoints,
+  digestEqual,
+  digestJson,
+  sha256,
+} from "./canonical-json.mjs";
+import {
+  SCHEMA_VERSION,
+  assertContract,
+  validateIdentityBinding,
+} from "./contracts.mjs";
+
+const THREAD_KEYS = new Set([
+  "threadid",
+  "sessionid",
+  "codexthreadid",
+  "codexsessionid",
+  "openaithreadid",
+  "openaisessionid",
+]);
+const TURN_KEYS = new Set([
+  "turnid",
+  "codexturnid",
+  "openaiturnid",
+]);
+const AGENT_KEYS = new Set([
+  "agentid",
+  "codexagentid",
+  "openaiagentid",
+]);
+const TRUSTED_HOST_METADATA_FIELDS = new Map([
+  ["params.threadId", "thread"],
+  ["params.x-codex-turn-metadata.session_id", "thread"],
+  ["params.x-codex-turn-metadata.thread_id", "thread"],
+  ["params.x-codex-turn-metadata.parent_thread_id", "thread"],
+  ["params.x-codex-turn-metadata.forked_from_thread_id", "thread"],
+  ["params.x-codex-turn-metadata.turn_id", "turn"],
+  ["params.x-codex-turn-metadata.agent_id", "agent"],
+]);
+const HOST_IDENTITY_PROOF = Symbol("looperators.host-identity-proof");
+
+function normalizedKey(value) {
+  return value.toLowerCase().replaceAll(/[^a-z0-9]/g, "");
+}
+
+function valueType(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (Array.isArray(value)) {
+    return "array";
+  }
+  return typeof value;
+}
+
+function flattenMetadata(value, prefix = "", depth = 0, output = []) {
+  if (
+    value === null ||
+    typeof value !== "object" ||
+    Array.isArray(value) ||
+    depth > 3
+  ) {
+    return output;
+  }
+  for (const key of Object.keys(value).sort(compareCodePoints)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    const item = value[key];
+    output.push({ key: fullKey, type: valueType(item) });
+    if (item && typeof item === "object" && !Array.isArray(item)) {
+      flattenMetadata(item, fullKey, depth + 1, output);
+    }
+  }
+  return output;
+}
+
+function candidateValues(value, prefix = "", depth = 0, output = []) {
+  if (
+    value === null ||
+    typeof value !== "object" ||
+    Array.isArray(value) ||
+    depth > 3
+  ) {
+    return output;
+  }
+  for (const [key, item] of Object.entries(value)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    const kind = TRUSTED_HOST_METADATA_FIELDS.get(fullKey);
+    if (
+      kind &&
+      (typeof item === "string" || typeof item === "number")
+    ) {
+      output.push({
+        kind,
+        key: fullKey,
+        type: typeof item,
+        valueDigest: digestJson({ key: fullKey, value: String(item) }),
+      });
+    }
+    if (item && typeof item === "object" && !Array.isArray(item)) {
+      candidateValues(item, fullKey, depth + 1, output);
+    }
+  }
+  return output;
+}
+
+function identityClaimKeys(argumentsValue) {
+  if (
+    argumentsValue === null ||
+    typeof argumentsValue !== "object" ||
+    Array.isArray(argumentsValue)
+  ) {
+    return [];
+  }
+  return Object.keys(argumentsValue)
+    .filter((key) => {
+      const normalized = normalizedKey(key);
+      return (
+        [...THREAD_KEYS, ...TURN_KEYS, ...AGENT_KEYS].includes(normalized) ||
+        normalized === "fromnode"
+      );
+    })
+    .sort(compareCodePoints);
+}
+
+export function summarizeMcpIdentity(message) {
+  const metadata = {
+    ...(message?._meta && typeof message._meta === "object"
+      ? { request: message._meta }
+      : {}),
+    ...(message?.params?._meta && typeof message.params._meta === "object"
+      ? { params: message.params._meta }
+      : {}),
+  };
+  const shape = flattenMetadata(metadata);
+  const candidates = candidateValues(metadata).sort((left, right) =>
+    compareCodePoints(
+      `${left.kind}:${left.key}`,
+      `${right.kind}:${right.key}`,
+    ),
+  );
+  const kinds = new Set(candidates.map((candidate) => candidate.kind));
+  const trustedIdentityAvailable = kinds.has("thread") && kinds.has("agent");
+  const turnMetadata = message?.params?._meta?.["x-codex-turn-metadata"];
+  const threadSource =
+    typeof turnMetadata?.thread_source === "string"
+      ? turnMetadata.thread_source.slice(0, 128)
+      : undefined;
+  const summary = {
+    schemaVersion: SCHEMA_VERSION,
+    classification: trustedIdentityAvailable
+      ? "host-metadata-v1"
+      : "trusted_identity_unavailable",
+    trustedIdentityAvailable,
+    metadataShape: shape,
+    candidateFields: candidates,
+    ...(threadSource ? { contextHints: { threadSource } } : {}),
+    untrustedArgumentIdentityClaims: identityClaimKeys(
+      message?.params?.arguments,
+    ),
+  };
+  for (const candidate of summary.candidateFields) {
+    Object.freeze(candidate);
+  }
+  Object.freeze(summary.candidateFields);
+  Object.defineProperty(summary, HOST_IDENTITY_PROOF, {
+    value: digestJson({
+      schemaVersion: summary.schemaVersion,
+      classification: summary.classification,
+      trustedIdentityAvailable: summary.trustedIdentityAvailable,
+      candidateFields: summary.candidateFields,
+    }),
+    enumerable: false,
+    configurable: false,
+    writable: false,
+  });
+  Object.freeze(summary);
+  return summary;
+}
+
+export class CapabilityAlreadyIssuedError extends Error {
+  constructor() {
+    super("a capability binding already exists for this agent");
+    this.name = "CapabilityAlreadyIssuedError";
+    this.code = "CAPABILITY_ALREADY_ISSUED";
+  }
+}
+
+export class AgentNotObservedError extends Error {
+  constructor(message = "agent was not observed by a SubagentStart hook") {
+    super(message);
+    this.name = "AgentNotObservedError";
+    this.code = "AGENT_NOT_OBSERVED";
+  }
+}
+
+export async function issueRunCapability(store, input) {
+  const {
+    runId,
+    agentId,
+    rootSessionId,
+    role,
+    requestId,
+    requestDigest,
+    observationId,
+    originEventId,
+    createdAt = new Date().toISOString(),
+  } = input;
+  const state = await store.readState(runId);
+  if (state.rootSessionId !== rootSessionId) {
+    throw new AgentNotObservedError(
+      "capability root does not match the authoritative run",
+    );
+  }
+  const observed = await store.findObservedSubagentStart(
+    runId,
+    rootSessionId,
+    agentId,
+  );
+  if (!observed) {
+    throw new AgentNotObservedError();
+  }
+  try {
+    await store.readIdentityBinding(runId, agentId);
+    throw new CapabilityAlreadyIssuedError();
+  } catch (error) {
+    if (error?.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  const token = randomBytes(32).toString("base64url");
+  const binding = assertContract(
+    "identity binding",
+    {
+      schemaVersion: SCHEMA_VERSION,
+      bindingId: `binding_${sha256(
+        canonicalJson({ runId, agentId }),
+      )}`,
+      runId,
+      agentId,
+      rootSessionId,
+      method: "capability-token-v1",
+      tokenDigest: sha256(token),
+      ...(role ? { role } : {}),
+      ...(requestId ? { requestId } : {}),
+      ...(requestDigest ? { requestDigest } : {}),
+      ...(observationId ? { observationId } : {}),
+      ...(originEventId ? { originEventId } : {}),
+      createdAt,
+    },
+    validateIdentityBinding,
+  );
+  const result = await store.putIdentityBinding(runId, binding);
+  if (result.status !== "created") {
+    throw new CapabilityAlreadyIssuedError();
+  }
+  return {
+    token,
+    binding: {
+      ...binding,
+      tokenDigest: binding.tokenDigest,
+    },
+  };
+}
+
+export async function bindHostIdentity(store, input) {
+  const {
+    runId,
+    agentId,
+    rootSessionId,
+    identitySummary,
+    createdAt = new Date().toISOString(),
+  } = input;
+  if (
+    identitySummary?.classification !== "host-metadata-v1" ||
+    identitySummary?.trustedIdentityAvailable !== true ||
+    !Array.isArray(identitySummary?.candidateFields)
+  ) {
+    const error = new TypeError("trusted host metadata is unavailable");
+    error.code = "TRUSTED_IDENTITY_UNAVAILABLE";
+    throw error;
+  }
+  const candidateFields = identitySummary.candidateFields.map(
+    (candidate) => ({ ...candidate }),
+  );
+  const expectedProof = digestJson({
+    schemaVersion: identitySummary.schemaVersion,
+    classification: identitySummary.classification,
+    trustedIdentityAvailable: identitySummary.trustedIdentityAvailable,
+    candidateFields,
+  });
+  if (identitySummary[HOST_IDENTITY_PROOF] !== expectedProof) {
+    const error = new TypeError("trusted host metadata is unavailable");
+    error.code = "TRUSTED_IDENTITY_UNAVAILABLE";
+    throw error;
+  }
+  const state = await store.readState(runId);
+  if (state.rootSessionId !== rootSessionId) {
+    throw new AgentNotObservedError(
+      "host identity root does not match the authoritative run",
+    );
+  }
+  const observed = await store.findObservedSubagentStart(
+    runId,
+    rootSessionId,
+    agentId,
+  );
+  if (!observed) {
+    throw new AgentNotObservedError();
+  }
+  const agentMatches = candidateFields.some(
+    (candidate) =>
+      candidate?.kind === "agent" &&
+      candidate?.key ===
+        "params.x-codex-turn-metadata.agent_id" &&
+      candidate?.valueDigest ===
+        digestJson({
+          key: candidate.key,
+          value: String(agentId),
+        }),
+  );
+  const rootMatches = candidateFields.some(
+    (candidate) =>
+      candidate?.kind === "thread" &&
+      candidate?.valueDigest ===
+        digestJson({
+          key: candidate.key,
+          value: String(rootSessionId),
+        }),
+  );
+  if (!agentMatches || !rootMatches) {
+    const error = new TypeError(
+      "host identity metadata does not match the observed agent lineage",
+    );
+    error.code = "HOST_IDENTITY_MISMATCH";
+    throw error;
+  }
+  const binding = assertContract(
+    "identity binding",
+    {
+      schemaVersion: SCHEMA_VERSION,
+      bindingId: `binding_${sha256(
+        canonicalJson({ runId, agentId }),
+      )}`,
+      runId,
+      agentId,
+      rootSessionId,
+      method: "host-metadata-v1",
+      hostIdentityDigest: digestJson(candidateFields),
+      createdAt,
+    },
+    validateIdentityBinding,
+  );
+  const result = await store.putIdentityBinding(runId, binding);
+  if (result.status === "conflict") {
+    const error = new TypeError("host identity binding conflicts");
+    error.code = "IDENTITY_BINDING_CONFLICT";
+    throw error;
+  }
+  return binding;
+}
+
+export async function verifyRunCapability(store, input) {
+  const { runId, agentId, token } = input;
+  if (typeof token !== "string" || token.length < 32) {
+    return false;
+  }
+  let binding;
+  let state;
+  try {
+    [binding, state] = await Promise.all([
+      store.readIdentityBinding(runId, agentId),
+      store.readState(runId),
+    ]);
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+  if (
+    binding.runId !== runId ||
+    state.runId !== runId ||
+    binding.rootSessionId !== state.rootSessionId ||
+    binding.method !== "capability-token-v1" ||
+    binding.revokedAt !== undefined
+  ) {
+    return false;
+  }
+  return digestEqual(binding.tokenDigest, sha256(token));
+}
diff --git a/plugins/looperators-agent-loop/lib/privacy-scan.mjs b/plugins/looperators-agent-loop/lib/privacy-scan.mjs
new file mode 100644
index 0000000..0f51437
--- /dev/null
+++ b/plugins/looperators-agent-loop/lib/privacy-scan.mjs
@@ -0,0 +1,74 @@
+const CAPABILITY_SHAPE = /^[A-Za-z0-9_-]{43}$/;
+const ACCEPTANCE_PROMPT_FRAGMENTS = Object.freeze([
+  "Run the disposable looperators P1-E release-candidate acceptance",
+  "P1E_ROOT_STOP_PROBE",
+]);
+
+function secretBearingField(name) {
+  if (typeof name !== "string") {
+    return false;
+  }
+  const normalized = name.toLowerCase();
+  if (
+    normalized.includes("digest") ||
+    normalized.includes("hash")
+  ) {
+    return false;
+  }
+  return (
+    normalized === "capability" ||
+    normalized === "capabilitytoken" ||
+    normalized === "token" ||
+    normalized.endsWith("token") ||
+    normalized.includes("secret") ||
+    normalized.includes("credential")
+  );
+}
+
+export function createPrivacyScanResult() {
+  return {
+    jsonFiles: 0,
+    plaintextCapabilityFields: 0,
+    plaintextCapabilityCandidates: 0,
+    rawAcceptancePromptFragments: 0,
+  };
+}
+
+export function scanPrivacyValue(
+  value,
+  result,
+  fieldName = undefined,
+) {
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      scanPrivacyValue(item, result, fieldName);
+    }
+    return result;
+  }
+  if (value && typeof value === "object") {
+    for (const [key, item] of Object.entries(value)) {
+      if (secretBearingField(key)) {
+        result.plaintextCapabilityFields += 1;
+      }
+      scanPrivacyValue(item, result, key);
+    }
+    return result;
+  }
+  if (typeof value !== "string") {
+    return result;
+  }
+  if (
+    secretBearingField(fieldName) &&
+    CAPABILITY_SHAPE.test(value)
+  ) {
+    result.plaintextCapabilityCandidates += 1;
+  }
+  if (
+    ACCEPTANCE_PROMPT_FRAGMENTS.some((fragment) =>
+      value.includes(fragment),
+    )
+  ) {
+    result.rawAcceptancePromptFragments += 1;
+  }
+  return result;
+}
diff --git a/plugins/looperators-agent-loop/lib/projection-to-graph-model.d.mts b/plugins/looperators-agent-loop/lib/projection-to-graph-model.d.mts
new file mode 100644
index 0000000..4faafd0
--- /dev/null
+++ b/plugins/looperators-agent-loop/lib/projection-to-graph-model.d.mts
@@ -0,0 +1,9 @@
+import type { AgentGraphModel } from "@looperators/agent-graph-ui";
+
+export function projectionToAgentGraphModel(
+  value: unknown,
+  options?: {
+    expectedProjectionDigest?: string;
+    expectedRunId?: string;
+  },
+): AgentGraphModel;
diff --git a/plugins/looperators-agent-loop/lib/projection-to-graph-model.mjs b/plugins/looperators-agent-loop/lib/projection-to-graph-model.mjs
new file mode 100644
index 0000000..87b09d5
--- /dev/null
+++ b/plugins/looperators-agent-loop/lib/projection-to-graph-model.mjs
@@ -0,0 +1,430 @@
+const STATUSES = new Set([
+  "draft",
+  "running",
+  "paused",
+  "interrupted",
+  "succeeded",
+  "capped",
+  "cancelled",
+  "failed",
+]);
+const NODE_STATES = new Set([
+  "active",
+  "waiting",
+  "bound",
+  "unbound",
+  "terminal",
+]);
+const TIMELINE_KINDS = new Set([
+  "event",
+  "report",
+  "transition",
+  "governor-decision",
+  "recovery",
+]);
+const DIGEST = /^[a-f0-9]{64}$/u;
+const NODE_DEFINITIONS = [
+  {
+    id: "root",
+    kind: "root",
+    role: "root",
+  },
+  {
+    id: "role:implementer",
+    kind: "worker-role",
+    role: "implementer",
+  },
+  {
+    id: "role:reviewer",
+    kind: "worker-role",
+    role: "reviewer",
+  },
+];
+const EDGE_DEFINITIONS = [
+  {
+    id: "root-governs-implementer",
+    source: "root",
+    target: "role:implementer",
+    kind: "governs",
+  },
+  {
+    id: "implementer-handoff-reviewer",
+    source: "role:implementer",
+    target: "role:reviewer",
+    kind: "handoff",
+  },
+  {
+    id: "reviewer-feedback-implementer",
+    source: "role:reviewer",
+    target: "role:implementer",
+    kind: "feedback",
+  },
+  {
+    id: "reviewer-verdict-root",
+    source: "role:reviewer",
+    target: "root",
+    kind: "verdict",
+  },
+];
+
+function projectionError(code, message) {
+  return Object.assign(new TypeError(message), { code });
+}
+
+function invalid(message) {
+  throw projectionError(
+    "GRAPH_VIEW_PROJECTION_INVALID",
+    message,
+  );
+}
+
+function isRecord(value) {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    !Array.isArray(value)
+  );
+}
+
+function boundedString(value, path, max = 256) {
+  if (
+    typeof value !== "string" ||
+    value.length === 0 ||
+    value.length > max
+  ) {
+    invalid(`${path} must be a bounded string`);
+  }
+  return value;
+}
+
+function optionalString(value, path, max = 256) {
+  return value === undefined
+    ? undefined
+    : boundedString(value, path, max);
+}
+
+function boundedInteger(
+  value,
+  path,
+  { min = 0, max = Number.MAX_SAFE_INTEGER } = {},
+) {
+  if (
+    !Number.isSafeInteger(value) ||
+    value < min ||
+    value > max
+  ) {
+    invalid(`${path} must be a bounded integer`);
+  }
+  return value;
+}
+
+function requireBoolean(value, path) {
+  if (typeof value !== "boolean") {
+    invalid(`${path} must be a boolean`);
+  }
+  return value;
+}
+
+function assertProjectionEnvelope(value, options) {
+  if (!isRecord(value)) {
+    invalid("projection must be an object");
+  }
+  if (
+    value.schemaVersion !== 1 ||
+    value.storeVersion !== 1 ||
+    value.projectionVersion !== 3 ||
+    value.recipe !== "review-until-clean"
+  ) {
+    invalid("projection version or recipe is unsupported");
+  }
+  const runId = boundedString(value.runId, "projection.runId", 128);
+  const revision = boundedInteger(
+    value.revision,
+    "projection.revision",
+  );
+  if (
+    !isRecord(value.integrity) ||
+    value.integrity.status !== "verified" ||
+    value.integrity.verifiedRevision !== revision
+  ) {
+    throw projectionError(
+      "GRAPH_VIEW_PROJECTION_UNVERIFIED",
+      "projection integrity is not verified",
+    );
+  }
+  if (
+    typeof value.projectionDigest !== "string" ||
+    !DIGEST.test(value.projectionDigest)
+  ) {
+    invalid("projection.projectionDigest is invalid");
+  }
+  if (
+    options.expectedProjectionDigest !== undefined &&
+    value.projectionDigest !== options.expectedProjectionDigest
+  ) {
+    throw projectionError(
+      "PROJECTION_DIGEST_MISMATCH",
+      "projection digest does not match the expected snapshot",
+    );
+  }
+  if (
+    options.expectedRunId !== undefined &&
+    runId !== options.expectedRunId
+  ) {
+    throw projectionError(
+      "SNAPSHOT_IDENTITY_MISMATCH",
+      "projection belongs to another run",
+    );
+  }
+  return {
+    runId,
+    revision,
+    projectionDigest: value.projectionDigest,
+  };
+}
+
+function mapNodes(value) {
+  if (!Array.isArray(value) || value.length !== NODE_DEFINITIONS.length) {
+    invalid("projection.nodes must contain exactly three nodes");
+  }
+  const byId = new Map(value.map((node) => [node?.id, node]));
+  return NODE_DEFINITIONS.map((definition) => {
+    const node = byId.get(definition.id);
+    if (
+      !isRecord(node) ||
+      node.kind !== definition.kind ||
+      (definition.role !== "root" && node.role !== definition.role) ||
+      !NODE_STATES.has(node.state)
+    ) {
+      invalid(`projection node ${definition.id} is invalid`);
+    }
+    const nativeAgentId = optionalString(
+      node.nativeAgentId,
+      `projection node ${definition.id}.nativeAgentId`,
+      256,
+    );
+    const nativeAgentType = optionalString(
+      node.nativeAgentType,
+      `projection node ${definition.id}.nativeAgentType`,
+      128,
+    );
+    return {
+      id: definition.id,
+      kind: definition.kind,
+      role: definition.role,
+      label: boundedString(
+        node.label,
+        `projection node ${definition.id}.label`,
+        80,
+      ),
+      state: node.state,
+      ...(nativeAgentId ? { nativeAgentId } : {}),
+      ...(nativeAgentType ? { nativeAgentType } : {}),
+    };
+  });
+}
+
+function mapEdges(value) {
+  if (!Array.isArray(value) || value.length !== EDGE_DEFINITIONS.length) {
+    invalid("projection.edges must contain exactly four relationships");
+  }
+  const byId = new Map(value.map((edge) => [edge?.id, edge]));
+  return EDGE_DEFINITIONS.map((definition) => {
+    const edge = byId.get(definition.id);
+    if (
+      !isRecord(edge) ||
+      edge.source !== definition.source ||
+      edge.target !== definition.target ||
+      edge.kind !== definition.kind
+    ) {
+      invalid(`projection edge ${definition.id} is invalid`);
+    }
+    return {
+      ...definition,
+      active: requireBoolean(
+        edge.active,
+        `projection edge ${definition.id}.active`,
+      ),
+      reportCount: boundedInteger(
+        edge.reportCount,
+        `projection edge ${definition.id}.reportCount`,
+      ),
+    };
+  });
+}
+
+function mapPending(value, lapCap) {
+  if (value === undefined) {
+    return undefined;
+  }
+  if (
+    !isRecord(value) ||
+    !["implementer", "reviewer"].includes(value.role) ||
+    value.kind !== `activate-${value.role}`
+  ) {
+    invalid("projection.pending is invalid");
+  }
+  boundedString(
+    value.transitionId,
+    "projection.pending.transitionId",
+    128,
+  );
+  return {
+    role: value.role,
+    kind: value.kind,
+    lap: boundedInteger(value.lap, "projection.pending.lap", {
+      max: lapCap,
+    }),
+  };
+}
+
+function mapLatestReport(value) {
+  if (value === undefined) {
+    return undefined;
+  }
+  if (
+    !isRecord(value) ||
+    !["implementer", "reviewer"].includes(value.fromRole) ||
+    !["info", "verdict"].includes(value.type)
+  ) {
+    invalid("projection.latestReport is invalid");
+  }
+  boundedString(
+    value.reportId,
+    "projection.latestReport.reportId",
+    128,
+  );
+  if (
+    value.verdict !== undefined &&
+    !["issues", "clean"].includes(value.verdict)
+  ) {
+    invalid("projection.latestReport.verdict is invalid");
+  }
+  return {
+    fromRole: value.fromRole,
+    type: value.type,
+    ...(value.verdict ? { verdict: value.verdict } : {}),
+    issueCount: boundedInteger(
+      value.issueCount,
+      "projection.latestReport.issueCount",
+    ),
+  };
+}
+
+function mapTimeline(value) {
+  if (!Array.isArray(value) || value.length > 32) {
+    invalid("projection.timeline is invalid");
+  }
+  return value.map((item, index) => {
+    if (!isRecord(item) || !TIMELINE_KINDS.has(item.kind)) {
+      invalid(`projection.timeline[${index}] is invalid`);
+    }
+    const role = optionalString(
+      item.role,
+      `projection.timeline[${index}].role`,
+      16,
+    );
+    if (
+      role !== undefined &&
+      !["implementer", "reviewer"].includes(role)
+    ) {
+      invalid(`projection.timeline[${index}].role is invalid`);
+    }
+    return {
+      id: boundedString(
+        item.id,
+        `projection.timeline[${index}].id`,
+        128,
+      ),
+      at: boundedString(
+        item.at,
+        `projection.timeline[${index}].at`,
+        40,
+      ),
+      label: boundedString(
+        item.label,
+        `projection.timeline[${index}].label`,
+        128,
+      ),
+      kind: item.kind,
+      ...(role ? { role } : {}),
+    };
+  });
+}
+
+export function projectionToAgentGraphModel(
+  value,
+  options = {},
+) {
+  const identity = assertProjectionEnvelope(value, options);
+  if (!STATUSES.has(value.status)) {
+    invalid("projection.status is invalid");
+  }
+  const lapCap = boundedInteger(
+    value.lapCap,
+    "projection.lapCap",
+    { min: 1, max: 6 },
+  );
+  const currentLap = boundedInteger(
+    value.currentLap,
+    "projection.currentLap",
+    { max: lapCap },
+  );
+  if (!isRecord(value.continuationLease)) {
+    invalid("projection.continuationLease must be an object");
+  }
+  const granted = boundedInteger(
+    value.continuationLease.granted,
+    "projection.continuationLease.granted",
+    { max: 6 },
+  );
+  const consumed = boundedInteger(
+    value.continuationLease.consumed,
+    "projection.continuationLease.consumed",
+    { max: granted },
+  );
+  const pending = mapPending(value.pending, lapCap);
+  const latestReport = mapLatestReport(value.latestReport);
+  let recovery;
+  if (value.recovery !== undefined) {
+    if (!isRecord(value.recovery)) {
+      invalid("projection.recovery is invalid");
+    }
+    boundedString(
+      value.recovery.recoveryId,
+      "projection.recovery.recoveryId",
+      128,
+    );
+    recovery = {
+      reason: boundedString(
+        value.recovery.reason,
+        "projection.recovery.reason",
+        80,
+      ),
+    };
+  }
+  return {
+    identity: {
+      ...identity,
+      integrity: "verified",
+    },
+    status: value.status,
+    currentLap,
+    lapCap,
+    lease: { granted, consumed },
+    cancelRequested: requireBoolean(
+      value.cancelRequested,
+      "projection.cancelRequested",
+    ),
+    needsHuman: requireBoolean(
+      value.needsHuman,
+      "projection.needsHuman",
+    ),
+    nodes: mapNodes(value.nodes),
+    edges: mapEdges(value.edges),
+    ...(pending ? { pending } : {}),
+    ...(latestReport ? { latestReport } : {}),
+    ...(recovery ? { recovery } : {}),
+    timeline: mapTimeline(value.timeline),
+  };
+}
diff --git a/plugins/looperators-agent-loop/lib/projection.mjs b/plugins/looperators-agent-loop/lib/projection.mjs
new file mode 100644
index 0000000..913f98c
--- /dev/null
+++ b/plugins/looperators-agent-loop/lib/projection.mjs
@@ -0,0 +1,571 @@
+import {
+  canonicalJson,
+  compareCodePoints,
+  digestJson,
+} from "./canonical-json.mjs";
+import {
+  PROJECTION_VERSION,
+  SCHEMA_VERSION,
+  STORE_VERSION,
+  assertContract,
+  validateGraphProjection,
+} from "./contracts.mjs";
+
+export const MAX_PROJECTION_BYTES = 512 * 1024;
+export const MAX_PROJECTION_TIMELINE = 32;
+
+const TERMINAL_STATUSES = new Set([
+  "succeeded",
+  "capped",
+  "cancelled",
+  "failed",
+]);
+
+function projectionError(code, message) {
+  const error = new TypeError(message);
+  error.code = code;
+  return error;
+}
+
+function roleForTransition(transition) {
+  if (transition.kind === "activate-implementer") {
+    return "implementer";
+  }
+  if (transition.kind === "activate-reviewer") {
+    return "reviewer";
+  }
+  return undefined;
+}
+
+function factOrder(left, right) {
+  const timeOrder = compareCodePoints(left.at, right.at);
+  if (timeOrder !== 0) {
+    return timeOrder;
+  }
+  const kindOrder = compareCodePoints(left.kind, right.kind);
+  return kindOrder !== 0
+    ? kindOrder
+    : compareCodePoints(left.id, right.id);
+}
+
+function canonicalizeEvents(events) {
+  const groups = new Map();
+  for (const event of events) {
+    const key = event.conflictEligible
+      ? event.semanticKey
+      : `${event.semanticKey}:${event.eventId}`;
+    const values = groups.get(key) ?? [];
+    values.push(event);
+    groups.set(key, values);
+  }
+  const canonical = [];
+  let conflicts = 0;
+  for (const values of groups.values()) {
+    const sorted = [...values].sort((left, right) =>
+      compareCodePoints(left.eventId, right.eventId),
+    );
+    canonical.push(sorted[0]);
+    if (
+      sorted[0].conflictEligible &&
+      new Set(sorted.map((event) => event.payloadDigest)).size > 1
+    ) {
+      conflicts += 1;
+    }
+  }
+  canonical.sort((left, right) =>
+    compareCodePoints(left.eventId, right.eventId),
+  );
+  return { canonical, conflicts };
+}
+
+function activeBindings(bindings, rootSessionId) {
+  const byRole = new Map();
+  const byAgentId = new Map();
+  for (const binding of bindings) {
+    if (
+      binding.method !== "capability-token-v1" ||
+      binding.rootSessionId !== rootSessionId ||
+      binding.revokedAt !== undefined ||
+      !["implementer", "reviewer"].includes(binding.role)
+    ) {
+      continue;
+    }
+    if (byRole.has(binding.role) || byAgentId.has(binding.agentId)) {
+      throw projectionError(
+        "HISTORY_CORRUPT",
+        "verified projection requires unique active worker bindings",
+      );
+    }
+    byRole.set(binding.role, binding);
+    byAgentId.set(binding.agentId, binding);
+  }
+  return { byRole, byAgentId };
+}
+
+function workerTypes(events) {
+  const byAgentId = new Map();
+  const starts = events
+    .filter(
+      (event) =>
+        event.event === "SubagentStart" &&
+        typeof event.agentId === "string",
+    )
+    .sort((left, right) => {
+      const timeOrder = compareCodePoints(
+        left.observedAt,
+        right.observedAt,
+      );
+      return timeOrder !== 0
+        ? timeOrder
+        : compareCodePoints(left.eventId, right.eventId);
+    });
+  for (const event of starts) {
+    if (event.agentType) {
+      byAgentId.set(event.agentId, event.agentType);
+    }
+  }
+  return byAgentId;
+}
+
+function nodeState(status, pendingRole, role, bound) {
+  if (TERMINAL_STATUSES.has(status)) {
+    return "terminal";
+  }
+  if (status === "running" && pendingRole === role) {
+    return "active";
+  }
+  return bound ? "bound" : "unbound";
+}
+
+function timelineEvent(event, roleByAgentId) {
+  return {
+    kind: "event",
+    id: event.eventId,
+    at: event.observedAt,
+    label: event.event,
+    ...(event.agentId && roleByAgentId.has(event.agentId)
+      ? { role: roleByAgentId.get(event.agentId).role }
+      : {}),
+  };
+}
+
+function timelineReport(report, role) {
+  const suffix =
+    report.type === "verdict"
+      ? `: ${report.verdict}`
+      : report.status
+        ? `: ${report.status}`
+        : "";
+  return {
+    kind: "report",
+    id: report.reportId,
+    at: report.createdAt,
+    label: `${role} ${report.type}${suffix}`,
+    role,
+  };
+}
+
+function timelineTransition(transition) {
+  const role = roleForTransition(transition);
+  return {
+    kind: "transition",
+    id: transition.transitionId,
+    at: transition.createdAt,
+    label: transition.kind,
+    ...(role ? { role } : {}),
+  };
+}
+
+function timelineDecision(decision) {
+  return {
+    kind: "governor-decision",
+    id: decision.decisionId,
+    at: decision.createdAt,
+    label: `${decision.action}: ${decision.reasonCode}`,
+  };
+}
+
+function timelineRecovery(recovery) {
+  return {
+    kind: "recovery",
+    id: recovery.recoveryId,
+    at: recovery.createdAt,
+    label: "legacy history quarantined",
+  };
+}
+
+function checkedRole(bindingByAgentId, agentId, factKind) {
+  const binding = bindingByAgentId.get(agentId);
+  if (!binding) {
+    throw projectionError(
+      "HISTORY_CORRUPT",
+      `verified ${factKind} lacks an active worker role binding`,
+    );
+  }
+  return binding.role;
+}
+
+export function assertGraphProjectionIntegrity(value) {
+  assertContract(
+    "graph projection",
+    value,
+    validateGraphProjection,
+  );
+  const { projectionDigest, ...base } = value;
+  if (projectionDigest !== digestJson(base)) {
+    throw projectionError(
+      "PROJECTION_DIGEST_MISMATCH",
+      "graph projection digest is invalid",
+    );
+  }
+  const bytes = Buffer.byteLength(canonicalJson(value), "utf8");
+  if (bytes > MAX_PROJECTION_BYTES) {
+    throw projectionError(
+      "PROJECTION_TOO_LARGE",
+      "graph projection exceeds its canonical payload bound",
+    );
+  }
+  return value;
+}
+
+export function canonicalProjectionBytes(value) {
+  return canonicalJson(assertGraphProjectionIntegrity(value));
+}
+
+export function snapshotIdentity(value) {
+  const projection = assertGraphProjectionIntegrity(value);
+  return {
+    runId: projection.runId,
+    revision: projection.revision,
+    eventWatermark: projection.eventWatermark,
+  };
+}
+
+export function buildAgentLoopProjection(input) {
+  const {
+    state,
+    definition,
+    bindings = [],
+    events = [],
+    reports = [],
+    transitions = [],
+    operations = [],
+    governorDecisions = [],
+    recoveries = [],
+    diagnostics = [],
+    timelineLimit = MAX_PROJECTION_TIMELINE,
+  } = input;
+  if (
+    !Number.isInteger(timelineLimit) ||
+    timelineLimit < 0 ||
+    timelineLimit > MAX_PROJECTION_TIMELINE
+  ) {
+    throw projectionError(
+      "INVALID_PROJECTION_LIMIT",
+      "projection timeline limit is invalid",
+    );
+  }
+
+  const { canonical: canonicalEvents, conflicts } =
+    canonicalizeEvents(events);
+  const appliedOperations = operations
+    .filter((operation) => operation.toRevision <= state.revision)
+    .sort(
+      (left, right) =>
+        left.toRevision - right.toRevision ||
+        compareCodePoints(left.operationId, right.operationId),
+    );
+  const appliedDecisions = governorDecisions
+    .filter((decision) => decision.toRevision <= state.revision)
+    .sort(
+      (left, right) =>
+        left.toRevision - right.toRevision ||
+        compareCodePoints(left.decisionId, right.decisionId),
+    );
+  const appliedRecoveries = recoveries
+    .filter(
+      (recovery) =>
+        recovery.toRevision <= state.revision,
+    )
+    .sort(
+      (left, right) =>
+        left.toRevision - right.toRevision ||
+        compareCodePoints(
+          left.recoveryId,
+          right.recoveryId,
+        ),
+    );
+  if (
+    appliedRecoveries.length > 1 ||
+    state.latestRecoveryId !==
+      appliedRecoveries.at(-1)?.recoveryId
+  ) {
+    throw projectionError(
+      "HISTORY_CORRUPT",
+      "verified projection has an invalid recovery receipt set",
+    );
+  }
+  const appliedReportIds = new Set(
+    appliedOperations.map((operation) => operation.reportId).filter(Boolean),
+  );
+  const appliedTransitionIds = new Set(
+    appliedOperations.map((operation) => operation.transitionId),
+  );
+  const appliedReports = reports
+    .filter((report) => appliedReportIds.has(report.reportId))
+    .sort((left, right) =>
+      compareCodePoints(left.reportId, right.reportId),
+    );
+  const appliedTransitions = transitions
+    .filter((transition) =>
+      appliedTransitionIds.has(transition.transitionId),
+    )
+    .sort((left, right) =>
+      compareCodePoints(left.transitionId, right.transitionId),
+    );
+
+  if (
+    appliedReportIds.size !== appliedReports.length ||
+    appliedTransitionIds.size !== appliedTransitions.length
+  ) {
+    throw projectionError(
+      "HISTORY_CORRUPT",
+      "verified receipt history references missing graph facts",
+    );
+  }
+
+  const bindingIndex = activeBindings(
+    bindings,
+    state.rootSessionId,
+  );
+  const roleByAgentId = bindingIndex.byAgentId;
+  const pendingTransition = state.pendingTransitionId
+    ? appliedTransitions.find(
+        (transition) =>
+          transition.transitionId === state.pendingTransitionId,
+      )
+    : undefined;
+  const pendingRole = pendingTransition
+    ? roleForTransition(pendingTransition)
+    : undefined;
+  if (state.pendingTransitionId && !pendingRole) {
+    throw projectionError(
+      "HISTORY_CORRUPT",
+      "verified pending transition is not a worker obligation",
+    );
+  }
+
+  const nativeTypes = workerTypes(canonicalEvents);
+  const nodes = [
+    {
+      id: "root",
+      kind: "root",
+      label: "Governor",
+      state: TERMINAL_STATUSES.has(state.status)
+        ? "terminal"
+        : ["paused", "interrupted"].includes(state.status)
+          ? "waiting"
+          : "active",
+    },
+    ...["implementer", "reviewer"].map((role) => {
+      const binding = bindingIndex.byRole.get(role);
+      const nativeBinding =
+        binding && !binding.agentId.startsWith("role:")
+          ? binding
+          : undefined;
+      return {
+        id: `role:${role}`,
+        kind: "worker-role",
+        role,
+        label: role === "implementer" ? "Implementer" : "Reviewer",
+        state: nodeState(
+          state.status,
+          pendingRole,
+          role,
+          Boolean(binding),
+        ),
+        ...(nativeBinding
+          ? {
+              nativeAgentId: nativeBinding.agentId,
+              ...(nativeTypes.has(nativeBinding.agentId)
+                ? {
+                    nativeAgentType:
+                      nativeTypes.get(nativeBinding.agentId),
+                  }
+                : {}),
+            }
+          : {}),
+      };
+    }),
+  ];
+
+  const reportRoles = new Map(
+    appliedReports.map((report) => [
+      report.reportId,
+      checkedRole(
+        roleByAgentId,
+        report.fromNode,
+        "report",
+      ),
+    ]),
+  );
+  const implementerReports = appliedReports.filter(
+    (report) => reportRoles.get(report.reportId) === "implementer",
+  );
+  const reviewerIssueReports = appliedReports.filter(
+    (report) =>
+      reportRoles.get(report.reportId) === "reviewer" &&
+      report.verdict === "issues",
+  );
+  const reviewerCleanReports = appliedReports.filter(
+    (report) =>
+      reportRoles.get(report.reportId) === "reviewer" &&
+      report.verdict === "clean",
+  );
+  const edges = [
+    {
+      id: "root-governs-implementer",
+      source: "root",
+      target: "role:implementer",
+      kind: "governs",
+      active: state.status === "running" && pendingRole === "implementer",
+      reportCount: 0,
+    },
+    {
+      id: "implementer-handoff-reviewer",
+      source: "role:implementer",
+      target: "role:reviewer",
+      kind: "handoff",
+      active: state.status === "running" && pendingRole === "reviewer",
+      reportCount: implementerReports.length,
+    },
+    {
+      id: "reviewer-feedback-implementer",
+      source: "role:reviewer",
+      target: "role:implementer",
+      kind: "feedback",
+      active:
+        state.status === "running" &&
+        pendingRole === "implementer" &&
+        reviewerIssueReports.length > 0,
+      reportCount: reviewerIssueReports.length,
+    },
+    {
+      id: "reviewer-verdict-root",
+      source: "role:reviewer",
+      target: "root",
+      kind: "verdict",
+      active:
+        state.status === "succeeded" &&
+        reviewerCleanReports.length > 0,
+      reportCount: reviewerCleanReports.length,
+    },
+  ];
+
+  const latestReport = state.latestReportId
+    ? appliedReports.find(
+        (report) => report.reportId === state.latestReportId,
+      )
+    : undefined;
+  if (state.latestReportId && !latestReport) {
+    throw projectionError(
+      "HISTORY_CORRUPT",
+      "verified latest report is missing from applied receipts",
+    );
+  }
+
+  const timeline = [
+    ...canonicalEvents.map((event) =>
+      timelineEvent(event, roleByAgentId),
+    ),
+    ...appliedReports.map((report) =>
+      timelineReport(
+        report,
+        reportRoles.get(report.reportId),
+      ),
+    ),
+    ...appliedTransitions.map(timelineTransition),
+    ...appliedDecisions.map(timelineDecision),
+    ...appliedRecoveries.map(timelineRecovery),
+  ]
+    .sort(factOrder)
+    .slice(-timelineLimit);
+  const sortedEventIds = [
+    ...new Set(events.map((event) => event.eventId)),
+  ].sort(compareCodePoints);
+  const eventWatermark = {
+    eventCount: sortedEventIds.length,
+    ...(sortedEventIds.length > 0
+      ? { lastEventId: sortedEventIds.at(-1) }
+      : {}),
+  };
+  const base = {
+    schemaVersion: SCHEMA_VERSION,
+    storeVersion: STORE_VERSION,
+    projectionVersion: PROJECTION_VERSION,
+    runId: state.runId,
+    revision: state.revision,
+    status: state.status,
+    recipe: state.recipe,
+    currentLap: state.currentLap,
+    lapCap: definition.lapCap,
+    continuationLease: state.continuationLease,
+    cancelRequested: state.cancelRequested,
+    needsHuman: state.needsHuman ?? false,
+    integrity: {
+      status: "verified",
+      verifiedRevision: state.revision,
+    },
+    eventWatermark,
+    nodes,
+    edges,
+    ...(pendingTransition
+      ? {
+          pending: {
+            transitionId: pendingTransition.transitionId,
+            kind: pendingTransition.kind,
+            role: pendingRole,
+            lap: pendingTransition.lap,
+          },
+        }
+      : {}),
+    ...(latestReport
+      ? {
+          latestReport: {
+            reportId: latestReport.reportId,
+            fromRole: reportRoles.get(latestReport.reportId),
+            type: latestReport.type,
+            ...(latestReport.verdict
+              ? { verdict: latestReport.verdict }
+              : {}),
+            issueCount: latestReport.issues?.length ?? 0,
+          },
+        }
+      : {}),
+    ...(appliedRecoveries.length === 1
+      ? {
+          recovery: {
+            recoveryId:
+              appliedRecoveries[0].recoveryId,
+            reason: "legacy-history-quarantined",
+          },
+        }
+      : {}),
+    counts: {
+      events: canonicalEvents.length,
+      reports: appliedReports.length,
+      transitions: appliedTransitions.length,
+      operations: appliedOperations.length,
+      governorDecisions: appliedDecisions.length,
+      recoveries: appliedRecoveries.length,
+      diagnostics: diagnostics.length,
+      conflicts,
+      corrupt: 0,
+    },
+    timeline,
+  };
+  return assertGraphProjectionIntegrity({
+    ...base,
+    projectionDigest: digestJson(base),
+  });
+}
diff --git a/plugins/looperators-agent-loop/lib/recovery.mjs b/plugins/looperators-agent-loop/lib/recovery.mjs
new file mode 100644
index 0000000..d5cb2e6
--- /dev/null
+++ b/plugins/looperators-agent-loop/lib/recovery.mjs
@@ -0,0 +1,277 @@
+import {
+  canonicalJson,
+  compareCodePoints,
+  digestJson,
+  sha256,
+} from "./canonical-json.mjs";
+import {
+  LEGACY_EVIDENCE_VERSION,
+  LEGACY_RECOVERY_VERSION,
+  MAX_LEGACY_NATIVE_TARGET_FACTS,
+  SCHEMA_VERSION,
+  assertContract,
+  validateLegacyNativeTargetEvidence,
+  validateLegacyQuarantineReceipt,
+} from "./contracts.mjs";
+
+export const LEGACY_RECOVERY_REASON =
+  "unsupported-native-target-history";
+export const PROJECTION_RECOVERY_REASON =
+  "legacy-history-quarantined";
+
+function derivedId(prefix, value) {
+  return `${prefix}_${sha256(canonicalJson(value))}`;
+}
+
+export function recoveryIdFor(runId, requestId) {
+  return derivedId("recovery", {
+    runId,
+    requestId,
+    reason: LEGACY_RECOVERY_REASON,
+  });
+}
+
+export function recoveryRequestDigest(input) {
+  return digestJson({
+    schemaVersion: SCHEMA_VERSION,
+    kind: "legacy-quarantine",
+    runId: input.runId,
+    requestId: input.requestId,
+    actorKind: "root",
+    actorId: input.actorId,
+    expectedRevision: input.expectedRevision,
+    expectedEvidenceDigest: input.expectedEvidenceDigest,
+  });
+}
+
+export function legacyEntryKey(entry) {
+  return `${entry.factKind}:${entry.factId}:${entry.field}`;
+}
+
+function transitionRole(transition) {
+  if (transition?.kind === "activate-implementer") {
+    return "implementer";
+  }
+  if (transition?.kind === "activate-reviewer") {
+    return "reviewer";
+  }
+  return null;
+}
+
+function sortedFacts(values, idField) {
+  return [...values]
+    .map((value) => ({
+      id: value[idField],
+      digest: digestJson(value),
+    }))
+    .sort((left, right) =>
+      compareCodePoints(left.id, right.id),
+    );
+}
+
+function activeBindingByRole(state, bindings) {
+  const byRole = new Map();
+  for (const binding of bindings) {
+    if (
+      binding.rootSessionId !== state.rootSessionId ||
+      binding.method !== "capability-token-v1" ||
+      binding.revokedAt !== undefined ||
+      !["implementer", "reviewer"].includes(binding.role) ||
+      binding.agentId === `role:${binding.role}`
+    ) {
+      continue;
+    }
+    if (byRole.has(binding.role)) {
+      const error = new TypeError(
+        "legacy evidence requires one authoritative binding per role",
+      );
+      error.code = "RECOVERY_REQUIRED";
+      throw error;
+    }
+    byRole.set(binding.role, binding);
+  }
+  return byRole;
+}
+
+export function collectLegacyNativeTargetEntries(input) {
+  const {
+    state,
+    operations,
+    transitions,
+    reports,
+    bindings,
+  } = input;
+  const byRole = activeBindingByRole(state, bindings);
+  const transitionById = new Map(
+    transitions.map((value) => [
+      value.transitionId,
+      value,
+    ]),
+  );
+  const reportById = new Map(
+    reports.map((value) => [value.reportId, value]),
+  );
+  const entries = [];
+  for (const operation of operations) {
+    if (operation.toRevision > state.revision) {
+      continue;
+    }
+    const transition = transitionById.get(
+      operation.transitionId,
+    );
+    const role = transitionRole(transition);
+    const binding = role ? byRole.get(role) : null;
+    if (!transition || !role || !binding) {
+      continue;
+    }
+    if (transition.toNode === binding.agentId) {
+      entries.push({
+        factKind: "transition",
+        factId: transition.transitionId,
+        factDigest: digestJson(transition),
+        field: "toNode",
+        role,
+        bindingId: binding.bindingId,
+        bindingDigest: digestJson(binding),
+      });
+    }
+    const report = operation.reportId
+      ? reportById.get(operation.reportId)
+      : null;
+    if (report?.routedToNode === binding.agentId) {
+      entries.push({
+        factKind: "report",
+        factId: report.reportId,
+        factDigest: digestJson(report),
+        field: "routedToNode",
+        role,
+        bindingId: binding.bindingId,
+        bindingDigest: digestJson(binding),
+      });
+    }
+  }
+  entries.sort((left, right) =>
+    compareCodePoints(
+      legacyEntryKey(left),
+      legacyEntryKey(right),
+    ),
+  );
+  if (entries.length > MAX_LEGACY_NATIVE_TARGET_FACTS) {
+    const error = new TypeError(
+      "legacy native-target evidence exceeds its compatibility bound",
+    );
+    error.code = "LEGACY_RECOVERY_LIMIT";
+    throw error;
+  }
+  return entries;
+}
+
+export function buildLegacyNativeTargetEvidence(input) {
+  const entries =
+    input.entries ??
+    collectLegacyNativeTargetEntries(input);
+  if (entries.length === 0) {
+    return null;
+  }
+  const base = {
+    schemaVersion: SCHEMA_VERSION,
+    evidenceVersion: LEGACY_EVIDENCE_VERSION,
+    runId: input.state.runId,
+    stateRevision: input.state.revision,
+    historyDigest: digestJson({
+      runId: input.state.runId,
+      stateDigest: digestJson(input.state),
+      definition: {
+        id: input.definition.definitionId,
+        digest: digestJson(input.definition),
+      },
+      operations: sortedFacts(
+        input.operations,
+        "operationId",
+      ),
+      governorDecisions: sortedFacts(
+        input.governorDecisions,
+        "decisionId",
+      ),
+      transitions: sortedFacts(
+        input.transitions,
+        "transitionId",
+      ),
+      reports: sortedFacts(input.reports, "reportId"),
+      bindings: sortedFacts(input.bindings, "bindingId"),
+    }),
+    entries,
+  };
+  return assertContract(
+    "legacy native target evidence",
+    {
+      ...base,
+      evidenceDigest: digestJson(base),
+    },
+    validateLegacyNativeTargetEvidence,
+  );
+}
+
+export function legacyCompatibilityKeys(evidence) {
+  return new Set(
+    (evidence?.entries ?? []).map(legacyEntryKey),
+  );
+}
+
+export function terminalStateForRecovery(state, receipt) {
+  const {
+    pendingTransitionId: _pendingTransitionId,
+    ...withoutPending
+  } = state;
+  return {
+    ...withoutPending,
+    status: "failed",
+    needsHuman: true,
+    latestRecoveryId: receipt.recoveryId,
+    revision: receipt.toRevision,
+    updatedAt: receipt.createdAt,
+  };
+}
+
+export function createLegacyQuarantineReceipt(input) {
+  const recoveryId = recoveryIdFor(
+    input.state.runId,
+    input.requestId,
+  );
+  const common = {
+    schemaVersion: SCHEMA_VERSION,
+    recoveryVersion: LEGACY_RECOVERY_VERSION,
+    recoveryId,
+    runId: input.state.runId,
+    requestId: input.requestId,
+    requestDigest: recoveryRequestDigest({
+      runId: input.state.runId,
+      requestId: input.requestId,
+      actorId: input.actorId,
+      expectedRevision: input.state.revision,
+      expectedEvidenceDigest:
+        input.evidence.evidenceDigest,
+    }),
+    actorKind: "root",
+    actorId: input.actorId,
+    reason: LEGACY_RECOVERY_REASON,
+    evidenceDigest: input.evidence.evidenceDigest,
+    legacyFactCount: input.evidence.entries.length,
+    priorStateDigest: digestJson(input.state),
+    fromRevision: input.state.revision,
+    toRevision: input.state.revision + 1,
+    createdAt: input.createdAt,
+  };
+  const terminal = terminalStateForRecovery(input.state, {
+    ...common,
+    terminalStateDigest: "0".repeat(64),
+  });
+  return assertContract(
+    "legacy quarantine receipt",
+    {
+      ...common,
+      terminalStateDigest: digestJson(terminal),
+    },
+    validateLegacyQuarantineReceipt,
+  );
+}
diff --git a/plugins/looperators-agent-loop/lib/store.mjs b/plugins/looperators-agent-loop/lib/store.mjs
new file mode 100644
index 0000000..0820bb8
--- /dev/null
+++ b/plugins/looperators-agent-loop/lib/store.mjs
@@ -0,0 +1,2524 @@
+import { stat, unlink } from "node:fs/promises";
+import path from "node:path";
+import {
+  canonicalJson,
+  compareCodePoints,
+  digestJson,
+  sha256,
+} from "./canonical-json.mjs";
+import {
+  ACTIVE_RUN_STATUSES,
+  SCHEMA_VERSION,
+  SEMANTIC_KEY_VERSION,
+  STORE_VERSION,
+  assertContract,
+  assertSafeFileId,
+  createInterruptedRun,
+  isWorkerObservationEvent,
+  validateGovernorDecision,
+  validateIdentityBinding,
+  validateLegacyQuarantineReceipt,
+  validateLoopDefinition,
+  validateLoopOperation,
+  validateLoopReport,
+  validateLoopRun,
+  validateLoopTransition,
+  validateNormalizedHookEvent,
+  validateWorkerObservation,
+} from "./contracts.mjs";
+import { resolveDataRoot } from "./data-root.mjs";
+import {
+  atomicCreateJson,
+  atomicReplaceJson,
+  listJsonFiles,
+  readBoundedFile,
+  readJsonFile,
+  withFileLock,
+} from "./fs-utils.mjs";
+import {
+  recoveryIdFor,
+  recoveryRequestDigest,
+} from "./recovery.mjs";
+
+export const DEFAULT_RETENTION = Object.freeze({
+  definitions: 1,
+  events: 1_000,
+  operations: 1_000,
+  observations: 8,
+  reports: 250,
+  transitions: 250,
+  "governor-decisions": 250,
+  recoveries: 8,
+  diagnostics: 250,
+  terminalBytes: 8 * 1024 * 1024,
+  activeMultiplier: 4,
+  timeline: 32,
+});
+
+const TERMINAL_STATUSES = new Set([
+  "succeeded",
+  "capped",
+  "cancelled",
+  "failed",
+]);
+
+const HOOK_COLLECTION_STATUSES = new Set([
+  "running",
+  "paused",
+  "interrupted",
+]);
+
+// A burst of independent hook processes can all miss the optimistic read
+// before one of them publishes the fact. Keep the uncontended path lock-free,
+// but give the serialized retention check enough time to survive scheduler
+// pressure without dropping otherwise valid events.
+const FACT_LOCK_TIMEOUT_MS = 1_000;
+const SAFETY_RECEIPT_RESERVE = 8;
+const LEGACY_FOLD_PROJECTION_VERSION = 1;
+
+export class InvalidStateTransitionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidStateTransitionError";
+    this.code = "INVALID_STATE_TRANSITION";
+  }
+}
+
+export class StoreConflictError extends Error {
+  constructor(message, details = undefined) {
+    super(message);
+    this.name = "StoreConflictError";
+    this.code = "STORE_CONFLICT";
+    this.details = details;
+  }
+}
+
+export class RevisionConflictError extends Error {
+  constructor(expected, actual) {
+    super(`state revision mismatch: expected ${expected}, received ${actual}`);
+    this.name = "RevisionConflictError";
+    this.code = "REVISION_CONFLICT";
+    this.expected = expected;
+    this.actual = actual;
+  }
+}
+
+function factTime(kind, value) {
+  if (kind === "events") {
+    return value.observedAt;
+  }
+  return value.createdAt;
+}
+
+function factId(kind, value) {
+  if (kind === "definitions") {
+    return value.definitionId;
+  }
+  if (kind === "events") {
+    return value.eventId;
+  }
+  if (kind === "reports") {
+    return value.reportId;
+  }
+  if (kind === "transitions") {
+    return value.transitionId;
+  }
+  if (kind === "operations") {
+    return value.operationId;
+  }
+  if (kind === "governor-decisions") {
+    return value.decisionId;
+  }
+  if (kind === "recoveries") {
+    return value.recoveryId;
+  }
+  if (kind === "observations") {
+    return value.observationId;
+  }
+  return value.diagnosticId;
+}
+
+function validatorFor(kind) {
+  if (kind === "definitions") {
+    return validateLoopDefinition;
+  }
+  if (kind === "events") {
+    return validateNormalizedHookEvent;
+  }
+  if (kind === "reports") {
+    return validateLoopReport;
+  }
+  if (kind === "transitions") {
+    return validateLoopTransition;
+  }
+  if (kind === "identity") {
+    return validateIdentityBinding;
+  }
+  if (kind === "operations") {
+    return validateLoopOperation;
+  }
+  if (kind === "governor-decisions") {
+    return validateGovernorDecision;
+  }
+  if (kind === "recoveries") {
+    return validateLegacyQuarantineReceipt;
+  }
+  if (kind === "observations") {
+    return validateWorkerObservation;
+  }
+  throw new TypeError(`unsupported fact kind: ${kind}`);
+}
+
+function assertWorkerObservationIntegrity(
+  observation,
+  runId,
+  file = undefined,
+) {
+  assertContract(
+    "worker observation",
+    observation,
+    validateWorkerObservation,
+  );
+  const expectedId = `observation_${sha256(
+    canonicalJson({
+      runId,
+      requestId: observation.requestId,
+      kind: "prepare-worker-spawn",
+    }),
+  )}`;
+  const expectedDigest = digestJson({
+    spawnToolUseIds: observation.spawnToolUseIds,
+    subagentStartEventIds:
+      observation.subagentStartEventIds,
+    bindingIds: observation.bindingIds,
+  });
+  const expectedRequestDigest = digestJson({
+    schemaVersion: SCHEMA_VERSION,
+    kind: "prepare-worker-spawn",
+    runId,
+    requestId: observation.requestId,
+    rootSessionId: observation.rootSessionId,
+    role: observation.role,
+  });
+  if (
+    observation.runId !== runId ||
+    observation.observationId !== expectedId ||
+    observation.requestDigest !== expectedRequestDigest ||
+    observation.observationDigest !== expectedDigest ||
+    (file &&
+      path.basename(file) !==
+        `${observation.observationId}.json`)
+  ) {
+    const error = new TypeError(
+      "worker observation identity, digest, or location is invalid",
+    );
+    error.code = "INVALID_CONTRACT";
+    throw error;
+  }
+  return observation;
+}
+
+function assertLoopDefinitionIntegrity(
+  definition,
+  runId,
+  file = undefined,
+) {
+  assertContract(
+    "loop definition",
+    definition,
+    validateLoopDefinition,
+  );
+  const expectedId = `definition_${sha256(
+    canonicalJson({ runId, kind: "definition" }),
+  )}`;
+  if (
+    definition.runId !== runId ||
+    definition.definitionId !== expectedId ||
+    (file &&
+      path.basename(file) !==
+        `${definition.definitionId}.json`)
+  ) {
+    const error = new TypeError(
+      "loop definition identity or location is invalid",
+    );
+    error.code = "INVALID_CONTRACT";
+    throw error;
+  }
+  return definition;
+}
+
+function governorDecisionIdentity(decision) {
+  if (decision.action === "block") {
+    return {
+      runId: decision.runId,
+      obligationId: decision.obligationId,
+      kind: "continuation-block",
+    };
+  }
+  if (decision.action === "cap") {
+    return {
+      runId: decision.runId,
+      obligationId: decision.obligationId,
+      kind: "continuation-cap",
+    };
+  }
+  return {
+    runId: decision.runId,
+    sessionStartEventId: decision.originEventId,
+    stateRevision: decision.fromRevision,
+    kind: "resume-interrupt",
+  };
+}
+
+function assertGovernorDecisionIntegrity(
+  decision,
+  runId,
+  file = undefined,
+) {
+  assertContract(
+    "governor decision",
+    decision,
+    validateGovernorDecision,
+  );
+  const expectedId = `decision_${sha256(
+    canonicalJson(governorDecisionIdentity(decision)),
+  )}`;
+  if (
+    decision.runId !== runId ||
+    decision.obligationId !==
+      decision.pendingTransitionId ||
+    decision.decisionId !== expectedId ||
+    (file &&
+      path.basename(file) !== `${decision.decisionId}.json`)
+  ) {
+    const error = new TypeError(
+      "governor decision identity or location is invalid",
+    );
+    error.code = "INVALID_CONTRACT";
+    throw error;
+  }
+  return decision;
+}
+
+function assertLegacyRecoveryIntegrity(
+  recovery,
+  runId,
+  file = undefined,
+) {
+  assertContract(
+    "legacy quarantine receipt",
+    recovery,
+    validateLegacyQuarantineReceipt,
+  );
+  const expectedId = recoveryIdFor(
+    runId,
+    recovery.requestId,
+  );
+  const expectedRequestDigest = recoveryRequestDigest({
+    runId,
+    requestId: recovery.requestId,
+    actorId: recovery.actorId,
+    expectedRevision: recovery.fromRevision,
+    expectedEvidenceDigest: recovery.evidenceDigest,
+  });
+  if (
+    recovery.runId !== runId ||
+    recovery.recoveryId !== expectedId ||
+    recovery.requestDigest !== expectedRequestDigest ||
+    (file &&
+      path.basename(file) !== `${expectedId}.json`)
+  ) {
+    const error = new TypeError(
+      "legacy recovery identity, request digest, or location is invalid",
+    );
+    error.code = "INVALID_CONTRACT";
+    throw error;
+  }
+  return recovery;
+}
+
+function assertStoredEventIntegrity(event, file = undefined) {
+  assertContract(
+    "normalized hook event",
+    event,
+    validateNormalizedHookEvent,
+  );
+  if (
+    file &&
+    path.basename(file) !== `${event.eventId}.json`
+  ) {
+    const error = new TypeError(
+      "normalized hook event location is invalid",
+    );
+    error.code = "INVALID_CONTRACT";
+    throw error;
+  }
+  if (event.conflictEligible !== true) {
+    return event;
+  }
+  const identity = {
+    semanticKeyVersion: SEMANTIC_KEY_VERSION,
+    sessionId: event.sessionId,
+    ...(event.turnId ? { turnId: event.turnId } : {}),
+    event: event.event,
+    ...(event.agentId ? { agentId: event.agentId } : {}),
+    ...(event.toolUseId ? { toolUseId: event.toolUseId } : {}),
+    ...(event.stopHookActive === undefined
+      ? {}
+      : { stopHookActive: event.stopHookActive }),
+    ...(event.event === "SessionStart" &&
+    event.payloadSummary?.source
+      ? { source: event.payloadSummary.source }
+      : {}),
+  };
+  const semanticKey = `sem-v${SEMANTIC_KEY_VERSION}:${digestJson(identity)}`;
+  const payloadDigest = digestJson({
+    schemaVersion: SCHEMA_VERSION,
+    semanticKey,
+    sessionId: event.sessionId,
+    ...(event.turnId ? { turnId: event.turnId } : {}),
+    event: event.event,
+    ...(event.agentId ? { agentId: event.agentId } : {}),
+    ...(event.agentType ? { agentType: event.agentType } : {}),
+    ...(event.toolUseId ? { toolUseId: event.toolUseId } : {}),
+    ...(event.stopHookActive === undefined
+      ? {}
+      : { stopHookActive: event.stopHookActive }),
+    payloadSummary: event.payloadSummary,
+  });
+  const eventId = `evt_${sha256(
+    canonicalJson({ semanticKey, payloadDigest }),
+  )}`;
+  if (
+    event.semanticKey !== semanticKey ||
+    event.payloadDigest !== payloadDigest ||
+    event.eventId !== eventId
+  ) {
+    const error = new TypeError(
+      "normalized hook event identity or digest is invalid",
+    );
+    error.code = "INVALID_CONTRACT";
+    throw error;
+  }
+  return event;
+}
+
+function assertIdentityBindingIntegrity(
+  binding,
+  runId,
+  file = undefined,
+  expectedAgentId = undefined,
+) {
+  assertContract(
+    "identity binding",
+    binding,
+    validateIdentityBinding,
+  );
+  const expectedBindingId = `binding_${sha256(
+    canonicalJson({ runId, agentId: binding.agentId }),
+  )}`;
+  const expectedFileName = `binding_${sha256(
+    binding.agentId,
+  )}.json`;
+  const productFields = [
+    "requestId",
+    "requestDigest",
+    "observationId",
+    "originEventId",
+  ];
+  const hasProductBindingFields = productFields.some(
+    (field) => binding[field] !== undefined,
+  );
+  const completeProductBinding = productFields.every(
+    (field) => binding[field] !== undefined,
+  ) && binding.role !== undefined;
+  const expectedRequestDigest = completeProductBinding
+    ? digestJson({
+        kind: "bind-worker",
+        runId,
+        requestId: binding.requestId,
+        agentId: binding.agentId,
+        role: binding.role,
+        observationId: binding.observationId,
+        originEventId: binding.originEventId,
+      })
+    : undefined;
+  if (
+    binding.runId !== runId ||
+    binding.bindingId !== expectedBindingId ||
+    (expectedAgentId !== undefined &&
+      binding.agentId !== expectedAgentId) ||
+    (file && path.basename(file) !== expectedFileName) ||
+    (hasProductBindingFields &&
+      (!completeProductBinding ||
+        binding.requestDigest !==
+          expectedRequestDigest))
+  ) {
+    const error = new TypeError(
+      "identity binding identity, request digest, or location is invalid",
+    );
+    error.code = "INVALID_CONTRACT";
+    throw error;
+  }
+  return binding;
+}
+
+function compareFacts(kind, left, right) {
+  const timeOrder = compareCodePoints(
+    String(factTime(kind, left)),
+    String(factTime(kind, right)),
+  );
+  if (timeOrder !== 0) {
+    return timeOrder;
+  }
+  return compareCodePoints(factId(kind, left), factId(kind, right));
+}
+
+function diagnosticId(runId, kind, details) {
+  return `diag_${sha256(canonicalJson({ runId, kind, details }))}`;
+}
+
+function diagnosticPayload(runId, kind, details, severity = "warn") {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    diagnosticId: diagnosticId(runId, kind, details),
+    runId,
+    kind,
+    severity,
+    details,
+    createdAt: new Date().toISOString(),
+  };
+}
+
+function validateDiagnostic(value) {
+  const errors = [];
+  if (value?.schemaVersion !== SCHEMA_VERSION) {
+    errors.push("diagnostic.schemaVersion must be 1");
+  }
+  if (
+    typeof value?.diagnosticId !== "string" ||
+    !/^diag_[a-f0-9]{64}$/.test(value.diagnosticId)
+  ) {
+    errors.push("diagnostic.diagnosticId is invalid");
+  }
+  if (typeof value?.runId !== "string" || value.runId.length === 0) {
+    errors.push("diagnostic.runId is invalid");
+  }
+  if (typeof value?.kind !== "string" || value.kind.length === 0) {
+    errors.push("diagnostic.kind is invalid");
+  }
+  if (!["info", "warn", "error"].includes(value?.severity)) {
+    errors.push("diagnostic.severity is invalid");
+  }
+  if (
+    value?.details === null ||
+    typeof value?.details !== "object" ||
+    Array.isArray(value.details)
+  ) {
+    errors.push("diagnostic.details must be an object");
+  }
+  return errors;
+}
+
+function sessionBinding(run) {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    bindingId: `session_${sha256(
+      canonicalJson({
+        runId: run.runId,
+        rootSessionId: run.rootSessionId,
+      }),
+    )}`,
+    runId: run.runId,
+    rootSessionId: run.rootSessionId,
+    createdAt: run.createdAt,
+  };
+}
+
+function validateSessionBinding(value) {
+  const errors = [];
+  if (value?.schemaVersion !== SCHEMA_VERSION) {
+    errors.push("session binding schemaVersion must be 1");
+  }
+  if (
+    typeof value?.bindingId !== "string" ||
+    !/^session_[a-f0-9]{64}$/.test(value.bindingId)
+  ) {
+    errors.push("session binding id is invalid");
+  }
+  if (typeof value?.runId !== "string" || value.runId.length === 0) {
+    errors.push("session binding runId is invalid");
+  }
+  if (
+    typeof value?.rootSessionId !== "string" ||
+    value.rootSessionId.length === 0
+  ) {
+    errors.push("session binding rootSessionId is invalid");
+  }
+  if (
+    typeof value?.createdAt !== "string" ||
+    !Number.isFinite(Date.parse(value.createdAt))
+  ) {
+    errors.push("session binding createdAt is invalid");
+  }
+  return errors;
+}
+
+function assertSessionBindingLocation(binding, file, rootSessionId) {
+  assertContract(
+    "session binding",
+    binding,
+    validateSessionBinding,
+  );
+  const expectedBindingId = `session_${sha256(
+    canonicalJson({
+      runId: binding.runId,
+      rootSessionId: binding.rootSessionId,
+    }),
+  )}`;
+  if (
+    binding.rootSessionId !== rootSessionId ||
+    binding.bindingId !== expectedBindingId ||
+    path.basename(file) !== `${binding.runId}.json`
+  ) {
+    const error = new TypeError(
+      "session binding does not match its store location",
+    );
+    error.code = "INVALID_CONTRACT";
+    throw error;
+  }
+  return binding;
+}
+
+function runIdentity(value) {
+  return {
+    schemaVersion: value.schemaVersion,
+    runId: value.runId,
+    rootSessionId: value.rootSessionId,
+    originatingTurnId: value.originatingTurnId,
+    scope: value.scope,
+    masterNode: value.masterNode,
+    recipe: value.recipe,
+    createdAt: value.createdAt,
+  };
+}
+
+function assertStateTransition(current, next) {
+  if (
+    canonicalJson(runIdentity(current)) !==
+    canonicalJson(runIdentity(next))
+  ) {
+    throw new InvalidStateTransitionError(
+      "run identity fields are immutable",
+    );
+  }
+  if (
+    TERMINAL_STATUSES.has(current.status) &&
+    next.status !== current.status
+  ) {
+    throw new InvalidStateTransitionError(
+      "terminal runs cannot transition to another status",
+    );
+  }
+  if (current.cancelRequested && !next.cancelRequested) {
+    throw new InvalidStateTransitionError(
+      "cancelRequested cannot be cleared",
+    );
+  }
+  if (next.currentLap < current.currentLap) {
+    throw new InvalidStateTransitionError(
+      "currentLap cannot move backwards",
+    );
+  }
+  if (
+    next.continuationLease.granted !==
+      current.continuationLease.granted ||
+    next.continuationLease.consumed <
+      current.continuationLease.consumed
+  ) {
+    throw new InvalidStateTransitionError(
+      "continuation lease cannot be expanded or rewound",
+    );
+  }
+}
+
+async function fileDigest(file, root) {
+  try {
+    const buffer = await readBoundedFile(file, { root });
+    return {
+      sha256: sha256(buffer),
+      bytes: buffer.length,
+    };
+  } catch (error) {
+    return {
+      sha256: sha256(String(error?.code ?? "read-error")),
+      bytes: null,
+    };
+  }
+}
+
+export class LoopStore {
+  static async open(options = {}) {
+    const rootInfo = options.rootInfo ?? (await resolveDataRoot(options));
+    return new LoopStore(rootInfo, options.retention);
+  }
+
+  constructor(rootInfo, retention = {}) {
+    if (!rootInfo?.path || !rootInfo?.marker?.instanceId) {
+      throw new TypeError("LoopStore requires a resolved data root");
+    }
+    this.rootInfo = rootInfo;
+    this.dataRoot = rootInfo.path;
+    this.retention = { ...DEFAULT_RETENTION, ...retention };
+  }
+
+  runDirectory(runId) {
+    assertSafeFileId(runId, "runId");
+    return path.join(this.dataRoot, "runs", runId);
+  }
+
+  factDirectory(runId, kind) {
+    return path.join(this.runDirectory(runId), kind);
+  }
+
+  statePath(runId) {
+    return path.join(this.runDirectory(runId), "state.json");
+  }
+
+  projectionPath(runId) {
+    return path.join(this.runDirectory(runId), "projection.json");
+  }
+
+  actionCapabilityPath(runId, transitionId) {
+    assertSafeFileId(runId, "runId");
+    assertSafeFileId(transitionId, "transitionId");
+    return path.join(
+      this.runDirectory(runId),
+      "action-capabilities",
+      `${transitionId}.json`,
+    );
+  }
+
+  sessionBindingDirectory(rootSessionId) {
+    return path.join(
+      this.dataRoot,
+      "session-bindings",
+      sha256(rootSessionId),
+    );
+  }
+
+  sessionBindingPath(runId, rootSessionId) {
+    assertSafeFileId(runId, "runId");
+    return path.join(
+      this.sessionBindingDirectory(rootSessionId),
+      `${runId}.json`,
+    );
+  }
+
+  async initializeRun(state) {
+    assertContract("loop run", state, validateLoopRun);
+    assertSafeFileId(state.runId, "runId");
+    const sessionDirectory = this.sessionBindingDirectory(
+      state.rootSessionId,
+    );
+    const sessionLockPath = path.join(
+      sessionDirectory,
+      "session.lock",
+    );
+    const runLockPath = path.join(
+      this.runDirectory(state.runId),
+      "locks",
+      "initialize.lock",
+    );
+    return withFileLock(
+      sessionLockPath,
+      () =>
+        withFileLock(
+          runLockPath,
+          async () => {
+            const files = await listJsonFiles(sessionDirectory, {
+              root: this.dataRoot,
+            });
+            let sameRunBindingPath = null;
+            for (const file of files) {
+              const existingBinding = assertSessionBindingLocation(
+                await readJsonFile(file, { root: this.dataRoot }),
+                file,
+                state.rootSessionId,
+              );
+              if (existingBinding.runId === state.runId) {
+                sameRunBindingPath = file;
+                continue;
+              }
+              let existingState;
+              try {
+                existingState = await this.readState(
+                  existingBinding.runId,
+                );
+              } catch (error) {
+                if (error?.code === "ENOENT") {
+                  const reservation = new StoreConflictError(
+                    "another run reserved this task before publishing state",
+                    {
+                      rootSessionIdDigest: sha256(
+                        state.rootSessionId,
+                      ),
+                    },
+                  );
+                  reservation.code = "SESSION_BINDING_RESERVED";
+                  throw reservation;
+                }
+                throw error;
+              }
+              if (
+                existingState.rootSessionId !==
+                  state.rootSessionId
+              ) {
+                const error = new TypeError(
+                  "session binding state belongs to another task",
+                );
+                error.code = "INVALID_CONTRACT";
+                throw error;
+              }
+              if (ACTIVE_RUN_STATUSES.has(existingState.status)) {
+                const conflict = new StoreConflictError(
+                  "another active loop run is already bound to this task",
+                  {
+                    rootSessionIdDigest: sha256(
+                      state.rootSessionId,
+                    ),
+                  },
+                );
+                conflict.code = "SESSION_BINDING_CONFLICT";
+                throw conflict;
+              }
+            }
+
+            let existingRun = null;
+            try {
+              existingRun = await this.readState(state.runId);
+            } catch (error) {
+              if (error?.code !== "ENOENT") {
+                throw error;
+              }
+            }
+            if (existingRun) {
+              if (
+                canonicalJson(runIdentity(existingRun)) !==
+                canonicalJson(runIdentity(state))
+              ) {
+                if (
+                  sameRunBindingPath &&
+                  existingRun.rootSessionId !== state.rootSessionId
+                ) {
+                  await unlink(sameRunBindingPath);
+                }
+                const conflict = new StoreConflictError(
+                  "run id already belongs to another task or identity",
+                  { runId: state.runId },
+                );
+                conflict.code = "RUN_ID_CONFLICT";
+                throw conflict;
+              }
+              const repaired = await atomicCreateJson(
+                this.sessionBindingPath(
+                  existingRun.runId,
+                  existingRun.rootSessionId,
+                ),
+                sessionBinding(existingRun),
+                {
+                  root: this.dataRoot,
+                  equivalent: (left, right) =>
+                    canonicalJson(left) ===
+                    canonicalJson(right),
+                },
+              );
+              if (repaired.status === "conflict") {
+                throw new StoreConflictError(
+                  "session binding conflicts with the authoritative run",
+                  { runId: state.runId },
+                );
+              }
+              return {
+                status: "duplicate",
+                path: this.statePath(state.runId),
+                existing: existingRun,
+              };
+            }
+
+            const bindingPath = this.sessionBindingPath(
+              state.runId,
+              state.rootSessionId,
+            );
+            const bindingResult = await atomicCreateJson(
+              bindingPath,
+              sessionBinding(state),
+              {
+                root: this.dataRoot,
+                equivalent: (left, right) =>
+                  canonicalJson(left) === canonicalJson(right),
+              },
+            );
+            if (bindingResult.status === "conflict") {
+              throw new StoreConflictError(
+                "session binding already exists with different state",
+                { runId: state.runId },
+              );
+            }
+
+            const result = await atomicCreateJson(
+              this.statePath(state.runId),
+              state,
+              { root: this.dataRoot },
+            );
+            if (result.status === "conflict") {
+              if (bindingResult.status === "created") {
+                await unlink(bindingPath);
+              }
+              throw new StoreConflictError(
+                "run already exists with different state",
+                { runId: state.runId },
+              );
+            }
+            return result;
+          },
+          { root: this.dataRoot },
+        ),
+      { root: this.dataRoot },
+    );
+  }
+
+  async boundRunIdsForSession(rootSessionId) {
+    if (
+      typeof rootSessionId !== "string" ||
+      rootSessionId.length === 0
+    ) {
+      return [];
+    }
+    const directory = this.sessionBindingDirectory(rootSessionId);
+    const files = await listJsonFiles(directory, {
+      root: this.dataRoot,
+    });
+    const runIds = [];
+    for (const file of files) {
+      const binding = assertSessionBindingLocation(
+        await readJsonFile(file, {
+          root: this.dataRoot,
+        }),
+        file,
+        rootSessionId,
+      );
+      runIds.push(binding.runId);
+    }
+    return [...new Set(runIds)].sort(compareCodePoints);
+  }
+
+  async activeRunForSession(rootSessionId, options = {}) {
+    if (
+      typeof rootSessionId !== "string" ||
+      rootSessionId.length === 0
+    ) {
+      return null;
+    }
+    const runIds =
+      options.boundRunIds ??
+      (await this.boundRunIdsForSession(rootSessionId));
+    const active = [];
+    for (const runId of runIds) {
+      let state;
+      try {
+        state = await this.readState(runId);
+      } catch (error) {
+        if (error?.code === "ENOENT") {
+          continue;
+        }
+        throw error;
+      }
+      if (state.rootSessionId !== rootSessionId) {
+        const error = new TypeError(
+          "session binding state belongs to another task",
+        );
+        error.code = "INVALID_CONTRACT";
+        throw error;
+      }
+      if (HOOK_COLLECTION_STATUSES.has(state.status)) {
+        active.push(runId);
+      }
+    }
+    active.sort(compareCodePoints);
+    if (active.length > 1) {
+      const error = new StoreConflictError(
+        "multiple active loop runs are bound to one task",
+        { rootSessionIdDigest: sha256(rootSessionId) },
+      );
+      error.code = "SESSION_BINDING_AMBIGUOUS";
+      throw error;
+    }
+    return active[0] ?? null;
+  }
+
+  async boundRunsForSession(rootSessionId) {
+    if (
+      typeof rootSessionId !== "string" ||
+      rootSessionId.length === 0
+    ) {
+      return [];
+    }
+    const directory = this.sessionBindingDirectory(rootSessionId);
+    const files = await listJsonFiles(directory, {
+      root: this.dataRoot,
+    });
+    const results = [];
+    for (const file of files) {
+      const binding = assertSessionBindingLocation(
+        await readJsonFile(file, { root: this.dataRoot }),
+        file,
+        rootSessionId,
+      );
+      try {
+        const state = await this.readState(binding.runId);
+        if (state.rootSessionId !== rootSessionId) {
+          const error = new TypeError(
+            "session binding state belongs to another task",
+          );
+          error.code = "INVALID_CONTRACT";
+          throw error;
+        }
+        results.push({ binding, state });
+      } catch (error) {
+        if (error?.code !== "ENOENT") {
+          throw error;
+        }
+        results.push({ binding, state: null });
+      }
+    }
+    return results.sort((left, right) =>
+      compareCodePoints(left.binding.runId, right.binding.runId),
+    );
+  }
+
+  async readState(runId) {
+    const value = await readJsonFile(this.statePath(runId), {
+      root: this.dataRoot,
+    });
+    assertContract("loop run", value, validateLoopRun);
+    if (value.runId !== runId) {
+      const error = new TypeError("loop run is stored under a different run id");
+      error.code = "INVALID_CONTRACT";
+      throw error;
+    }
+    return value;
+  }
+
+  async readActionCapability(runId, transitionId) {
+    return readJsonFile(
+      this.actionCapabilityPath(runId, transitionId),
+      { root: this.dataRoot },
+    );
+  }
+
+  async replaceActionCapability(runId, transitionId, value) {
+    if (
+      value?.runId !== runId ||
+      value?.pendingTransitionId !== transitionId
+    ) {
+      throw new TypeError(
+        "action capability belongs to a different run or transition",
+      );
+    }
+    return atomicReplaceJson(
+      this.actionCapabilityPath(runId, transitionId),
+      value,
+      { root: this.dataRoot },
+    );
+  }
+
+  async compareAndSwapState(runId, expectedRevision, nextState, options = {}) {
+    assertSafeFileId(runId, "runId");
+    assertContract("loop run", nextState, validateLoopRun);
+    if (nextState.runId !== runId) {
+      throw new TypeError("next state belongs to a different run");
+    }
+    if (nextState.revision !== expectedRevision + 1) {
+      throw new RevisionConflictError(expectedRevision + 1, nextState.revision);
+    }
+    const lockPath = path.join(this.runDirectory(runId), "locks", "state.lock");
+    return withFileLock(
+      lockPath,
+      async () => {
+        const current = await this.readState(runId);
+        if (current.revision !== expectedRevision) {
+          throw new RevisionConflictError(expectedRevision, current.revision);
+        }
+        assertStateTransition(current, nextState);
+        await atomicReplaceJson(this.statePath(runId), nextState, {
+          root: this.dataRoot,
+        });
+        return nextState;
+      },
+      { ...options, root: this.dataRoot },
+    );
+  }
+
+  async withControlLock(runId, callback, options = {}) {
+    assertSafeFileId(runId, "runId");
+    const lockPath = path.join(
+      this.runDirectory(runId),
+      "locks",
+      "control.lock",
+    );
+    return withFileLock(lockPath, callback, {
+      ...options,
+      root: this.dataRoot,
+    });
+  }
+
+  async withWorkerObservationLock(
+    runId,
+    callback,
+    options = {},
+  ) {
+    assertSafeFileId(runId, "runId");
+    const lockPath = path.join(
+      this.runDirectory(runId),
+      "locks",
+      "worker-observation.lock",
+    );
+    return withFileLock(lockPath, callback, {
+      timeoutMs: FACT_LOCK_TIMEOUT_MS,
+      ...options,
+      root: this.dataRoot,
+    });
+  }
+
+  async withWorkerObservationIntentLock(
+    runId,
+    callback,
+    options = {},
+  ) {
+    assertSafeFileId(runId, "runId");
+    const lockPath = path.join(
+      this.runDirectory(runId),
+      "locks",
+      "worker-observation-intent.lock",
+    );
+    return withFileLock(lockPath, callback, {
+      timeoutMs: FACT_LOCK_TIMEOUT_MS,
+      ...options,
+      root: this.dataRoot,
+    });
+  }
+
+  async withWorkerObservationSnapshotLock(
+    runId,
+    callback,
+    options = {},
+  ) {
+    return this.withWorkerObservationIntentLock(
+      runId,
+      () =>
+        this.withWorkerObservationLock(
+          runId,
+          callback,
+          options,
+        ),
+      options,
+    );
+  }
+
+  async #stateStatus(runId) {
+    try {
+      return (await this.readState(runId)).status;
+    } catch {
+      return "interrupted";
+    }
+  }
+
+  async #putFact(runId, kind, value, options = {}) {
+    assertSafeFileId(runId, "runId");
+    const validator = validatorFor(kind);
+    assertContract(kind.slice(0, -1), value, validator);
+    if (value.runId !== undefined && value.runId !== runId) {
+      throw new TypeError(`${kind} fact belongs to a different run`);
+    }
+    const id = options.id ?? factId(kind, value);
+    assertSafeFileId(id, `${kind} id`);
+    const target = path.join(this.factDirectory(runId, kind), `${id}.json`);
+    const equivalent =
+      options.equivalent ??
+      ((left, right) => canonicalJson(left) === canonicalJson(right));
+    try {
+      const existing = await readJsonFile(target, {
+        root: this.dataRoot,
+      });
+      if (equivalent(existing, value)) {
+        return { status: "duplicate", id };
+      }
+      await this.writeDiagnostic(
+        runId,
+        `${kind.slice(0, -1)}_id_conflict`,
+        {
+          id,
+          existingDigest: digestJson(existing),
+          incomingDigest: digestJson(value),
+        },
+        "error",
+      );
+      return { status: "conflict", id };
+    } catch (error) {
+      if (error?.code !== "ENOENT") {
+        throw error;
+      }
+    }
+    const lockPath = path.join(
+      this.runDirectory(runId),
+      "locks",
+      `${kind}.lock`,
+    );
+    const result = await withFileLock(
+      lockPath,
+      async () => {
+        try {
+          const existing = await readJsonFile(target, {
+            root: this.dataRoot,
+          });
+          if (equivalent(existing, value)) {
+            return { status: "duplicate", id };
+          }
+          return {
+            status: "conflict",
+            id,
+            existingDigest: digestJson(existing),
+          };
+        } catch (error) {
+          if (error?.code !== "ENOENT") {
+            throw error;
+          }
+        }
+        const status = await this.#stateStatus(runId);
+        const active = ACTIVE_RUN_STATUSES.has(status);
+        const baseLimit =
+          this.retention[kind] ?? this.retention.diagnostics;
+        const limit = active
+          ? baseLimit * this.retention.activeMultiplier
+          : baseLimit;
+        const files = await listJsonFiles(
+          this.factDirectory(runId, kind),
+          { root: this.dataRoot },
+        );
+        const safetyReserve =
+          options.allowSafetyReserve === true &&
+          ["operations", "transitions"].includes(kind) &&
+          value.kind === "interrupt" &&
+          files.length < limit + SAFETY_RECEIPT_RESERVE;
+        const cancelReserve =
+          ["operations", "transitions"].includes(kind) &&
+          value.kind === "cancel" &&
+          files.length < limit + SAFETY_RECEIPT_RESERVE;
+        if (
+          files.length >= limit &&
+          !safetyReserve &&
+          !cancelReserve
+        ) {
+          return { status: "limit", id, limit, active };
+        }
+        const published = await atomicCreateJson(target, value, {
+          equivalent,
+          root: this.dataRoot,
+        });
+        return {
+          status: published.status,
+          id,
+          ...(published.status === "conflict"
+            ? { existingDigest: digestJson(published.existing) }
+            : {}),
+        };
+      },
+      {
+        root: this.dataRoot,
+        timeoutMs: FACT_LOCK_TIMEOUT_MS,
+      },
+    );
+    if (result.status === "conflict") {
+      await this.writeDiagnostic(
+        runId,
+        `${kind.slice(0, -1)}_id_conflict`,
+        {
+          id,
+          existingDigest: result.existingDigest,
+          incomingDigest: digestJson(value),
+        },
+        "error",
+      );
+    }
+    if (result.status === "limit") {
+      await this.writeDiagnostic(
+        runId,
+        "active_run_limit",
+        {
+          factKind: kind,
+          limit: result.limit,
+          active: result.active,
+        },
+        "error",
+      );
+    }
+    return result;
+  }
+
+  pendingWorkerObservationDirectory(runId) {
+    return path.join(
+      this.runDirectory(runId),
+      "pending-worker-observations",
+    );
+  }
+
+  async #putEventFact(runId, event) {
+    return this.#putFact(runId, "events", event, {
+      id: event.eventId,
+      equivalent: (left, right) =>
+        left?.eventId === right?.eventId &&
+        left?.payloadDigest === right?.payloadDigest,
+    });
+  }
+
+  async #stageWorkerObservation(runId, event) {
+    const target = path.join(
+      this.pendingWorkerObservationDirectory(runId),
+      `${event.eventId}.json`,
+    );
+    const result = await atomicCreateJson(target, event, {
+      root: this.dataRoot,
+      equivalent: (left, right) =>
+        left?.eventId === right?.eventId &&
+        left?.payloadDigest === right?.payloadDigest,
+    });
+    if (result.status === "conflict") {
+      throw new StoreConflictError(
+        "pending worker observation conflicts",
+        { eventId: event.eventId },
+      );
+    }
+    return result;
+  }
+
+  async readPendingWorkerObservations(runId) {
+    assertSafeFileId(runId, "runId");
+    const directory =
+      this.pendingWorkerObservationDirectory(runId);
+    const files = await listJsonFiles(directory, {
+      root: this.dataRoot,
+    });
+    const facts = [];
+    const corrupt = [];
+    for (const file of files) {
+      try {
+        const value = await readJsonFile(file, {
+          root: this.dataRoot,
+        });
+        assertContract(
+          "pending worker observation",
+          value,
+          validateNormalizedHookEvent,
+        );
+        if (
+          !isWorkerObservationEvent(value) ||
+          path.basename(file) !== `${value.eventId}.json`
+        ) {
+          const error = new TypeError(
+            "pending worker observation has an invalid location",
+          );
+          error.code = "INVALID_CONTRACT";
+          throw error;
+        }
+        facts.push(value);
+      } catch (error) {
+        corrupt.push({
+          relativeFile: path.relative(
+            this.runDirectory(runId),
+            file,
+          ),
+          code: error?.code ?? "READ_ERROR",
+          digest: await fileDigest(file, this.dataRoot),
+        });
+      }
+    }
+    facts.sort((left, right) =>
+      compareFacts("events", left, right),
+    );
+    return { facts, corrupt };
+  }
+
+  async reconcilePendingWorkerObservations(runId) {
+    const pending = await this.readPendingWorkerObservations(
+      runId,
+    );
+    const published = [];
+    const unresolved = [];
+    for (const event of pending.facts) {
+      const result = await this.#putEventFact(runId, event);
+      if (["created", "duplicate"].includes(result.status)) {
+        await unlink(
+          path.join(
+            this.pendingWorkerObservationDirectory(runId),
+            `${event.eventId}.json`,
+          ),
+        );
+        published.push({ eventId: event.eventId, status: result.status });
+      } else {
+        unresolved.push({
+          eventId: event.eventId,
+          status: result.status,
+        });
+      }
+    }
+    return {
+      published,
+      unresolved,
+      corrupt: pending.corrupt,
+    };
+  }
+
+  async readWorkerObservationEvidence(runId) {
+    const [eventRead, pendingRead] = await Promise.all([
+      this.listEvents(runId),
+      this.readPendingWorkerObservations(runId),
+    ]);
+    const byEventId = new Map();
+    const conflicts = [];
+    for (const event of [
+      ...eventRead.facts,
+      ...pendingRead.facts,
+    ]) {
+      const existing = byEventId.get(event.eventId);
+      if (
+        existing &&
+        existing.payloadDigest !== event.payloadDigest
+      ) {
+        conflicts.push({
+          eventId: event.eventId,
+          payloadDigests: [
+            existing.payloadDigest,
+            event.payloadDigest,
+          ].sort(compareCodePoints),
+        });
+        continue;
+      }
+      byEventId.set(event.eventId, event);
+    }
+    return {
+      facts: [...byEventId.values()].sort((left, right) =>
+        compareFacts("events", left, right),
+      ),
+      corrupt: [
+        ...eventRead.corrupt,
+        ...pendingRead.corrupt,
+      ],
+      conflicts,
+      pendingCount: pendingRead.facts.length,
+    };
+  }
+
+  async putEvent(runId, event) {
+    assertContract(
+      "normalized hook event",
+      event,
+      validateNormalizedHookEvent,
+    );
+    if (!isWorkerObservationEvent(event)) {
+      return this.#putEventFact(runId, event);
+    }
+    await this.withWorkerObservationIntentLock(
+      runId,
+      () => this.#stageWorkerObservation(runId, event),
+    );
+    return this.withWorkerObservationLock(
+      runId,
+      async () => {
+        const reconciled =
+          await this.reconcilePendingWorkerObservations(runId);
+        if (
+          reconciled.corrupt.length > 0 ||
+          reconciled.unresolved.length > 0
+        ) {
+          const error = new StoreConflictError(
+            "worker observation could not be published",
+            {
+              corrupt: reconciled.corrupt.length,
+              unresolved: reconciled.unresolved.length,
+            },
+          );
+          error.code = "OBSERVATION_INCOMPLETE";
+          throw error;
+        }
+        return (
+          reconciled.published.find(
+            ({ eventId }) => eventId === event.eventId,
+          ) ?? { eventId: event.eventId, status: "duplicate" }
+        );
+      },
+    );
+  }
+
+  async listEvents(runId) {
+    assertSafeFileId(runId, "runId");
+    return this.#readFacts(
+      runId,
+      "events",
+      validateNormalizedHookEvent,
+    );
+  }
+
+  async readEvent(runId, eventId) {
+    assertSafeFileId(runId, "runId");
+    assertSafeFileId(eventId, "eventId");
+    const file = path.join(
+      this.factDirectory(runId, "events"),
+      `${eventId}.json`,
+    );
+    return assertStoredEventIntegrity(
+      await readJsonFile(file, { root: this.dataRoot }),
+      file,
+    );
+  }
+
+  async putDefinition(runId, definition) {
+    assertLoopDefinitionIntegrity(definition, runId);
+    return this.#putFact(runId, "definitions", definition, {
+      id: definition.definitionId,
+    });
+  }
+
+  async readDefinition(runId) {
+    assertSafeFileId(runId, "runId");
+    const { facts, corrupt } = await this.#readFacts(
+      runId,
+      "definitions",
+      validateLoopDefinition,
+    );
+    if (corrupt.length > 0 || facts.length !== 1) {
+      const error = new TypeError(
+        "run must contain exactly one valid loop definition",
+      );
+      error.code =
+        corrupt.length > 0 ? "INVALID_CONTRACT" : "ENOENT";
+      error.details = {
+        facts: facts.length,
+        corrupt: corrupt.length,
+      };
+      throw error;
+    }
+    return facts[0];
+  }
+
+  async findObservedSubagentStart(runId, rootSessionId, agentId) {
+    assertSafeFileId(runId, "runId");
+    const state = await this.readState(runId);
+    if (state.rootSessionId !== rootSessionId) {
+      return null;
+    }
+    const { facts } = await this.#readFacts(
+      runId,
+      "events",
+      validateNormalizedHookEvent,
+    );
+    return (
+      facts
+        .filter(
+          (event) =>
+            event.event === "SubagentStart" &&
+            event.conflictEligible === true &&
+            event.sessionId === rootSessionId &&
+            event.agentId === agentId,
+        )
+        .sort((left, right) =>
+          compareCodePoints(left.eventId, right.eventId),
+        )[0] ?? null
+    );
+  }
+
+  async listObservedSubagentStarts(runId, rootSessionId) {
+    assertSafeFileId(runId, "runId");
+    const state = await this.readState(runId);
+    if (state.rootSessionId !== rootSessionId) {
+      return { facts: [], corrupt: [] };
+    }
+    const read = await this.#readFacts(
+      runId,
+      "events",
+      validateNormalizedHookEvent,
+    );
+    return {
+      ...read,
+      facts: read.facts
+        .filter(
+          (event) =>
+            event.event === "SubagentStart" &&
+            event.conflictEligible === true &&
+            event.sessionId === rootSessionId &&
+            typeof event.agentId === "string",
+        )
+        .sort((left, right) =>
+          compareFacts("events", left, right),
+        ),
+    };
+  }
+
+  async putWorkerObservation(runId, observation) {
+    assertWorkerObservationIntegrity(
+      observation,
+      runId,
+    );
+    return this.#putFact(
+      runId,
+      "observations",
+      observation,
+      { id: observation.observationId },
+    );
+  }
+
+  async readWorkerObservation(runId, observationId) {
+    assertSafeFileId(runId, "runId");
+    assertSafeFileId(observationId, "observationId");
+    const value = await readJsonFile(
+      path.join(
+        this.factDirectory(runId, "observations"),
+        `${observationId}.json`,
+      ),
+      { root: this.dataRoot },
+    );
+    assertWorkerObservationIntegrity(
+      value,
+      runId,
+      path.join(
+        this.factDirectory(runId, "observations"),
+        `${observationId}.json`,
+      ),
+    );
+    if (value.observationId !== observationId) {
+      const error = new TypeError(
+        "worker observation does not match its requested id",
+      );
+      error.code = "INVALID_CONTRACT";
+      throw error;
+    }
+    return value;
+  }
+
+  async listWorkerObservations(runId) {
+    assertSafeFileId(runId, "runId");
+    const directory = this.factDirectory(
+      runId,
+      "observations",
+    );
+    const files = await listJsonFiles(directory, {
+      root: this.dataRoot,
+    });
+    const facts = [];
+    const corrupt = [];
+    for (const file of files) {
+      try {
+        facts.push(
+          assertWorkerObservationIntegrity(
+            await readJsonFile(file, {
+              root: this.dataRoot,
+            }),
+            runId,
+            file,
+          ),
+        );
+      } catch (error) {
+        corrupt.push({
+          relativeFile: path.relative(
+            this.runDirectory(runId),
+            file,
+          ),
+          code: error?.code ?? "READ_ERROR",
+          digest: await fileDigest(file, this.dataRoot),
+        });
+      }
+    }
+    facts.sort((left, right) =>
+      compareFacts("observations", left, right),
+    );
+    return { facts, corrupt };
+  }
+
+  async putReport(runId, report) {
+    return this.#putFact(runId, "reports", report, { id: report.reportId });
+  }
+
+  async readReport(runId, reportId) {
+    assertSafeFileId(runId, "runId");
+    assertSafeFileId(reportId, "reportId");
+    const value = await readJsonFile(
+      path.join(
+        this.factDirectory(runId, "reports"),
+        `${reportId}.json`,
+      ),
+      { root: this.dataRoot },
+    );
+    return assertContract(
+      "report",
+      value,
+      validateLoopReport,
+    );
+  }
+
+  async listReports(runId) {
+    assertSafeFileId(runId, "runId");
+    return this.#readFacts(
+      runId,
+      "reports",
+      validateLoopReport,
+    );
+  }
+
+  async putTransition(runId, transition, options = {}) {
+    return this.#putFact(runId, "transitions", transition, {
+      id: transition.transitionId,
+      allowSafetyReserve:
+        options.allowSafetyReserve === true,
+    });
+  }
+
+  async readTransition(runId, transitionId) {
+    assertSafeFileId(runId, "runId");
+    assertSafeFileId(transitionId, "transitionId");
+    const value = await readJsonFile(
+      path.join(
+        this.factDirectory(runId, "transitions"),
+        `${transitionId}.json`,
+      ),
+      { root: this.dataRoot },
+    );
+    return assertContract(
+      "transition",
+      value,
+      validateLoopTransition,
+    );
+  }
+
+  async listTransitions(runId) {
+    assertSafeFileId(runId, "runId");
+    return this.#readFacts(
+      runId,
+      "transitions",
+      validateLoopTransition,
+    );
+  }
+
+  async putOperation(runId, operation, options = {}) {
+    return this.#putFact(runId, "operations", operation, {
+      id: operation.operationId,
+      allowSafetyReserve:
+        options.allowSafetyReserve === true,
+    });
+  }
+
+  async readOperation(runId, operationId) {
+    assertSafeFileId(runId, "runId");
+    assertSafeFileId(operationId, "operationId");
+    const value = await readJsonFile(
+      path.join(
+        this.factDirectory(runId, "operations"),
+        `${operationId}.json`,
+      ),
+      { root: this.dataRoot },
+    );
+    return assertContract(
+      "operation",
+      value,
+      validateLoopOperation,
+    );
+  }
+
+  async listOperations(runId) {
+    assertSafeFileId(runId, "runId");
+    return this.#readFacts(
+      runId,
+      "operations",
+      validateLoopOperation,
+    );
+  }
+
+  async putGovernorDecision(runId, decision) {
+    assertGovernorDecisionIntegrity(decision, runId);
+    return this.#putFact(
+      runId,
+      "governor-decisions",
+      decision,
+      { id: decision.decisionId },
+    );
+  }
+
+  async readGovernorDecision(runId, decisionId) {
+    assertSafeFileId(runId, "runId");
+    assertSafeFileId(decisionId, "decisionId");
+    const file = path.join(
+      this.factDirectory(runId, "governor-decisions"),
+      `${decisionId}.json`,
+    );
+    return assertGovernorDecisionIntegrity(
+      await readJsonFile(file, { root: this.dataRoot }),
+      runId,
+      file,
+    );
+  }
+
+  async listGovernorDecisions(runId) {
+    assertSafeFileId(runId, "runId");
+    return this.#readFacts(
+      runId,
+      "governor-decisions",
+      validateGovernorDecision,
+    );
+  }
+
+  async putRecovery(runId, recovery) {
+    assertLegacyRecoveryIntegrity(recovery, runId);
+    return this.#putFact(runId, "recoveries", recovery, {
+      id: recovery.recoveryId,
+    });
+  }
+
+  async readRecovery(runId, recoveryId) {
+    assertSafeFileId(runId, "runId");
+    assertSafeFileId(recoveryId, "recoveryId");
+    const file = path.join(
+      this.factDirectory(runId, "recoveries"),
+      `${recoveryId}.json`,
+    );
+    const value = assertLegacyRecoveryIntegrity(
+      await readJsonFile(file, { root: this.dataRoot }),
+      runId,
+      file,
+    );
+    if (value.recoveryId !== recoveryId) {
+      const error = new TypeError(
+        "legacy recovery does not match its requested id",
+      );
+      error.code = "INVALID_CONTRACT";
+      throw error;
+    }
+    return value;
+  }
+
+  async listRecoveries(runId) {
+    assertSafeFileId(runId, "runId");
+    return this.#readFacts(
+      runId,
+      "recoveries",
+      validateLegacyQuarantineReceipt,
+    );
+  }
+
+  async putIdentityBinding(runId, binding) {
+    assertIdentityBindingIntegrity(binding, runId);
+    const id = `binding_${sha256(binding.agentId)}`;
+    return this.#putFact(runId, "identity", binding, { id });
+  }
+
+  async readIdentityBinding(runId, agentId) {
+    assertSafeFileId(runId, "runId");
+    const id = `binding_${sha256(agentId)}`;
+    const file = path.join(
+      this.factDirectory(runId, "identity"),
+      `${id}.json`,
+    );
+    const value = await readJsonFile(
+      file,
+      { root: this.dataRoot },
+    );
+    return assertIdentityBindingIntegrity(
+      value,
+      runId,
+      file,
+      agentId,
+    );
+  }
+
+  async listIdentityBindings(runId) {
+    assertSafeFileId(runId, "runId");
+    const directory = this.factDirectory(
+      runId,
+      "identity",
+    );
+    const files = await listJsonFiles(directory, {
+      root: this.dataRoot,
+    });
+    const facts = [];
+    const corrupt = [];
+    for (const file of files) {
+      try {
+        facts.push(
+          assertIdentityBindingIntegrity(
+            await readJsonFile(file, {
+              root: this.dataRoot,
+            }),
+            runId,
+            file,
+          ),
+        );
+      } catch (error) {
+        corrupt.push({
+          relativeFile: path.relative(
+            this.runDirectory(runId),
+            file,
+          ),
+          code: error?.code ?? "READ_ERROR",
+          digest: await fileDigest(file, this.dataRoot),
+        });
+      }
+    }
+    facts.sort((left, right) =>
+      compareCodePoints(left.bindingId, right.bindingId),
+    );
+    return { facts, corrupt };
+  }
+
+  async writeDiagnostic(runId, kind, details, severity = "warn") {
+    assertSafeFileId(runId, "runId");
+    const value = diagnosticPayload(runId, kind, details, severity);
+    const target = path.join(
+      this.factDirectory(runId, "diagnostics"),
+      `${value.diagnosticId}.json`,
+    );
+    const lockPath = path.join(
+      this.runDirectory(runId),
+      "locks",
+      "diagnostics.lock",
+    );
+    const reservedLimitDiagnostic =
+      ["active_run_limit", "diagnostic_limit"].includes(kind) &&
+      details?.factKind === "diagnostics";
+    const result = await withFileLock(
+      lockPath,
+      async () => {
+        try {
+          const existing = await readJsonFile(target, {
+            root: this.dataRoot,
+          });
+          if (existing?.diagnosticId === value.diagnosticId) {
+            return { status: "duplicate", existing };
+          }
+          return { status: "conflict", existing };
+        } catch (error) {
+          if (error?.code !== "ENOENT") {
+            throw error;
+          }
+        }
+        const status = await this.#stateStatus(runId);
+        const active = ACTIVE_RUN_STATUSES.has(status);
+        const limit = active
+          ? this.retention.diagnostics * this.retention.activeMultiplier
+          : this.retention.diagnostics;
+        const files = await listJsonFiles(
+          this.factDirectory(runId, "diagnostics"),
+          { root: this.dataRoot },
+        );
+        const allowed = reservedLimitDiagnostic
+          ? limit
+          : Math.max(0, limit - 1);
+        if (files.length >= allowed) {
+          return { status: "limit", active, limit };
+        }
+        return atomicCreateJson(target, value, {
+          equivalent: (left, right) =>
+            left?.diagnosticId === right?.diagnosticId,
+          root: this.dataRoot,
+        });
+      },
+      { root: this.dataRoot },
+    );
+    if (result.status === "limit" && !reservedLimitDiagnostic) {
+      const limitKind = result.active
+        ? "active_run_limit"
+        : "diagnostic_limit";
+      await this.writeDiagnostic(
+        runId,
+        limitKind,
+        {
+          factKind: "diagnostics",
+          limit: result.limit,
+          active: result.active,
+        },
+        "error",
+      );
+    }
+    return { ...result, diagnostic: value };
+  }
+
+  async #readFacts(runId, kind, validator) {
+    const directory = this.factDirectory(runId, kind);
+    const files = await listJsonFiles(directory, {
+      root: this.dataRoot,
+    });
+    const facts = [];
+    const corrupt = [];
+    for (const file of files) {
+      try {
+        const value = await readJsonFile(file, {
+          root: this.dataRoot,
+        });
+        const errors = validator(value);
+        if (errors.length > 0) {
+          const error = new TypeError(errors.join("; "));
+          error.code = "INVALID_CONTRACT";
+          throw error;
+        }
+        facts.push(
+          kind === "definitions"
+            ? assertLoopDefinitionIntegrity(
+                value,
+                runId,
+                file,
+              )
+            : kind === "events"
+            ? assertStoredEventIntegrity(value, file)
+            : kind === "governor-decisions"
+            ? assertGovernorDecisionIntegrity(
+                value,
+                runId,
+                file,
+              )
+            : kind === "recoveries"
+            ? assertLegacyRecoveryIntegrity(
+                value,
+                runId,
+                file,
+              )
+            : value,
+        );
+      } catch (error) {
+        corrupt.push({
+          relativeFile: path.relative(this.runDirectory(runId), file),
+          code: error?.code ?? "READ_ERROR",
+          digest: await fileDigest(file, this.dataRoot),
+        });
+      }
+    }
+    return { facts, corrupt };
+  }
+
+  async #readDiagnostics(runId) {
+    return this.#readFacts(runId, "diagnostics", validateDiagnostic);
+  }
+
+  async listDiagnostics(runId) {
+    assertSafeFileId(runId, "runId");
+    return this.#readDiagnostics(runId);
+  }
+
+  async #readOrRebuildState(runId, canonicalEvents) {
+    try {
+      return await this.readState(runId);
+    } catch {
+      // Recheck under the same state lock used by CAS so a recovery fold
+      // cannot overwrite a concurrently repaired or resumed run.
+    }
+    const stateFile = this.statePath(runId);
+    const lockPath = path.join(
+      this.runDirectory(runId),
+      "locks",
+      "state.lock",
+    );
+    const outcome = await withFileLock(
+      lockPath,
+      async () => {
+        try {
+          return { state: await this.readState(runId) };
+        } catch (error) {
+          const details = {
+            relativeFile: "state.json",
+            code: error?.code ?? "STATE_MISSING_OR_CORRUPT",
+            digest: await fileDigest(stateFile, this.dataRoot),
+          };
+          const rebuilt = createInterruptedRun(
+            runId,
+            canonicalEvents[0],
+          );
+          await atomicReplaceJson(stateFile, rebuilt, {
+            root: this.dataRoot,
+          });
+          return { state: rebuilt, diagnosticDetails: details };
+        }
+      },
+      { root: this.dataRoot },
+    );
+    if (outcome.diagnosticDetails) {
+      await this.writeDiagnostic(
+        runId,
+        "state_rebuilt",
+        outcome.diagnosticDetails,
+        "error",
+      );
+    }
+    return outcome.state;
+  }
+
+  async #writeSemanticIndexes(runId, groups) {
+    const indexDirectory = path.join(
+      this.runDirectory(runId),
+      "indexes",
+      "events",
+    );
+    const expectedFiles = new Set(
+      [...groups.keys()].map((semanticKey) => `${sha256(semanticKey)}.json`),
+    );
+    const existingFiles = await listJsonFiles(indexDirectory, {
+      root: this.dataRoot,
+    });
+    for (const file of existingFiles) {
+      if (!expectedFiles.has(path.basename(file))) {
+        await unlink(file);
+      }
+    }
+    for (const [semanticKey, values] of groups) {
+      const sorted = [...values].sort((left, right) =>
+        compareCodePoints(left.eventId, right.eventId),
+      );
+      const index = {
+        schemaVersion: SCHEMA_VERSION,
+        semanticKeyVersion: 1,
+        semanticKey,
+        canonicalEventId: sorted[0].eventId,
+        candidateEventIds: sorted.map((event) => event.eventId),
+        payloadDigests: [
+          ...new Set(sorted.map((event) => event.payloadDigest)),
+        ].sort(compareCodePoints),
+      };
+      await atomicReplaceJson(
+        path.join(indexDirectory, `${sha256(semanticKey)}.json`),
+        index,
+        { root: this.dataRoot },
+      );
+    }
+  }
+
+  async foldRun(runId, options = {}) {
+    assertSafeFileId(runId, "runId");
+    const {
+      writeProjection = true,
+      timelineLimit = this.retention.timeline,
+    } = options;
+    const [
+      eventRead,
+      reportCandidates,
+      transitionCandidates,
+      operationRead,
+      governorDecisionRead,
+    ] = await Promise.all([
+      this.#readFacts(runId, "events", validateNormalizedHookEvent),
+      this.#readFacts(runId, "reports", validateLoopReport),
+      this.#readFacts(runId, "transitions", validateLoopTransition),
+      this.#readFacts(runId, "operations", validateLoopOperation),
+      this.#readFacts(
+        runId,
+        "governor-decisions",
+        validateGovernorDecision,
+      ),
+    ]);
+    const committedReportIds = new Set(
+      operationRead.facts
+        .map((operation) => operation.reportId)
+        .filter(Boolean),
+    );
+    const committedTransitionIds = new Set(
+      operationRead.facts.map((operation) => operation.transitionId),
+    );
+    const reportRead = {
+      ...reportCandidates,
+      facts: reportCandidates.facts.filter(
+        (report) =>
+          report.requestId === undefined ||
+          committedReportIds.has(report.reportId),
+      ),
+    };
+    const transitionRead = {
+      ...transitionCandidates,
+      facts: transitionCandidates.facts.filter(
+        (transition) =>
+          transition.requestId === undefined ||
+          committedTransitionIds.has(transition.transitionId),
+      ),
+    };
+    const corruptRecords = [
+      ...eventRead.corrupt,
+      ...reportCandidates.corrupt,
+      ...transitionCandidates.corrupt,
+      ...operationRead.corrupt,
+      ...governorDecisionRead.corrupt,
+    ];
+    for (const corrupt of corruptRecords) {
+      await this.writeDiagnostic(runId, "corrupt_fact", corrupt, "error");
+    }
+
+    const groups = new Map();
+    for (const event of eventRead.facts) {
+      const key = event.conflictEligible
+        ? event.semanticKey
+        : `${event.semanticKey}:${event.eventId}`;
+      const values = groups.get(key) ?? [];
+      values.push(event);
+      groups.set(key, values);
+    }
+    const canonicalEvents = [];
+    const conflictGroups = [];
+    for (const [key, values] of groups) {
+      const sorted = [...values].sort((left, right) =>
+        compareCodePoints(left.eventId, right.eventId),
+      );
+      canonicalEvents.push(sorted[0]);
+      const payloadDigests = [
+        ...new Set(sorted.map((event) => event.payloadDigest)),
+      ].sort(compareCodePoints);
+      if (sorted[0].conflictEligible && payloadDigests.length > 1) {
+        const details = {
+          semanticKey: sorted[0].semanticKey,
+          payloadDigests,
+          candidateEventIds: sorted.map((event) => event.eventId),
+          canonicalEventId: sorted[0].eventId,
+        };
+        conflictGroups.push(details);
+        await this.writeDiagnostic(
+          runId,
+          "semantic_event_conflict",
+          details,
+          "error",
+        );
+      }
+      if (!key.includes(":evt_")) {
+        groups.set(sorted[0].semanticKey, sorted);
+      }
+    }
+    const eligibleGroups = new Map(
+      [...groups.entries()].filter(
+        ([key, values]) =>
+          !key.includes(":evt_") && values[0]?.conflictEligible === true,
+      ),
+    );
+    await this.#writeSemanticIndexes(runId, eligibleGroups);
+    canonicalEvents.sort((left, right) => compareFacts("events", left, right));
+    eventRead.facts.sort((left, right) => compareFacts("events", left, right));
+    reportRead.facts.sort((left, right) => compareFacts("reports", left, right));
+    transitionRead.facts.sort((left, right) =>
+      compareFacts("transitions", left, right),
+    );
+    governorDecisionRead.facts.sort((left, right) =>
+      compareFacts("governor-decisions", left, right),
+    );
+
+    const state = await this.#readOrRebuildState(runId, canonicalEvents);
+    const diagnosticRead = await this.#readDiagnostics(runId);
+    for (const corrupt of diagnosticRead.corrupt) {
+      // A corrupt diagnostic cannot safely diagnose itself in the same
+      // directory. Count it separately and keep folding fail-open.
+      corruptRecords.push(corrupt);
+    }
+    const nodes = new Map();
+    nodes.set(state.rootSessionId, {
+      id: state.rootSessionId,
+      kind: "root",
+    });
+    for (const event of canonicalEvents) {
+      if (event.agentId) {
+        nodes.set(event.agentId, {
+          id: event.agentId,
+          kind: "subagent",
+          ...(event.agentType ? { agentType: event.agentType } : {}),
+        });
+      }
+    }
+    const timeline = [
+      ...canonicalEvents.map((event) => ({
+        kind: "event",
+        id: event.eventId,
+        at: event.observedAt,
+        event: event.event,
+        ...(event.agentId ? { agentId: event.agentId } : {}),
+      })),
+      ...reportRead.facts.map((report) => ({
+        kind: "report",
+        id: report.reportId,
+        at: report.createdAt,
+        type: report.type,
+        fromNode: report.fromNode,
+        ...(report.verdict ? { verdict: report.verdict } : {}),
+      })),
+      ...transitionRead.facts.map((transition) => ({
+        kind: "transition",
+        id: transition.transitionId,
+        at: transition.createdAt,
+        transitionKind: transition.kind,
+        lap: transition.lap,
+      })),
+      ...governorDecisionRead.facts.map((decision) => ({
+        kind: "governor-decision",
+        id: decision.decisionId,
+        at: decision.createdAt,
+        action: decision.action,
+        reasonCode: decision.reasonCode,
+      })),
+    ]
+      .sort((left, right) => {
+        const timeOrder = compareCodePoints(left.at, right.at);
+        if (timeOrder !== 0) {
+          return timeOrder;
+        }
+        const kindOrder = compareCodePoints(left.kind, right.kind);
+        return kindOrder !== 0
+          ? kindOrder
+          : compareCodePoints(left.id, right.id);
+      })
+      .slice(-timelineLimit);
+    const latestReport =
+      reportRead.facts.find((report) => report.reportId === state.latestReportId) ??
+      reportRead.facts.at(-1);
+    const baseProjection = {
+      schemaVersion: SCHEMA_VERSION,
+      storeVersion: STORE_VERSION,
+      // foldRun remains the P1-A maintenance/recovery projection. Product
+      // viewers use LoopController.snapshotForRun and graph-projection-v3.
+      projectionVersion: LEGACY_FOLD_PROJECTION_VERSION,
+      runId,
+      status: state.status,
+      revision: state.revision,
+      currentLap: state.currentLap,
+      continuationLease: state.continuationLease,
+      cancelRequested: state.cancelRequested,
+      needsHuman: state.needsHuman ?? false,
+      nodes: [...nodes.values()].sort((left, right) =>
+        compareCodePoints(left.id, right.id),
+      ),
+      counts: {
+        events: canonicalEvents.length,
+        eventCandidates: eventRead.facts.length,
+        reports: reportRead.facts.length,
+        transitions: transitionRead.facts.length,
+        operations: operationRead.facts.length,
+        governorDecisions:
+          governorDecisionRead.facts.length,
+        orphanReports:
+          reportCandidates.facts.length - reportRead.facts.length,
+        orphanTransitions:
+          transitionCandidates.facts.length -
+          transitionRead.facts.length,
+        diagnostics: diagnosticRead.facts.length,
+        conflicts: conflictGroups.length,
+        corrupt: corruptRecords.length,
+      },
+      ...(latestReport
+        ? {
+            latestReport: {
+              reportId: latestReport.reportId,
+              fromNode: latestReport.fromNode,
+              type: latestReport.type,
+              ...(latestReport.verdict
+                ? { verdict: latestReport.verdict }
+                : {}),
+            },
+          }
+        : {}),
+      ...(state.pendingTransitionId
+        ? { pendingTransitionId: state.pendingTransitionId }
+        : {}),
+      ...(state.latestGovernorDecisionId
+        ? {
+            latestGovernorDecisionId:
+              state.latestGovernorDecisionId,
+          }
+        : {}),
+      timeline,
+    };
+    const projection = {
+      ...baseProjection,
+      projectionDigest: digestJson(baseProjection),
+    };
+    if (writeProjection) {
+      await atomicReplaceJson(this.projectionPath(runId), projection, {
+        root: this.dataRoot,
+      });
+    }
+    return projection;
+  }
+
+  async enforceRetention(runId, options = {}) {
+    assertSafeFileId(runId, "runId");
+    const lockPath = path.join(
+      this.runDirectory(runId),
+      "locks",
+      "state.lock",
+    );
+    return withFileLock(
+      lockPath,
+      () => this.#enforceRetentionLocked(runId),
+      { ...options, root: this.dataRoot },
+    );
+  }
+
+  async #enforceRetentionLocked(runId) {
+    const state = await this.readState(runId);
+    if (!TERMINAL_STATUSES.has(state.status)) {
+      return { status: "skipped-active", removed: [] };
+    }
+    const operationRead = await this.#readFacts(
+      runId,
+      "operations",
+      validateLoopOperation,
+    );
+    const governorDecisionRead = await this.#readFacts(
+      runId,
+      "governor-decisions",
+      validateGovernorDecision,
+    );
+    const recoveryRead = await this.#readFacts(
+      runId,
+      "recoveries",
+      validateLegacyQuarantineReceipt,
+    );
+    const protectedIds = new Set(
+      [
+        state.latestReportId,
+        state.pendingTransitionId,
+        state.latestGovernorDecisionId,
+        state.latestRecoveryId,
+        ...operationRead.facts.flatMap((operation) => [
+          operation.reportId,
+          operation.transitionId,
+        ]),
+        ...governorDecisionRead.facts.flatMap(
+          (decision) => [
+            decision.decisionId,
+            decision.originEventId,
+            decision.pendingTransitionId,
+          ],
+        ),
+        ...recoveryRead.facts.map(
+          (recovery) => recovery.recoveryId,
+        ),
+      ].filter(Boolean),
+    );
+    const records = [];
+    const retentionKinds = [
+      "definitions",
+      "events",
+      "observations",
+      "operations",
+      "governor-decisions",
+      "recoveries",
+      "reports",
+      "transitions",
+      "diagnostics",
+    ];
+    for (const kind of retentionKinds) {
+      const validator =
+        kind === "diagnostics" ? validateDiagnostic : validatorFor(kind);
+      const { facts } =
+        kind === "operations"
+          ? operationRead
+          : kind === "governor-decisions"
+            ? governorDecisionRead
+            : kind === "recoveries"
+              ? recoveryRead
+            : await this.#readFacts(runId, kind, validator);
+      for (const value of facts) {
+        const id = factId(kind, value);
+        const file = path.join(this.factDirectory(runId, kind), `${id}.json`);
+        const metadata = await stat(file);
+        records.push({
+          kind,
+          id,
+          file,
+          bytes: metadata.size,
+          at:
+            kind === "diagnostics"
+              ? value.createdAt
+              : factTime(kind, value),
+          protected:
+            [
+              "definitions",
+              "operations",
+              "governor-decisions",
+              "recoveries",
+            ].includes(kind) ||
+            protectedIds.has(id),
+        });
+      }
+    }
+    const removed = [];
+    for (const kind of retentionKinds) {
+      const limit =
+        kind === "diagnostics"
+          ? Math.max(0, this.retention[kind] - 1)
+          : this.retention[kind];
+      const candidates = records
+        .filter((record) => record.kind === kind)
+        .sort((left, right) => {
+          const timeOrder = compareCodePoints(
+            String(left.at),
+            String(right.at),
+          );
+          return timeOrder !== 0
+            ? timeOrder
+            : compareCodePoints(left.id, right.id);
+        });
+      while (candidates.length > limit) {
+        const index = candidates.findIndex((record) => !record.protected);
+        if (index < 0) {
+          break;
+        }
+        const [record] = candidates.splice(index, 1);
+        await unlink(record.file);
+        removed.push(record);
+      }
+    }
+    let remainingBytes = records
+      .filter((record) => !removed.includes(record))
+      .reduce((sum, record) => sum + record.bytes, 0);
+    const byteCandidates = records
+      .filter((record) => !record.protected && !removed.includes(record))
+      .sort((left, right) => {
+        const timeOrder = compareCodePoints(
+          String(left.at),
+          String(right.at),
+        );
+        return timeOrder !== 0
+          ? timeOrder
+          : compareCodePoints(left.id, right.id);
+      });
+    while (
+      remainingBytes > this.retention.terminalBytes &&
+      byteCandidates.length > 0
+    ) {
+      const record = byteCandidates.shift();
+      await unlink(record.file);
+      removed.push(record);
+      remainingBytes -= record.bytes;
+    }
+    if (removed.length > 0) {
+      await this.writeDiagnostic(runId, "retention_pruned", {
+        removedCount: removed.length,
+        removedDigest: digestJson(
+          removed
+            .map((record) => ({ kind: record.kind, id: record.id }))
+            .sort((left, right) =>
+              compareCodePoints(
+                `${left.kind}:${left.id}`,
+                `${right.kind}:${right.id}`,
+              ),
+            ),
+        ),
+        remainingBytes,
+      });
+    }
+    return {
+      status: "pruned",
+      removed: removed.map((record) => ({
+        kind: record.kind,
+        id: record.id,
+      })),
+      remainingBytes,
+    };
+  }
+}
diff --git a/plugins/looperators-agent-loop/mcp/server.mjs b/plugins/looperators-agent-loop/mcp/server.mjs
new file mode 100644
index 0000000..95abd9b
--- /dev/null
+++ b/plugins/looperators-agent-loop/mcp/server.mjs
@@ -0,0 +1,496 @@
+#!/usr/bin/env node
+
+import { createInterface } from "node:readline";
+import process from "node:process";
+import {
+  LoopController,
+  rootContextFromMcpMessage,
+} from "../lib/control.mjs";
+import { LoopStore } from "../lib/store.mjs";
+import { startSidecar } from "../scripts/sidecar-server.mjs";
+
+const SUPPORTED_NODE_MAJOR = 24;
+const nodeMajor = Number.parseInt(
+  process.versions.node.split(".")[0] ?? "",
+  10,
+);
+if (nodeMajor !== SUPPORTED_NODE_MAJOR) {
+  process.stderr.write(
+    `looperators Agent Loop requires Node.js ${SUPPORTED_NODE_MAJOR}.x; received ${process.versions.node}.\n`,
+  );
+  process.exit(1);
+}
+
+const REQUEST_ID = {
+  type: "string",
+  pattern: "^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$",
+};
+const RUN_ID = { ...REQUEST_ID };
+const STATE_OUTPUT = {
+  schemaVersion: { type: "integer", const: 1 },
+  runId: { type: "string" },
+  status: { type: "string" },
+  revision: { type: "integer" },
+  currentLap: { type: "integer" },
+  lapCap: { type: "integer" },
+  duplicate: { type: "boolean" },
+};
+const SNAPSHOT_OUTPUT = {
+  schemaVersion: { type: "integer", const: 1 },
+  storeVersion: { type: "integer", const: 1 },
+  projectionVersion: { type: "integer", const: 3 },
+  runId: { type: "string" },
+  revision: { type: "integer" },
+  status: { type: "string" },
+  recipe: { type: "string", const: "review-until-clean" },
+  currentLap: { type: "integer" },
+  lapCap: { type: "integer" },
+  continuationLease: { type: "object" },
+  cancelRequested: { type: "boolean" },
+  needsHuman: { type: "boolean" },
+  integrity: { type: "object" },
+  eventWatermark: { type: "object" },
+  nodes: { type: "array" },
+  edges: { type: "array" },
+  counts: { type: "object" },
+  timeline: { type: "array" },
+  projectionDigest: {
+    type: "string",
+    pattern: "^[a-f0-9]{64}$",
+  },
+};
+
+function tool(
+  name,
+  description,
+  properties,
+  required,
+  outputProperties,
+  options = {},
+) {
+  return {
+    name,
+    title: name
+      .split("_")
+      .map((part) => part[0].toUpperCase() + part.slice(1))
+      .join(" "),
+    description,
+    inputSchema: {
+      type: "object",
+      properties,
+      required,
+      additionalProperties: false,
+    },
+    outputSchema: {
+      type: "object",
+      properties: outputProperties,
+      required:
+        options.outputRequired ?? Object.keys(outputProperties),
+      additionalProperties: true,
+    },
+    annotations: {
+      readOnlyHint: options.readOnlyHint ?? false,
+      destructiveHint: options.destructiveHint ?? false,
+      idempotentHint: options.idempotentHint ?? true,
+      openWorldHint: false,
+    },
+  };
+}
+
+function toolsList() {
+  const control = [
+    [
+      "start",
+      "Start a user-confirmed draft and return the current cooperative role capability. This does not create a subagent.",
+      {},
+    ],
+    ["pause", "Pause a running or interrupted loop.", {}],
+    ["resume", "Resume a paused or interrupted loop.", {}],
+    [
+      "cancel",
+      "Cancel a non-terminal loop and revoke its action.",
+      { destructiveHint: true },
+    ],
+  ];
+  return [
+    tool(
+      "looperators_preview_loop",
+      "Create or replay a task-scoped draft without starting provider work.",
+      {
+        requestId: REQUEST_ID,
+        goal: { type: "string", minLength: 1, maxLength: 8192 },
+        implementerInstructions: {
+          type: "string",
+          minLength: 1,
+          maxLength: 16384,
+        },
+        reviewerInstructions: {
+          type: "string",
+          minLength: 1,
+          maxLength: 16384,
+        },
+        lapCap: {
+          type: "integer",
+          minimum: 1,
+          maximum: 6,
+          default: 3,
+        },
+      },
+      [
+        "requestId",
+        "goal",
+        "implementerInstructions",
+        "reviewerInstructions",
+      ],
+      STATE_OUTPUT,
+    ),
+    ...control.map(([action, description, options]) =>
+      tool(
+        `looperators_${action}_loop`,
+        description,
+        { runId: RUN_ID, requestId: REQUEST_ID },
+        ["runId", "requestId"],
+        STATE_OUTPUT,
+        options,
+      ),
+    ),
+    tool(
+      "looperators_report",
+      "Submit one action-scoped typed implementer or reviewer report.",
+      {
+        runId: RUN_ID,
+        requestId: REQUEST_ID,
+        role: { enum: ["implementer", "reviewer"] },
+        capabilityToken: {
+          type: "string",
+          minLength: 64,
+          maxLength: 2048,
+        },
+        type: { enum: ["info", "verdict"] },
+        status: { const: "done" },
+        verdict: { enum: ["clean", "issues"] },
+        issues: {
+          type: "array",
+          maxItems: 200,
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["message"],
+            properties: {
+              message: {
+                type: "string",
+                minLength: 1,
+                maxLength: 4000,
+              },
+              file: {
+                type: "string",
+                minLength: 1,
+                maxLength: 2000,
+              },
+              line: { type: "integer", minimum: 1 },
+              severity: { enum: ["info", "warn", "error"] },
+            },
+          },
+        },
+        summary: { type: "string", minLength: 1, maxLength: 8000 },
+      },
+      ["runId", "requestId", "role", "capabilityToken", "type"],
+      STATE_OUTPUT,
+    ),
+    tool(
+      "looperators_get_loop",
+      "Read authoritative loop state and return the current cooperative role capability for this root task; a new Governor MCP process rotates the token.",
+      { runId: RUN_ID },
+      ["runId"],
+      STATE_OUTPUT,
+      { readOnlyHint: false },
+    ),
+    tool(
+      "looperators_get_snapshot",
+      "Read the complete verified graph projection for this root task.",
+      { runId: RUN_ID },
+      ["runId"],
+      SNAPSHOT_OUTPUT,
+      { readOnlyHint: true },
+    ),
+    tool(
+      "looperators_open_review_surface",
+      "Open or refresh the authenticated localhost live review surface for this root task. Return the URL for Codex Desktop's built-in Browser.",
+      { runId: RUN_ID },
+      ["runId"],
+      {
+        schemaVersion: { type: "integer", const: 1 },
+        runId: { type: "string" },
+        status: { const: "ready" },
+        reviewUrl: { type: "string" },
+        origin: { type: "string" },
+        expiresAt: { type: "string" },
+      },
+      { idempotentHint: false },
+    ),
+    tool(
+      "looperators_close_review_surface",
+      "Close the localhost live review surface for this root task.",
+      { runId: RUN_ID },
+      ["runId"],
+      {
+        schemaVersion: { type: "integer", const: 1 },
+        runId: { type: "string" },
+        status: { const: "closed" },
+      },
+    ),
+  ];
+}
+
+const TOOL_ARGUMENT_KEYS = new Map([
+  [
+    "looperators_preview_loop",
+    new Set([
+      "requestId",
+      "goal",
+      "implementerInstructions",
+      "reviewerInstructions",
+      "lapCap",
+    ]),
+  ],
+  ...["start", "pause", "resume", "cancel"].map((action) => [
+    `looperators_${action}_loop`,
+    new Set(["runId", "requestId"]),
+  ]),
+  [
+    "looperators_report",
+    new Set([
+      "runId",
+      "requestId",
+      "role",
+      "capabilityToken",
+      "type",
+      "status",
+      "verdict",
+      "issues",
+      "summary",
+    ]),
+  ],
+  ["looperators_get_loop", new Set(["runId"])],
+  ["looperators_get_snapshot", new Set(["runId"])],
+  ["looperators_open_review_surface", new Set(["runId"])],
+  ["looperators_close_review_surface", new Set(["runId"])],
+]);
+
+function validatedArguments(message, name) {
+  const value = message.params?.arguments;
+  const allowed = TOOL_ARGUMENT_KEYS.get(name);
+  if (
+    value === null ||
+    typeof value !== "object" ||
+    Array.isArray(value) ||
+    !allowed ||
+    Object.keys(value).some((key) => !allowed.has(key))
+  ) {
+    const error = new TypeError("tool arguments are invalid");
+    error.code = "INVALID_TOOL_INPUT";
+    throw error;
+  }
+  return value;
+}
+
+let runtimePromise;
+
+async function runtime() {
+  runtimePromise ??= LoopStore.open().then((store) => ({
+    store,
+    control: new LoopController(store),
+    sidecars: new Map(),
+  }));
+  return runtimePromise;
+}
+
+async function openReviewSurface(message, args) {
+  const current = await runtime();
+  const context = rootContextFromMcpMessage(message);
+  await current.control.getLoop(context, args);
+  let entry = current.sidecars.get(args.runId);
+  if (!entry) {
+    entry = { context, sidecar: undefined };
+    entry.sidecar = await startSidecar({
+      runId: args.runId,
+      host: "127.0.0.1",
+      port: 0,
+      store: current.store,
+      controller: current.control,
+      onControl: ({ action, requestId }) =>
+        current.control[action](entry.context, {
+          runId: args.runId,
+          requestId,
+        }),
+    });
+    current.sidecars.set(args.runId, entry);
+  } else {
+    entry.context = context;
+  }
+  const ticket = entry.sidecar.issueTicket();
+  return {
+    schemaVersion: 1,
+    runId: args.runId,
+    status: "ready",
+    reviewUrl: ticket.url,
+    origin: entry.sidecar.origin,
+    expiresAt: ticket.expiresAt,
+  };
+}
+
+async function closeReviewSurface(message, args) {
+  const current = await runtime();
+  const context = rootContextFromMcpMessage(message);
+  await current.control.getLoop(context, args);
+  const entry = current.sidecars.get(args.runId);
+  if (entry) {
+    await entry.sidecar.close();
+    current.sidecars.delete(args.runId);
+  }
+  return {
+    schemaVersion: 1,
+    runId: args.runId,
+    status: "closed",
+  };
+}
+
+async function callProductTool(message, name) {
+  const args = validatedArguments(message, name);
+  const { control } = await runtime();
+  switch (name) {
+    case "looperators_preview_loop":
+      return control.preview(rootContextFromMcpMessage(message), args);
+    case "looperators_start_loop":
+      return control.start(rootContextFromMcpMessage(message), args);
+    case "looperators_pause_loop":
+      return control.pause(rootContextFromMcpMessage(message), args);
+    case "looperators_resume_loop":
+      return control.resume(rootContextFromMcpMessage(message), args);
+    case "looperators_cancel_loop":
+      return control.cancel(rootContextFromMcpMessage(message), args);
+    case "looperators_report":
+      return control.report(args);
+    case "looperators_get_loop":
+      return control.getLoop(rootContextFromMcpMessage(message), args);
+    case "looperators_get_snapshot":
+      return control.getSnapshot(rootContextFromMcpMessage(message), args);
+    case "looperators_open_review_surface":
+      return openReviewSurface(message, args);
+    case "looperators_close_review_surface":
+      return closeReviewSurface(message, args);
+    default: {
+      const error = new Error(`unknown tool: ${name}`);
+      error.code = -32601;
+      throw error;
+    }
+  }
+}
+
+function toolExecutionError(error) {
+  const code =
+    typeof error?.code === "string" &&
+    /^[A-Z][A-Z0-9_]{0,63}$/u.test(error.code)
+      ? error.code
+      : "TOOL_EXECUTION_ERROR";
+  return {
+    content: [{ type: "text", text: `looperators tool failed: ${code}` }],
+    isError: true,
+  };
+}
+
+async function dispatch(message) {
+  switch (message.method) {
+    case "initialize":
+      return {
+        protocolVersion: message.params?.protocolVersion ?? "2025-06-18",
+        capabilities: { tools: { listChanged: false } },
+        serverInfo: { name: "looperators-agent-loop", version: "0.3.2" },
+      };
+    case "notifications/initialized":
+      return undefined;
+    case "tools/list":
+      return { tools: toolsList() };
+    case "tools/call": {
+      const name = message.params?.name;
+      if (!TOOL_ARGUMENT_KEYS.has(name)) {
+        const error = new Error(`unknown tool: ${String(name)}`);
+        error.code = -32601;
+        throw error;
+      }
+      let structuredContent;
+      try {
+        structuredContent = await callProductTool(message, name);
+      } catch (error) {
+        return toolExecutionError(error);
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: `looperators ${structuredContent.runId} is ${structuredContent.status}`,
+          },
+        ],
+        structuredContent,
+        isError: false,
+      };
+    }
+    default: {
+      if (message.id === undefined) return undefined;
+      const error = new Error(`method not found: ${message.method}`);
+      error.code = -32601;
+      throw error;
+    }
+  }
+}
+
+const input = createInterface({
+  input: process.stdin,
+  crlfDelay: Infinity,
+  terminal: false,
+});
+
+for await (const line of input) {
+  if (!line.trim()) continue;
+  let message;
+  try {
+    message = JSON.parse(line);
+  } catch {
+    process.stdout.write(
+      `${JSON.stringify({
+        jsonrpc: "2.0",
+        id: null,
+        error: { code: -32700, message: "parse error" },
+      })}\n`,
+    );
+    continue;
+  }
+  try {
+    const result = await dispatch(message);
+    if (message.id !== undefined && result !== undefined) {
+      process.stdout.write(
+        `${JSON.stringify({ jsonrpc: "2.0", id: message.id, result })}\n`,
+      );
+    }
+  } catch (error) {
+    if (message.id !== undefined) {
+      process.stdout.write(
+        `${JSON.stringify({
+          jsonrpc: "2.0",
+          id: message.id,
+          error: {
+            code: Number.isInteger(error?.code) ? error.code : -32603,
+            message: String(error?.code ?? "internal error"),
+          },
+        })}\n`,
+      );
+    }
+  }
+}
+
+if (runtimePromise) {
+  const current = await runtimePromise;
+  await Promise.allSettled(
+    [...current.sidecars.values()].map((entry) => entry.sidecar.close()),
+  );
+}
diff --git a/plugins/looperators-agent-loop/schemas/definition.schema.json b/plugins/looperators-agent-loop/schemas/definition.schema.json
new file mode 100644
index 0000000..22dbd7d
--- /dev/null
+++ b/plugins/looperators-agent-loop/schemas/definition.schema.json
@@ -0,0 +1,53 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://looperators.local/schemas/agent-loop/definition-v1.json",
+  "title": "looperators Loop Definition v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schemaVersion",
+    "definitionId",
+    "runId",
+    "requestId",
+    "requestDigest",
+    "recipe",
+    "goal",
+    "implementerInstructions",
+    "reviewerInstructions",
+    "lapCap",
+    "createdAt"
+  ],
+  "properties": {
+    "schemaVersion": { "const": 1 },
+    "definitionId": {
+      "type": "string",
+      "pattern": "^definition_[a-f0-9]{64}$"
+    },
+    "runId": {
+      "type": "string",
+      "pattern": "^run_[a-f0-9]{64}$"
+    },
+    "requestId": {
+      "type": "string",
+      "pattern": "^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$"
+    },
+    "requestDigest": {
+      "type": "string",
+      "pattern": "^[a-f0-9]{64}$"
+    },
+    "recipe": { "const": "review-until-clean" },
+    "goal": { "type": "string", "minLength": 1, "maxLength": 8192 },
+    "implementerInstructions": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 16384
+    },
+    "reviewerInstructions": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 16384
+    },
+    "lapCap": { "type": "integer", "minimum": 1, "maximum": 6 },
+    "createdAt": { "type": "string", "format": "date-time" }
+  }
+}
diff --git a/plugins/looperators-agent-loop/schemas/event.schema.json b/plugins/looperators-agent-loop/schemas/event.schema.json
new file mode 100644
index 0000000..763b98c
--- /dev/null
+++ b/plugins/looperators-agent-loop/schemas/event.schema.json
@@ -0,0 +1,36 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://looperators.local/schemas/agent-loop/event-v1.json",
+  "title": "looperators Normalized Hook Event v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schemaVersion",
+    "semanticKeyVersion",
+    "eventId",
+    "semanticKey",
+    "sessionId",
+    "event",
+    "observedAt",
+    "payloadDigest",
+    "conflictEligible"
+  ],
+  "properties": {
+    "schemaVersion": { "const": 1 },
+    "semanticKeyVersion": { "const": 1 },
+    "eventId": { "type": "string", "pattern": "^evt_[a-f0-9]{64}$" },
+    "semanticKey": { "type": "string", "pattern": "^sem-v1:[a-f0-9]{64}$" },
+    "sessionId": { "type": "string", "minLength": 1, "maxLength": 256 },
+    "turnId": { "type": "string", "minLength": 1, "maxLength": 256 },
+    "event": { "type": "string", "minLength": 1, "maxLength": 64 },
+    "agentId": { "type": "string", "minLength": 1, "maxLength": 256 },
+    "agentType": { "type": "string", "minLength": 1, "maxLength": 128 },
+    "toolUseId": { "type": "string", "minLength": 1, "maxLength": 256 },
+    "stopHookActive": { "type": "boolean" },
+    "observedAt": { "type": "string", "format": "date-time" },
+    "payloadDigest": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+    "payloadSummary": { "type": "object" },
+    "causeRef": { "type": "string", "minLength": 1, "maxLength": 256 },
+    "conflictEligible": { "type": "boolean" }
+  }
+}
diff --git a/plugins/looperators-agent-loop/schemas/governor-decision.schema.json b/plugins/looperators-agent-loop/schemas/governor-decision.schema.json
new file mode 100644
index 0000000..e78173a
--- /dev/null
+++ b/plugins/looperators-agent-loop/schemas/governor-decision.schema.json
@@ -0,0 +1,182 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://looperators.local/schemas/agent-loop/governor-decision-v1.json",
+  "title": "looperators Governor Decision v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schemaVersion",
+    "decisionId",
+    "runId",
+    "obligationId",
+    "originEventId",
+    "hookEvent",
+    "rootSessionId",
+    "action",
+    "reasonCode",
+    "pendingTransitionId",
+    "fromRevision",
+    "toRevision",
+    "createdAt"
+  ],
+  "properties": {
+    "schemaVersion": { "const": 1 },
+    "decisionId": {
+      "type": "string",
+      "pattern": "^decision_[a-f0-9]{64}$"
+    },
+    "runId": { "type": "string", "minLength": 1, "maxLength": 128 },
+    "obligationId": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 128
+    },
+    "originEventId": {
+      "type": "string",
+      "pattern": "^evt_[a-f0-9]{64}$"
+    },
+    "hookEvent": {
+      "enum": ["Stop", "SubagentStop", "SessionStart"]
+    },
+    "rootSessionId": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 256
+    },
+    "turnId": { "type": "string", "minLength": 1, "maxLength": 256 },
+    "agentId": { "type": "string", "minLength": 1, "maxLength": 256 },
+    "action": { "enum": ["block", "cap", "interrupt"] },
+    "reasonCode": {
+      "enum": [
+        "pending-root-transition",
+        "pending-worker-report",
+        "lease-exhausted",
+        "resume-in-flight"
+      ]
+    },
+    "pendingTransitionId": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 128
+    },
+    "fromRevision": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 9007199254740991
+    },
+    "toRevision": {
+      "type": "integer",
+      "minimum": 1,
+      "maximum": 9007199254740991
+    },
+    "leaseEpoch": { "type": "integer", "minimum": 1, "maximum": 6 },
+    "createdAt": { "type": "string", "format": "date-time" }
+  },
+  "allOf": [
+    {
+      "if": {
+        "properties": { "hookEvent": { "const": "SubagentStop" } },
+        "required": ["hookEvent"]
+      },
+      "then": {
+        "properties": { "agentId": true },
+        "required": ["agentId"]
+      },
+      "else": {
+        "not": {
+          "properties": { "agentId": true },
+          "required": ["agentId"]
+        }
+      }
+    },
+    {
+      "if": {
+        "properties": {
+          "hookEvent": { "enum": ["Stop", "SubagentStop"] }
+        },
+        "required": ["hookEvent"]
+      },
+      "then": {
+        "properties": { "turnId": true },
+        "required": ["turnId"]
+      }
+    },
+    {
+      "if": {
+        "properties": { "action": { "const": "block" } },
+        "required": ["action"]
+      },
+      "then": {
+        "required": ["leaseEpoch"],
+        "properties": {
+          "leaseEpoch": true,
+          "hookEvent": { "enum": ["Stop", "SubagentStop"] }
+        }
+      },
+      "else": {
+        "not": {
+          "properties": { "leaseEpoch": true },
+          "required": ["leaseEpoch"]
+        }
+      }
+    },
+    {
+      "if": {
+        "properties": { "action": { "const": "cap" } },
+        "required": ["action"]
+      },
+      "then": {
+        "properties": {
+          "hookEvent": { "enum": ["Stop", "SubagentStop"] },
+          "reasonCode": { "const": "lease-exhausted" }
+        }
+      }
+    },
+    {
+      "if": {
+        "properties": { "action": { "const": "interrupt" } },
+        "required": ["action"]
+      },
+      "then": {
+        "properties": {
+          "hookEvent": { "const": "SessionStart" },
+          "reasonCode": { "const": "resume-in-flight" }
+        }
+      }
+    },
+    {
+      "if": {
+        "properties": { "hookEvent": { "const": "Stop" } },
+        "required": ["hookEvent", "action"]
+      },
+      "then": {
+        "if": {
+          "properties": { "action": { "const": "block" } },
+          "required": ["action"]
+        },
+        "then": {
+          "properties": {
+            "reasonCode": { "const": "pending-root-transition" }
+          }
+        }
+      }
+    },
+    {
+      "if": {
+        "properties": { "hookEvent": { "const": "SubagentStop" } },
+        "required": ["hookEvent", "action"]
+      },
+      "then": {
+        "if": {
+          "properties": { "action": { "const": "block" } },
+          "required": ["action"]
+        },
+        "then": {
+          "properties": {
+            "reasonCode": { "const": "pending-worker-report" }
+          }
+        }
+      }
+    }
+  ]
+}
diff --git a/plugins/looperators-agent-loop/schemas/graph-projection.schema.json b/plugins/looperators-agent-loop/schemas/graph-projection.schema.json
new file mode 100644
index 0000000..0ff86f4
--- /dev/null
+++ b/plugins/looperators-agent-loop/schemas/graph-projection.schema.json
@@ -0,0 +1,441 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://looperators.local/schemas/agent-loop/graph-projection-v3.json",
+  "title": "looperators Agent Loop Graph Projection v3",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schemaVersion",
+    "storeVersion",
+    "projectionVersion",
+    "runId",
+    "revision",
+    "status",
+    "recipe",
+    "currentLap",
+    "lapCap",
+    "continuationLease",
+    "cancelRequested",
+    "needsHuman",
+    "integrity",
+    "eventWatermark",
+    "nodes",
+    "edges",
+    "counts",
+    "timeline",
+    "projectionDigest"
+  ],
+  "properties": {
+    "schemaVersion": { "const": 1 },
+    "storeVersion": { "const": 1 },
+    "projectionVersion": { "const": 3 },
+    "runId": { "type": "string", "minLength": 1, "maxLength": 128 },
+    "revision": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 9007199254740991
+    },
+    "status": {
+      "enum": [
+        "draft",
+        "running",
+        "paused",
+        "succeeded",
+        "capped",
+        "cancelled",
+        "failed",
+        "interrupted"
+      ]
+    },
+    "recipe": { "const": "review-until-clean" },
+    "currentLap": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 9007199254740991
+    },
+    "lapCap": { "type": "integer", "minimum": 1, "maximum": 6 },
+    "continuationLease": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["granted", "consumed"],
+      "properties": {
+        "granted": { "type": "integer", "minimum": 0, "maximum": 6 },
+        "consumed": { "type": "integer", "minimum": 0, "maximum": 6 }
+      },
+      "oneOf": [
+        {
+          "properties": {
+            "granted": { "const": 0 },
+            "consumed": { "type": "integer", "maximum": 0 }
+          }
+        },
+        {
+          "properties": {
+            "granted": { "const": 1 },
+            "consumed": { "type": "integer", "maximum": 1 }
+          }
+        },
+        {
+          "properties": {
+            "granted": { "const": 2 },
+            "consumed": { "type": "integer", "maximum": 2 }
+          }
+        },
+        {
+          "properties": {
+            "granted": { "const": 3 },
+            "consumed": { "type": "integer", "maximum": 3 }
+          }
+        },
+        {
+          "properties": {
+            "granted": { "const": 4 },
+            "consumed": { "type": "integer", "maximum": 4 }
+          }
+        },
+        {
+          "properties": {
+            "granted": { "const": 5 },
+            "consumed": { "type": "integer", "maximum": 5 }
+          }
+        },
+        {
+          "properties": {
+            "granted": { "const": 6 },
+            "consumed": { "type": "integer", "maximum": 6 }
+          }
+        }
+      ]
+    },
+    "cancelRequested": { "type": "boolean" },
+    "needsHuman": { "type": "boolean" },
+    "integrity": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["status", "verifiedRevision"],
+      "properties": {
+        "status": { "const": "verified" },
+        "verifiedRevision": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 9007199254740991
+        }
+      }
+    },
+    "eventWatermark": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["eventCount"],
+      "properties": {
+        "eventCount": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 9007199254740991
+        },
+        "lastEventId": {
+          "type": "string",
+          "pattern": "^evt_[a-f0-9]{64}$"
+        }
+      },
+      "allOf": [
+        {
+          "if": { "properties": { "eventCount": { "const": 0 } } },
+          "then": { "properties": { "lastEventId": false } },
+          "else": {
+            "properties": {
+              "lastEventId": {
+                "type": "string",
+                "pattern": "^evt_[a-f0-9]{64}$"
+              }
+            },
+            "required": ["lastEventId"]
+          }
+        }
+      ]
+    },
+    "nodes": {
+      "type": "array",
+      "minItems": 3,
+      "maxItems": 3,
+      "items": { "$ref": "#/$defs/node" },
+      "allOf": [
+        {
+          "contains": {
+            "type": "object",
+            "required": ["id"],
+            "properties": { "id": { "const": "root" } }
+          }
+        },
+        {
+          "contains": {
+            "type": "object",
+            "required": ["id"],
+            "properties": { "id": { "const": "role:implementer" } }
+          }
+        },
+        {
+          "contains": {
+            "type": "object",
+            "required": ["id"],
+            "properties": { "id": { "const": "role:reviewer" } }
+          }
+        }
+      ]
+    },
+    "edges": {
+      "type": "array",
+      "minItems": 4,
+      "maxItems": 4,
+      "items": { "$ref": "#/$defs/edge" }
+    },
+    "pending": { "$ref": "#/$defs/pending" },
+    "latestReport": { "$ref": "#/$defs/latestReport" },
+    "recovery": { "$ref": "#/$defs/recovery" },
+    "counts": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "events",
+        "reports",
+        "transitions",
+        "operations",
+        "governorDecisions",
+        "recoveries",
+        "diagnostics",
+        "conflicts",
+        "corrupt"
+      ],
+      "properties": {
+        "events": { "$ref": "#/$defs/count" },
+        "reports": { "$ref": "#/$defs/count" },
+        "transitions": { "$ref": "#/$defs/count" },
+        "operations": { "$ref": "#/$defs/count" },
+        "governorDecisions": { "$ref": "#/$defs/count" },
+        "recoveries": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 1
+        },
+        "diagnostics": { "$ref": "#/$defs/count" },
+        "conflicts": { "$ref": "#/$defs/count" },
+        "corrupt": { "const": 0 }
+      }
+    },
+    "timeline": {
+      "type": "array",
+      "maxItems": 32,
+      "items": { "$ref": "#/$defs/timelineItem" }
+    },
+    "projectionDigest": {
+      "type": "string",
+      "pattern": "^[a-f0-9]{64}$"
+    }
+  },
+  "$defs": {
+    "count": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 9007199254740991
+    },
+    "role": { "enum": ["implementer", "reviewer"] },
+    "nodeId": {
+      "enum": ["root", "role:implementer", "role:reviewer"]
+    },
+    "node": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "kind", "label", "state"],
+      "properties": {
+        "id": { "$ref": "#/$defs/nodeId" },
+        "kind": { "enum": ["root", "worker-role"] },
+        "role": { "$ref": "#/$defs/role" },
+        "label": { "type": "string", "minLength": 1, "maxLength": 64 },
+        "state": {
+          "enum": ["active", "waiting", "bound", "unbound", "terminal"]
+        },
+        "nativeAgentId": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 256
+        },
+        "nativeAgentType": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 128
+        }
+      },
+      "dependentRequired": {
+        "nativeAgentType": ["nativeAgentId"]
+      },
+      "oneOf": [
+        {
+          "properties": {
+            "id": { "const": "root" },
+            "kind": { "const": "root" },
+            "role": false,
+            "nativeAgentId": false,
+            "nativeAgentType": false
+          }
+        },
+        {
+          "properties": {
+            "id": { "const": "role:implementer" },
+            "kind": { "const": "worker-role" },
+            "role": { "const": "implementer" }
+          },
+          "required": ["role"]
+        },
+        {
+          "properties": {
+            "id": { "const": "role:reviewer" },
+            "kind": { "const": "worker-role" },
+            "role": { "const": "reviewer" }
+          },
+          "required": ["role"]
+        }
+      ]
+    },
+    "edge": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "id",
+        "source",
+        "target",
+        "kind",
+        "active",
+        "reportCount"
+      ],
+      "properties": {
+        "id": { "type": "string", "minLength": 1, "maxLength": 64 },
+        "source": { "$ref": "#/$defs/nodeId" },
+        "target": { "$ref": "#/$defs/nodeId" },
+        "kind": {
+          "enum": ["governs", "handoff", "feedback", "verdict"]
+        },
+        "active": { "type": "boolean" },
+        "reportCount": { "$ref": "#/$defs/count" }
+      }
+    },
+    "pending": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["transitionId", "kind", "role", "lap"],
+      "properties": {
+        "transitionId": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 128
+        },
+        "kind": {
+          "enum": ["activate-implementer", "activate-reviewer"]
+        },
+        "role": { "$ref": "#/$defs/role" },
+        "lap": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 9007199254740991
+        }
+      },
+      "oneOf": [
+        {
+          "properties": {
+            "kind": { "const": "activate-implementer" },
+            "role": { "const": "implementer" }
+          }
+        },
+        {
+          "properties": {
+            "kind": { "const": "activate-reviewer" },
+            "role": { "const": "reviewer" }
+          }
+        }
+      ]
+    },
+    "latestReport": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["reportId", "fromRole", "type", "issueCount"],
+      "properties": {
+        "reportId": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 128
+        },
+        "fromRole": { "$ref": "#/$defs/role" },
+        "type": { "enum": ["info", "verdict"] },
+        "verdict": { "enum": ["issues", "clean"] },
+        "issueCount": { "type": "integer", "minimum": 0, "maximum": 200 }
+      },
+      "allOf": [
+        {
+          "if": {
+            "properties": { "type": { "const": "verdict" } },
+            "required": ["type"]
+          },
+          "then": {
+            "properties": {
+              "verdict": { "enum": ["issues", "clean"] }
+            },
+            "required": ["verdict"]
+          },
+          "else": { "properties": { "verdict": false } }
+        },
+        {
+          "if": {
+            "properties": { "verdict": { "const": "clean" } },
+            "required": ["verdict"]
+          },
+          "then": {
+            "properties": { "issueCount": { "const": 0 } }
+          }
+        },
+        {
+          "if": {
+            "properties": { "verdict": { "const": "issues" } },
+            "required": ["verdict"]
+          },
+          "then": {
+            "properties": {
+              "issueCount": { "type": "integer", "minimum": 1 }
+            }
+          }
+        }
+      ]
+    },
+    "recovery": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["recoveryId", "reason"],
+      "properties": {
+        "recoveryId": {
+          "type": "string",
+          "pattern": "^recovery_[a-f0-9]{64}$"
+        },
+        "reason": {
+          "const": "legacy-history-quarantined"
+        }
+      }
+    },
+    "timelineItem": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["kind", "id", "at", "label"],
+      "properties": {
+        "kind": {
+          "enum": [
+            "event",
+            "report",
+            "transition",
+            "governor-decision",
+            "recovery"
+          ]
+        },
+        "id": { "type": "string", "minLength": 1, "maxLength": 128 },
+        "at": { "type": "string", "format": "date-time" },
+        "label": { "type": "string", "minLength": 1, "maxLength": 128 },
+        "role": { "$ref": "#/$defs/role" }
+      }
+    }
+  }
+}
diff --git a/plugins/looperators-agent-loop/schemas/identity-binding.schema.json b/plugins/looperators-agent-loop/schemas/identity-binding.schema.json
new file mode 100644
index 0000000..0730dd7
--- /dev/null
+++ b/plugins/looperators-agent-loop/schemas/identity-binding.schema.json
@@ -0,0 +1,135 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://looperators.local/schemas/agent-loop/identity-binding-v1.json",
+  "title": "looperators Identity Binding v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schemaVersion",
+    "bindingId",
+    "runId",
+    "agentId",
+    "rootSessionId",
+    "method",
+    "createdAt"
+  ],
+  "properties": {
+    "schemaVersion": { "const": 1 },
+    "bindingId": { "type": "string", "minLength": 1, "maxLength": 128 },
+    "runId": { "type": "string", "minLength": 1, "maxLength": 128 },
+    "agentId": { "type": "string", "minLength": 1, "maxLength": 256 },
+    "rootSessionId": { "type": "string", "minLength": 1, "maxLength": 256 },
+    "method": { "enum": ["host-metadata-v1", "capability-token-v1"] },
+    "role": { "enum": ["implementer", "reviewer"] },
+    "requestId": {
+      "type": "string",
+      "pattern": "^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$"
+    },
+    "requestDigest": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+    "observationId": {
+      "type": "string",
+      "pattern": "^observation_[a-f0-9]{64}$"
+    },
+    "originEventId": {
+      "type": "string",
+      "pattern": "^evt_[a-f0-9]{64}$"
+    },
+    "tokenDigest": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+    "hostIdentityDigest": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+    "createdAt": { "type": "string", "format": "date-time" },
+    "revokedAt": { "type": "string", "format": "date-time" }
+  },
+  "allOf": [
+    {
+      "if": {
+        "properties": { "method": { "const": "capability-token-v1" } },
+        "required": ["method"]
+      },
+      "then": {
+        "properties": { "tokenDigest": true },
+        "required": ["tokenDigest"]
+      }
+    },
+    {
+      "if": {
+        "properties": { "method": { "const": "host-metadata-v1" } },
+        "required": ["method"]
+      },
+      "then": {
+        "properties": { "hostIdentityDigest": true },
+        "required": ["hostIdentityDigest"]
+      }
+    },
+    {
+      "if": {
+        "properties": { "requestId": true },
+        "required": ["requestId"]
+      },
+      "then": {
+        "properties": { "requestDigest": true },
+        "required": ["requestDigest"]
+      }
+    },
+    {
+      "if": {
+        "properties": { "requestDigest": true },
+        "required": ["requestDigest"]
+      },
+      "then": {
+        "properties": { "requestId": true },
+        "required": ["requestId"]
+      }
+    },
+    {
+      "if": {
+        "properties": { "observationId": true },
+        "required": ["observationId"]
+      },
+      "then": {
+        "properties": { "originEventId": true },
+        "required": ["originEventId"]
+      }
+    },
+    {
+      "if": {
+        "properties": { "originEventId": true },
+        "required": ["originEventId"]
+      },
+      "then": {
+        "properties": { "observationId": true },
+        "required": ["observationId"]
+      }
+    },
+    {
+      "if": {
+        "anyOf": [
+          {
+            "properties": { "requestId": true },
+            "required": ["requestId"]
+          },
+          {
+            "properties": { "requestDigest": true },
+            "required": ["requestDigest"]
+          },
+          {
+            "properties": { "observationId": true },
+            "required": ["observationId"]
+          },
+          {
+            "properties": { "originEventId": true },
+            "required": ["originEventId"]
+          }
+        ]
+      },
+      "then": {
+        "required": [
+          "role",
+          "requestId",
+          "requestDigest",
+          "observationId",
+          "originEventId"
+        ]
+      }
+    }
+  ]
+}
diff --git a/plugins/looperators-agent-loop/schemas/legacy-native-target-evidence.schema.json b/plugins/looperators-agent-loop/schemas/legacy-native-target-evidence.schema.json
new file mode 100644
index 0000000..6aa97fc
--- /dev/null
+++ b/plugins/looperators-agent-loop/schemas/legacy-native-target-evidence.schema.json
@@ -0,0 +1,96 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://looperators.local/schemas/agent-loop/legacy-native-target-evidence-v1.json",
+  "title": "looperators Legacy Native Target Evidence v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schemaVersion",
+    "evidenceVersion",
+    "runId",
+    "stateRevision",
+    "historyDigest",
+    "entries",
+    "evidenceDigest"
+  ],
+  "properties": {
+    "schemaVersion": { "const": 1 },
+    "evidenceVersion": { "const": 1 },
+    "runId": { "type": "string", "minLength": 1, "maxLength": 128 },
+    "stateRevision": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 9007199254740991
+    },
+    "historyDigest": {
+      "type": "string",
+      "pattern": "^[a-f0-9]{64}$"
+    },
+    "entries": {
+      "type": "array",
+      "minItems": 1,
+      "maxItems": 16,
+      "uniqueItems": true,
+      "items": { "$ref": "#/$defs/entry" }
+    },
+    "evidenceDigest": {
+      "type": "string",
+      "pattern": "^[a-f0-9]{64}$"
+    }
+  },
+  "$defs": {
+    "entry": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "factKind",
+        "factId",
+        "factDigest",
+        "field",
+        "role",
+        "bindingId",
+        "bindingDigest"
+      ],
+      "properties": {
+        "factKind": { "enum": ["transition", "report"] },
+        "factId": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 128
+        },
+        "factDigest": {
+          "type": "string",
+          "pattern": "^[a-f0-9]{64}$"
+        },
+        "field": { "enum": ["toNode", "routedToNode"] },
+        "role": { "enum": ["implementer", "reviewer"] },
+        "bindingId": {
+          "type": "string",
+          "pattern": "^binding_[a-f0-9]{64}$"
+        },
+        "bindingDigest": {
+          "type": "string",
+          "pattern": "^[a-f0-9]{64}$"
+        }
+      },
+      "allOf": [
+        {
+          "if": {
+            "properties": {
+              "factKind": { "const": "transition" }
+            },
+            "required": ["factKind"]
+          },
+          "then": {
+            "properties": { "field": { "const": "toNode" } }
+          },
+          "else": {
+            "properties": {
+              "field": { "const": "routedToNode" }
+            }
+          }
+        }
+      ]
+    }
+  }
+}
diff --git a/plugins/looperators-agent-loop/schemas/legacy-quarantine.schema.json b/plugins/looperators-agent-loop/schemas/legacy-quarantine.schema.json
new file mode 100644
index 0000000..66b8218
--- /dev/null
+++ b/plugins/looperators-agent-loop/schemas/legacy-quarantine.schema.json
@@ -0,0 +1,74 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://looperators.local/schemas/agent-loop/legacy-quarantine-v1.json",
+  "title": "looperators Legacy Quarantine Receipt v1",
+  "$comment": "JSON Schema validates each revision field independently. The invariant toRevision === fromRevision + 1 is enforced by validateLegacyQuarantineReceipt and covered by the runtime-semantic fixture lane.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schemaVersion",
+    "recoveryVersion",
+    "recoveryId",
+    "runId",
+    "requestId",
+    "requestDigest",
+    "actorKind",
+    "actorId",
+    "reason",
+    "evidenceDigest",
+    "legacyFactCount",
+    "priorStateDigest",
+    "terminalStateDigest",
+    "fromRevision",
+    "toRevision",
+    "createdAt"
+  ],
+  "properties": {
+    "schemaVersion": { "const": 1 },
+    "recoveryVersion": { "const": 1 },
+    "recoveryId": {
+      "type": "string",
+      "pattern": "^recovery_[a-f0-9]{64}$"
+    },
+    "runId": { "type": "string", "minLength": 1, "maxLength": 128 },
+    "requestId": {
+      "type": "string",
+      "pattern": "^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$"
+    },
+    "requestDigest": {
+      "type": "string",
+      "pattern": "^[a-f0-9]{64}$"
+    },
+    "actorKind": { "const": "root" },
+    "actorId": { "type": "string", "minLength": 1, "maxLength": 256 },
+    "reason": { "const": "unsupported-native-target-history" },
+    "evidenceDigest": {
+      "type": "string",
+      "pattern": "^[a-f0-9]{64}$"
+    },
+    "legacyFactCount": {
+      "type": "integer",
+      "minimum": 1,
+      "maximum": 16
+    },
+    "priorStateDigest": {
+      "type": "string",
+      "pattern": "^[a-f0-9]{64}$"
+    },
+    "terminalStateDigest": {
+      "type": "string",
+      "pattern": "^[a-f0-9]{64}$"
+    },
+    "fromRevision": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 9007199254740991
+    },
+    "toRevision": {
+      "type": "integer",
+      "minimum": 1,
+      "maximum": 9007199254740991
+    },
+    "createdAt": { "type": "string", "format": "date-time" }
+  }
+}
diff --git a/plugins/looperators-agent-loop/schemas/operation.schema.json b/plugins/looperators-agent-loop/schemas/operation.schema.json
new file mode 100644
index 0000000..0632402
--- /dev/null
+++ b/plugins/looperators-agent-loop/schemas/operation.schema.json
@@ -0,0 +1,71 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://looperators.local/schemas/agent-loop/operation-v1.json",
+  "title": "looperators Loop Operation v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schemaVersion",
+    "operationId",
+    "runId",
+    "requestId",
+    "requestDigest",
+    "kind",
+    "actorKind",
+    "actorId",
+    "fromRevision",
+    "toRevision",
+    "transitionId",
+    "createdAt"
+  ],
+  "properties": {
+    "schemaVersion": { "const": 1 },
+    "operationId": {
+      "type": "string",
+      "pattern": "^op_[a-f0-9]{64}$"
+    },
+    "runId": { "type": "string", "minLength": 1, "maxLength": 128 },
+    "requestId": {
+      "type": "string",
+      "pattern": "^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$"
+    },
+    "requestDigest": {
+      "type": "string",
+      "pattern": "^[a-f0-9]{64}$"
+    },
+    "kind": {
+      "enum": ["start", "report", "pause", "resume", "cancel", "interrupt"]
+    },
+    "actorKind": { "enum": ["root", "worker"] },
+    "actorId": { "type": "string", "minLength": 1, "maxLength": 256 },
+    "fromRevision": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 9007199254740991
+    },
+    "toRevision": {
+      "type": "integer",
+      "minimum": 1,
+      "maximum": 9007199254740991
+    },
+    "reportId": { "type": "string", "minLength": 1, "maxLength": 128 },
+    "transitionId": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 128
+    },
+    "createdAt": { "type": "string", "format": "date-time" }
+  },
+  "allOf": [
+    {
+      "if": {
+        "properties": { "kind": { "const": "report" } },
+        "required": ["kind"]
+      },
+      "then": {
+        "properties": { "reportId": true },
+        "required": ["reportId"]
+      }
+    }
+  ]
+}
diff --git a/plugins/looperators-agent-loop/schemas/report.schema.json b/plugins/looperators-agent-loop/schemas/report.schema.json
new file mode 100644
index 0000000..fff34dd
--- /dev/null
+++ b/plugins/looperators-agent-loop/schemas/report.schema.json
@@ -0,0 +1,165 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://looperators.local/schemas/agent-loop/report-v1.json",
+  "title": "looperators Loop Report v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schemaVersion",
+    "reportId",
+    "runId",
+    "fromNode",
+    "receiver",
+    "type",
+    "createdAt"
+  ],
+  "properties": {
+    "schemaVersion": { "const": 1 },
+    "reportId": { "type": "string", "minLength": 1, "maxLength": 128 },
+    "runId": { "type": "string", "minLength": 1, "maxLength": 128 },
+    "requestId": {
+      "type": "string",
+      "pattern": "^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$"
+    },
+    "requestDigest": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+    "fromRevision": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 9007199254740991
+    },
+    "toRevision": {
+      "type": "integer",
+      "minimum": 1,
+      "maximum": 9007199254740991
+    },
+    "fromNode": { "type": "string", "minLength": 1, "maxLength": 256 },
+    "receiver": { "enum": ["root-master", "human"] },
+    "routedToNode": { "type": "string", "minLength": 1, "maxLength": 256 },
+    "type": { "enum": ["verdict", "info", "relationship"] },
+    "status": { "const": "done" },
+    "verdict": { "enum": ["clean", "issues"] },
+    "issues": {
+      "type": "array",
+      "maxItems": 200,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["message"],
+        "properties": {
+          "message": { "type": "string", "minLength": 1, "maxLength": 4000 },
+          "file": { "type": "string", "minLength": 1, "maxLength": 2000 },
+          "line": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 9007199254740991
+          },
+          "severity": { "enum": ["info", "warn", "error"] }
+        }
+      }
+    },
+    "summary": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 8000
+    },
+    "originEventId": { "type": "string", "minLength": 1, "maxLength": 128 },
+    "createdAt": { "type": "string", "format": "date-time" }
+  },
+  "allOf": [
+    {
+      "if": {
+        "properties": { "type": { "const": "verdict" } },
+        "required": ["type"]
+      },
+      "then": {
+        "properties": { "verdict": true },
+        "required": ["verdict"]
+      }
+    },
+    {
+      "if": {
+        "properties": { "verdict": { "const": "issues" } },
+        "required": ["verdict"]
+      },
+      "then": {
+        "properties": {
+          "issues": {
+            "type": "array",
+            "minItems": 1
+          }
+        },
+        "required": ["issues"]
+      }
+    },
+    {
+      "if": {
+        "properties": { "verdict": { "const": "clean" } },
+        "required": ["verdict"]
+      },
+      "then": {
+        "properties": {
+          "issues": {
+            "type": "array",
+            "maxItems": 0
+          }
+        }
+      }
+    },
+    {
+      "if": {
+        "properties": { "requestId": true },
+        "required": ["requestId"]
+      },
+      "then": {
+        "properties": {
+          "requestDigest": true,
+          "fromRevision": true,
+          "toRevision": true
+        },
+        "required": ["requestDigest", "fromRevision", "toRevision"]
+      }
+    },
+    {
+      "if": {
+        "properties": { "requestDigest": true },
+        "required": ["requestDigest"]
+      },
+      "then": {
+        "properties": {
+          "requestId": true,
+          "fromRevision": true,
+          "toRevision": true
+        },
+        "required": ["requestId", "fromRevision", "toRevision"]
+      }
+    },
+    {
+      "if": {
+        "properties": { "fromRevision": true },
+        "required": ["fromRevision"]
+      },
+      "then": {
+        "properties": {
+          "requestId": true,
+          "requestDigest": true,
+          "toRevision": true
+        },
+        "required": ["requestId", "requestDigest", "toRevision"]
+      }
+    },
+    {
+      "if": {
+        "properties": { "toRevision": true },
+        "required": ["toRevision"]
+      },
+      "then": {
+        "properties": {
+          "requestId": true,
+          "requestDigest": true,
+          "fromRevision": true
+        },
+        "required": ["requestId", "requestDigest", "fromRevision"]
+      }
+    }
+  ]
+}
diff --git a/plugins/looperators-agent-loop/schemas/run.schema.json b/plugins/looperators-agent-loop/schemas/run.schema.json
new file mode 100644
index 0000000..f76cee3
--- /dev/null
+++ b/plugins/looperators-agent-loop/schemas/run.schema.json
@@ -0,0 +1,131 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://looperators.local/schemas/agent-loop/run-v1.json",
+  "title": "looperators Loop Run v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schemaVersion",
+    "runId",
+    "rootSessionId",
+    "originatingTurnId",
+    "scope",
+    "masterNode",
+    "recipe",
+    "status",
+    "currentLap",
+    "continuationLease",
+    "cancelRequested",
+    "revision",
+    "createdAt",
+    "updatedAt"
+  ],
+  "properties": {
+    "schemaVersion": { "const": 1 },
+    "runId": { "type": "string", "minLength": 1, "maxLength": 128 },
+    "rootSessionId": { "type": "string", "minLength": 1, "maxLength": 256 },
+    "originatingTurnId": { "type": "string", "minLength": 1, "maxLength": 256 },
+    "scope": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["kind"],
+      "properties": { "kind": { "const": "task" } }
+    },
+    "masterNode": { "type": "string", "minLength": 1, "maxLength": 256 },
+    "recipe": { "const": "review-until-clean" },
+    "status": {
+      "enum": [
+        "draft",
+        "running",
+        "paused",
+        "succeeded",
+        "capped",
+        "cancelled",
+        "failed",
+        "interrupted"
+      ]
+    },
+    "currentLap": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 9007199254740991
+    },
+    "continuationLease": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["granted", "consumed"],
+      "properties": {
+        "granted": { "type": "integer", "minimum": 0, "maximum": 6 },
+        "consumed": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 9007199254740991
+        }
+      },
+      "oneOf": [
+        {
+          "properties": {
+            "granted": { "const": 0 },
+            "consumed": { "type": "integer", "maximum": 0 }
+          }
+        },
+        {
+          "properties": {
+            "granted": { "const": 1 },
+            "consumed": { "type": "integer", "maximum": 1 }
+          }
+        },
+        {
+          "properties": {
+            "granted": { "const": 2 },
+            "consumed": { "type": "integer", "maximum": 2 }
+          }
+        },
+        {
+          "properties": {
+            "granted": { "const": 3 },
+            "consumed": { "type": "integer", "maximum": 3 }
+          }
+        },
+        {
+          "properties": {
+            "granted": { "const": 4 },
+            "consumed": { "type": "integer", "maximum": 4 }
+          }
+        },
+        {
+          "properties": {
+            "granted": { "const": 5 },
+            "consumed": { "type": "integer", "maximum": 5 }
+          }
+        },
+        {
+          "properties": {
+            "granted": { "const": 6 },
+            "consumed": { "type": "integer", "maximum": 6 }
+          }
+        }
+      ]
+    },
+    "pendingTransitionId": { "type": "string", "minLength": 1, "maxLength": 128 },
+    "cancelRequested": { "type": "boolean" },
+    "latestReportId": { "type": "string", "minLength": 1, "maxLength": 128 },
+    "latestOperationId": { "type": "string", "minLength": 1, "maxLength": 128 },
+    "latestGovernorDecisionId": {
+      "type": "string",
+      "pattern": "^decision_[a-f0-9]{64}$"
+    },
+    "latestRecoveryId": {
+      "type": "string",
+      "pattern": "^recovery_[a-f0-9]{64}$"
+    },
+    "needsHuman": { "type": "boolean" },
+    "revision": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 9007199254740991
+    },
+    "createdAt": { "type": "string", "format": "date-time" },
+    "updatedAt": { "type": "string", "format": "date-time" }
+  }
+}
diff --git a/plugins/looperators-agent-loop/schemas/transition.schema.json b/plugins/looperators-agent-loop/schemas/transition.schema.json
new file mode 100644
index 0000000..49a23d6
--- /dev/null
+++ b/plugins/looperators-agent-loop/schemas/transition.schema.json
@@ -0,0 +1,75 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://looperators.local/schemas/agent-loop/transition-v1.json",
+  "title": "looperators Loop Transition v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schemaVersion",
+    "transitionId",
+    "runId",
+    "kind",
+    "lap",
+    "createdAt"
+  ],
+  "properties": {
+    "schemaVersion": { "const": 1 },
+    "transitionId": { "type": "string", "minLength": 1, "maxLength": 128 },
+    "runId": { "type": "string", "minLength": 1, "maxLength": 128 },
+    "requestId": { "type": "string", "minLength": 1, "maxLength": 128 },
+    "requestDigest": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+    "kind": {
+      "enum": [
+        "activate-reviewer",
+        "activate-implementer",
+        "succeed",
+        "pause",
+        "resume",
+        "cancel",
+        "interrupt",
+        "cap"
+      ]
+    },
+    "fromNode": { "type": "string", "minLength": 1, "maxLength": 256 },
+    "toNode": { "type": "string", "minLength": 1, "maxLength": 256 },
+    "originReportId": { "type": "string", "minLength": 1, "maxLength": 128 },
+    "originEventId": { "type": "string", "minLength": 1, "maxLength": 128 },
+    "lap": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 9007199254740991
+    },
+    "leaseEpoch": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 9007199254740991
+    },
+    "fromRevision": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 9007199254740991
+    },
+    "toRevision": {
+      "type": "integer",
+      "minimum": 1,
+      "maximum": 9007199254740991
+    },
+    "createdAt": { "type": "string", "format": "date-time" }
+  },
+  "allOf": [
+    {
+      "if": {
+        "properties": { "requestId": true },
+        "required": ["requestId"]
+      },
+      "then": {
+        "properties": {
+          "requestDigest": true,
+          "fromRevision": true,
+          "toRevision": true
+        },
+        "required": ["requestDigest", "fromRevision", "toRevision"]
+      }
+    }
+  ]
+}
diff --git a/plugins/looperators-agent-loop/schemas/worker-observation.schema.json b/plugins/looperators-agent-loop/schemas/worker-observation.schema.json
new file mode 100644
index 0000000..332891a
--- /dev/null
+++ b/plugins/looperators-agent-loop/schemas/worker-observation.schema.json
@@ -0,0 +1,72 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://looperators.local/schemas/agent-loop/worker-observation-v1.json",
+  "title": "looperators Worker Observation v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schemaVersion",
+    "observationId",
+    "runId",
+    "requestId",
+    "requestDigest",
+    "rootSessionId",
+    "role",
+    "spawnToolUseIds",
+    "subagentStartEventIds",
+    "bindingIds",
+    "observationDigest",
+    "createdAt"
+  ],
+  "properties": {
+    "schemaVersion": { "const": 1 },
+    "observationId": {
+      "type": "string",
+      "pattern": "^observation_[a-f0-9]{64}$"
+    },
+    "runId": { "type": "string", "minLength": 1, "maxLength": 128 },
+    "requestId": {
+      "type": "string",
+      "pattern": "^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$"
+    },
+    "requestDigest": {
+      "type": "string",
+      "pattern": "^[a-f0-9]{64}$"
+    },
+    "rootSessionId": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 256
+    },
+    "role": { "enum": ["implementer", "reviewer"] },
+    "spawnToolUseIds": {
+      "type": "array",
+      "maxItems": 64,
+      "uniqueItems": true,
+      "items": { "type": "string", "minLength": 1, "maxLength": 256 }
+    },
+    "subagentStartEventIds": {
+      "type": "array",
+      "maxItems": 64,
+      "uniqueItems": true,
+      "items": {
+        "type": "string",
+        "pattern": "^evt_[a-f0-9]{64}$"
+      }
+    },
+    "bindingIds": {
+      "type": "array",
+      "maxItems": 64,
+      "uniqueItems": true,
+      "items": {
+        "type": "string",
+        "pattern": "^binding_[a-f0-9]{64}$"
+      }
+    },
+    "observationDigest": {
+      "type": "string",
+      "pattern": "^[a-f0-9]{64}$"
+    },
+    "createdAt": { "type": "string", "format": "date-time" }
+  }
+}
diff --git a/plugins/looperators-agent-loop/scripts/probe-capabilities.mjs b/plugins/looperators-agent-loop/scripts/probe-capabilities.mjs
new file mode 100644
index 0000000..a7069fe
--- /dev/null
+++ b/plugins/looperators-agent-loop/scripts/probe-capabilities.mjs
@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+
+import { spawnSync } from "node:child_process";
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { atomicReplaceJson } from "../lib/fs-utils.mjs";
+
+function argument(name, fallback = undefined) {
+  const index = process.argv.indexOf(`--${name}`);
+  return index >= 0 ? process.argv[index + 1] : fallback;
+}
+
+function run(command, args) {
+  const result = spawnSync(command, args, {
+    encoding: "utf8",
+    timeout: 15_000,
+  });
+  return {
+    status: result.status,
+    stdout: result.stdout?.trim() ?? "",
+    stderr: result.stderr?.trim() ?? "",
+  };
+}
+
+function parseFeatures(output) {
+  return output
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      const match = line.match(/^(\S+)\s{2,}(.+?)\s{2,}(true|false)$/);
+      return match
+        ? {
+            name: match[1],
+            maturity: match[2].trim(),
+            enabled: match[3] === "true",
+          }
+        : { raw: line };
+    });
+}
+
+const outputValue = argument("output");
+if (!outputValue || !path.isAbsolute(outputValue)) {
+  throw new Error("--output must be an absolute path");
+}
+const pluginRoot = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "..",
+);
+const codexBin =
+  argument("codex-bin") ??
+  "/Applications/ChatGPT.app/Contents/Resources/codex";
+const appRoot = "/Applications/ChatGPT.app";
+const versionResult = run(codexBin, ["--version"]);
+const featuresResult = run(codexBin, ["features", "list"]);
+const manifest = JSON.parse(
+  await readFile(
+    path.join(pluginRoot, ".codex-plugin", "plugin.json"),
+    "utf8",
+  ),
+);
+const infoPlist = path.join(appRoot, "Contents", "Info.plist");
+const appMetadata = await stat(infoPlist).then(
+  () => ({
+    shortVersion: run("/usr/bin/plutil", [
+      "-extract",
+      "CFBundleShortVersionString",
+      "raw",
+      "-o",
+      "-",
+      infoPlist,
+    ]).stdout,
+    buildVersion: run("/usr/bin/plutil", [
+      "-extract",
+      "CFBundleVersion",
+      "raw",
+      "-o",
+      "-",
+      infoPlist,
+    ]).stdout,
+  }),
+  () => null,
+);
+const features = parseFeatures(featuresResult.stdout);
+const byName = new Map(
+  features
+    .filter((feature) => feature.name)
+    .map((feature) => [feature.name, feature]),
+);
+const evidence = {
+  schemaVersion: 1,
+  capturedAt: new Date().toISOString(),
+  platform: {
+    platform: process.platform,
+    arch: process.arch,
+    node: process.version,
+  },
+  desktop: appMetadata,
+  codex: {
+    binary: codexBin,
+    version: versionResult.stdout,
+    versionStatus: versionResult.status,
+    featuresStatus: featuresResult.status,
+    required: {
+      hooks: byName.get("hooks") ?? null,
+      plugins: byName.get("plugins") ?? null,
+      multiAgent: byName.get("multi_agent") ?? null,
+      mcpApps: byName.get("enable_mcp_apps") ?? null,
+      inlineVisualization:
+        byName.get("terminal_visualization_instructions") ?? null,
+      agentIdentity: byName.get("use_agent_identity") ?? null,
+    },
+  },
+  plugin: {
+    name: manifest.name,
+    version: manifest.version,
+  },
+};
+await atomicReplaceJson(outputValue, evidence);
+process.stdout.write(
+  `${JSON.stringify({
+    output: outputValue,
+    codex: evidence.codex.version,
+    desktop: evidence.desktop,
+  })}\n`,
+);
diff --git a/plugins/looperators-agent-loop/scripts/probe-collector-latency.mjs b/plugins/looperators-agent-loop/scripts/probe-collector-latency.mjs
new file mode 100644
index 0000000..4e418e0
--- /dev/null
+++ b/plugins/looperators-agent-loop/scripts/probe-collector-latency.mjs
@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+
+import { spawn } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { performance } from "node:perf_hooks";
+import { fileURLToPath } from "node:url";
+import { resolveDataRoot } from "../lib/data-root.mjs";
+import { atomicReplaceJson } from "../lib/fs-utils.mjs";
+import { LoopStore } from "../lib/store.mjs";
+
+function argument(name, fallback = undefined) {
+  const index = process.argv.indexOf(`--${name}`);
+  return index >= 0 ? process.argv[index + 1] : fallback;
+}
+
+function numberArgument(name, fallback) {
+  const value = Number(argument(name, fallback));
+  if (!Number.isInteger(value) || value < 1 || value > 1_000) {
+    throw new Error(`--${name} must be an integer between 1 and 1000`);
+  }
+  return value;
+}
+
+async function invokeHook(hook, env, index) {
+  const started = performance.now();
+  const child = spawn(process.execPath, [hook], {
+    env,
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+  child.stdin.end(
+    JSON.stringify({
+      session_id: "collector-latency-session",
+      turn_id: `collector-latency-turn-${index}`,
+      hook_event_name: "UserPromptSubmit",
+      prompt: "redacted-by-contract",
+    }),
+  );
+  const stdout = [];
+  const stderr = [];
+  child.stdout.on("data", (chunk) => stdout.push(chunk));
+  child.stderr.on("data", (chunk) => stderr.push(chunk));
+  const exitCode = await new Promise((resolve, reject) => {
+    child.on("error", reject);
+    child.on("close", resolve);
+  });
+  return {
+    durationMs: performance.now() - started,
+    exitCode,
+    stdoutBytes: Buffer.concat(stdout).length,
+    stderrBytes: Buffer.concat(stderr).length,
+  };
+}
+
+function percentile(sorted, quantile) {
+  const index = Math.max(
+    0,
+    Math.min(sorted.length - 1, Math.ceil(sorted.length * quantile) - 1),
+  );
+  return sorted[index];
+}
+
+function rounded(value) {
+  return Math.round(value * 1_000) / 1_000;
+}
+
+const output = argument("output");
+if (!output || !path.isAbsolute(output)) {
+  throw new Error("--output must be an absolute path");
+}
+const samples = numberArgument("samples", 30);
+const warmupSamples = numberArgument("warmup-samples", 3);
+const targetP95Ms = numberArgument("target-p95-ms", 50);
+const dataRoot = await mkdtemp(
+  path.join(os.tmpdir(), "looperators-p1a-collector-latency-"),
+);
+try {
+  const pluginRoot = path.resolve(
+    path.dirname(fileURLToPath(import.meta.url)),
+    "..",
+  );
+  const hook = path.join(pluginRoot, "hooks", "collect-event.mjs");
+  const runId = "run-collector-latency";
+  const sessionId = "collector-latency-session";
+  const env = {
+    ...process.env,
+    LOOPERATORS_DATA_DIR: dataRoot,
+    LOOPERATORS_RUN_ID: runId,
+  };
+  const rootInfo = await resolveDataRoot({ env });
+  const store = new LoopStore(rootInfo);
+  const timestamp = new Date().toISOString();
+  await store.initializeRun({
+    schemaVersion: 1,
+    runId,
+    rootSessionId: sessionId,
+    originatingTurnId: "collector-latency-origin",
+    scope: { kind: "task" },
+    masterNode: sessionId,
+    recipe: "review-until-clean",
+    status: "running",
+    currentLap: 0,
+    continuationLease: { granted: 0, consumed: 0 },
+    cancelRequested: false,
+    revision: 0,
+    createdAt: timestamp,
+    updatedAt: timestamp,
+  });
+  const observations = [];
+  for (
+    let index = 0;
+    index < warmupSamples + samples;
+    index += 1
+  ) {
+    observations.push(await invokeHook(hook, env, index));
+  }
+  const measured = observations.slice(warmupSamples);
+  const durations = measured
+    .map((observation) => observation.durationMs)
+    .sort((left, right) => left - right);
+  const processesPassed = observations.every(
+    (observation) =>
+      observation.exitCode === 0 &&
+      observation.stdoutBytes === 0 &&
+      observation.stderrBytes === 0,
+  );
+  const result = {
+    schemaVersion: 1,
+    samples,
+    warmupSamples,
+    minMs: rounded(durations[0]),
+    p50Ms: rounded(percentile(durations, 0.5)),
+    p95Ms: rounded(percentile(durations, 0.95)),
+    maxMs: rounded(durations.at(-1)),
+    includesProcessStartup: true,
+    targetP95Ms,
+    processesPassed,
+  };
+  result.passed =
+    processesPassed && result.p95Ms < result.targetP95Ms;
+  await atomicReplaceJson(output, result);
+  process.stdout.write(`${JSON.stringify({ ...result, output })}\n`);
+  if (!result.passed) {
+    process.exitCode = 1;
+  }
+} finally {
+  await rm(dataRoot, { recursive: true, force: true });
+}
diff --git a/plugins/looperators-agent-loop/scripts/probe-governor-latency.mjs b/plugins/looperators-agent-loop/scripts/probe-governor-latency.mjs
new file mode 100644
index 0000000..e905bb3
--- /dev/null
+++ b/plugins/looperators-agent-loop/scripts/probe-governor-latency.mjs
@@ -0,0 +1,310 @@
+#!/usr/bin/env node
+
+import { spawn } from "node:child_process";
+import { mkdtemp, rm, unlink } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { performance } from "node:perf_hooks";
+import { fileURLToPath } from "node:url";
+import { LoopController } from "../lib/control.mjs";
+import {
+  HOOK_COLLECTOR_PROTOCOL,
+  normalizeHookEvent,
+} from "../lib/contracts.mjs";
+import { resolveDataRoot } from "../lib/data-root.mjs";
+import { atomicReplaceJson } from "../lib/fs-utils.mjs";
+import { currentHookDefinitionDigest } from "../lib/hook-readiness.mjs";
+import { LoopStore } from "../lib/store.mjs";
+
+function argument(name, fallback = undefined) {
+  const index = process.argv.indexOf(`--${name}`);
+  return index >= 0 ? process.argv[index + 1] : fallback;
+}
+
+function numberArgument(name, fallback) {
+  const value = Number(argument(name, fallback));
+  if (!Number.isInteger(value) || value < 1 || value > 1_000) {
+    throw new Error(`--${name} must be an integer between 1 and 1000`);
+  }
+  return value;
+}
+
+async function putHookReadiness(store, runId, context) {
+  const state = await store.readState(runId);
+  await store.putEvent(
+    runId,
+    normalizeHookEvent(
+      {
+        session_id: context.rootSessionId,
+        turn_id: context.turnId,
+        hook_event_name: "UserPromptSubmit",
+      },
+      {
+        observedAt: new Date(
+          Date.parse(state.createdAt) + 1,
+        ).toISOString(),
+        hookCollectorProtocol: HOOK_COLLECTOR_PROTOCOL,
+        hookDefinitionDigest:
+          await currentHookDefinitionDigest(),
+      },
+    ),
+  );
+}
+
+async function invokeHook(
+  hook,
+  env,
+  rootSessionId = "governor-latency-session",
+) {
+  const started = performance.now();
+  const child = spawn(process.execPath, [hook], {
+    env,
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+  child.stdin.end(
+    JSON.stringify({
+      session_id: rootSessionId,
+      turn_id: "governor-latency-turn",
+      hook_event_name: "Stop",
+      stop_hook_active: false,
+    }),
+  );
+  const stdout = [];
+  const stderr = [];
+  child.stdout.on("data", (chunk) => stdout.push(chunk));
+  child.stderr.on("data", (chunk) => stderr.push(chunk));
+  const exitCode = await new Promise((resolve, reject) => {
+    child.on("error", reject);
+    child.on("close", resolve);
+  });
+  const stdoutText = Buffer.concat(stdout).toString("utf8");
+  let output = null;
+  try {
+    output = stdoutText ? JSON.parse(stdoutText) : null;
+  } catch {
+    output = { invalidJson: true };
+  }
+  return {
+    durationMs: performance.now() - started,
+    exitCode,
+    stderrBytes: Buffer.concat(stderr).length,
+    outputKind:
+      output?.decision === "block"
+        ? "block"
+        : output?.continue === true
+          ? "allow"
+          : "invalid",
+    recoveryFailOpen:
+      output?.continue === true &&
+      /RECOVERY_REQUIRED/.test(output?.systemMessage ?? ""),
+  };
+}
+
+function percentile(sorted, quantile) {
+  const index = Math.max(
+    0,
+    Math.min(sorted.length - 1, Math.ceil(sorted.length * quantile) - 1),
+  );
+  return sorted[index];
+}
+
+function rounded(value) {
+  return Math.round(value * 1_000) / 1_000;
+}
+
+const output = argument("output");
+if (!output || !path.isAbsolute(output)) {
+  throw new Error("--output must be an absolute path");
+}
+const samples = numberArgument("samples", 30);
+const warmupSamples = numberArgument("warmup-samples", 3);
+const errorPathSamples = numberArgument(
+  "error-path-samples",
+  10,
+);
+const targetP95Ms = numberArgument("target-p95-ms", 100);
+const dataRoot = await mkdtemp(
+  path.join(os.tmpdir(), "looperators-p1c-governor-latency-"),
+);
+
+try {
+  const pluginRoot = path.resolve(
+    path.dirname(fileURLToPath(import.meta.url)),
+    "..",
+  );
+  const hook = path.join(pluginRoot, "hooks", "collect-event.mjs");
+  const rootInfo = await resolveDataRoot({
+    env: { LOOPERATORS_DATA_DIR: dataRoot },
+  });
+  const store = new LoopStore(rootInfo);
+  const context = {
+    rootSessionId: "governor-latency-session",
+    turnId: "governor-latency-turn",
+    threadSource: "user",
+  };
+  const controller = new LoopController(store);
+  const preview = await controller.preview(context, {
+    requestId: "governor-latency-preview",
+    goal: "Measure bounded governor hook latency.",
+    implementerInstructions: "Return a typed done report.",
+    reviewerInstructions: "Return a typed verdict.",
+    lapCap: 1,
+  });
+  const { runId } = preview;
+  const startContext = {
+    ...context,
+    turnId: "governor-latency-confirmed-turn",
+  };
+  await putHookReadiness(store, runId, startContext);
+  await controller.start(startContext, {
+    runId,
+    requestId: "governor-latency-start",
+  });
+  const env = {
+    ...process.env,
+    LOOPERATORS_DATA_DIR: dataRoot,
+    LOOPERATORS_RUN_ID: runId,
+  };
+  const observations = [];
+  for (
+    let index = 0;
+    index < warmupSamples + samples;
+    index += 1
+  ) {
+    observations.push(await invokeHook(hook, env));
+  }
+  const measured = observations.slice(warmupSamples);
+  const durations = measured
+    .map((observation) => observation.durationMs)
+    .sort((left, right) => left - right);
+  const blocks = observations.filter(
+    (observation) => observation.outputKind === "block",
+  ).length;
+  const invalidOutputs = observations.filter(
+    (observation) => observation.outputKind === "invalid",
+  ).length;
+  const processesPassed = observations.every(
+    (observation) =>
+      observation.exitCode === 0 && observation.stderrBytes === 0,
+  );
+  const state = await store.readState(runId);
+  const decisions = await store.listGovernorDecisions(runId);
+  const errorContext = {
+    rootSessionId: "governor-error-latency-session",
+    turnId: "governor-error-latency-turn",
+    threadSource: "user",
+  };
+  const errorPreview = await controller.preview(
+    errorContext,
+    {
+      requestId: "governor-error-latency-preview",
+      goal: "Measure fail-open governor hook latency.",
+      implementerInstructions: "Return a typed done report.",
+      reviewerInstructions: "Return a typed verdict.",
+      lapCap: 1,
+    },
+  );
+  const errorStartContext = {
+    ...errorContext,
+    turnId: "governor-error-latency-confirmed-turn",
+  };
+  await putHookReadiness(
+    store,
+    errorPreview.runId,
+    errorStartContext,
+  );
+  await controller.start(errorStartContext, {
+    runId: errorPreview.runId,
+    requestId: "governor-error-latency-start",
+  });
+  const errorState = await store.readState(
+    errorPreview.runId,
+  );
+  await unlink(
+    path.join(
+      store.factDirectory(
+        errorPreview.runId,
+        "operations",
+      ),
+      `${errorState.latestOperationId}.json`,
+    ),
+  );
+  const errorEnv = {
+    ...process.env,
+    LOOPERATORS_DATA_DIR: dataRoot,
+    LOOPERATORS_RUN_ID: errorPreview.runId,
+  };
+  const errorObservations = [];
+  for (let index = 0; index < errorPathSamples; index += 1) {
+    errorObservations.push(
+      await invokeHook(
+        hook,
+        errorEnv,
+        errorContext.rootSessionId,
+      ),
+    );
+  }
+  const errorDurations = errorObservations
+    .map((observation) => observation.durationMs)
+    .sort((left, right) => left - right);
+  const errorStateAfter = await store.readState(
+    errorPreview.runId,
+  );
+  const errorDecisions =
+    await store.listGovernorDecisions(errorPreview.runId);
+  const result = {
+    schemaVersion: 1,
+    samples,
+    warmupSamples,
+    minMs: rounded(durations[0]),
+    p50Ms: rounded(percentile(durations, 0.5)),
+    p95Ms: rounded(percentile(durations, 0.95)),
+    maxMs: rounded(durations.at(-1)),
+    includesProcessStartup: true,
+    targetP95Ms,
+    blocks,
+    invalidOutputs,
+    processesPassed,
+    leaseConsumed: state.continuationLease.consumed,
+    decisionFacts: decisions.facts.length,
+    corruptDecisionFacts: decisions.corrupt.length,
+    errorPathSamples,
+    errorPathP50Ms: rounded(
+      percentile(errorDurations, 0.5),
+    ),
+    errorPathP95Ms: rounded(
+      percentile(errorDurations, 0.95),
+    ),
+    errorPathMaxMs: rounded(errorDurations.at(-1)),
+    errorPathPassed:
+      errorObservations.every(
+        (observation) =>
+          observation.exitCode === 0 &&
+          observation.stderrBytes === 0 &&
+          observation.outputKind === "allow" &&
+          observation.recoveryFailOpen,
+      ) &&
+      errorStateAfter.revision === 1 &&
+      errorStateAfter.continuationLease.consumed === 0 &&
+      errorDecisions.facts.length === 0 &&
+      errorDecisions.corrupt.length === 0,
+  };
+  result.passed =
+    processesPassed &&
+    result.p95Ms < result.targetP95Ms &&
+    blocks === 1 &&
+    invalidOutputs === 0 &&
+    result.leaseConsumed === 1 &&
+    result.decisionFacts === 1 &&
+    result.corruptDecisionFacts === 0 &&
+    result.errorPathP95Ms < result.targetP95Ms &&
+    result.errorPathPassed;
+  await atomicReplaceJson(output, result);
+  process.stdout.write(`${JSON.stringify({ ...result, output })}\n`);
+  if (!result.passed) {
+    process.exitCode = 1;
+  }
+} finally {
+  await rm(dataRoot, { recursive: true, force: true });
+}
diff --git a/plugins/looperators-agent-loop/scripts/probe-isolated-install.mjs b/plugins/looperators-agent-loop/scripts/probe-isolated-install.mjs
new file mode 100644
index 0000000..0af1ba1
--- /dev/null
+++ b/plugins/looperators-agent-loop/scripts/probe-isolated-install.mjs
@@ -0,0 +1,329 @@
+#!/usr/bin/env node
+
+import { execFile } from "node:child_process";
+import {
+  lstat,
+  mkdtemp,
+  readFile,
+  readdir,
+  rm,
+} from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { promisify } from "node:util";
+import { fileURLToPath } from "node:url";
+import {
+  canonicalJson,
+  compareCodePoints,
+  sha256,
+} from "../lib/canonical-json.mjs";
+import { atomicReplaceJson } from "../lib/fs-utils.mjs";
+
+const run = promisify(execFile);
+const MARKETPLACE = "looperators-p0";
+const PLUGIN_NAME = "looperators-agent-loop";
+const PLUGIN_ID = `${PLUGIN_NAME}@${MARKETPLACE}`;
+const PLUGIN_ROOT = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "..",
+);
+export const PLUGIN_VERSION = JSON.parse(
+  await readFile(
+    path.join(PLUGIN_ROOT, ".codex-plugin", "plugin.json"),
+    "utf8",
+  ),
+).version;
+export const ISOLATED_ENV_ALLOWLIST = Object.freeze([
+  "LANG",
+  "LC_ALL",
+  "LC_CTYPE",
+  "PATH",
+  "TEMP",
+  "TERM",
+  "TMP",
+  "TMPDIR",
+]);
+
+function argument(name, argv = process.argv) {
+  const index = argv.indexOf(`--${name}`);
+  return index >= 0 ? argv[index + 1] : undefined;
+}
+
+async function treeManifest(root) {
+  const entries = [];
+  async function walk(current) {
+    for (const entry of await readdir(current, {
+      withFileTypes: true,
+    })) {
+      const target = path.join(current, entry.name);
+      const relative = path.relative(root, target);
+      if (entry.isSymbolicLink()) {
+        throw new Error(
+          `install comparison rejects symlink: ${relative}`,
+        );
+      }
+      if (entry.isDirectory()) {
+        await walk(target);
+      } else if (entry.isFile()) {
+        const metadata = await lstat(target);
+        const bytes = await readFile(target);
+        entries.push({
+          path: relative,
+          bytes: metadata.size,
+          digest: sha256(bytes),
+        });
+      } else {
+        throw new Error(
+          `install comparison rejects special file: ${relative}`,
+        );
+      }
+    }
+  }
+  await walk(root);
+  entries.sort((left, right) =>
+    compareCodePoints(left.path, right.path),
+  );
+  return {
+    entries,
+    digest: sha256(canonicalJson(entries)),
+  };
+}
+
+export function isolatedCommandEnvironment(
+  codexHome,
+  parentEnvironment = process.env,
+) {
+  const environment = { CODEX_HOME: codexHome };
+  for (const name of ISOLATED_ENV_ALLOWLIST) {
+    const value = parentEnvironment[name];
+    if (typeof value === "string" && value.length > 0) {
+      environment[name] = value;
+    }
+  }
+  return environment;
+}
+
+function parsedJson(stdout) {
+  try {
+    return { valid: true, value: JSON.parse(stdout) };
+  } catch {
+    return { valid: false, value: null };
+  }
+}
+
+export function inspectPluginCommandOutputs(input) {
+  const add = parsedJson(input.addStdout);
+  const list = parsedJson(input.listStdout);
+  const installed =
+    list.valid && Array.isArray(list.value?.installed)
+      ? list.value.installed
+      : [];
+  const matches = installed.filter(
+    (record) => record?.pluginId === PLUGIN_ID,
+  );
+  const record = matches.length === 1 ? matches[0] : null;
+  const normalizedSource = record?.source?.path
+    ? path.normalize(record.source.path)
+    : null;
+  const normalizedMarketplace =
+    record?.marketplaceSource?.source
+      ? path.normalize(record.marketplaceSource.source)
+      : null;
+  const addMatches =
+    add.valid &&
+    add.value?.pluginId === PLUGIN_ID &&
+    add.value?.name === PLUGIN_NAME &&
+    add.value?.marketplaceName === MARKETPLACE &&
+    add.value?.version === PLUGIN_VERSION;
+  const listMatches =
+    list.valid &&
+    matches.length === 1 &&
+    record?.name === PLUGIN_NAME &&
+    record?.marketplaceName === MARKETPLACE &&
+    record?.version === PLUGIN_VERSION &&
+    record?.installed === true &&
+    record?.enabled === true &&
+    record?.source?.source === "local" &&
+    normalizedSource === path.normalize(input.sourceRoot) &&
+    record?.marketplaceSource?.sourceType === "local" &&
+    normalizedMarketplace ===
+      path.normalize(input.repoRoot);
+  return {
+    passed: Boolean(addMatches && listMatches),
+    addJsonValid: add.valid,
+    addMatches,
+    listJsonValid: list.valid,
+    exactRecordCount: matches.length,
+    listMatches,
+    enabled: record?.enabled === true,
+    installed: record?.installed === true,
+    versionMatches: record?.version === PLUGIN_VERSION,
+    sourceMatches:
+      record?.source?.source === "local" &&
+      normalizedSource === path.normalize(input.sourceRoot),
+    marketplaceSourceMatches:
+      record?.marketplaceSource?.sourceType === "local" &&
+      normalizedMarketplace ===
+        path.normalize(input.repoRoot),
+  };
+}
+
+async function codexCommand(binary, codexHome, args) {
+  return run(binary, args, {
+    env: isolatedCommandEnvironment(codexHome),
+    timeout: 30_000,
+    maxBuffer: 4 * 1024 * 1024,
+  });
+}
+
+export async function main(argv = process.argv) {
+  const output = argument("output", argv);
+  if (!output || !path.isAbsolute(output)) {
+    throw new TypeError("--output must be absolute");
+  }
+  const binary =
+    argument("codex", argv) ??
+    "/Applications/ChatGPT.app/Contents/Resources/codex";
+  if (!path.isAbsolute(binary)) {
+    throw new TypeError("--codex must be absolute");
+  }
+  const repoRoot = path.resolve(
+    path.dirname(fileURLToPath(import.meta.url)),
+    "../../..",
+  );
+  const sourceRoot = path.join(
+    repoRoot,
+    "plugins",
+    PLUGIN_NAME,
+  );
+  const temporary = await mkdtemp(
+    path.join(os.tmpdir(), "looperators-p1e-install-"),
+  );
+  try {
+    const versionResult = await codexCommand(
+      binary,
+      temporary,
+      ["--version"],
+    );
+    await codexCommand(binary, temporary, [
+      "plugin",
+      "marketplace",
+      "add",
+      repoRoot,
+    ]);
+    const addResult = await codexCommand(
+      binary,
+      temporary,
+      ["plugin", "add", PLUGIN_ID, "--json"],
+    );
+    const listResult = await codexCommand(
+      binary,
+      temporary,
+      ["plugin", "list", "--json"],
+    );
+    const inspection = inspectPluginCommandOutputs({
+      addStdout: addResult.stdout,
+      listStdout: listResult.stdout,
+      repoRoot,
+      sourceRoot,
+    });
+    const installedRoot = path.join(
+      temporary,
+      "plugins",
+      "cache",
+      MARKETPLACE,
+      PLUGIN_NAME,
+      PLUGIN_VERSION,
+    );
+    const [source, installed] = await Promise.all([
+      treeManifest(sourceRoot),
+      treeManifest(installedRoot),
+    ]);
+    const treeMatches =
+      source.digest === installed.digest &&
+      canonicalJson(source.entries) ===
+        canonicalJson(installed.entries);
+    const passed = inspection.passed && treeMatches;
+    const evidence = {
+      schemaVersion: 1,
+      probe: "p1e-isolated-plugin-install",
+      capturedAt: new Date().toISOString(),
+      passed,
+      desktopRestarted: false,
+      globalConfigModified: false,
+      isolation: {
+        temporaryCodexHome: true,
+        codexHomePathRecorded: false,
+        cleanedAfterProbe: true,
+        inheritedCredentialVariables: false,
+        environmentAllowlist: [
+          "CODEX_HOME",
+          ...ISOLATED_ENV_ALLOWLIST,
+        ],
+      },
+      codex: {
+        lane: "desktop-bundled",
+        version: versionResult.stdout.trim(),
+      },
+      marketplace: {
+        name: MARKETPLACE,
+        added: true,
+      },
+      plugin: {
+        pluginId: PLUGIN_ID,
+        name: PLUGIN_NAME,
+        version: PLUGIN_VERSION,
+        addReturnedJson: inspection.addJsonValid,
+        addMatches: inspection.addMatches,
+        listReturnedJson: inspection.listJsonValid,
+        exactListRecordCount:
+          inspection.exactRecordCount,
+        listed: inspection.listMatches,
+        installed: inspection.installed,
+        enabled: inspection.enabled,
+        versionMatches: inspection.versionMatches,
+        sourceMatches: inspection.sourceMatches,
+        marketplaceSourceMatches:
+          inspection.marketplaceSourceMatches,
+        sourceMatchesInstalledCache: treeMatches,
+        fileCount: source.entries.length,
+        sourceTreeDigest: source.digest,
+        installedTreeDigest: installed.digest,
+      },
+      commands: [
+        "env -i <allowlist> CODEX_HOME=<temporary> <desktop-bundled-codex> --version",
+        "env -i <allowlist> CODEX_HOME=<temporary> <desktop-bundled-codex> plugin marketplace add <repo>",
+        `env -i <allowlist> CODEX_HOME=<temporary> <desktop-bundled-codex> plugin add ${PLUGIN_ID} --json`,
+        "env -i <allowlist> CODEX_HOME=<temporary> <desktop-bundled-codex> plugin list --json",
+        `compare canonical source tree with plugins/cache/${MARKETPLACE}/${PLUGIN_NAME}/${PLUGIN_VERSION}`,
+      ],
+    };
+    await atomicReplaceJson(output, evidence);
+    process.stdout.write(
+      `${JSON.stringify({
+        passed,
+        output,
+        version: evidence.codex.version,
+        fileCount: evidence.plugin.fileCount,
+        treeDigest: evidence.plugin.sourceTreeDigest,
+      })}\n`,
+    );
+    if (!passed) {
+      process.exitCode = 1;
+    }
+  } finally {
+    await rm(temporary, {
+      recursive: true,
+      force: true,
+    });
+  }
+}
+
+if (
+  process.argv[1] &&
+  path.resolve(process.argv[1]) ===
+    fileURLToPath(import.meta.url)
+) {
+  await main();
+}
diff --git a/plugins/looperators-agent-loop/scripts/probe-mcp-identity-host.mjs b/plugins/looperators-agent-loop/scripts/probe-mcp-identity-host.mjs
new file mode 100644
index 0000000..dbcba94
--- /dev/null
+++ b/plugins/looperators-agent-loop/scripts/probe-mcp-identity-host.mjs
@@ -0,0 +1,296 @@
+#!/usr/bin/env node
+
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { rmSync } from "node:fs";
+import { mkdir, mkdtemp, readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { digestJson } from "../lib/canonical-json.mjs";
+import { assertSafeFileId } from "../lib/contracts.mjs";
+import { atomicReplaceJson } from "../lib/fs-utils.mjs";
+
+function argument(name, fallback = undefined) {
+  const index = process.argv.indexOf(`--${name}`);
+  return index >= 0 ? process.argv[index + 1] : fallback;
+}
+
+function parseJsonLines(text) {
+  return text
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return { type: "unparsed" };
+      }
+    });
+}
+
+function summarizeStderr(text) {
+  const lines = text
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean);
+  const stateDbDiscrepancyCount = lines.filter((line) =>
+    line.includes("state db discrepancy"),
+  ).length;
+  return {
+    lineCount: lines.length,
+    stateDbDiscrepancyCount,
+    categories: {
+      pathAliasPermission: lines.filter((line) =>
+        line.includes("could not create PATH aliases"),
+      ).length,
+      stateDbReadOnly: lines.filter((line) =>
+        line.includes("readonly database"),
+      ).length,
+      appServerPermission: lines.filter((line) =>
+        line.includes("in-process app-server"),
+      ).length,
+      parentThreadLookup: lines.filter((line) =>
+        line.includes("parent thread"),
+      ).length,
+    },
+  };
+}
+
+const outputValue = argument("output");
+const artifactDir = argument("artifact-dir");
+if (
+  !outputValue ||
+  !artifactDir ||
+  !path.isAbsolute(outputValue) ||
+  !path.isAbsolute(artifactDir)
+) {
+  throw new Error("--output and --artifact-dir must be absolute paths");
+}
+const probeId = argument("probe-id", `host-${randomUUID()}`);
+assertSafeFileId(probeId, "probeId");
+const mode = argument("mode", "root");
+if (!["root", "subagent"].includes(mode)) {
+  throw new Error("--mode must be root or subagent");
+}
+const persistThread = process.argv.includes("--persist-thread");
+const codexBin =
+  argument("codex-bin") ??
+  "/Applications/ChatGPT.app/Contents/Resources/codex";
+const requestedDataRoot = argument("data-root");
+const dataRoot =
+  requestedDataRoot ??
+  (await mkdtemp(path.join(os.tmpdir(), "looperators-p1a-host-root-")));
+const requestedProbeCwd = argument("probe-cwd");
+const probeCwd =
+  requestedProbeCwd ??
+  (await mkdtemp(path.join(os.tmpdir(), "looperators-p1a-host-cwd-")));
+const ownedTemporaryPaths = [
+  ...(requestedDataRoot ? [] : [dataRoot]),
+  ...(requestedProbeCwd ? [] : [probeCwd]),
+];
+process.once("exit", () => {
+  for (const temporaryPath of ownedTemporaryPaths) {
+    rmSync(temporaryPath, { recursive: true, force: true });
+  }
+});
+for (const value of [dataRoot, probeCwd]) {
+  if (!path.isAbsolute(value)) {
+    throw new Error("probe paths must be absolute");
+  }
+}
+await Promise.all([
+  mkdir(dataRoot, { recursive: true, mode: 0o700 }),
+  mkdir(probeCwd, { recursive: true, mode: 0o700 }),
+  mkdir(artifactDir, { recursive: true, mode: 0o700 }),
+]);
+const pluginRoot = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "..",
+);
+const serverPath = path.join(pluginRoot, "mcp", "server.mjs");
+const prompt =
+  mode === "subagent"
+    ? [
+        "Run one synthetic looperators P1-A subagent identity gate.",
+        "Spawn exactly one native subagent named identity_worker.",
+        `Tell that subagent to call the MCP tool looperators_identity_probe from server looperators_agent_loop with probeId ${probeId} exactly once and report the returned classification.`,
+        "The root must not call the identity tool.",
+        "Do not inspect files or use unrelated tools.",
+        "Wait for the subagent and then stop.",
+      ].join(" ")
+    : [
+        "Run one synthetic looperators P1-A root identity gate.",
+        `Call the MCP tool looperators_identity_probe from server looperators_agent_loop with probeId ${probeId} exactly once.`,
+        "Do not call any other tool, do not inspect files, and stop after reporting the returned classification.",
+      ].join(" ");
+const args = [
+  "exec",
+  "--cd",
+  probeCwd,
+  "--skip-git-repo-check",
+  "--sandbox",
+  "read-only",
+  ...(persistThread ? [] : ["--ephemeral"]),
+  "--ignore-user-config",
+  "--ignore-rules",
+  "--config",
+  `mcp_servers.looperators_agent_loop.command=${JSON.stringify(process.execPath)}`,
+  "--config",
+  `mcp_servers.looperators_agent_loop.args=${JSON.stringify([serverPath])}`,
+  "--config",
+  `mcp_servers.looperators_agent_loop.env={ LOOPERATORS_DATA_DIR = ${JSON.stringify(dataRoot)}, LOOPERATORS_PROBE_ARTIFACT_DIR = ${JSON.stringify(artifactDir)} }`,
+  "--config",
+  `model_reasoning_effort=${JSON.stringify(
+    mode === "subagent" ? "high" : "low",
+  )}`,
+  "--json",
+  prompt,
+];
+const child = spawn(codexBin, args, {
+  cwd: probeCwd,
+  env: process.env,
+  stdio: ["ignore", "pipe", "pipe"],
+});
+const stdout = [];
+const stderr = [];
+child.stdout.on("data", (chunk) => stdout.push(chunk));
+child.stderr.on("data", (chunk) => stderr.push(chunk));
+const exitCode = await new Promise((resolve, reject) => {
+  child.on("error", reject);
+  child.on("close", resolve);
+});
+const stdoutText = Buffer.concat(stdout).toString("utf8");
+const stderrText = Buffer.concat(stderr).toString("utf8");
+const events = parseJsonLines(stdoutText);
+const toolCall = events
+  .filter((event) => event.type === "item.completed")
+  .map((event) => event.item)
+  .find(
+    (item) =>
+      item?.type === "mcp_tool_call" &&
+      item?.tool === "looperators_identity_probe",
+  );
+let serverRecord = null;
+try {
+  serverRecord = JSON.parse(
+    await readFile(
+      path.join(artifactDir, `mcp-identity-${probeId}.json`),
+      "utf8",
+    ),
+  );
+} catch {
+  serverRecord = null;
+}
+const completedItems = events
+  .filter((event) => event.type === "item.completed")
+  .map((event) => event.item)
+  .filter(Boolean)
+  .map((item) => {
+    if (item.type === "mcp_tool_call") {
+      return {
+        type: item.type,
+        server: item.server,
+        tool: item.tool,
+        status: item.status,
+        errorPresent: item.error !== undefined && item.error !== null,
+      };
+    }
+    if (item.type === "error") {
+      return {
+        type: item.type,
+        messageDigest: digestJson({
+          message: String(item.message ?? "").slice(0, 2000),
+        }),
+      };
+    }
+    if (item.type === "agent_message") {
+      const text = String(item.text ?? "").slice(0, 2000);
+      return {
+        type: item.type,
+        textBytes: Buffer.byteLength(text, "utf8"),
+        textDigest: digestJson({ text }),
+      };
+    }
+    if (item.type === "collab_tool_call") {
+      return {
+        type: item.type,
+        tool: item.tool ?? item.name ?? null,
+        status: item.status ?? null,
+        errorPresent: item.error !== undefined && item.error !== null,
+      };
+    }
+    return { type: item.type ?? "unknown" };
+  });
+const passed =
+  exitCode === 0 &&
+  serverRecord?.probeId === probeId &&
+  (mode === "subagent"
+    ? serverRecord?.contextHints?.threadSource === "subagent"
+    : toolCall?.status === "completed");
+const result = {
+  schemaVersion: 1,
+  capturedAt: new Date().toISOString(),
+  probeId,
+  codexBin,
+  dataRootDigest: digestJson({ dataRoot }),
+  probeCwdDigest: digestJson({ probeCwd }),
+  isolation: {
+    ephemeral: !persistThread,
+    persistedIndependentThread: persistThread,
+    ignoredUserConfig: true,
+    ignoredRules: true,
+    desktopRestarted: false,
+    globalConfigModified: false,
+  },
+  commandShape: {
+    subcommand: "exec",
+    sandbox: "read-only",
+    injectedMcpServer: "looperators_agent_loop",
+    mode,
+    reasoningEffort: mode === "subagent" ? "high" : "low",
+  },
+  exitCode,
+  stderrSummary: summarizeStderr(stderrText),
+  eventTypes: events.reduce((counts, event) => {
+    counts[event.type ?? "unknown"] =
+      (counts[event.type ?? "unknown"] ?? 0) + 1;
+    return counts;
+  }, {}),
+  completedItems,
+  threadIdDigest: events.find(
+    (event) => event.type === "thread.started",
+  )?.thread_id
+    ? digestJson({
+        threadId: events.find(
+          (event) => event.type === "thread.started",
+        ).thread_id,
+      })
+    : null,
+  toolCall: toolCall
+    ? {
+        server: toolCall.server,
+        tool: toolCall.tool,
+        status: toolCall.status,
+        errorPresent:
+          toolCall.error !== undefined && toolCall.error !== null,
+        structuredContent: toolCall.result?.structured_content ?? null,
+      }
+    : null,
+  serverRecord,
+  passed,
+};
+await atomicReplaceJson(outputValue, result);
+process.stdout.write(
+  `${JSON.stringify({
+    output: outputValue,
+    probeId,
+    passed: result.passed,
+    classification: serverRecord?.classification ?? null,
+  })}\n`,
+);
+if (!result.passed) {
+  process.exitCode = 1;
+}
diff --git a/plugins/looperators-agent-loop/scripts/probe-shared-data-root.mjs b/plugins/looperators-agent-loop/scripts/probe-shared-data-root.mjs
new file mode 100644
index 0000000..fc25e2e
--- /dev/null
+++ b/plugins/looperators-agent-loop/scripts/probe-shared-data-root.mjs
@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { mkdtemp, mkdir, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { digestJson } from "../lib/canonical-json.mjs";
+import { assertSafeFileId } from "../lib/contracts.mjs";
+import { resolveDataRoot } from "../lib/data-root.mjs";
+import { atomicReplaceJson, readJsonFile } from "../lib/fs-utils.mjs";
+import { LoopStore } from "../lib/store.mjs";
+
+function argument(name, fallback = undefined) {
+  const index = process.argv.indexOf(`--${name}`);
+  return index >= 0 ? process.argv[index + 1] : fallback;
+}
+
+async function runHook(hookPath, env, input) {
+  const child = spawn(process.execPath, [hookPath], {
+    env,
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+  child.stdin.end(JSON.stringify(input));
+  const stdout = [];
+  const stderr = [];
+  child.stdout.on("data", (chunk) => stdout.push(chunk));
+  child.stderr.on("data", (chunk) => stderr.push(chunk));
+  const exitCode = await new Promise((resolve, reject) => {
+    child.on("error", reject);
+    child.on("close", resolve);
+  });
+  return {
+    exitCode,
+    stdout: Buffer.concat(stdout).toString("utf8"),
+    stderr: Buffer.concat(stderr).toString("utf8"),
+  };
+}
+
+async function callMcp(serverPath, env, probeId) {
+  const child = spawn(process.execPath, [serverPath], {
+    env,
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+  const pending = new Map();
+  let buffer = "";
+  const stderr = [];
+  child.stderr.on("data", (chunk) => stderr.push(chunk));
+  child.stdout.on("data", (chunk) => {
+    buffer += chunk.toString("utf8");
+    while (buffer.includes("\n")) {
+      const newline = buffer.indexOf("\n");
+      const line = buffer.slice(0, newline);
+      buffer = buffer.slice(newline + 1);
+      if (!line.trim()) {
+        continue;
+      }
+      const message = JSON.parse(line);
+      pending.get(message.id)?.(message);
+      pending.delete(message.id);
+    }
+  });
+  function request(id, method, params = {}) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        pending.delete(id);
+        reject(new Error(`MCP request timed out: ${method}`));
+      }, 5_000);
+      pending.set(id, (message) => {
+        clearTimeout(timer);
+        resolve(message);
+      });
+      child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}\n`);
+    });
+  }
+  await request(1, "initialize", {
+    protocolVersion: "2025-06-18",
+    capabilities: {},
+    clientInfo: { name: "looperators-p1a-shared-root-probe", version: "1" },
+  });
+  child.stdin.write(
+    `${JSON.stringify({
+      jsonrpc: "2.0",
+      method: "notifications/initialized",
+      params: {},
+    })}\n`,
+  );
+  const result = await request(2, "tools/call", {
+    name: "looperators_shared_root_probe",
+    arguments: { probeId },
+  });
+  child.stdin.end();
+  const exitCode = await new Promise((resolve, reject) => {
+    child.on("error", reject);
+    child.on("close", resolve);
+  });
+  return {
+    exitCode,
+    response: result,
+    stderr: Buffer.concat(stderr).toString("utf8"),
+  };
+}
+
+const outputValue = argument("output");
+if (!outputValue || !path.isAbsolute(outputValue)) {
+  throw new Error("--output must be an absolute path");
+}
+const probeId = argument("probe-id", `shared-${randomUUID()}`);
+assertSafeFileId(probeId, "probeId");
+const requestedDataRoot = argument("data-root");
+const dataRoot =
+  requestedDataRoot ??
+  (await mkdtemp(path.join(os.tmpdir(), "looperators-p1a-shared-root-")));
+if (!path.isAbsolute(dataRoot)) {
+  throw new Error("--data-root must be absolute");
+}
+await mkdir(dataRoot, { recursive: true, mode: 0o700 });
+const pluginRoot = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "..",
+);
+const hookPath = path.join(pluginRoot, "hooks", "collect-event.mjs");
+const serverPath = path.join(pluginRoot, "mcp", "server.mjs");
+const sessionId = "p1a-shared-root-session";
+const runId = "run-shared-root-probe";
+const env = {
+  ...process.env,
+  LOOPERATORS_DATA_DIR: dataRoot,
+  PLUGIN_DATA: dataRoot,
+  LOOPERATORS_SHARED_ROOT_PROBE_ID: probeId,
+  LOOPERATORS_RUN_ID: runId,
+};
+const timestamp = new Date().toISOString();
+const rootInfo = await resolveDataRoot({ env });
+const store = new LoopStore(rootInfo);
+await store.initializeRun({
+  schemaVersion: 1,
+  runId,
+  rootSessionId: sessionId,
+  originatingTurnId: "p1a-shared-root-turn",
+  scope: { kind: "task" },
+  masterNode: sessionId,
+  recipe: "review-until-clean",
+  status: "running",
+  currentLap: 0,
+  continuationLease: { granted: 0, consumed: 0 },
+  cancelRequested: false,
+  revision: 0,
+  createdAt: timestamp,
+  updatedAt: timestamp,
+});
+const hook = await runHook(hookPath, env, {
+  session_id: sessionId,
+  turn_id: "p1a-shared-root-turn",
+  hook_event_name: "SessionStart",
+  source: "startup",
+});
+const mcp = await callMcp(serverPath, env, probeId);
+const hookMarker = await readJsonFile(
+  path.join(dataRoot, "probes", "shared-root", `${probeId}-hook.json`),
+);
+const mcpMarker = await readJsonFile(
+  path.join(dataRoot, "probes", "shared-root", `${probeId}-mcp.json`),
+);
+const result = {
+  schemaVersion: 1,
+  probeId,
+  dataRootDigest: digestJson({ dataRoot }),
+  hook: {
+    exitCode: hook.exitCode,
+    stdoutEmpty: hook.stdout.length === 0,
+    stderrEmpty: hook.stderr.length === 0,
+    marker: hookMarker,
+  },
+  mcp: {
+    exitCode: mcp.exitCode,
+    error: mcp.response.error ?? null,
+    structuredContent: mcp.response.result?.structuredContent ?? null,
+    stderrEmpty: mcp.stderr.length === 0,
+    marker: mcpMarker,
+  },
+  sameInstance:
+    hookMarker.instanceIdDigest === mcpMarker.instanceIdDigest,
+  passed:
+    hook.exitCode === 0 &&
+    mcp.exitCode === 0 &&
+    !mcp.response.error &&
+    hookMarker.instanceIdDigest === mcpMarker.instanceIdDigest,
+};
+await atomicReplaceJson(outputValue, result);
+process.stdout.write(
+  `${JSON.stringify({
+    output: outputValue,
+    probeId,
+    sameInstance: result.sameInstance,
+    passed: result.passed,
+  })}\n`,
+);
+if (!result.passed) {
+  process.exitCode = 1;
+}
+if (!requestedDataRoot) {
+  await rm(dataRoot, { recursive: true, force: true });
+}
diff --git a/plugins/looperators-agent-loop/scripts/render-inline-graph.mjs b/plugins/looperators-agent-loop/scripts/render-inline-graph.mjs
new file mode 100644
index 0000000..bc93930
--- /dev/null
+++ b/plugins/looperators-agent-loop/scripts/render-inline-graph.mjs
@@ -0,0 +1,618 @@
+#!/usr/bin/env node
+
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import {
+  lstat,
+  open,
+  realpath,
+  rename,
+  stat,
+  unlink,
+} from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import {
+  fileURLToPath,
+  pathToFileURL,
+} from "node:url";
+import { sha256 } from "../lib/canonical-json.mjs";
+import { LoopController } from "../lib/control.mjs";
+import { renderGraphFragment } from "../lib/graph-view.mjs";
+import { LoopStore } from "../lib/store.mjs";
+
+export const MAX_INLINE_FRAGMENT_BYTES = 2 * 1024 * 1024;
+const OUTPUT_NAME_PATTERN =
+  /^looperators-agent-loop-[a-f0-9]{12}-r(?:0|[1-9]\d*)-[a-f0-9]{12}\.html$/;
+const DIGEST_PATTERN = /^[a-f0-9]{64}$/;
+const WRITER_OUTPUT_LIMIT = 8 * 1024;
+const WRITER_TIMEOUT_MS = 10_000;
+
+function argument(name) {
+  const index = process.argv.indexOf(`--${name}`);
+  return index >= 0 ? process.argv[index + 1] : undefined;
+}
+
+function unsafeRoot(message) {
+  return Object.assign(new Error(message), {
+    code: "UNSAFE_VISUALIZATION_ROOT",
+  });
+}
+
+function unsafeOutput(message) {
+  return Object.assign(new Error(message), {
+    code: "UNSAFE_VISUALIZATION_OUTPUT",
+  });
+}
+
+async function openVisualizationRoot(
+  directory,
+  { afterCanonicalPathCheck } = {},
+) {
+  const resolved = path.resolve(directory);
+  const parsed = path.parse(resolved);
+  let current = parsed.root;
+  const relative = resolved.slice(parsed.root.length);
+  for (const segment of relative.split(path.sep).filter(Boolean)) {
+    current = path.join(current, segment);
+    const metadata = await lstat(current);
+    if (metadata.isSymbolicLink()) {
+      throw unsafeRoot(
+        "visualization root cannot contain symlink components",
+      );
+    }
+  }
+  const metadata = await lstat(resolved);
+  if (!metadata.isDirectory()) {
+    throw unsafeRoot(
+      "visualization root must be an existing directory",
+    );
+  }
+  if ((await realpath(resolved)) !== resolved) {
+    throw unsafeRoot(
+      "visualization root must use its canonical path",
+    );
+  }
+  await afterCanonicalPathCheck?.();
+  const handle = await open(
+    resolved,
+    constants.O_RDONLY |
+      (constants.O_DIRECTORY ?? 0) |
+      (constants.O_NOFOLLOW ?? 0),
+  );
+  try {
+    const identity = await handle.stat({ bigint: true });
+    if (!identity.isDirectory()) {
+      throw unsafeRoot(
+        "visualization root must be an existing directory",
+      );
+    }
+    const anchor = {
+      path: resolved,
+      handle,
+      device: String(identity.dev),
+      inode: String(identity.ino),
+    };
+    await assertCurrentRoot(anchor);
+    return anchor;
+  } catch (error) {
+    await handle.close();
+    throw error;
+  }
+}
+
+async function assertCurrentRoot(anchor) {
+  let metadata;
+  let canonical;
+  try {
+    metadata = await lstat(anchor.path, {
+      bigint: true,
+    });
+    canonical = await realpath(anchor.path);
+  } catch {
+    throw unsafeRoot("visualization root identity changed");
+  }
+  if (
+    metadata.isSymbolicLink() ||
+    !metadata.isDirectory() ||
+    String(metadata.dev) !== anchor.device ||
+    String(metadata.ino) !== anchor.inode ||
+    canonical !== anchor.path
+  ) {
+    throw unsafeRoot("visualization root identity changed");
+  }
+}
+
+function assertOutputTarget(root, output) {
+  const relative = path.relative(root, output);
+  if (
+    relative.startsWith(`..${path.sep}`) ||
+    relative === ".." ||
+    path.isAbsolute(relative) ||
+    path.dirname(relative) !== "."
+  ) {
+    throw unsafeOutput(
+      "inline output must be directly contained by its root",
+    );
+  }
+  if (!OUTPUT_NAME_PATTERN.test(path.basename(output))) {
+    throw unsafeOutput("inline output basename is invalid");
+  }
+}
+
+function assertFragmentContract(fragment) {
+  const bytes = Buffer.byteLength(fragment, "utf8");
+  if (bytes >= MAX_INLINE_FRAGMENT_BYTES) {
+    throw Object.assign(
+      new Error("inline fragment exceeds the 2 MiB bound"),
+      { code: "INLINE_FRAGMENT_TOO_LARGE" },
+    );
+  }
+  if (
+    /<(?:!doctype|html|head|body)\b/iu.test(fragment) ||
+    /\b(?:fetch|XMLHttpRequest|WebSocket|EventSource)\s*\(/u.test(
+      fragment,
+    ) ||
+    /(?:src|href)\s*=\s*["']https?:/iu.test(fragment)
+  ) {
+    throw Object.assign(
+      new Error("inline fragment contains a forbidden shell or network API"),
+      { code: "UNSAFE_INLINE_FRAGMENT" },
+    );
+  }
+  return bytes;
+}
+
+async function readBoundedStdin() {
+  const chunks = [];
+  let bytes = 0;
+  for await (const chunk of process.stdin) {
+    bytes += chunk.length;
+    if (bytes >= MAX_INLINE_FRAGMENT_BYTES) {
+      throw Object.assign(
+        new Error("anchored writer input exceeds its bound"),
+        { code: "UNSAFE_INLINE_FRAGMENT" },
+      );
+    }
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks, bytes);
+}
+
+function childError(stderr) {
+  const code =
+    stderr.match(/^([A-Z][A-Z0-9_]{0,63}):/u)?.[1] ??
+    "INLINE_ANCHORED_WRITE_FAILED";
+  return Object.assign(
+    new Error("anchored inline writer rejected the output"),
+    { code },
+  );
+}
+
+async function childWriteFragment(
+  anchor,
+  outputName,
+  fragment,
+) {
+  const contentDigest = sha256(
+    Buffer.from(fragment, "utf8"),
+  );
+  await new Promise((resolve, reject) => {
+    const child = spawn(
+      process.execPath,
+      [
+        fileURLToPath(import.meta.url),
+        "--anchored-write",
+        "--output-name",
+        outputName,
+        "--expected-device",
+        anchor.device,
+        "--expected-inode",
+        anchor.inode,
+        "--content-digest",
+        contentDigest,
+      ],
+      {
+        cwd: anchor.path,
+        stdio: ["pipe", "pipe", "pipe"],
+      },
+    );
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    let timer;
+    const finish = (error = null) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      if (error) {
+        reject(error);
+      } else {
+        resolve();
+      }
+    };
+    const overflow = () => {
+      child.kill("SIGKILL");
+      finish(
+        Object.assign(
+          new Error("anchored inline writer output exceeded its bound"),
+          { code: "INLINE_ANCHORED_WRITE_FAILED" },
+        ),
+      );
+    };
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+      if (
+        Buffer.byteLength(stdout, "utf8") >
+        WRITER_OUTPUT_LIMIT
+      ) {
+        overflow();
+      }
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+      if (
+        Buffer.byteLength(stderr, "utf8") >
+        WRITER_OUTPUT_LIMIT
+      ) {
+        overflow();
+      }
+    });
+    child.once("error", (error) => {
+      finish(
+        Object.assign(
+          new Error("anchored inline writer could not start"),
+          {
+            code:
+              error?.code === "ENOENT"
+                ? "INLINE_ANCHORED_WRITE_UNAVAILABLE"
+                : "INLINE_ANCHORED_WRITE_FAILED",
+          },
+        ),
+      );
+    });
+    child.once("close", (code) => {
+      if (settled) {
+        return;
+      }
+      if (code !== 0) {
+        finish(childError(stderr));
+        return;
+      }
+      let result;
+      try {
+        result = JSON.parse(stdout);
+      } catch {
+        finish(
+          Object.assign(
+            new Error("anchored inline writer returned invalid output"),
+            { code: "INLINE_ANCHORED_WRITE_FAILED" },
+          ),
+        );
+        return;
+      }
+      if (
+        result?.status !== "written" ||
+        result.outputName !== outputName ||
+        result.bytes !==
+          Buffer.byteLength(fragment, "utf8") ||
+        result.contentDigest !== contentDigest
+      ) {
+        finish(
+          Object.assign(
+            new Error("anchored inline writer result did not match"),
+            { code: "INLINE_ANCHORED_WRITE_FAILED" },
+          ),
+        );
+        return;
+      }
+      finish();
+    });
+    timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      finish(
+        Object.assign(
+          new Error("anchored inline writer timed out"),
+          { code: "INLINE_ANCHORED_WRITE_FAILED" },
+        ),
+      );
+    }, WRITER_TIMEOUT_MS);
+    timer.unref?.();
+    child.stdin.on("error", () => {});
+    child.stdin.end(fragment, "utf8");
+  });
+  await assertCurrentRoot(anchor);
+}
+
+async function anchoredWriteMain() {
+  const outputName = argument("output-name");
+  const expectedDevice = argument("expected-device");
+  const expectedInode = argument("expected-inode");
+  const expectedDigest = argument("content-digest");
+  if (
+    !OUTPUT_NAME_PATTERN.test(outputName ?? "") ||
+    !/^\d+$/u.test(expectedDevice ?? "") ||
+    !/^\d+$/u.test(expectedInode ?? "") ||
+    !DIGEST_PATTERN.test(expectedDigest ?? "")
+  ) {
+    throw unsafeOutput("anchored writer arguments are invalid");
+  }
+  const directory = await stat(".", { bigint: true });
+  if (
+    !directory.isDirectory() ||
+    String(directory.dev) !== expectedDevice ||
+    String(directory.ino) !== expectedInode
+  ) {
+    throw unsafeRoot("visualization root identity changed");
+  }
+  const fragmentBuffer = await readBoundedStdin();
+  if (
+    fragmentBuffer.length >= MAX_INLINE_FRAGMENT_BYTES ||
+    sha256(fragmentBuffer) !== expectedDigest
+  ) {
+    throw Object.assign(
+      new Error("anchored writer input is invalid"),
+      { code: "UNSAFE_INLINE_FRAGMENT" },
+    );
+  }
+  const fragment = fragmentBuffer.toString("utf8");
+  const bytes = assertFragmentContract(fragment);
+  try {
+    const existing = await lstat(outputName);
+    if (
+      existing.isSymbolicLink() ||
+      !existing.isFile()
+    ) {
+      throw unsafeOutput(
+        "inline output must be a regular file",
+      );
+    }
+  } catch (error) {
+    if (error?.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  const temporary =
+    `.${outputName}.${process.pid}.${randomUUID()}.tmp`;
+  let handle;
+  try {
+    handle = await open(
+      temporary,
+      constants.O_RDWR |
+        constants.O_CREAT |
+        constants.O_EXCL |
+        (constants.O_NOFOLLOW ?? 0),
+      0o600,
+    );
+    await handle.writeFile(fragmentBuffer);
+    await handle.sync();
+    await rename(temporary, outputName);
+    const metadata = await handle.stat({
+      bigint: true,
+    });
+    if (
+      !metadata.isFile() ||
+      (metadata.mode & 0o777n) !== 0o600n
+    ) {
+      throw Object.assign(
+        new Error("inline output read-back metadata is invalid"),
+        { code: "INLINE_READBACK_FAILED" },
+      );
+    }
+    const readBack = Buffer.alloc(fragmentBuffer.length);
+    let offset = 0;
+    while (offset < readBack.length) {
+      const result = await handle.read(
+        readBack,
+        offset,
+        readBack.length - offset,
+        offset,
+      );
+      if (result.bytesRead === 0) {
+        break;
+      }
+      offset += result.bytesRead;
+    }
+    if (
+      offset !== fragmentBuffer.length ||
+      !readBack.equals(fragmentBuffer)
+    ) {
+      throw Object.assign(
+        new Error("inline output read-back differs from generated bytes"),
+        { code: "INLINE_READBACK_FAILED" },
+      );
+    }
+    const linked = await lstat(outputName, {
+      bigint: true,
+    });
+    if (
+      linked.isSymbolicLink() ||
+      !linked.isFile() ||
+      linked.dev !== metadata.dev ||
+      linked.ino !== metadata.ino
+    ) {
+      throw Object.assign(
+        new Error("inline output path changed during read-back"),
+        { code: "INLINE_READBACK_FAILED" },
+      );
+    }
+  } finally {
+    await handle?.close();
+    await unlink(temporary).catch((error) => {
+      if (error?.code !== "ENOENT") {
+        throw error;
+      }
+    });
+  }
+  process.stdout.write(
+    `${JSON.stringify({
+      status: "written",
+      outputName,
+      bytes,
+      contentDigest: expectedDigest,
+    })}\n`,
+  );
+}
+
+export async function renderInlineGraph(options) {
+  const anchor = await openVisualizationRoot(
+    options.visualizationRoot,
+    {
+      afterCanonicalPathCheck:
+        options.testHooks?.afterRootCanonicalPathCheck,
+    },
+  );
+  try {
+    const expectedTaskIds = [
+      ...(options.expectedTaskId === undefined
+        ? []
+        : [options.expectedTaskId]),
+      ...(options.expectedHostTaskId === undefined
+        ? []
+        : [options.expectedHostTaskId]),
+    ];
+    if (
+      expectedTaskIds.some(
+        (taskId) =>
+          typeof taskId !== "string" ||
+          taskId.length === 0 ||
+          taskId.length > 512,
+      ) ||
+      (expectedTaskIds.length > 0 &&
+        !expectedTaskIds.includes(path.basename(anchor.path)))
+    ) {
+      throw Object.assign(
+        new Error(
+          "visualization root does not belong to the current or delegated host task",
+        ),
+        { code: "VISUALIZATION_ROOT_MISMATCH" },
+      );
+    }
+    if (
+      options.expectedProjectionDigest !== undefined &&
+      !DIGEST_PATTERN.test(options.expectedProjectionDigest)
+    ) {
+      throw Object.assign(
+        new TypeError("expected projection digest is invalid"),
+        { code: "INVALID_EXPECTED_DIGEST" },
+      );
+    }
+    const controller =
+      options.controller ??
+      new LoopController(
+        options.store ?? (await LoopStore.open()),
+      );
+    let projection = await controller.snapshotForRun(
+      options.runId,
+    );
+    if (projection.runId !== options.runId) {
+      throw Object.assign(
+        new Error("snapshot belongs to another run"),
+        { code: "SNAPSHOT_IDENTITY_MISMATCH" },
+      );
+    }
+    let rereads = 0;
+    let driftNote = "";
+    if (
+      options.expectedProjectionDigest &&
+      projection.projectionDigest !==
+        options.expectedProjectionDigest
+    ) {
+      projection = await controller.snapshotForRun(
+        options.runId,
+      );
+      if (projection.runId !== options.runId) {
+        throw Object.assign(
+          new Error("snapshot belongs to another run"),
+          { code: "SNAPSHOT_IDENTITY_MISMATCH" },
+        );
+      }
+      rereads = 1;
+      driftNote =
+        "Snapshot advanced while rendering: expected " +
+        options.expectedProjectionDigest.slice(0, 12) +
+        ", rendered " +
+        projection.projectionDigest.slice(0, 12) +
+        ".";
+    }
+    const fragment = renderGraphFragment(projection, {
+      mode: "inline",
+      driftNote,
+    });
+    const bytes = assertFragmentContract(fragment);
+    const outputName =
+      `looperators-agent-loop-${sha256(projection.runId).slice(0, 12)}` +
+      `-r${projection.revision}-${projection.projectionDigest.slice(0, 12)}.html`;
+    const output = path.join(anchor.path, outputName);
+    assertOutputTarget(anchor.path, output);
+    await childWriteFragment(
+      anchor,
+      outputName,
+      fragment,
+    );
+    return {
+      output,
+      outputName,
+      bytes,
+      projection,
+      projectionDigest: projection.projectionDigest,
+      snapshotIdentity: {
+        runId: projection.runId,
+        revision: projection.revision,
+        eventWatermark: projection.eventWatermark,
+      },
+      rereads,
+      drifted: Boolean(driftNote),
+    };
+  } finally {
+    await anchor.handle.close();
+  }
+}
+
+async function main() {
+  const runId = argument("run-id");
+  const visualizationRoot = argument("visualization-root");
+  if (!runId || !visualizationRoot) {
+    throw new Error(
+      "Usage: render-inline-graph.mjs --run-id <id> --visualization-root <absolute-existing-directory> [--expected-projection-digest <sha256>]",
+    );
+  }
+  if (!path.isAbsolute(visualizationRoot)) {
+    throw unsafeRoot(
+      "--visualization-root must be absolute",
+    );
+  }
+  const result = await renderInlineGraph({
+    runId,
+    visualizationRoot,
+    expectedProjectionDigest: argument(
+      "expected-projection-digest",
+    ),
+  });
+  process.stdout.write(
+    `${JSON.stringify({
+      output: result.output,
+      outputName: result.outputName,
+      bytes: result.bytes,
+      projectionDigest: result.projectionDigest,
+      snapshotIdentity: result.snapshotIdentity,
+      rereads: result.rereads,
+      drifted: result.drifted,
+    })}\n`,
+  );
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1] ?? "").href) {
+  const entry = process.argv.includes("--anchored-write")
+    ? anchoredWriteMain
+    : main;
+  entry().catch((error) => {
+    process.stderr.write(
+      `${String(error?.code ?? "RENDER_FAILED")}: ${error?.message ?? error}\n`,
+    );
+    process.exitCode = 1;
+  });
+}
diff --git a/plugins/looperators-agent-loop/scripts/run-p1d-headless.mjs b/plugins/looperators-agent-loop/scripts/run-p1d-headless.mjs
new file mode 100644
index 0000000..6e9f20c
--- /dev/null
+++ b/plugins/looperators-agent-loop/scripts/run-p1d-headless.mjs
@@ -0,0 +1,408 @@
+#!/usr/bin/env node
+
+import {
+  mkdir,
+  mkdtemp,
+  readFile,
+  readdir,
+  realpath,
+  rm,
+} from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { pathToFileURL } from "node:url";
+import { canonicalJson } from "../lib/canonical-json.mjs";
+import { LoopController } from "../lib/control.mjs";
+import {
+  HOOK_COLLECTOR_PROTOCOL,
+  normalizeHookEvent,
+} from "../lib/contracts.mjs";
+import { resolveDataRoot } from "../lib/data-root.mjs";
+import { atomicReplaceJson } from "../lib/fs-utils.mjs";
+import { currentHookDefinitionDigest } from "../lib/hook-readiness.mjs";
+import { LoopStore } from "../lib/store.mjs";
+import { renderInlineGraph } from "./render-inline-graph.mjs";
+
+function argument(name) {
+  const index = process.argv.indexOf(`--${name}`);
+  return index >= 0 ? process.argv[index + 1] : undefined;
+}
+
+function clock() {
+  let seconds = 0;
+  return () => {
+    const value = new Date(
+      Date.UTC(2026, 6, 26, 23, 0, seconds),
+    ).toISOString();
+    seconds += 1;
+    return value;
+  };
+}
+
+async function putSpawnEvidence(
+  store,
+  runId,
+  rootSessionId,
+  rootTurnId,
+  role,
+  agentId,
+  index,
+) {
+  await store.putEvent(
+    runId,
+    normalizeHookEvent(
+      {
+        session_id: rootSessionId,
+        turn_id: rootTurnId,
+        hook_event_name: "PreToolUse",
+        tool_use_id: `p1d-spawn-${index}`,
+        tool_name: "collaborationspawn_agent",
+        tool_input: { task_name: role },
+      },
+      {
+        observedAt:
+          `2026-07-26T23:10:0${index}.000Z`,
+      },
+    ),
+  );
+  const start = normalizeHookEvent(
+    {
+      session_id: rootSessionId,
+      turn_id: `p1d-worker-turn-${index}`,
+      hook_event_name: "SubagentStart",
+      agent_id: agentId,
+      agent_type: "worker",
+    },
+    {
+      observedAt:
+        `2026-07-26T23:10:0${index}.500Z`,
+    },
+  );
+  await store.putEvent(runId, start);
+  return start;
+}
+
+async function allJsonText(directory) {
+  const values = [];
+  async function walk(current) {
+    for (const entry of await readdir(current, {
+      withFileTypes: true,
+    })) {
+      const target = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        await walk(target);
+      } else if (
+        entry.isFile() &&
+        entry.name.endsWith(".json")
+      ) {
+        values.push(await readFile(target, "utf8"));
+      }
+    }
+  }
+  await walk(directory);
+  return values.join("\n");
+}
+
+export async function runP1dHeadless(
+  outputDirectory,
+  options = {},
+) {
+  if (!path.isAbsolute(outputDirectory)) {
+    throw new TypeError("--output must be absolute");
+  }
+  await mkdir(outputDirectory, {
+    recursive: true,
+    mode: 0o700,
+  });
+  const canonicalOutput = await realpath(outputDirectory);
+  if (canonicalOutput !== path.resolve(outputDirectory)) {
+    throw new Error("--output must use a canonical non-symlink path");
+  }
+  const visualizationRoot = path.join(
+    canonicalOutput,
+    "visualization",
+  );
+  await mkdir(visualizationRoot, {
+    recursive: true,
+    mode: 0o700,
+  });
+  const temporary = await mkdtemp(
+    path.join(os.tmpdir(), "looperators-p1d-headless-"),
+  );
+  const dataRoot = path.join(temporary, "data");
+  try {
+    const rootInfo = await resolveDataRoot({
+      env: { LOOPERATORS_DATA_DIR: dataRoot },
+    });
+    const store = new LoopStore(rootInfo);
+    const controller = new LoopController(store, {
+      now: clock(),
+    });
+    const previewContext = {
+      rootSessionId: "p1d-headless-root",
+      turnId: "p1d-headless-turn",
+      threadSource: "user",
+    };
+    const preview = await controller.preview(previewContext, {
+      requestId: "p1d-preview",
+      goal: "Exercise a bounded synthetic review-until-clean loop.",
+      implementerInstructions:
+        "Return a typed done report after each synthetic implementation.",
+      reviewerInstructions:
+        "Return one issues verdict, then a clean verdict.",
+      lapCap: 2,
+    });
+    const context = {
+      ...previewContext,
+      turnId: "p1d-headless-confirmed-turn",
+    };
+    await store.putEvent(
+      preview.runId,
+      normalizeHookEvent(
+        {
+          session_id: context.rootSessionId,
+          turn_id: context.turnId,
+          hook_event_name: "UserPromptSubmit",
+        },
+        {
+          observedAt: "2026-07-26T23:00:01.000Z",
+          hookCollectorProtocol:
+            HOOK_COLLECTOR_PROTOCOL,
+          hookDefinitionDigest:
+            await currentHookDefinitionDigest(),
+        },
+      ),
+    );
+    await controller.start(context, {
+      runId: preview.runId,
+      requestId: "p1d-start",
+    });
+
+    const tokens = {};
+    for (const [index, role, agentId] of [
+      [1, "implementer", "p1d-native-implementer"],
+      [2, "reviewer", "p1d-native-reviewer"],
+    ]) {
+      const baseline =
+        await controller.prepareWorkerSpawn(context, {
+          runId: preview.runId,
+          requestId: `p1d-prepare-${role}`,
+          role,
+        });
+      const observed = await putSpawnEvidence(
+        store,
+        preview.runId,
+        context.rootSessionId,
+        context.turnId,
+        role,
+        agentId,
+        index,
+      );
+      const bound = await controller.bindWorker(context, {
+        runId: preview.runId,
+        requestId: `p1d-bind-${role}`,
+        observationId: baseline.observationId,
+        originEventId: observed.eventId,
+        agentId,
+        role,
+      });
+      tokens[role] = bound.capabilityToken;
+    }
+
+    await controller.report({
+      runId: preview.runId,
+      requestId: "p1d-implementer-first",
+      agentId: "p1d-native-implementer",
+      capabilityToken: tokens.implementer,
+      type: "info",
+      status: "done",
+      summary: "Synthetic first implementation completed.",
+    });
+    await controller.report({
+      runId: preview.runId,
+      requestId: "p1d-reviewer-issues",
+      agentId: "p1d-native-reviewer",
+      capabilityToken: tokens.reviewer,
+      type: "verdict",
+      verdict: "issues",
+      issues: [
+        {
+          message: "Synthetic review issue for the P1-D fixture.",
+          file: "synthetic.js",
+          line: 1,
+          severity: "warn",
+        },
+      ],
+      summary: "One synthetic issue remains.",
+    });
+    const issuesProjection =
+      await controller.snapshotForRun(preview.runId);
+    await atomicReplaceJson(
+      path.join(canonicalOutput, "issues-projection.json"),
+      issuesProjection,
+      { root: canonicalOutput },
+    );
+    const inline = await renderInlineGraph({
+      runId: preview.runId,
+      visualizationRoot,
+      expectedProjectionDigest:
+        issuesProjection.projectionDigest,
+      store,
+      controller,
+    });
+    const threadInline = options.visualizationRoot
+      ? await renderInlineGraph({
+          runId: preview.runId,
+          visualizationRoot: options.visualizationRoot,
+          expectedProjectionDigest:
+            issuesProjection.projectionDigest,
+          store,
+          controller,
+        })
+      : null;
+    const threadInlineExactArtifactBytes = threadInline
+      ? (
+          await readFile(threadInline.output)
+        ).equals(await readFile(inline.output))
+      : null;
+    if (
+      threadInline &&
+      !threadInlineExactArtifactBytes
+    ) {
+      throw new Error(
+        "task-scoped inline bytes differ from the checked evidence fragment",
+      );
+    }
+
+    await controller.report({
+      runId: preview.runId,
+      requestId: "p1d-implementer-fix",
+      agentId: "p1d-native-implementer",
+      capabilityToken: tokens.implementer,
+      type: "info",
+      status: "done",
+      summary: "Synthetic issue addressed.",
+    });
+    await controller.report({
+      runId: preview.runId,
+      requestId: "p1d-reviewer-clean",
+      agentId: "p1d-native-reviewer",
+      capabilityToken: tokens.reviewer,
+      type: "verdict",
+      verdict: "clean",
+      summary: "Synthetic review is clean.",
+    });
+    const succeededProjection =
+      await controller.snapshotForRun(preview.runId);
+    await atomicReplaceJson(
+      path.join(
+        canonicalOutput,
+        "succeeded-projection.json",
+      ),
+      succeededProjection,
+      { root: canonicalOutput },
+    );
+    const durableText = await allJsonText(dataRoot);
+    const plaintextCapabilityPersisted = Object.values(
+      tokens,
+    ).some((token) => durableText.includes(token));
+    if (plaintextCapabilityPersisted) {
+      throw new Error(
+        "headless fixture found a plaintext capability in durable state",
+      );
+    }
+    const summary = {
+      schemaVersion: 1,
+      passed: true,
+      runId: preview.runId,
+      issues: {
+        status: issuesProjection.status,
+        revision: issuesProjection.revision,
+        currentLap: issuesProjection.currentLap,
+        pendingRole: issuesProjection.pending?.role,
+        projectionDigest:
+          issuesProjection.projectionDigest,
+        eventWatermark:
+          issuesProjection.eventWatermark,
+      },
+      succeeded: {
+        status: succeededProjection.status,
+        revision: succeededProjection.revision,
+        currentLap: succeededProjection.currentLap,
+        projectionDigest:
+          succeededProjection.projectionDigest,
+        eventWatermark:
+          succeededProjection.eventWatermark,
+      },
+      inline: {
+        outputName: inline.outputName,
+        bytes: inline.bytes,
+        projectionDigest: inline.projectionDigest,
+        rereads: inline.rereads,
+        drifted: inline.drifted,
+      },
+      ...(threadInline
+        ? {
+            threadInline: {
+              outputName: threadInline.outputName,
+              bytes: threadInline.bytes,
+              projectionDigest:
+                threadInline.projectionDigest,
+              exactArtifactBytes:
+                threadInlineExactArtifactBytes,
+            },
+          }
+        : {}),
+      stableNodeIds: succeededProjection.nodes.map(
+        (node) => node.id,
+      ),
+      edgeCount: succeededProjection.edges.length,
+      timelineBounded:
+        succeededProjection.timeline.length <= 32,
+      plaintextCapabilityPersisted,
+      canonicalIssuesProjectionBytes: Buffer.byteLength(
+        canonicalJson(issuesProjection),
+        "utf8",
+      ),
+    };
+    await atomicReplaceJson(
+      path.join(canonicalOutput, "headless-summary.json"),
+      summary,
+      { root: canonicalOutput },
+    );
+    return summary;
+  } finally {
+    await rm(temporary, {
+      recursive: true,
+      force: true,
+    });
+  }
+}
+
+async function main() {
+  const output = argument("output");
+  if (!output) {
+    throw new Error(
+      "Usage: run-p1d-headless.mjs --output <absolute-directory> [--visualization-root <absolute-existing-task-directory>]",
+    );
+  }
+  process.stdout.write(
+    `${JSON.stringify(
+      await runP1dHeadless(output, {
+        visualizationRoot: argument(
+          "visualization-root",
+        ),
+      }),
+    )}\n`,
+  );
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1] ?? "").href) {
+  main().catch((error) => {
+    process.stderr.write(
+      `${String(error?.code ?? "P1D_HEADLESS_FAILED")}: ${error?.message ?? error}\n`,
+    );
+    process.exitCode = 1;
+  });
+}
diff --git a/plugins/looperators-agent-loop/scripts/sanitize-identity-artifacts.mjs b/plugins/looperators-agent-loop/scripts/sanitize-identity-artifacts.mjs
new file mode 100644
index 0000000..6c0d4a3
--- /dev/null
+++ b/plugins/looperators-agent-loop/scripts/sanitize-identity-artifacts.mjs
@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+
+import { readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { digestJson } from "../lib/canonical-json.mjs";
+import { atomicReplaceJson } from "../lib/fs-utils.mjs";
+
+function argument(name) {
+  const index = process.argv.indexOf(`--${name}`);
+  return index >= 0 ? process.argv[index + 1] : undefined;
+}
+
+function digestValue(name, value) {
+  return digestJson({ [name]: value });
+}
+
+function sanitizeItem(item) {
+  const sanitized = { ...item };
+  if (typeof sanitized.text === "string") {
+    sanitized.textBytes = Buffer.byteLength(sanitized.text, "utf8");
+    sanitized.textDigest = digestValue("text", sanitized.text);
+    delete sanitized.text;
+  }
+  if (typeof sanitized.message === "string") {
+    sanitized.messageDigest = digestValue(
+      "message",
+      sanitized.message,
+    );
+    delete sanitized.message;
+  }
+  if (Object.hasOwn(sanitized, "error")) {
+    sanitized.errorPresent =
+      sanitized.error !== undefined && sanitized.error !== null;
+    delete sanitized.error;
+  }
+  return sanitized;
+}
+
+function sanitizeArtifact(value) {
+  const sanitized = structuredClone(value);
+  for (const key of ["threadId", "dataRoot", "probeCwd"]) {
+    if (typeof sanitized[key] === "string") {
+      sanitized[`${key}Digest`] = digestValue(key, sanitized[key]);
+      delete sanitized[key];
+    }
+  }
+  for (const key of ["stderr", "stderrHead", "stderrTail"]) {
+    if (typeof sanitized[key] === "string") {
+      sanitized[`${key}Bytes`] = Buffer.byteLength(
+        sanitized[key],
+        "utf8",
+      );
+      sanitized[`${key}Digest`] = digestValue(key, sanitized[key]);
+      delete sanitized[key];
+    }
+  }
+  if (Array.isArray(sanitized.stderrSummary?.noteworthy)) {
+    sanitized.stderrSummary.noteworthyDigests =
+      sanitized.stderrSummary.noteworthy.map((line) =>
+        digestValue("stderrLine", line),
+      );
+    delete sanitized.stderrSummary.noteworthy;
+  }
+  if (Array.isArray(sanitized.completedItems)) {
+    sanitized.completedItems =
+      sanitized.completedItems.map(sanitizeItem);
+  }
+  if (
+    sanitized.toolCall &&
+    typeof sanitized.toolCall === "object" &&
+    Object.hasOwn(sanitized.toolCall, "error")
+  ) {
+    sanitized.toolCall.errorPresent =
+      sanitized.toolCall.error !== undefined &&
+      sanitized.toolCall.error !== null;
+    delete sanitized.toolCall.error;
+  }
+  return sanitized;
+}
+
+async function filesBelow(directory) {
+  const files = [];
+  for (const entry of await readdir(directory, { withFileTypes: true })) {
+    const target = path.join(directory, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...(await filesBelow(target)));
+    } else if (
+      entry.isFile() &&
+      entry.name.startsWith("mcp-identity-") &&
+      entry.name.endsWith(".json")
+    ) {
+      files.push(target);
+    }
+  }
+  return files;
+}
+
+const artifactDirectory = argument("artifact-dir");
+if (!artifactDirectory || !path.isAbsolute(artifactDirectory)) {
+  throw new Error("--artifact-dir must be an absolute path");
+}
+const changed = [];
+for (const file of await filesBelow(artifactDirectory)) {
+  const before = JSON.parse(await readFile(file, "utf8"));
+  const after = sanitizeArtifact(before);
+  if (JSON.stringify(before) !== JSON.stringify(after)) {
+    await atomicReplaceJson(file, after);
+    changed.push(path.relative(artifactDirectory, file));
+  }
+}
+process.stdout.write(
+  `${JSON.stringify({ schemaVersion: 1, changed })}\n`,
+);
diff --git a/plugins/looperators-agent-loop/scripts/sanitize-p1b-headless.mjs b/plugins/looperators-agent-loop/scripts/sanitize-p1b-headless.mjs
new file mode 100644
index 0000000..85d6887
--- /dev/null
+++ b/plugins/looperators-agent-loop/scripts/sanitize-p1b-headless.mjs
@@ -0,0 +1,476 @@
+#!/usr/bin/env node
+
+import { readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { compareCodePoints, sha256 } from "../lib/canonical-json.mjs";
+import {
+  assertSafeFileId,
+  isNativeSpawnPreToolUse,
+} from "../lib/contracts.mjs";
+import { resolveDataRoot } from "../lib/data-root.mjs";
+import { atomicReplaceJson } from "../lib/fs-utils.mjs";
+import { LoopStore } from "../lib/store.mjs";
+
+function argument(name) {
+  const index = process.argv.indexOf(`--${name}`);
+  return index >= 0 ? process.argv[index + 1] : undefined;
+}
+
+function requiredAbsoluteArgument(name) {
+  const value = argument(name);
+  if (!value || !path.isAbsolute(value)) {
+    throw new TypeError(`--${name} must be an absolute path`);
+  }
+  return path.normalize(value);
+}
+
+function addError(errors, condition, code) {
+  if (!condition && !errors.includes(code)) {
+    errors.push(code);
+  }
+}
+
+function countsBy(values, key) {
+  const result = {};
+  for (const value of values) {
+    const label = String(value[key] ?? "unknown");
+    result[label] = (result[label] ?? 0) + 1;
+  }
+  return Object.fromEntries(
+    Object.entries(result).sort(([left], [right]) =>
+      compareCodePoints(left, right),
+    ),
+  );
+}
+
+function sortedFacts(read, kind, errors) {
+  addError(errors, read.corrupt.length === 0, `CORRUPT_${kind}`);
+  return read.facts;
+}
+
+function scanJson(value, result) {
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      scanJson(item, result);
+    }
+    return;
+  }
+  if (value && typeof value === "object") {
+    for (const [key, item] of Object.entries(value)) {
+      if (["capabilityToken", "token"].includes(key)) {
+        result.plaintextCapabilityFields += 1;
+      }
+      scanJson(item, result);
+    }
+    return;
+  }
+  if (
+    typeof value === "string" &&
+    /^[A-Za-z0-9_-]{43}$/.test(value)
+  ) {
+    result.plaintextCapabilityCandidates += 1;
+  }
+}
+
+async function scanStoreJson(directory) {
+  const result = {
+    jsonFiles: 0,
+    plaintextCapabilityFields: 0,
+    plaintextCapabilityCandidates: 0,
+  };
+  async function walk(current) {
+    const entries = await readdir(current, {
+      withFileTypes: true,
+    });
+    for (const entry of entries) {
+      const target = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        await walk(target);
+      } else if (
+        entry.isFile() &&
+        entry.name.endsWith(".json")
+      ) {
+        result.jsonFiles += 1;
+        scanJson(
+          JSON.parse(await readFile(target, "utf8")),
+          result,
+        );
+      }
+    }
+  }
+  await walk(directory);
+  return result;
+}
+
+const dataRoot = requiredAbsoluteArgument("data-root");
+const output = requiredAbsoluteArgument("output");
+const rootInfo = await resolveDataRoot({
+  env: { LOOPERATORS_DATA_DIR: dataRoot },
+});
+const store = new LoopStore(rootInfo);
+const runEntries = (
+  await readdir(path.join(rootInfo.path, "runs"), {
+    withFileTypes: true,
+  })
+)
+  .filter((entry) => entry.isDirectory())
+  .map((entry) => assertSafeFileId(entry.name, "runId"));
+
+const errors = [];
+const inspected = [];
+for (const runId of runEntries) {
+  const state = await store.readState(runId);
+  const definition = await store.readDefinition(runId);
+  const events = sortedFacts(
+    await store.listEvents(runId),
+    "EVENTS",
+    errors,
+  );
+  const operations = sortedFacts(
+    await store.listOperations(runId),
+    "OPERATIONS",
+    errors,
+  ).sort((left, right) => left.fromRevision - right.fromRevision);
+  const reports = sortedFacts(
+    await store.listReports(runId),
+    "REPORTS",
+    errors,
+  );
+  const transitions = sortedFacts(
+    await store.listTransitions(runId),
+    "TRANSITIONS",
+    errors,
+  );
+  const bindings = sortedFacts(
+    await store.listIdentityBindings(runId),
+    "IDENTITY",
+    errors,
+  );
+  const observations = sortedFacts(
+    await store.listWorkerObservations(runId),
+    "WORKER_OBSERVATIONS",
+    errors,
+  ).sort((left, right) =>
+    compareCodePoints(left.createdAt, right.createdAt),
+  );
+  const pending = sortedFacts(
+    await store.readPendingWorkerObservations(runId),
+    "PENDING_WORKER_OBSERVATIONS",
+    errors,
+  );
+  const observed = sortedFacts(
+    await store.listObservedSubagentStarts(
+      runId,
+      state.rootSessionId,
+    ),
+    "OBSERVED_WORKERS",
+    errors,
+  );
+  const reportById = new Map(
+    reports.map((report) => [report.reportId, report]),
+  );
+  const transitionById = new Map(
+    transitions.map((transition) => [
+      transition.transitionId,
+      transition,
+    ]),
+  );
+  const bindingByAgent = new Map(
+    bindings.map((binding) => [binding.agentId, binding]),
+  );
+  const observedByAgent = new Map(
+    observed.map((event) => [event.agentId, event]),
+  );
+  const observationById = new Map(
+    observations.map((observation) => [
+      observation.observationId,
+      observation,
+    ]),
+  );
+  const observedByEvent = new Map(
+    observed.map((event) => [event.eventId, event]),
+  );
+  const spawnToolUseIds = [
+    ...new Set(
+      events
+        .filter(isNativeSpawnPreToolUse)
+        .map((event) => event.toolUseId),
+    ),
+  ].sort(compareCodePoints);
+
+  const steps = operations.map((operation) => {
+    const transition = transitionById.get(
+      operation.transitionId,
+    );
+    const report = operation.reportId
+      ? reportById.get(operation.reportId)
+      : null;
+    addError(
+      errors,
+      Boolean(transition),
+      "OPERATION_TRANSITION_MISSING",
+    );
+    addError(
+      errors,
+      !operation.reportId || Boolean(report),
+      "OPERATION_REPORT_MISSING",
+    );
+    addError(
+      errors,
+      transition?.fromRevision === operation.fromRevision &&
+        transition?.toRevision === operation.toRevision,
+      "TRANSITION_REVISION_MISMATCH",
+    );
+    addError(
+      errors,
+      !report ||
+        (report.fromRevision === operation.fromRevision &&
+          report.toRevision === operation.toRevision),
+      "REPORT_REVISION_MISMATCH",
+    );
+    return {
+      kind: operation.kind,
+      actorKind: operation.actorKind,
+      fromRevision: operation.fromRevision,
+      toRevision: operation.toRevision,
+      transitionKind: transition?.kind ?? "missing",
+      ...(report
+        ? {
+            report: {
+              type: report.type,
+              ...(report.status
+                ? { status: report.status }
+                : {}),
+              ...(report.verdict
+                ? { verdict: report.verdict }
+                : {}),
+              actorMatchesBinding:
+                bindingByAgent.has(report.fromNode),
+            },
+          }
+        : {}),
+    };
+  });
+
+  const sessionIds = new Set(
+    events
+      .map((event) => event.sessionId)
+      .filter((value) => typeof value === "string"),
+  );
+  addError(
+    errors,
+    [...sessionIds].every(
+      (sessionId) => sessionId === state.rootSessionId,
+    ),
+    "HOOK_MCP_SESSION_MISMATCH",
+  );
+  addError(
+    errors,
+    bindings.every((binding) =>
+      observedByAgent.has(binding.agentId),
+    ),
+    "BOUND_AGENT_NOT_OBSERVED",
+  );
+  addError(
+    errors,
+    pending.length === 0,
+    "PENDING_WORKER_OBSERVATION_REMAINS",
+  );
+  addError(
+    errors,
+    bindings.every((binding) => {
+      const baseline = observationById.get(
+        binding.observationId,
+      );
+      const origin = observedByEvent.get(
+        binding.originEventId,
+      );
+      return (
+        baseline?.role === binding.role &&
+        origin?.agentId === binding.agentId &&
+        !baseline.subagentStartEventIds.includes(
+          binding.originEventId,
+        )
+      );
+    }),
+    "BINDING_OBSERVATION_PROVENANCE_MISMATCH",
+  );
+  addError(
+    errors,
+    new Set(
+      bindings.map((binding) => binding.observationId),
+    ).size === bindings.length,
+    "OBSERVATION_REUSED_BY_BINDINGS",
+  );
+  addError(
+    errors,
+    new Set(bindings.map((binding) => binding.role)).size ===
+      bindings.length,
+    "DUPLICATE_BOUND_ROLE",
+  );
+  addError(
+    errors,
+    new Set(operations.map((operation) => operation.requestId))
+      .size === operations.length,
+    "DUPLICATE_OPERATION_REQUEST",
+  );
+  const start = operations.find(
+    (operation) => operation.kind === "start",
+  );
+  const firstObserved = observed[0];
+  addError(
+    errors,
+    !firstObserved ||
+      (start &&
+        Date.parse(firstObserved.observedAt) >
+          Date.parse(start.createdAt)),
+    "WORKER_OBSERVED_BEFORE_START",
+  );
+
+  inspected.push({
+    createdAt: definition.createdAt,
+    runDigest: sha256(runId),
+    rootSessionDigest: sha256(state.rootSessionId),
+    status: state.status,
+    revision: state.revision,
+    currentLap: state.currentLap,
+    lapCap: definition.lapCap,
+    continuationLease: state.continuationLease,
+    cancelRequested: state.cancelRequested,
+    needsHuman: state.needsHuman ?? false,
+    counts: {
+      events: events.length,
+      operations: operations.length,
+      reports: reports.length,
+      transitions: transitions.length,
+      bindings: bindings.length,
+      observations: observations.length,
+      pendingWorkerObservations: pending.length,
+      observedWorkers: observed.length,
+      nativeSpawnAttempts: spawnToolUseIds.length,
+    },
+    eventCounts: countsBy(events, "event"),
+    observedWorkers: observed.map((event) => ({
+      agentDigest: sha256(event.agentId),
+      eventDigest: sha256(event.eventId),
+      boundRole:
+        bindingByAgent.get(event.agentId)?.role ?? null,
+    })),
+    workerObservations: observations.map(
+      (observation) => ({
+        observationDigest: sha256(
+          observation.observationId,
+        ),
+        role: observation.role,
+        baselineSpawnCount:
+          observation.spawnToolUseIds.length,
+        baselineWorkerCount:
+          observation.subagentStartEventIds.length,
+        baselineBindingCount:
+          observation.bindingIds.length,
+        consumed: bindings.some(
+          (binding) =>
+            binding.observationId ===
+            observation.observationId,
+        ),
+      }),
+    ),
+    hookSessionMatchesMcpRoot: [...sessionIds].every(
+      (sessionId) => sessionId === state.rootSessionId,
+    ),
+    workerObservedAfterStart:
+      !firstObserved ||
+      (start &&
+        Date.parse(firstObserved.observedAt) >
+          Date.parse(start.createdAt)),
+    steps,
+  });
+}
+
+inspected.sort((left, right) =>
+  compareCodePoints(left.createdAt, right.createdAt),
+);
+for (const run of inspected) {
+  delete run.createdAt;
+}
+
+addError(errors, inspected.length === 2, "EXPECTED_TWO_RUNS");
+const reviewRun = inspected[0];
+const controlRun = inspected[1];
+addError(
+  errors,
+  reviewRun?.status === "succeeded" &&
+    reviewRun.revision === 3 &&
+    reviewRun.counts.observedWorkers === 2 &&
+    reviewRun.counts.bindings === 2 &&
+    reviewRun.counts.observations === 2 &&
+    reviewRun.counts.pendingWorkerObservations === 0 &&
+    reviewRun.counts.nativeSpawnAttempts === 2 &&
+    reviewRun.workerObservations
+      .map(
+        (observation) =>
+          `${observation.role}:${observation.baselineSpawnCount}:${observation.baselineWorkerCount}:${observation.baselineBindingCount}:${observation.consumed}`,
+      )
+      .join(",") ===
+      "implementer:0:0:0:true,reviewer:1:1:1:true" &&
+    reviewRun.steps.map((step) => step.kind).join(",") ===
+      "start,report,report" &&
+    reviewRun.steps[1]?.report?.status === "done" &&
+    reviewRun.steps[2]?.report?.verdict === "clean",
+  "REVIEW_LOOP_SEQUENCE_MISMATCH",
+);
+addError(
+  errors,
+  controlRun?.status === "cancelled" &&
+    controlRun.revision === 4 &&
+    controlRun.steps.map((step) => step.kind).join(",") ===
+      "start,pause,resume,cancel",
+  "CONTROL_LOOP_SEQUENCE_MISMATCH",
+);
+addError(
+  errors,
+  new Set(
+    inspected.map((run) => run.rootSessionDigest),
+  ).size === 1,
+  "RUN_ROOT_SESSION_MISMATCH",
+);
+
+const storeScan = await scanStoreJson(rootInfo.path);
+addError(
+  errors,
+  storeScan.plaintextCapabilityFields === 0,
+  "PLAINTEXT_CAPABILITY_FIELD_FOUND",
+);
+addError(
+  errors,
+  storeScan.plaintextCapabilityCandidates === 0,
+  "PLAINTEXT_CAPABILITY_CANDIDATE_FOUND",
+);
+
+const evidence = {
+  schemaVersion: 1,
+  probe: "p1b-real-headless",
+  passed: errors.length === 0,
+  errors,
+  storeInstanceDigest: rootInfo.instanceIdDigest,
+  runCount: inspected.length,
+  runs: inspected,
+  storeScan,
+  privacy: {
+    rawHostIdsIncluded: false,
+    rawPromptIncluded: false,
+    capabilityPlaintextIncluded: false,
+  },
+};
+await atomicReplaceJson(output, evidence);
+process.stdout.write(
+  `${JSON.stringify({
+    passed: evidence.passed,
+    errors: evidence.errors,
+    output,
+  })}\n`,
+);
+if (!evidence.passed) {
+  process.exitCode = 1;
+}
diff --git a/plugins/looperators-agent-loop/scripts/sanitize-p1c-headless.mjs b/plugins/looperators-agent-loop/scripts/sanitize-p1c-headless.mjs
new file mode 100644
index 0000000..a360ce9
--- /dev/null
+++ b/plugins/looperators-agent-loop/scripts/sanitize-p1c-headless.mjs
@@ -0,0 +1,414 @@
+#!/usr/bin/env node
+
+import { readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import {
+  compareCodePoints,
+  sha256,
+} from "../lib/canonical-json.mjs";
+import {
+  assertSafeFileId,
+  isNativeSpawnPreToolUse,
+} from "../lib/contracts.mjs";
+import { resolveDataRoot } from "../lib/data-root.mjs";
+import { atomicReplaceJson } from "../lib/fs-utils.mjs";
+import { LoopStore } from "../lib/store.mjs";
+
+function argument(name) {
+  const index = process.argv.indexOf(`--${name}`);
+  return index >= 0 ? process.argv[index + 1] : undefined;
+}
+
+function requiredAbsoluteArgument(name) {
+  const value = argument(name);
+  if (!value || !path.isAbsolute(value)) {
+    throw new TypeError(`--${name} must be an absolute path`);
+  }
+  return path.normalize(value);
+}
+
+function addError(errors, condition, code) {
+  if (!condition && !errors.includes(code)) {
+    errors.push(code);
+  }
+}
+
+function countsBy(values, key) {
+  const result = {};
+  for (const value of values) {
+    const label = String(value[key] ?? "unknown");
+    result[label] = (result[label] ?? 0) + 1;
+  }
+  return Object.fromEntries(
+    Object.entries(result).sort(([left], [right]) =>
+      compareCodePoints(left, right),
+    ),
+  );
+}
+
+function facts(read, kind, errors) {
+  addError(errors, read.corrupt.length === 0, `CORRUPT_${kind}`);
+  return read.facts;
+}
+
+function scanJson(value, result) {
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      scanJson(item, result);
+    }
+    return;
+  }
+  if (value && typeof value === "object") {
+    for (const [key, item] of Object.entries(value)) {
+      if (["capabilityToken", "token"].includes(key)) {
+        result.plaintextCapabilityFields += 1;
+      }
+      scanJson(item, result);
+    }
+    return;
+  }
+  if (typeof value !== "string") {
+    return;
+  }
+  if (/^[A-Za-z0-9_-]{43}$/.test(value)) {
+    result.plaintextCapabilityCandidates += 1;
+  }
+  if (
+    value.includes(
+      "Run a disposable looperators P1-C native headless acceptance",
+    ) ||
+    value.includes("P1C_ROOT_STOP_PROBE")
+  ) {
+    result.rawAcceptancePromptFragments += 1;
+  }
+}
+
+async function scanStoreJson(directory) {
+  const result = {
+    jsonFiles: 0,
+    plaintextCapabilityFields: 0,
+    plaintextCapabilityCandidates: 0,
+    rawAcceptancePromptFragments: 0,
+  };
+  async function walk(current) {
+    for (const entry of await readdir(current, {
+      withFileTypes: true,
+    })) {
+      const target = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        await walk(target);
+      } else if (
+        entry.isFile() &&
+        entry.name.endsWith(".json")
+      ) {
+        result.jsonFiles += 1;
+        scanJson(
+          JSON.parse(await readFile(target, "utf8")),
+          result,
+        );
+      }
+    }
+  }
+  await walk(directory);
+  return result;
+}
+
+const dataRoot = requiredAbsoluteArgument("data-root");
+const output = requiredAbsoluteArgument("output");
+const rootInfo = await resolveDataRoot({
+  env: { LOOPERATORS_DATA_DIR: dataRoot },
+});
+const store = new LoopStore(rootInfo);
+const runIds = (
+  await readdir(path.join(rootInfo.path, "runs"), {
+    withFileTypes: true,
+  })
+)
+  .filter((entry) => entry.isDirectory())
+  .map((entry) => assertSafeFileId(entry.name, "runId"));
+const errors = [];
+addError(errors, runIds.length === 1, "EXPECTED_ONE_RUN");
+
+const runId = runIds[0];
+const state = await store.readState(runId);
+const definition = await store.readDefinition(runId);
+const events = facts(
+  await store.listEvents(runId),
+  "EVENTS",
+  errors,
+);
+const operations = facts(
+  await store.listOperations(runId),
+  "OPERATIONS",
+  errors,
+).sort((left, right) => left.fromRevision - right.fromRevision);
+const decisions = facts(
+  await store.listGovernorDecisions(runId),
+  "GOVERNOR_DECISIONS",
+  errors,
+).sort((left, right) => left.fromRevision - right.fromRevision);
+const reports = facts(
+  await store.listReports(runId),
+  "REPORTS",
+  errors,
+);
+const transitions = facts(
+  await store.listTransitions(runId),
+  "TRANSITIONS",
+  errors,
+);
+const bindings = facts(
+  await store.listIdentityBindings(runId),
+  "IDENTITY",
+  errors,
+);
+const observations = facts(
+  await store.listWorkerObservations(runId),
+  "WORKER_OBSERVATIONS",
+  errors,
+);
+const pendingObservations = facts(
+  await store.readPendingWorkerObservations(runId),
+  "PENDING_WORKER_OBSERVATIONS",
+  errors,
+);
+const observedWorkers = facts(
+  await store.listObservedSubagentStarts(
+    runId,
+    state.rootSessionId,
+  ),
+  "OBSERVED_WORKERS",
+  errors,
+);
+const eventById = new Map(
+  events.map((event) => [event.eventId, event]),
+);
+const transitionById = new Map(
+  transitions.map((transition) => [
+    transition.transitionId,
+    transition,
+  ]),
+);
+const reportById = new Map(
+  reports.map((report) => [report.reportId, report]),
+);
+const bindingByAgent = new Map(
+  bindings.map((binding) => [binding.agentId, binding]),
+);
+const nativeSpawnAttempts = new Set(
+  events
+    .filter(isNativeSpawnPreToolUse)
+    .map((event) => event.toolUseId),
+);
+
+const operationSteps = operations.map((operation) => {
+  const transition = transitionById.get(operation.transitionId);
+  const report = operation.reportId
+    ? reportById.get(operation.reportId)
+    : null;
+  addError(
+    errors,
+    Boolean(transition),
+    "OPERATION_TRANSITION_MISSING",
+  );
+  addError(
+    errors,
+    !operation.reportId || Boolean(report),
+    "OPERATION_REPORT_MISSING",
+  );
+  return {
+    kind: operation.kind,
+    actorKind: operation.actorKind,
+    fromRevision: operation.fromRevision,
+    toRevision: operation.toRevision,
+    transitionKind: transition?.kind ?? "missing",
+    ...(report
+      ? {
+          report: {
+            type: report.type,
+            ...(report.status ? { status: report.status } : {}),
+            ...(report.verdict
+              ? { verdict: report.verdict }
+              : {}),
+            actorMatchesBinding:
+              bindingByAgent.has(report.fromNode),
+          },
+        }
+      : {}),
+  };
+});
+
+const continuationSteps = decisions.map((decision) => {
+  const origin = eventById.get(decision.originEventId);
+  addError(
+    errors,
+    origin?.event === decision.hookEvent,
+    "DECISION_ORIGIN_EVENT_MISMATCH",
+  );
+  addError(
+    errors,
+    decision.hookEvent !== "SubagentStop" ||
+      (origin?.agentId === decision.agentId &&
+        bindingByAgent.has(decision.agentId)),
+    "DECISION_WORKER_BINDING_MISMATCH",
+  );
+  return {
+    action: decision.action,
+    hookEvent: decision.hookEvent,
+    reasonCode: decision.reasonCode,
+    fromRevision: decision.fromRevision,
+    toRevision: decision.toRevision,
+    leaseEpoch: decision.leaseEpoch,
+    obligationDigest: sha256(decision.obligationId),
+    originEventMatches: origin?.event === decision.hookEvent,
+    ...(decision.agentId
+      ? {
+          boundRole:
+            bindingByAgent.get(decision.agentId)?.role ?? null,
+        }
+      : {}),
+  };
+});
+
+const combinedRevisions = [
+  ...operations.map((operation) => ({
+    fromRevision: operation.fromRevision,
+    toRevision: operation.toRevision,
+  })),
+  ...decisions.map((decision) => ({
+    fromRevision: decision.fromRevision,
+    toRevision: decision.toRevision,
+  })),
+].sort((left, right) => left.fromRevision - right.fromRevision);
+addError(
+  errors,
+  combinedRevisions
+    .map((step) => `${step.fromRevision}:${step.toRevision}`)
+    .join(",") === "0:1,1:2,2:3,3:4,4:5",
+  "REVISION_CHAIN_MISMATCH",
+);
+addError(
+  errors,
+  state.status === "succeeded" &&
+    state.revision === 5 &&
+    state.continuationLease.granted === 3 &&
+    state.continuationLease.consumed === 2 &&
+    state.pendingTransitionId === undefined &&
+    state.latestGovernorDecisionId ===
+      decisions.at(-1)?.decisionId,
+  "FINAL_STATE_MISMATCH",
+);
+addError(
+  errors,
+  operationSteps.map((step) => step.kind).join(",") ===
+    "start,report,report" &&
+    operationSteps[1]?.report?.status === "done" &&
+    operationSteps[2]?.report?.verdict === "clean",
+  "TYPED_REVIEW_SEQUENCE_MISMATCH",
+);
+addError(
+  errors,
+  continuationSteps
+    .map(
+      (step) =>
+        `${step.action}:${step.hookEvent}:${step.leaseEpoch}`,
+    )
+    .join(",") ===
+    "block:Stop:1,block:SubagentStop:2" &&
+    continuationSteps[1]?.boundRole === "reviewer",
+  "CONTINUATION_SEQUENCE_MISMATCH",
+);
+addError(
+  errors,
+  bindings.length === 2 &&
+    new Set(bindings.map((binding) => binding.role)).size === 2 &&
+    observedWorkers.length === 2 &&
+    observations.length === 2 &&
+    pendingObservations.length === 0 &&
+    nativeSpawnAttempts.size === 2,
+  "WORKER_PROVENANCE_MISMATCH",
+);
+addError(
+  errors,
+  events.every(
+    (event) => event.sessionId === state.rootSessionId,
+  ),
+  "HOOK_MCP_SESSION_MISMATCH",
+);
+
+const storeScan = await scanStoreJson(rootInfo.path);
+addError(
+  errors,
+  storeScan.plaintextCapabilityFields === 0,
+  "PLAINTEXT_CAPABILITY_FIELD_FOUND",
+);
+addError(
+  errors,
+  storeScan.plaintextCapabilityCandidates === 0,
+  "PLAINTEXT_CAPABILITY_CANDIDATE_FOUND",
+);
+addError(
+  errors,
+  storeScan.rawAcceptancePromptFragments === 0,
+  "RAW_ACCEPTANCE_PROMPT_FOUND",
+);
+
+const evidence = {
+  schemaVersion: 1,
+  probe: "p1c-real-headless",
+  passed: errors.length === 0,
+  errors,
+  storeInstanceDigest: rootInfo.instanceIdDigest,
+  runCount: runIds.length,
+  run: {
+    runDigest: sha256(runId),
+    rootSessionDigest: sha256(state.rootSessionId),
+    status: state.status,
+    revision: state.revision,
+    currentLap: state.currentLap,
+    lapCap: definition.lapCap,
+    continuationLease: state.continuationLease,
+    cancelRequested: state.cancelRequested,
+    needsHuman: state.needsHuman ?? false,
+    counts: {
+      events: events.length,
+      operations: operations.length,
+      reports: reports.length,
+      transitions: transitions.length,
+      governorDecisions: decisions.length,
+      bindings: bindings.length,
+      observations: observations.length,
+      pendingWorkerObservations: pendingObservations.length,
+      observedWorkers: observedWorkers.length,
+      nativeSpawnAttempts: nativeSpawnAttempts.size,
+    },
+    eventCounts: countsBy(events, "event"),
+    operationSteps,
+    continuationSteps,
+    observedWorkers: observedWorkers.map((event) => ({
+      agentDigest: sha256(event.agentId),
+      eventDigest: sha256(event.eventId),
+      boundRole:
+        bindingByAgent.get(event.agentId)?.role ?? null,
+    })),
+  },
+  storeScan,
+  finalMarker: "P1C_HEADLESS_OK",
+  privacy: {
+    rawHostIdsIncluded: false,
+    rawPromptIncluded: false,
+    capabilityPlaintextIncluded: false,
+  },
+};
+await atomicReplaceJson(output, evidence);
+process.stdout.write(
+  `${JSON.stringify({
+    passed: evidence.passed,
+    errors: evidence.errors,
+    output,
+  })}\n`,
+);
+if (!evidence.passed) {
+  process.exitCode = 1;
+}
diff --git a/plugins/looperators-agent-loop/scripts/sanitize-p1c-resume.mjs b/plugins/looperators-agent-loop/scripts/sanitize-p1c-resume.mjs
new file mode 100644
index 0000000..46339da
--- /dev/null
+++ b/plugins/looperators-agent-loop/scripts/sanitize-p1c-resume.mjs
@@ -0,0 +1,262 @@
+#!/usr/bin/env node
+
+import { readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { sha256 } from "../lib/canonical-json.mjs";
+import { assertSafeFileId } from "../lib/contracts.mjs";
+import { resolveDataRoot } from "../lib/data-root.mjs";
+import { atomicReplaceJson } from "../lib/fs-utils.mjs";
+import { LoopStore } from "../lib/store.mjs";
+
+function argument(name) {
+  const index = process.argv.indexOf(`--${name}`);
+  return index >= 0 ? process.argv[index + 1] : undefined;
+}
+
+function requiredAbsoluteArgument(name) {
+  const value = argument(name);
+  if (!value || !path.isAbsolute(value)) {
+    throw new TypeError(`--${name} must be an absolute path`);
+  }
+  return path.normalize(value);
+}
+
+function addError(errors, condition, code) {
+  if (!condition && !errors.includes(code)) {
+    errors.push(code);
+  }
+}
+
+function facts(read, kind, errors) {
+  addError(errors, read.corrupt.length === 0, `CORRUPT_${kind}`);
+  return read.facts;
+}
+
+function scanJson(value, result) {
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      scanJson(item, result);
+    }
+    return;
+  }
+  if (value && typeof value === "object") {
+    for (const [key, item] of Object.entries(value)) {
+      if (["capabilityToken", "token"].includes(key)) {
+        result.plaintextCapabilityFields += 1;
+      }
+      scanJson(item, result);
+    }
+    return;
+  }
+  if (
+    typeof value === "string" &&
+    /^[A-Za-z0-9_-]{43}$/.test(value)
+  ) {
+    result.plaintextCapabilityCandidates += 1;
+  }
+}
+
+async function scanStoreJson(directory) {
+  const result = {
+    jsonFiles: 0,
+    plaintextCapabilityFields: 0,
+    plaintextCapabilityCandidates: 0,
+  };
+  async function walk(current) {
+    for (const entry of await readdir(current, {
+      withFileTypes: true,
+    })) {
+      const target = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        await walk(target);
+      } else if (
+        entry.isFile() &&
+        entry.name.endsWith(".json")
+      ) {
+        result.jsonFiles += 1;
+        scanJson(
+          JSON.parse(await readFile(target, "utf8")),
+          result,
+        );
+      }
+    }
+  }
+  await walk(directory);
+  return result;
+}
+
+const dataRoot = requiredAbsoluteArgument("data-root");
+const output = requiredAbsoluteArgument("output");
+const rootInfo = await resolveDataRoot({
+  env: { LOOPERATORS_DATA_DIR: dataRoot },
+});
+const store = new LoopStore(rootInfo);
+const runIds = (
+  await readdir(path.join(rootInfo.path, "runs"), {
+    withFileTypes: true,
+  })
+)
+  .filter((entry) => entry.isDirectory())
+  .map((entry) => assertSafeFileId(entry.name, "runId"));
+const errors = [];
+addError(errors, runIds.length === 1, "EXPECTED_ONE_RUN");
+
+const runId = runIds[0];
+const state = await store.readState(runId);
+const events = facts(
+  await store.listEvents(runId),
+  "EVENTS",
+  errors,
+);
+const operations = facts(
+  await store.listOperations(runId),
+  "OPERATIONS",
+  errors,
+).sort((left, right) => left.fromRevision - right.fromRevision);
+const decisions = facts(
+  await store.listGovernorDecisions(runId),
+  "GOVERNOR_DECISIONS",
+  errors,
+).sort((left, right) => left.fromRevision - right.fromRevision);
+const transitions = facts(
+  await store.listTransitions(runId),
+  "TRANSITIONS",
+  errors,
+);
+const resumeEvents = events.filter(
+  (event) =>
+    event.event === "SessionStart" &&
+    event.payloadSummary?.source === "resume",
+);
+const interrupt = decisions[0];
+const origin = events.find(
+  (event) => event.eventId === interrupt?.originEventId,
+);
+
+addError(
+  errors,
+  state.status === "cancelled" &&
+    state.revision === 3 &&
+    state.cancelRequested === true &&
+    state.continuationLease.granted === 2 &&
+    state.continuationLease.consumed === 0 &&
+    state.pendingTransitionId === undefined,
+  "FINAL_STATE_MISMATCH",
+);
+addError(
+  errors,
+  operations.map((operation) => operation.kind).join(",") ===
+    "start,cancel" &&
+    operations[0]?.fromRevision === 0 &&
+    operations[0]?.toRevision === 1 &&
+    operations[1]?.fromRevision === 2 &&
+    operations[1]?.toRevision === 3,
+  "OPERATION_SEQUENCE_MISMATCH",
+);
+addError(
+  errors,
+  decisions.length === 1 &&
+    interrupt?.action === "interrupt" &&
+    interrupt?.hookEvent === "SessionStart" &&
+    interrupt?.reasonCode === "resume-in-flight" &&
+    interrupt?.fromRevision === 1 &&
+    interrupt?.toRevision === 2 &&
+    interrupt?.leaseEpoch === undefined &&
+    origin?.event === "SessionStart" &&
+    origin?.payloadSummary?.source === "resume",
+  "INTERRUPT_DECISION_MISMATCH",
+);
+addError(
+  errors,
+  resumeEvents.length === 1 &&
+    events.every(
+      (event) => event.sessionId === state.rootSessionId,
+    ) &&
+    interrupt?.rootSessionId === state.rootSessionId,
+  "RESUME_SESSION_CONTINUITY_MISMATCH",
+);
+addError(
+  errors,
+  transitions.length === 2 &&
+    transitions.some(
+      (transition) => transition.kind === "activate-implementer",
+    ) &&
+    transitions.some(
+      (transition) => transition.kind === "cancel",
+    ),
+  "TRANSITION_SEQUENCE_MISMATCH",
+);
+
+const storeScan = await scanStoreJson(rootInfo.path);
+addError(
+  errors,
+  storeScan.plaintextCapabilityFields === 0,
+  "PLAINTEXT_CAPABILITY_FIELD_FOUND",
+);
+addError(
+  errors,
+  storeScan.plaintextCapabilityCandidates === 0,
+  "PLAINTEXT_CAPABILITY_CANDIDATE_FOUND",
+);
+
+const evidence = {
+  schemaVersion: 1,
+  probe: "p1c-real-resume",
+  passed: errors.length === 0,
+  errors,
+  storeInstanceDigest: rootInfo.instanceIdDigest,
+  runDigest: sha256(runId),
+  rootSessionDigest: sha256(state.rootSessionId),
+  status: state.status,
+  revision: state.revision,
+  cancelRequested: state.cancelRequested,
+  continuationLease: state.continuationLease,
+  counts: {
+    events: events.length,
+    operations: operations.length,
+    transitions: transitions.length,
+    governorDecisions: decisions.length,
+    resumeEvents: resumeEvents.length,
+  },
+  sequence: [
+    {
+      kind: operations[0]?.kind,
+      fromRevision: operations[0]?.fromRevision,
+      toRevision: operations[0]?.toRevision,
+    },
+    {
+      kind: interrupt?.action,
+      hookEvent: interrupt?.hookEvent,
+      reasonCode: interrupt?.reasonCode,
+      fromRevision: interrupt?.fromRevision,
+      toRevision: interrupt?.toRevision,
+    },
+    {
+      kind: operations[1]?.kind,
+      fromRevision: operations[1]?.fromRevision,
+      toRevision: operations[1]?.toRevision,
+    },
+  ],
+  sameSessionRootAcrossEvents: events.every(
+    (event) => event.sessionId === state.rootSessionId,
+  ),
+  storeScan,
+  finalMarker: "P1C_RESUME_OK",
+  privacy: {
+    rawHostIdsIncluded: false,
+    rawPromptIncluded: false,
+    capabilityPlaintextIncluded: false,
+  },
+};
+await atomicReplaceJson(output, evidence);
+process.stdout.write(
+  `${JSON.stringify({
+    passed: evidence.passed,
+    errors: evidence.errors,
+    output,
+  })}\n`,
+);
+if (!evidence.passed) {
+  process.exitCode = 1;
+}
diff --git a/plugins/looperators-agent-loop/scripts/sanitize-p1e-headless.mjs b/plugins/looperators-agent-loop/scripts/sanitize-p1e-headless.mjs
new file mode 100644
index 0000000..6410b7e
--- /dev/null
+++ b/plugins/looperators-agent-loop/scripts/sanitize-p1e-headless.mjs
@@ -0,0 +1,450 @@
+#!/usr/bin/env node
+
+import {
+  readFile,
+  readdir,
+} from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import {
+  compareCodePoints,
+  sha256,
+} from "../lib/canonical-json.mjs";
+import {
+  assertSafeFileId,
+  isNativeSpawnPreToolUse,
+} from "../lib/contracts.mjs";
+import { LoopController } from "../lib/control.mjs";
+import { resolveDataRoot } from "../lib/data-root.mjs";
+import { atomicReplaceJson } from "../lib/fs-utils.mjs";
+import {
+  createPrivacyScanResult,
+  scanPrivacyValue,
+} from "../lib/privacy-scan.mjs";
+import { LoopStore } from "../lib/store.mjs";
+
+function argument(name) {
+  const index = process.argv.indexOf(`--${name}`);
+  return index >= 0 ? process.argv[index + 1] : undefined;
+}
+
+function absoluteArgument(name) {
+  const value = argument(name);
+  if (!value || !path.isAbsolute(value)) {
+    throw new TypeError(`--${name} must be absolute`);
+  }
+  return path.normalize(value);
+}
+
+function addError(errors, condition, code) {
+  if (!condition && !errors.includes(code)) {
+    errors.push(code);
+  }
+}
+
+function facts(read, kind, errors) {
+  addError(
+    errors,
+    read.corrupt.length === 0,
+    `CORRUPT_${kind}`,
+  );
+  return read.facts;
+}
+
+function countsBy(values, field) {
+  const counts = new Map();
+  for (const value of values) {
+    const key = String(value[field] ?? "unknown");
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  return Object.fromEntries(
+    [...counts.entries()].sort(([left], [right]) =>
+      compareCodePoints(left, right),
+    ),
+  );
+}
+
+async function scanStore(directory) {
+  const result = createPrivacyScanResult();
+  async function walk(current) {
+    for (const entry of await readdir(current, {
+      withFileTypes: true,
+    })) {
+      const target = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        await walk(target);
+      } else if (
+        entry.isFile() &&
+        entry.name.endsWith(".json")
+      ) {
+        result.jsonFiles += 1;
+        scanPrivacyValue(
+          JSON.parse(await readFile(target, "utf8")),
+          result,
+        );
+      }
+    }
+  }
+  await walk(directory);
+  return result;
+}
+
+const dataRoot = absoluteArgument("data-root");
+const output = absoluteArgument("output");
+const lastMessageFile = absoluteArgument("last-message");
+const rootInfo = await resolveDataRoot({
+  env: { LOOPERATORS_DATA_DIR: dataRoot },
+});
+const store = new LoopStore(rootInfo);
+const runIds = (
+  await readdir(path.join(rootInfo.path, "runs"), {
+    withFileTypes: true,
+  })
+)
+  .filter((entry) => entry.isDirectory())
+  .map((entry) => assertSafeFileId(entry.name, "runId"))
+  .sort(compareCodePoints);
+const errors = [];
+addError(errors, runIds.length === 1, "EXPECTED_ONE_RUN");
+const runId = runIds[0];
+if (!runId) {
+  throw new Error("P1-E headless data root contains no run");
+}
+
+const state = await store.readState(runId);
+const definition = await store.readDefinition(runId);
+const events = facts(
+  await store.listEvents(runId),
+  "EVENTS",
+  errors,
+);
+const operations = facts(
+  await store.listOperations(runId),
+  "OPERATIONS",
+  errors,
+).sort(
+  (left, right) =>
+    left.fromRevision - right.fromRevision,
+);
+const decisions = facts(
+  await store.listGovernorDecisions(runId),
+  "GOVERNOR_DECISIONS",
+  errors,
+).sort(
+  (left, right) =>
+    left.fromRevision - right.fromRevision,
+);
+const reports = facts(
+  await store.listReports(runId),
+  "REPORTS",
+  errors,
+);
+const transitions = facts(
+  await store.listTransitions(runId),
+  "TRANSITIONS",
+  errors,
+);
+const bindings = facts(
+  await store.listIdentityBindings(runId),
+  "IDENTITY",
+  errors,
+);
+const observations = facts(
+  await store.listWorkerObservations(runId),
+  "OBSERVATIONS",
+  errors,
+);
+const pendingObservations = facts(
+  await store.readPendingWorkerObservations(runId),
+  "PENDING_OBSERVATIONS",
+  errors,
+);
+const recoveries = facts(
+  await store.listRecoveries(runId),
+  "RECOVERIES",
+  errors,
+);
+const observedWorkers = facts(
+  await store.listObservedSubagentStarts(
+    runId,
+    state.rootSessionId,
+  ),
+  "OBSERVED_WORKERS",
+  errors,
+);
+const transitionById = new Map(
+  transitions.map((transition) => [
+    transition.transitionId,
+    transition,
+  ]),
+);
+const reportById = new Map(
+  reports.map((report) => [
+    report.reportId,
+    report,
+  ]),
+);
+const bindingByAgent = new Map(
+  bindings.map((binding) => [
+    binding.agentId,
+    binding,
+  ]),
+);
+
+const operationSteps = operations.map((operation) => {
+  const transition = transitionById.get(
+    operation.transitionId,
+  );
+  const report = operation.reportId
+    ? reportById.get(operation.reportId)
+    : null;
+  addError(
+    errors,
+    Boolean(transition),
+    "OPERATION_TRANSITION_MISSING",
+  );
+  addError(
+    errors,
+    !operation.reportId || Boolean(report),
+    "OPERATION_REPORT_MISSING",
+  );
+  return {
+    kind: operation.kind,
+    actorKind: operation.actorKind,
+    actorRole:
+      operation.actorKind === "worker"
+        ? bindingByAgent.get(operation.actorId)?.role ??
+          "unbound"
+        : "root",
+    actorDigest: sha256(operation.actorId),
+    fromRevision: operation.fromRevision,
+    toRevision: operation.toRevision,
+    transitionKind: transition?.kind ?? "missing",
+    ...(report
+      ? {
+          report: {
+            type: report.type,
+            ...(report.status
+              ? { status: report.status }
+              : {}),
+            ...(report.verdict
+              ? { verdict: report.verdict }
+              : {}),
+            issueCount: report.issues?.length ?? 0,
+          },
+        }
+      : {}),
+  };
+});
+
+const decisionSteps = decisions.map((decision) => ({
+  action: decision.action,
+  hookEvent: decision.hookEvent,
+  reasonCode: decision.reasonCode,
+  leaseEpoch: decision.leaseEpoch,
+  fromRevision: decision.fromRevision,
+  toRevision: decision.toRevision,
+  ...(decision.agentId
+    ? {
+        actorRole:
+          bindingByAgent.get(decision.agentId)?.role ??
+          "unbound",
+      }
+    : {}),
+}));
+const combinedRevisions = [
+  ...operations,
+  ...decisions,
+].sort(
+  (left, right) =>
+    left.fromRevision - right.fromRevision,
+);
+const revisionShape = combinedRevisions
+  .map(
+    (item) =>
+      `${item.fromRevision}:${item.toRevision}`,
+  )
+  .join(",");
+addError(
+  errors,
+  revisionShape ===
+    "0:1,1:2,2:3,3:4,4:5,5:6,6:7",
+  "REVISION_CHAIN_MISMATCH",
+);
+addError(
+  errors,
+  state.status === "succeeded" &&
+    state.revision === 7 &&
+    state.currentLap === 1 &&
+    state.continuationLease.granted === 3 &&
+    state.continuationLease.consumed === 2 &&
+    state.pendingTransitionId === undefined &&
+    state.cancelRequested === false &&
+    state.needsHuman !== true &&
+    state.latestRecoveryId === undefined,
+  "FINAL_STATE_MISMATCH",
+);
+addError(
+  errors,
+  operationSteps
+    .map(
+      (step) =>
+        `${step.actorRole}:${step.transitionKind}:${
+          step.report?.status ??
+          step.report?.verdict ??
+          "none"
+        }`,
+    )
+    .join(",") ===
+    [
+      "root:activate-implementer:none",
+      "implementer:activate-reviewer:done",
+      "reviewer:activate-implementer:issues",
+      "implementer:activate-reviewer:done",
+      "reviewer:succeed:clean",
+    ].join(","),
+  "TYPED_REVIEW_SEQUENCE_MISMATCH",
+);
+addError(
+  errors,
+  operationSteps[1]?.actorDigest ===
+    operationSteps[3]?.actorDigest &&
+    operationSteps[2]?.actorDigest ===
+      operationSteps[4]?.actorDigest,
+  "WORKER_FOLLOWUP_IDENTITY_MISMATCH",
+);
+addError(
+  errors,
+  decisionSteps
+    .map(
+      (step) =>
+        `${step.action}:${step.hookEvent}:${step.leaseEpoch}`,
+    )
+    .join(",") ===
+    "block:Stop:1,block:SubagentStop:2" &&
+    decisionSteps[1]?.actorRole === "reviewer",
+  "CONTINUATION_SEQUENCE_MISMATCH",
+);
+addError(
+  errors,
+  bindings.length === 2 &&
+    new Set(
+      bindings.map((binding) => binding.role),
+    ).size === 2 &&
+    observations.length === 2 &&
+    pendingObservations.length === 0 &&
+    observedWorkers.length === 2 &&
+    new Set(
+      events
+        .filter(isNativeSpawnPreToolUse)
+        .map((event) => event.toolUseId),
+    ).size === 2,
+  "WORKER_PROVENANCE_MISMATCH",
+);
+addError(
+  errors,
+  recoveries.length === 0,
+  "FRESH_RUN_UNEXPECTED_RECOVERY",
+);
+
+const projection =
+  await new LoopController(store).snapshotForRun(runId);
+addError(
+  errors,
+  projection.projectionVersion === 3 &&
+    projection.status === "succeeded" &&
+    projection.recovery === undefined &&
+    projection.counts.recoveries === 0 &&
+    projection.integrity.status === "verified" &&
+    projection.nodes
+      .map((node) => node.id)
+      .join(",") ===
+      "root,role:implementer,role:reviewer",
+  "PROJECTION_MISMATCH",
+);
+
+const lastMessage = (
+  await readFile(lastMessageFile, "utf8")
+).trim();
+addError(
+  errors,
+  lastMessage === "P1E_HEADLESS_OK",
+  "FINAL_MARKER_MISMATCH",
+);
+const storeScan = await scanStore(rootInfo.path);
+addError(
+  errors,
+  storeScan.plaintextCapabilityFields === 0 &&
+    storeScan.plaintextCapabilityCandidates === 0,
+  "PLAINTEXT_CAPABILITY_FOUND",
+);
+addError(
+  errors,
+  storeScan.rawAcceptancePromptFragments === 0,
+  "RAW_ACCEPTANCE_PROMPT_FOUND",
+);
+
+const evidence = {
+  schemaVersion: 1,
+  probe: "p1e-real-headless",
+  passed: errors.length === 0,
+  errors,
+  codexLane: "desktop-bundled",
+  storeInstanceDigest: rootInfo.instanceIdDigest,
+  runCount: runIds.length,
+  run: {
+    runDigest: sha256(runId),
+    rootSessionDigest: sha256(state.rootSessionId),
+    status: state.status,
+    revision: state.revision,
+    currentLap: state.currentLap,
+    lapCap: definition.lapCap,
+    continuationLease: state.continuationLease,
+    counts: {
+      events: events.length,
+      operations: operations.length,
+      reports: reports.length,
+      transitions: transitions.length,
+      governorDecisions: decisions.length,
+      recoveries: recoveries.length,
+      bindings: bindings.length,
+      observations: observations.length,
+      pendingObservations:
+        pendingObservations.length,
+      observedWorkers: observedWorkers.length,
+    },
+    eventCounts: countsBy(events, "event"),
+    operationSteps,
+    decisionSteps,
+    revisionShape,
+  },
+  projection: {
+    projectionVersion: projection.projectionVersion,
+    status: projection.status,
+    revision: projection.revision,
+    digest: projection.projectionDigest,
+    stableNodeIds: projection.nodes.map(
+      (node) => node.id,
+    ),
+    timelineCount: projection.timeline.length,
+    recoveryCount: projection.counts.recoveries,
+  },
+  storeScan,
+  finalMarkerMatched: lastMessage === "P1E_HEADLESS_OK",
+  privacy: {
+    rawHostIdsIncluded: false,
+    rawPromptIncluded: false,
+    capabilityPlaintextIncluded: false,
+  },
+};
+await atomicReplaceJson(output, evidence);
+process.stdout.write(
+  `${JSON.stringify({
+    passed: evidence.passed,
+    errors: evidence.errors,
+    output,
+  })}\n`,
+);
+if (!evidence.passed) {
+  process.exitCode = 1;
+}
diff --git a/plugins/looperators-agent-loop/scripts/serve-graph-ui-browser-acceptance.mjs b/plugins/looperators-agent-loop/scripts/serve-graph-ui-browser-acceptance.mjs
new file mode 100644
index 0000000..5e47bc5
--- /dev/null
+++ b/plugins/looperators-agent-loop/scripts/serve-graph-ui-browser-acceptance.mjs
@@ -0,0 +1,317 @@
+#!/usr/bin/env node
+
+import { randomBytes } from "node:crypto";
+import {
+  mkdir,
+  mkdtemp,
+  readFile,
+  realpath,
+  rm,
+  writeFile,
+} from "node:fs/promises";
+import http from "node:http";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { pathToFileURL } from "node:url";
+import { renderGraphFragment } from "../lib/graph-view.mjs";
+import { startSidecar } from "./sidecar-server.mjs";
+import { runP1dHeadless } from "./run-p1d-headless.mjs";
+
+const HOST = "127.0.0.1";
+const UPDATE_TIMEOUT_MS = 3_000;
+
+function documentFor(projection) {
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  <meta name="color-scheme" content="light dark">
+  <title>looperators inline graph acceptance</title>
+  <link rel="icon" href="data:,">
+  <style>
+    body {
+      margin: 0;
+      padding: 16px;
+      background: var(--background, Canvas);
+      color: var(--foreground, CanvasText);
+    }
+  </style>
+</head>
+<body>
+${renderGraphFragment(projection)}
+</body>
+</html>`;
+}
+
+function delay(milliseconds) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, milliseconds);
+  });
+}
+
+async function listen(server) {
+  await new Promise((resolve, reject) => {
+    const onError = (error) => {
+      server.off("listening", onListening);
+      reject(error);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      resolve();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(0, HOST);
+  });
+  const address = server.address();
+  if (!address || typeof address === "string") {
+    throw new Error("inline acceptance server did not bind a TCP address");
+  }
+  return address.port;
+}
+
+async function closeServer(server) {
+  await new Promise((resolve, reject) => {
+    server.close((error) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve();
+      }
+    });
+  });
+}
+
+export async function startGraphUiBrowserAcceptance() {
+  const temporary = await realpath(
+    await mkdtemp(
+      path.join(os.tmpdir(), "looperators-graph-ui-browser-"),
+    ),
+  );
+  const fixtureDirectory = path.join(temporary, "fixture");
+  const watchDirectory = path.join(temporary, "watch");
+  await mkdir(watchDirectory, {
+    recursive: true,
+    mode: 0o700,
+  });
+  await runP1dHeadless(fixtureDirectory);
+  const [issuesProjection, succeededProjection] =
+    await Promise.all(
+      ["issues", "succeeded"].map(async (name) =>
+        JSON.parse(
+          await readFile(
+            path.join(
+              fixtureDirectory,
+              `${name}-projection.json`,
+            ),
+            "utf8",
+          ),
+        ),
+      ),
+    );
+  if (issuesProjection.runId !== succeededProjection.runId) {
+    throw new Error("browser acceptance projections belong to different runs");
+  }
+
+  let currentProjection = issuesProjection;
+  const store = {
+    runDirectory(runId) {
+      if (runId !== currentProjection.runId) {
+        throw new Error("browser acceptance run identity mismatch");
+      }
+      return watchDirectory;
+    },
+  };
+  const controller = {
+    async snapshotForRun(runId) {
+      if (runId !== currentProjection.runId) {
+        throw new Error("browser acceptance run identity mismatch");
+      }
+      return currentProjection;
+    },
+  };
+  const sidecar = await startSidecar({
+    runId: currentProjection.runId,
+    host: HOST,
+    port: 0,
+    store,
+    controller,
+    heartbeatMs: 2_000,
+  });
+
+  const inlineToken = randomBytes(24).toString("base64url");
+  const inlinePath = `/inline/${inlineToken}`;
+  let inlinePort = null;
+  const inlineServer = http.createServer((request, response) => {
+    const expectedHost = `${HOST}:${inlinePort}`;
+    if (
+      request.method !== "GET" ||
+      request.headers.host !== expectedHost ||
+      request.url !== inlinePath
+    ) {
+      response.writeHead(404, {
+        "Content-Type": "text/plain; charset=utf-8",
+        "Cache-Control": "no-store",
+        "X-Content-Type-Options": "nosniff",
+      });
+      response.end("Not found\n");
+      return;
+    }
+    response.writeHead(200, {
+      "Content-Type": "text/html; charset=utf-8",
+      "Cache-Control": "no-store",
+      "X-Content-Type-Options": "nosniff",
+      "Referrer-Policy": "no-referrer",
+      "Content-Security-Policy":
+        "default-src 'none'; script-src 'unsafe-inline'; " +
+        "style-src 'unsafe-inline'; img-src data:; " +
+        "frame-ancestors 'none'; base-uri 'none'; form-action 'none'",
+    });
+    response.end(documentFor(issuesProjection));
+  });
+  inlineServer.maxHeadersCount = 32;
+  inlineServer.requestTimeout = 10_000;
+  inlineServer.headersTimeout = 10_000;
+  inlinePort = await listen(inlineServer);
+
+  let closed = false;
+  async function advance() {
+    currentProjection = succeededProjection;
+    await writeFile(
+      path.join(watchDirectory, "acceptance-update.json"),
+      `${JSON.stringify({
+        projectionDigest: succeededProjection.projectionDigest,
+      })}\n`,
+      {
+        encoding: "utf8",
+        mode: 0o600,
+      },
+    );
+    const deadline = Date.now() + UPDATE_TIMEOUT_MS;
+    while (
+      sidecar.projection().projectionDigest !==
+        succeededProjection.projectionDigest &&
+      Date.now() < deadline
+    ) {
+      await delay(25);
+    }
+    if (
+      sidecar.projection().projectionDigest !==
+      succeededProjection.projectionDigest
+    ) {
+      throw Object.assign(
+        new Error("sidecar did not observe the browser acceptance update"),
+        { code: "SIDECAR_WATCH_TIMEOUT" },
+      );
+    }
+    return {
+      status: "advanced",
+      projectionDigest: succeededProjection.projectionDigest,
+      sidecarStats: sidecar.stats(),
+    };
+  }
+
+  async function close() {
+    if (closed) {
+      return;
+    }
+    closed = true;
+    await Promise.all([
+      sidecar.close(),
+      closeServer(inlineServer),
+    ]);
+    await rm(temporary, {
+      recursive: true,
+      force: true,
+    });
+  }
+
+  return {
+    ready: {
+      status: "ready",
+      runId: issuesProjection.runId,
+      inlineUrl: `http://${HOST}:${inlinePort}${inlinePath}`,
+      sidecarLoginUrl: sidecar.loginUrl,
+      issuesProjectionDigest: issuesProjection.projectionDigest,
+      succeededProjectionDigest: succeededProjection.projectionDigest,
+      tokenPolicy:
+        "random inline path; one-time sidecar query token to independent session cookie",
+    },
+    advance,
+    close,
+  };
+}
+
+async function main() {
+  const acceptance = await startGraphUiBrowserAcceptance();
+  process.stdout.write(`${JSON.stringify(acceptance.ready)}\n`);
+  process.stdin.setEncoding("utf8");
+  process.stdin.resume();
+  let buffer = "";
+  let stopping = false;
+
+  const stop = async () => {
+    if (stopping) {
+      return;
+    }
+    stopping = true;
+    await acceptance.close();
+    process.stdin.pause();
+  };
+
+  process.stdin.on("data", (chunk) => {
+    buffer += chunk;
+    const lines = buffer.split(/\r?\n/u);
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const command = line.trim();
+      if (!command) {
+        continue;
+      }
+      if (command === "advance") {
+        acceptance
+          .advance()
+          .then((result) => {
+            process.stdout.write(`${JSON.stringify(result)}\n`);
+          })
+          .catch((error) => {
+            process.stderr.write(
+              `${String(error?.code ?? "ADVANCE_FAILED")}: ${error?.message ?? error}\n`,
+            );
+            process.exitCode = 1;
+          });
+      } else if (command === "close") {
+        stop().catch((error) => {
+          process.stderr.write(
+            `${String(error?.code ?? "CLOSE_FAILED")}: ${error?.message ?? error}\n`,
+          );
+          process.exitCode = 1;
+        });
+      } else {
+        process.stderr.write(`UNKNOWN_COMMAND: ${command}\n`);
+        process.exitCode = 1;
+      }
+    }
+  });
+  process.once("SIGINT", () => {
+    stop().catch(() => {
+      process.exitCode = 1;
+    });
+  });
+  process.once("SIGTERM", () => {
+    stop().catch(() => {
+      process.exitCode = 1;
+    });
+  });
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1] ?? "").href) {
+  main().catch((error) => {
+    process.stderr.write(
+      `${String(error?.code ?? "BROWSER_ACCEPTANCE_FAILED")}: ${error?.message ?? error}\n`,
+    );
+    process.exitCode = 1;
+  });
+}
diff --git a/plugins/looperators-agent-loop/scripts/sidecar-server.mjs b/plugins/looperators-agent-loop/scripts/sidecar-server.mjs
new file mode 100644
index 0000000..9d098c5
--- /dev/null
+++ b/plugins/looperators-agent-loop/scripts/sidecar-server.mjs
@@ -0,0 +1,657 @@
+#!/usr/bin/env node
+
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import { watch } from "node:fs";
+import http from "node:http";
+import process from "node:process";
+import { pathToFileURL } from "node:url";
+import {
+  canonicalJson,
+  digestEqual,
+  sha256,
+} from "../lib/canonical-json.mjs";
+import { LoopController } from "../lib/control.mjs";
+import { renderSidecarDocument } from "../lib/graph-view.mjs";
+import {
+  MAX_PROJECTION_BYTES,
+  assertGraphProjectionIntegrity,
+  canonicalProjectionBytes,
+} from "../lib/projection.mjs";
+import { LoopStore } from "../lib/store.mjs";
+
+const MAX_CLIENTS = 8;
+const MAX_CONTROL_BYTES = 4096;
+const HEARTBEAT_MS = 15_000;
+const DEBOUNCE_MS = 75;
+const SNAPSHOT_LOCK_TIMEOUT_MS = 100;
+const TICKET_TTL_MS = 120_000;
+const SAFE_INTEGRITY_CODES = new Set([
+  "HISTORY_CORRUPT",
+  "UNSUPPORTED_NATIVE_TARGET_HISTORY",
+  "PROJECTION_TOO_LARGE",
+]);
+const CONTROL_ACTIONS = new Set(["pause", "resume", "cancel"]);
+const REQUEST_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+
+function argument(name, fallback = undefined) {
+  const index = process.argv.indexOf(`--${name}`);
+  return index >= 0 ? process.argv[index + 1] : fallback;
+}
+
+function tokenEqual(left, right) {
+  const leftBytes = Buffer.from(String(left), "utf8");
+  const rightBytes = Buffer.from(String(right), "utf8");
+  return (
+    leftBytes.length === rightBytes.length &&
+    timingSafeEqual(leftBytes, rightBytes)
+  );
+}
+
+function parseCookies(header) {
+  const result = new Map();
+  for (const part of String(header ?? "").split(";")) {
+    const separator = part.indexOf("=");
+    if (separator <= 0) continue;
+    result.set(
+      part.slice(0, separator).trim(),
+      part.slice(separator + 1).trim(),
+    );
+  }
+  return result;
+}
+
+function securityHeaders(contentType) {
+  return {
+    "Content-Type": contentType,
+    "Cache-Control": "no-store",
+    "X-Content-Type-Options": "nosniff",
+    "Referrer-Policy": "no-referrer",
+    "Content-Security-Policy":
+      "default-src 'none'; script-src 'unsafe-inline'; " +
+      "style-src 'unsafe-inline'; connect-src 'self'; " +
+      "img-src 'self' data:; frame-ancestors 'none'; base-uri 'none'; " +
+      "form-action 'none'",
+  };
+}
+
+function boundedIntegrityCode(error) {
+  return SAFE_INTEGRITY_CODES.has(error?.code)
+    ? error.code
+    : "HISTORY_CORRUPT";
+}
+
+function ignoredWatchPath(fileName) {
+  if (!fileName) return false;
+  const normalized = String(fileName).replaceAll("\\", "/");
+  return (
+    normalized === "locks" ||
+    normalized.startsWith("locks/") ||
+    normalized.includes("/locks/") ||
+    normalized.endsWith(".lock") ||
+    normalized.endsWith(".reclaim") ||
+    normalized.includes(".lock.") ||
+    normalized.includes(".tmp-")
+  );
+}
+
+function safetyPage(title, message) {
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>${title}</title></head><body><main><h1>${title}</h1><p>${message}</p></main></body></html>`;
+}
+
+function publicControlResult(value) {
+  return {
+    schemaVersion: value.schemaVersion,
+    runId: value.runId,
+    status: value.status,
+    revision: value.revision,
+    currentLap: value.currentLap,
+    lapCap: value.lapCap,
+  };
+}
+
+export async function startSidecar(options) {
+  const host = options.host ?? "127.0.0.1";
+  const port = options.port ?? 0;
+  if (host !== "127.0.0.1") {
+    throw Object.assign(
+      new TypeError("sidecar host must be the literal 127.0.0.1"),
+      { code: "SIDECAR_HOST_REJECTED" },
+    );
+  }
+  if (!Number.isInteger(port) || port < 0 || port > 65_535) {
+    throw Object.assign(
+      new TypeError("sidecar port must be an integer from 0 to 65535"),
+      { code: "SIDECAR_PORT_REJECTED" },
+    );
+  }
+  const ticketTtlMs = options.ticketTtlMs ?? TICKET_TTL_MS;
+  if (
+    !Number.isInteger(ticketTtlMs) ||
+    ticketTtlMs < 1_000 ||
+    ticketTtlMs > 10 * 60_000
+  ) {
+    throw Object.assign(new TypeError("sidecar ticket TTL is invalid"), {
+      code: "SIDECAR_TICKET_TTL_REJECTED",
+    });
+  }
+  if (
+    options.token !== undefined &&
+    Buffer.byteLength(String(options.token), "utf8") < 32
+  ) {
+    throw Object.assign(
+      new TypeError("sidecar ticket must contain at least 32 UTF-8 bytes"),
+      { code: "SIDECAR_TOKEN_REJECTED" },
+    );
+  }
+  const store = options.store ?? (await LoopStore.open());
+  const controller = options.controller ?? new LoopController(store);
+  const runId = options.runId;
+  const basePath = `/runs/${encodeURIComponent(runId)}`;
+  const cookieName = `looperators_loop_${sha256(runId).slice(0, 12)}`;
+  const sessionSecret = randomBytes(32).toString("base64url");
+  const csrfToken = randomBytes(32).toString("base64url");
+  const tickets = new Map();
+  let latestProjection = assertGraphProjectionIntegrity(
+    await controller.snapshotForRun(runId, {
+      lockTimeoutMs:
+        options.snapshotLockTimeoutMs ?? SNAPSHOT_LOCK_TIMEOUT_MS,
+    }),
+  );
+  if (latestProjection.runId !== runId) {
+    throw Object.assign(
+      new Error("sidecar snapshot belongs to another run"),
+      { code: "SNAPSHOT_IDENTITY_MISMATCH" },
+    );
+  }
+  let latestCanonical = canonicalProjectionBytes(latestProjection);
+  let boundPort = null;
+  let closed = false;
+  let watcher = null;
+  let debounceTimer = null;
+  let retryTimer = null;
+  let heartbeatTimer = null;
+  let refreshPromise = null;
+  const clients = new Set();
+  const stats = {
+    broadcasts: 0,
+    unchanged: 0,
+    busySkips: 0,
+    integrityErrors: 0,
+    slowClientsClosed: 0,
+    controls: 0,
+  };
+
+  function exactOrigin() {
+    return `http://${host}:${boundPort}`;
+  }
+
+  function issueTicket(candidate = undefined) {
+    if (closed) {
+      throw Object.assign(new Error("sidecar is closed"), {
+        code: "SIDECAR_CLOSED",
+      });
+    }
+    const ticket = candidate ?? randomBytes(32).toString("base64url");
+    if (Buffer.byteLength(ticket, "utf8") < 32) {
+      throw Object.assign(
+        new TypeError("sidecar ticket must contain at least 32 UTF-8 bytes"),
+        { code: "SIDECAR_TOKEN_REJECTED" },
+      );
+    }
+    tickets.set(ticket, Date.now() + ticketTtlMs);
+    return {
+      ticket,
+      expiresAt: new Date(Date.now() + ticketTtlMs).toISOString(),
+      url: `${exactOrigin()}${basePath}?ticket=${encodeURIComponent(ticket)}`,
+    };
+  }
+
+  function closeClient(response, slow = false) {
+    clients.delete(response);
+    if (slow) stats.slowClientsClosed += 1;
+    response.end();
+  }
+
+  function writeSse(response, event, value, id = undefined) {
+    const data = canonicalJson(value);
+    if (Buffer.byteLength(data, "utf8") > MAX_PROJECTION_BYTES) {
+      closeClient(response, true);
+      return false;
+    }
+    const frame =
+      `${id ? `id: ${id}\n` : ""}` +
+      `event: ${event}\n` +
+      `data: ${data}\n\n`;
+    if (!response.write(frame)) {
+      closeClient(response, true);
+      return false;
+    }
+    return true;
+  }
+
+  function broadcastSnapshot(projection) {
+    for (const response of [...clients]) {
+      writeSse(
+        response,
+        "snapshot",
+        projection,
+        projection.projectionDigest,
+      );
+    }
+    stats.broadcasts += 1;
+  }
+
+  function broadcastIntegrityError(error) {
+    const payload = { code: boundedIntegrityCode(error) };
+    for (const response of [...clients]) {
+      writeSse(response, "integrity-error", payload);
+    }
+    stats.integrityErrors += 1;
+  }
+
+  async function refresh() {
+    if (closed) return;
+    refreshPromise ??= (async () => {
+      try {
+        const next = assertGraphProjectionIntegrity(
+          await controller.snapshotForRun(runId, {
+            lockTimeoutMs:
+              options.snapshotLockTimeoutMs ?? SNAPSHOT_LOCK_TIMEOUT_MS,
+          }),
+        );
+        if (next.runId !== runId) {
+          throw Object.assign(
+            new Error("sidecar snapshot belongs to another run"),
+            { code: "SNAPSHOT_IDENTITY_MISMATCH" },
+          );
+        }
+        const canonical = canonicalProjectionBytes(next);
+        if (
+          digestEqual(
+            next.projectionDigest,
+            latestProjection.projectionDigest,
+          )
+        ) {
+          stats.unchanged += 1;
+          return;
+        }
+        latestProjection = next;
+        latestCanonical = canonical;
+        broadcastSnapshot(latestProjection);
+      } catch (error) {
+        if (error?.code === "SNAPSHOT_BUSY") {
+          stats.busySkips += 1;
+          clearTimeout(retryTimer);
+          retryTimer = setTimeout(() => {
+            refresh().catch(() => {});
+          }, DEBOUNCE_MS * 2);
+          retryTimer.unref?.();
+          return;
+        }
+        broadcastIntegrityError(error);
+      } finally {
+        refreshPromise = null;
+      }
+    })();
+    return refreshPromise;
+  }
+
+  function scheduleRefresh(fileName) {
+    if (closed || ignoredWatchPath(fileName)) return;
+    clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(() => {
+      refresh().catch(() => {});
+    }, DEBOUNCE_MS);
+    debounceTimer.unref?.();
+  }
+
+  function authenticated(request) {
+    const cookie = parseCookies(request.headers.cookie).get(cookieName);
+    return Boolean(cookie && tokenEqual(cookie, sessionSecret));
+  }
+
+  async function readControlBody(request) {
+    const chunks = [];
+    let bytes = 0;
+    for await (const chunk of request) {
+      bytes += chunk.length;
+      if (bytes > MAX_CONTROL_BYTES) {
+        throw Object.assign(new Error("control body is too large"), {
+          code: "CONTROL_BODY_TOO_LARGE",
+          status: 413,
+        });
+      }
+      chunks.push(chunk);
+    }
+    let value;
+    try {
+      value = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    } catch {
+      throw Object.assign(new Error("control body is invalid"), {
+        code: "INVALID_CONTROL_REQUEST",
+        status: 400,
+      });
+    }
+    if (
+      !value ||
+      typeof value !== "object" ||
+      Array.isArray(value) ||
+      !CONTROL_ACTIONS.has(value.action) ||
+      typeof value.requestId !== "string" ||
+      !REQUEST_ID_PATTERN.test(value.requestId) ||
+      Object.keys(value).some(
+        (key) => !["action", "requestId"].includes(key),
+      )
+    ) {
+      throw Object.assign(new Error("control body is invalid"), {
+        code: "INVALID_CONTROL_REQUEST",
+        status: 400,
+      });
+    }
+    return value;
+  }
+
+  const server = http.createServer(async (request, response) => {
+    const expectedHost = `${host}:${boundPort}`;
+    if (request.headers.host !== expectedHost) {
+      response.writeHead(421, securityHeaders("text/plain; charset=utf-8"));
+      response.end("Misdirected request\n");
+      return;
+    }
+    let url;
+    try {
+      url = new URL(request.url ?? "/", exactOrigin());
+    } catch {
+      response.writeHead(400, securityHeaders("text/plain; charset=utf-8"));
+      response.end("Bad request\n");
+      return;
+    }
+    if (url.origin !== exactOrigin()) {
+      response.writeHead(400, securityHeaders("text/plain; charset=utf-8"));
+      response.end("Bad request\n");
+      return;
+    }
+
+    const ticket = url.searchParams.get("ticket");
+    if (ticket !== null) {
+      const expiresAt = tickets.get(ticket);
+      const exactTicketRoute =
+        request.method === "GET" &&
+        url.pathname === basePath &&
+        url.searchParams.getAll("ticket").length === 1 &&
+        [...url.searchParams.keys()].every((key) => key === "ticket");
+      if (!exactTicketRoute || !expiresAt) {
+        response.writeHead(401, securityHeaders("text/html; charset=utf-8"));
+        response.end(
+          safetyPage(
+            "Review link unavailable",
+            "Return to the looperators task and open the live review surface again.",
+          ),
+        );
+        return;
+      }
+      tickets.delete(ticket);
+      if (expiresAt < Date.now()) {
+        response.writeHead(410, securityHeaders("text/html; charset=utf-8"));
+        response.end(
+          safetyPage(
+            "Review link expired",
+            "Return to the looperators task and request a fresh review link.",
+          ),
+        );
+        return;
+      }
+      response.writeHead(303, {
+        ...securityHeaders("text/plain; charset=utf-8"),
+        Location: basePath,
+        "Set-Cookie":
+          `${cookieName}=${sessionSecret}; ` +
+          `HttpOnly; SameSite=Strict; Path=${basePath}`,
+      });
+      response.end("Authenticated\n");
+      return;
+    }
+
+    if (!authenticated(request)) {
+      response.writeHead(401, securityHeaders("text/html; charset=utf-8"));
+      response.end(
+        safetyPage(
+          "Review session unavailable",
+          "Return to the looperators task and reopen the live review surface.",
+        ),
+      );
+      return;
+    }
+
+    const eventsPath = `${basePath}/events`;
+    const snapshotPath = `${basePath}/snapshot`;
+    const controlPath = `${basePath}/control`;
+
+    if (request.method === "GET" && url.pathname === basePath) {
+      response.writeHead(200, securityHeaders("text/html; charset=utf-8"));
+      response.end(
+        renderSidecarDocument(latestProjection, {
+          eventsUrl: eventsPath,
+          ...(options.onControl
+            ? { controlUrl: controlPath, csrfToken }
+            : {}),
+        }),
+      );
+      return;
+    }
+    if (request.method === "GET" && url.pathname === snapshotPath) {
+      response.writeHead(
+        200,
+        securityHeaders("application/json; charset=utf-8"),
+      );
+      response.end(`${latestCanonical}\n`);
+      return;
+    }
+    if (request.method === "GET" && url.pathname === eventsPath) {
+      const origin = request.headers.origin;
+      if (origin !== undefined && origin !== exactOrigin()) {
+        response.writeHead(403, securityHeaders("text/plain; charset=utf-8"));
+        response.end("Origin rejected\n");
+        return;
+      }
+      if (clients.size >= MAX_CLIENTS) {
+        response.writeHead(503, securityHeaders("text/plain; charset=utf-8"));
+        response.end("Too many clients\n");
+        return;
+      }
+      response.writeHead(200, {
+        ...securityHeaders("text/event-stream; charset=utf-8"),
+        Connection: "keep-alive",
+      });
+      clients.add(response);
+      const lastEventId = request.headers["last-event-id"];
+      if (
+        !lastEventId ||
+        !digestEqual(
+          String(lastEventId),
+          latestProjection.projectionDigest,
+        )
+      ) {
+        writeSse(
+          response,
+          "snapshot",
+          latestProjection,
+          latestProjection.projectionDigest,
+        );
+      } else if (!response.write(": current\n\n")) {
+        closeClient(response, true);
+      }
+      request.on("close", () => clients.delete(response));
+      return;
+    }
+    if (request.method === "POST" && url.pathname === controlPath) {
+      if (!options.onControl) {
+        response.writeHead(503, securityHeaders("application/json; charset=utf-8"));
+        response.end(`${canonicalJson({ code: "CONTROL_UNAVAILABLE" })}\n`);
+        return;
+      }
+      if (
+        request.headers.origin !== exactOrigin() ||
+        !tokenEqual(request.headers["x-looperators-csrf"] ?? "", csrfToken) ||
+        !String(request.headers["content-type"] ?? "")
+          .toLowerCase()
+          .startsWith("application/json")
+      ) {
+        response.writeHead(403, securityHeaders("application/json; charset=utf-8"));
+        response.end(`${canonicalJson({ code: "CONTROL_FORBIDDEN" })}\n`);
+        return;
+      }
+      try {
+        const input = await readControlBody(request);
+        const result = await options.onControl(input);
+        stats.controls += 1;
+        await refresh();
+        response.writeHead(200, securityHeaders("application/json; charset=utf-8"));
+        response.end(`${canonicalJson(publicControlResult(result))}\n`);
+      } catch (error) {
+        const code =
+          typeof error?.code === "string" &&
+          /^[A-Z][A-Z0-9_]{0,63}$/u.test(error.code)
+            ? error.code
+            : "CONTROL_FAILED";
+        const status = Number.isInteger(error?.status) ? error.status : 409;
+        response.writeHead(status, securityHeaders("application/json; charset=utf-8"));
+        response.end(`${canonicalJson({ code })}\n`);
+      }
+      return;
+    }
+    if (!["GET", "POST"].includes(request.method ?? "")) {
+      response.writeHead(405, {
+        ...securityHeaders("text/plain; charset=utf-8"),
+        Allow: "GET, POST",
+      });
+      response.end("Method not allowed\n");
+      return;
+    }
+    response.writeHead(404, securityHeaders("text/plain; charset=utf-8"));
+    response.end("Not found\n");
+  });
+  server.maxHeadersCount = 64;
+  server.requestTimeout = 10_000;
+  server.headersTimeout = 10_000;
+
+  await new Promise((resolve, reject) => {
+    const onError = (error) => {
+      server.off("listening", onListening);
+      reject(error);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      resolve();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(port, host);
+  });
+  const address = server.address();
+  if (!address || typeof address === "string") {
+    throw new Error("sidecar did not bind a TCP address");
+  }
+  boundPort = address.port;
+
+  try {
+    watcher = watch(
+      store.runDirectory(runId),
+      { recursive: true },
+      (_eventType, fileName) => scheduleRefresh(fileName),
+    );
+  } catch (error) {
+    await new Promise((resolve) => server.close(() => resolve()));
+    throw error;
+  }
+  watcher.on("error", (error) => broadcastIntegrityError(error));
+  heartbeatTimer = setInterval(() => {
+    refresh().catch(() => {});
+    for (const response of [...clients]) {
+      if (!response.write(": heartbeat\n\n")) closeClient(response, true);
+    }
+  }, options.heartbeatMs ?? HEARTBEAT_MS);
+  heartbeatTimer.unref?.();
+
+  async function close() {
+    if (closed) return;
+    closed = true;
+    tickets.clear();
+    clearTimeout(debounceTimer);
+    clearTimeout(retryTimer);
+    clearInterval(heartbeatTimer);
+    watcher?.close();
+    for (const response of [...clients]) closeClient(response);
+    await new Promise((resolve, reject) => {
+      server.close((error) => (error ? reject(error) : resolve()));
+    });
+  }
+
+  const initialTicket = issueTicket(options.token);
+  return {
+    host,
+    port: boundPort,
+    origin: exactOrigin(),
+    runId,
+    basePath,
+    loginUrl: initialTicket.url,
+    loginToken: initialTicket.ticket,
+    issueTicket,
+    projection: () => latestProjection,
+    canonicalProjection: () => latestCanonical,
+    stats: () => ({ ...stats, clients: clients.size }),
+    refresh,
+    close,
+  };
+}
+
+async function main() {
+  const runId = argument("run-id");
+  const host = argument("host", "127.0.0.1");
+  const rawPort = argument("port", "0");
+  if (!runId || !/^\d{1,5}$/u.test(rawPort)) {
+    throw new Error(
+      "Usage: sidecar-server.mjs --run-id <id> --host 127.0.0.1 --port <0-65535> [--token <32-byte-minimum>]",
+    );
+  }
+  const sidecar = await startSidecar({
+    runId,
+    host,
+    port: Number(rawPort),
+    token: argument("token") ?? process.env.LOOPERATORS_SIDECAR_TOKEN,
+  });
+  process.stdout.write(
+    `${JSON.stringify({
+      status: "ready",
+      host: sidecar.host,
+      port: sidecar.port,
+      loginUrl: sidecar.loginUrl,
+      tokenPolicy: "one-time-ticket-to-run-scoped-session-cookie",
+    })}\n`,
+  );
+  let stopping = false;
+  const shutdown = async () => {
+    if (stopping) return;
+    stopping = true;
+    await sidecar.close();
+  };
+  process.once("SIGINT", () => {
+    shutdown().catch(() => {
+      process.exitCode = 1;
+    });
+  });
+  process.once("SIGTERM", () => {
+    shutdown().catch(() => {
+      process.exitCode = 1;
+    });
+  });
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1] ?? "").href) {
+  main().catch((error) => {
+    process.stderr.write(
+      `${String(error?.code ?? "SIDECAR_FAILED")}: ${error?.message ?? error}\n`,
+    );
+    process.exitCode = 1;
+  });
+}
diff --git a/plugins/looperators-agent-loop/scripts/validate-schema-fixtures.mjs b/plugins/looperators-agent-loop/scripts/validate-schema-fixtures.mjs
new file mode 100644
index 0000000..3bf148d
--- /dev/null
+++ b/plugins/looperators-agent-loop/scripts/validate-schema-fixtures.mjs
@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { validateLegacyQuarantineReceipt } from "../lib/contracts.mjs";
+import { atomicReplaceJson } from "../lib/fs-utils.mjs";
+
+function argument(name) {
+  const index = process.argv.indexOf(`--${name}`);
+  return index >= 0 ? process.argv[index + 1] : undefined;
+}
+
+async function json(file) {
+  return JSON.parse(await readFile(file, "utf8"));
+}
+
+async function moduleDefault(file) {
+  const loaded = await import(pathToFileURL(file));
+  return loaded.default?.default ?? loaded.default ?? loaded;
+}
+
+const moduleDirectory = argument("module-dir");
+if (!moduleDirectory || !path.isAbsolute(moduleDirectory)) {
+  throw new Error("--module-dir must be an absolute node_modules path");
+}
+
+const pluginRoot = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "..",
+);
+const Ajv2020 = await moduleDefault(
+  path.join(moduleDirectory, "ajv", "dist", "2020.js"),
+);
+const addFormats = await moduleDefault(
+  path.join(moduleDirectory, "ajv-formats", "dist", "index.js"),
+);
+const validator = new Ajv2020({
+  allErrors: true,
+  strict: true,
+});
+addFormats(validator);
+
+const cases = [
+  {
+    contract: "governor-decision",
+    schema: "governor-decision.schema.json",
+    valid: "governor-decision-valid.json",
+    invalid: "governor-decision-invalid-missing-lease.json",
+  },
+  {
+    contract: "worker-observation",
+    schema: "worker-observation.schema.json",
+    valid: "worker-observation-valid.json",
+    invalid: "worker-observation-invalid-duplicate.json",
+  },
+  {
+    contract: "definition",
+    schema: "definition.schema.json",
+    valid: "definition-valid.json",
+    invalid: "definition-invalid-lap-cap.json",
+  },
+  {
+    contract: "operation",
+    schema: "operation.schema.json",
+    valid: "operation-valid-report.json",
+    invalid: "operation-invalid-missing-report.json",
+  },
+  {
+    contract: "report",
+    schema: "report.schema.json",
+    valid: "report-valid.json",
+    invalid: "report-invalid-missing-verdict.json",
+  },
+  {
+    contract: "product-report-revisions",
+    schema: "report.schema.json",
+    valid: "report-valid-product.json",
+    invalid: "report-invalid-missing-revisions.json",
+  },
+  {
+    contract: "identity-binding",
+    schema: "identity-binding.schema.json",
+    valid: "identity-valid-capability.json",
+    invalid: "identity-invalid-missing-token.json",
+  },
+  {
+    contract: "run",
+    schema: "run.schema.json",
+    valid: "run-valid.json",
+    invalid: "run-invalid-consumed-over-granted.json",
+  },
+  {
+    contract: "graph-projection",
+    schema: "graph-projection.schema.json",
+    valid: "graph-projection-valid.json",
+    invalid: "graph-projection-invalid-corrupt.json",
+  },
+  {
+    contract: "legacy-native-target-evidence",
+    schema: "legacy-native-target-evidence.schema.json",
+    valid: "legacy-native-target-evidence-valid.json",
+    invalid: "legacy-native-target-evidence-invalid-field.json",
+  },
+  {
+    contract: "legacy-quarantine",
+    schema: "legacy-quarantine.schema.json",
+    valid: "legacy-quarantine-valid.json",
+    invalid: "legacy-quarantine-invalid-count.json",
+  },
+];
+
+const compiledSchemas = new Map();
+const results = [];
+for (const item of cases) {
+  let validate = compiledSchemas.get(item.schema);
+  if (!validate) {
+    validate = validator.compile(
+      await json(path.join(pluginRoot, "schemas", item.schema)),
+    );
+    compiledSchemas.set(item.schema, validate);
+  }
+  const validAccepted = validate(
+    await json(
+      path.join(
+        pluginRoot,
+        "tests",
+        "fixtures",
+        "schema",
+        item.valid,
+      ),
+    ),
+  );
+  const invalidAccepted = validate(
+    await json(
+      path.join(
+        pluginRoot,
+        "tests",
+        "fixtures",
+        "schema",
+        item.invalid,
+      ),
+    ),
+  );
+  results.push({
+    contract: item.contract,
+    validAccepted,
+    invalidRejected: !invalidAccepted,
+    invalidErrorKeywords: (validate.errors ?? [])
+      .map((error) => error.keyword)
+      .sort(),
+  });
+}
+
+const passed = results.every(
+  (result) => result.validAccepted && result.invalidRejected,
+);
+const runtimeSemantic = {
+  contract: "legacy-quarantine-revision-adjacency",
+  validator: "validateLegacyQuarantineReceipt",
+  validAccepted:
+    validateLegacyQuarantineReceipt(
+      await json(
+        path.join(
+          pluginRoot,
+          "tests",
+          "fixtures",
+          "schema",
+          "legacy-quarantine-valid.json",
+        ),
+      ),
+    ).length === 0,
+  invalidRejected:
+    validateLegacyQuarantineReceipt(
+      await json(
+        path.join(
+          pluginRoot,
+          "tests",
+          "fixtures",
+          "schema",
+          "legacy-quarantine-invalid-adjacency.json",
+        ),
+      ),
+    ).length > 0,
+};
+const semanticPassed =
+  runtimeSemantic.validAccepted &&
+  runtimeSemantic.invalidRejected;
+const evidence = {
+  schemaVersion: 1,
+  validator: "ajv-2020+runtime-semantic",
+  passed: passed && semanticPassed,
+  results,
+  runtimeSemantic: [runtimeSemantic],
+};
+const output = argument("output");
+if (output) {
+  if (!path.isAbsolute(output)) {
+    throw new Error("--output must be an absolute path");
+  }
+  await atomicReplaceJson(output, evidence);
+}
+process.stdout.write(
+  `${JSON.stringify({
+    ...evidence,
+    ...(output ? { output } : {}),
+  })}\n`,
+);
+if (!evidence.passed) {
+  process.exitCode = 1;
+}
diff --git a/plugins/looperators-agent-loop/skills/review-until-clean/SKILL.md b/plugins/looperators-agent-loop/skills/review-until-clean/SKILL.md
new file mode 100644
index 0000000..76ce060
--- /dev/null
+++ b/plugins/looperators-agent-loop/skills/review-until-clean/SKILL.md
@@ -0,0 +1,69 @@
+---
+name: review-until-clean
+description: Preview and run a bounded looperators implementer–reviewer loop inside one Codex task. Use when the user asks for review-until-clean, an implementer/reviewer loop, iterative code review with a lap cap, or governed pause/resume/cancel controls.
+---
+
+# Review Until Clean
+
+Use looperators typed MCP state as the only loop authority. The root task is
+Governor; native Codex subagents are cooperative workers.
+
+## Preview and confirmation
+
+1. Collect the goal, separate implementer/reviewer instructions, and a lap cap
+   from 1–6.
+2. Call `looperators_preview_loop` with a fresh stable request id.
+3. Show the topology and cap, then stop for explicit user confirmation.
+
+Do not start work or create a subagent during preview. After confirmation call
+`looperators_start_loop`. Default looperators has no Hooks and does not require
+Hook trust. Start returns the first `roleCapability`. Then call
+`looperators_open_review_surface` and give the returned localhost URL to Codex
+Desktop's built-in Browser. Do not open the URL in an external browser unless
+the user explicitly asks.
+
+## Cooperative worker sequence
+
+For each pending action:
+
+1. Read `looperators_get_loop` as Governor. Treat its `pendingTransition` and
+   `roleCapability` as authoritative. Do this before dispatching the worker;
+   do not poll or re-read the loop while that worker is in flight.
+2. Create or follow up exactly one native subagent for the returned role. Pass
+   that worker its role, exact scoped instructions, `runId`, and current
+   `capabilityToken`. Never save or show the token to the user.
+3. Instruct the worker to call `looperators_report` directly:
+   - implementer: `role=implementer`, `type=info`, `status=done`;
+   - reviewer: `role=reviewer`, `type=verdict`, then `verdict=issues` with at
+     least one structured issue or `verdict=clean` with no issues.
+4. After the worker returns, re-read `looperators_get_loop`. Do not infer state
+   from the worker's prose or transcript.
+
+The capability is scoped to `runId + role + pendingTransitionId + action
+revision`. Its plaintext never enters the shared store; independent MCP
+processes verify it against a durable digest. A stale, wrong-role or
+post-cancel token must fail. After a Governor MCP restart, a root-only
+`get_loop` rotates the current token and invalidates the previously issued
+one. Workers cannot use root-only read tools.
+
+Do not run Node scripts, shell helpers, hook probes, bind-worker tools, or inline
+renderers. The plugin MCP tools own the protocol.
+
+## Govern and stop
+
+- Success requires a typed reviewer `verdict=clean`.
+- Stop at clean, cancellation, failure, or lap cap.
+- Use `looperators_pause_loop`, `looperators_resume_loop`, and
+  `looperators_cancel_loop` for explicit user control.
+- Use a fresh request id for each distinct mutation; reuse it only to retry the
+  exact same call.
+- Give user steering or cancellation priority over the planned next action.
+- Default mode is cooperative: it cannot force a native worker to call the
+  report tool or prevent Codex from ending a turn. If a worker omits its typed
+  report, follow up once; otherwise pause and report the missing obligation.
+
+Keep the localhost review surface open as the primary live visualization. Its
+pause/resume/cancel controls mutate the same authoritative typed store. Call
+`looperators_close_review_surface` when the user asks to close it; otherwise
+the MCP process owns its lifetime. Inline visualization is not part of this
+workflow.
diff --git a/plugins/looperators-agent-loop/skills/review-until-clean/agents/openai.yaml b/plugins/looperators-agent-loop/skills/review-until-clean/agents/openai.yaml
new file mode 100644
index 0000000..8d5fc24
--- /dev/null
+++ b/plugins/looperators-agent-loop/skills/review-until-clean/agents/openai.yaml
@@ -0,0 +1,4 @@
+interface:
+  display_name: "Review Until Clean"
+  short_description: "Run a bounded implementer-reviewer loop"
+  default_prompt: "Use $review-until-clean to preview a bounded implementer-reviewer loop for this task."
diff --git a/plugins/looperators-agent-loop/tests/canonical-and-contracts.test.mjs b/plugins/looperators-agent-loop/tests/canonical-and-contracts.test.mjs
new file mode 100644
index 0000000..2d738be
--- /dev/null
+++ b/plugins/looperators-agent-loop/tests/canonical-and-contracts.test.mjs
@@ -0,0 +1,577 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import test from "node:test";
+import {
+  canonicalJson,
+  digestJson,
+} from "../lib/canonical-json.mjs";
+import {
+  normalizeHookEvent,
+  validateGraphProjection,
+  validateGovernorDecision,
+  validateIdentityBinding,
+  validateLegacyNativeTargetEvidence,
+  validateLegacyQuarantineReceipt,
+  validateLoopDefinition,
+  validateLoopOperation,
+  validateLoopReport,
+  validateLoopRun,
+  validateLoopTransition,
+  validateNormalizedHookEvent,
+  validateWorkerObservation,
+} from "../lib/contracts.mjs";
+import {
+  buildLegacyNativeTargetEvidence,
+  collectLegacyNativeTargetEntries,
+  terminalStateForRecovery,
+} from "../lib/recovery.mjs";
+import { PLUGIN_ROOT, loopState } from "./helpers.mjs";
+
+test("canonical JSON v1 is key-order independent and rejects unsafe values", () => {
+  const left = { z: [3, { b: true, a: -0 }], a: "ok" };
+  const right = { a: "ok", z: [3, { a: 0, b: true }] };
+  assert.equal(canonicalJson(left), canonicalJson(right));
+  assert.equal(digestJson(left), digestJson(right));
+  assert.throws(() => canonicalJson({ bad: Number.NaN }), /non-finite/);
+  assert.throws(() => canonicalJson({ bad: undefined }), /rejects undefined/);
+  const circular = {};
+  circular.self = circular;
+  assert.throws(() => canonicalJson(circular), /circular/);
+});
+
+test("legacy evidence is bounded and never serializes native worker ids", () => {
+  const state = {
+    ...loopState({
+      runId: "run-legacy-evidence",
+      rootSessionId: "session-legacy-evidence",
+    }),
+    revision: 1,
+  };
+  const definition = {
+    schemaVersion: 1,
+    definitionId: `definition_${"1".repeat(64)}`,
+    runId: state.runId,
+    requestId: "preview-legacy-evidence",
+    requestDigest: "2".repeat(64),
+    recipe: "review-until-clean",
+    goal: "Synthetic evidence fixture.",
+    implementerInstructions: "Implement.",
+    reviewerInstructions: "Review.",
+    lapCap: 3,
+    createdAt: state.createdAt,
+  };
+  const binding = {
+    schemaVersion: 1,
+    bindingId: `binding_${"3".repeat(64)}`,
+    runId: state.runId,
+    agentId: "native-agent-secret-shape",
+    rootSessionId: state.rootSessionId,
+    method: "capability-token-v1",
+    tokenDigest: "4".repeat(64),
+    role: "implementer",
+    requestId: "bind-legacy-evidence",
+    requestDigest: "5".repeat(64),
+    observationId: `observation_${"6".repeat(64)}`,
+    originEventId: `evt_${"7".repeat(64)}`,
+    createdAt: state.createdAt,
+  };
+  const operation = {
+    schemaVersion: 1,
+    operationId: `op_${"8".repeat(64)}`,
+    runId: state.runId,
+    requestId: "start-legacy-evidence",
+    requestDigest: "9".repeat(64),
+    kind: "start",
+    actorKind: "root",
+    actorId: state.rootSessionId,
+    fromRevision: 0,
+    toRevision: 1,
+    transitionId: `transition_${"a".repeat(64)}`,
+    createdAt: state.createdAt,
+  };
+  const transition = {
+    schemaVersion: 1,
+    transitionId: operation.transitionId,
+    runId: state.runId,
+    requestId: operation.requestId,
+    requestDigest: operation.requestDigest,
+    kind: "activate-implementer",
+    fromNode: state.masterNode,
+    toNode: binding.agentId,
+    lap: 0,
+    fromRevision: 0,
+    toRevision: 1,
+    createdAt: state.createdAt,
+  };
+  const evidence = buildLegacyNativeTargetEvidence({
+    state,
+    definition,
+    operations: [operation],
+    governorDecisions: [],
+    transitions: [transition],
+    reports: [],
+    bindings: [binding],
+  });
+  assert.deepEqual(
+    validateLegacyNativeTargetEvidence(evidence),
+    [],
+  );
+  assert.doesNotMatch(
+    JSON.stringify(evidence),
+    /native-agent-secret-shape/,
+  );
+
+  const operations = [];
+  const transitions = [];
+  for (let index = 0; index < 17; index += 1) {
+    const transitionId = `legacy-transition-${index}`;
+    operations.push({
+      ...operation,
+      operationId: `legacy-operation-${index}`,
+      requestId: `legacy-request-${index}`,
+      transitionId,
+      fromRevision: index,
+      toRevision: index + 1,
+    });
+    transitions.push({
+      ...transition,
+      transitionId,
+      requestId: `legacy-request-${index}`,
+      fromRevision: index,
+      toRevision: index + 1,
+    });
+  }
+  assert.throws(
+    () =>
+      collectLegacyNativeTargetEntries({
+        state: { ...state, revision: 17 },
+        operations,
+        transitions,
+        reports: [],
+        bindings: [binding],
+      }),
+    { code: "LEGACY_RECOVERY_LIMIT" },
+  );
+  const preserved = terminalStateForRecovery(
+    { ...state, cancelRequested: true },
+    {
+      recoveryId: `recovery_${"c".repeat(64)}`,
+      toRevision: state.revision + 1,
+      createdAt: "2026-07-26T00:00:02.000Z",
+    },
+  );
+  assert.equal(preserved.cancelRequested, true);
+  assert.equal(preserved.status, "failed");
+});
+
+test("hook normalization is deterministic and excludes prompt and tool payloads", () => {
+  const input = {
+    session_id: "session-1",
+    turn_id: "turn-1",
+    hook_event_name: "PreToolUse",
+    tool_use_id: "call-1",
+    tool_name: "Bash",
+    prompt: "private prompt must not persist",
+    last_assistant_message: "private transcript tail",
+    tool_input: {
+      command: "SECRET_VALUE=should-not-persist",
+      nested: { secret: "also-private" },
+    },
+  };
+  const first = normalizeHookEvent(input, {
+    observedAt: "2026-07-26T00:00:00.000Z",
+  });
+  const duplicate = normalizeHookEvent(input, {
+    observedAt: "2026-07-26T01:00:00.000Z",
+  });
+  assert.equal(first.eventId, duplicate.eventId);
+  assert.equal(first.semanticKey, duplicate.semanticKey);
+  assert.equal(first.payloadDigest, duplicate.payloadDigest);
+  const serialized = JSON.stringify(first);
+  assert.doesNotMatch(
+    serialized,
+    /private prompt|transcript tail|SECRET_VALUE|also-private/,
+  );
+  assert.deepEqual(first.payloadSummary.toolInputKeys, ["command", "nested"]);
+  assert.deepEqual(validateNormalizedHookEvent(first), []);
+
+  const conflicting = normalizeHookEvent(
+    { ...input, tool_name: "functions.exec" },
+    { observedAt: "2026-07-26T00:00:01.000Z" },
+  );
+  assert.equal(conflicting.semanticKey, first.semanticKey);
+  assert.notEqual(conflicting.payloadDigest, first.payloadDigest);
+  assert.notEqual(conflicting.eventId, first.eventId);
+});
+
+test("unknown deliveries are isolated and do not enter semantic conflicts", () => {
+  const first = normalizeHookEvent(
+    { hook_event_name: "FutureHook", session_id: "session-1" },
+    {
+      observedAt: "2026-07-26T00:00:00.000Z",
+      deliveryDigest: "delivery-one",
+    },
+  );
+  const second = normalizeHookEvent(
+    { hook_event_name: "FutureHook", session_id: "session-1" },
+    {
+      observedAt: "2026-07-26T00:00:00.000Z",
+      deliveryDigest: "delivery-two",
+    },
+  );
+  assert.equal(first.conflictEligible, false);
+  assert.equal(second.conflictEligible, false);
+  assert.notEqual(first.semanticKey, second.semanticKey);
+});
+
+test("known hook deliveries without required correlation ids are isolated", () => {
+  const first = normalizeHookEvent(
+    {
+      hook_event_name: "UserPromptSubmit",
+      session_id: "session-1",
+      prompt: "first",
+    },
+    {
+      observedAt: "2026-07-26T00:00:00.000Z",
+      deliveryDigest: "missing-turn-one",
+    },
+  );
+  const second = normalizeHookEvent(
+    {
+      hook_event_name: "UserPromptSubmit",
+      session_id: "session-1",
+      prompt: "second",
+    },
+    {
+      observedAt: "2026-07-26T00:00:01.000Z",
+      deliveryDigest: "missing-turn-two",
+    },
+  );
+  assert.equal(first.conflictEligible, false);
+  assert.equal(second.conflictEligible, false);
+  assert.notEqual(first.semanticKey, second.semanticKey);
+  assert.notEqual(first.eventId, second.eventId);
+});
+
+test("versioned loop contracts reject invalid shapes", () => {
+  const timestamp = "2026-07-26T00:00:00.000Z";
+  const definition = {
+    schemaVersion: 1,
+    definitionId: `definition_${"a".repeat(64)}`,
+    runId: `run_${"b".repeat(64)}`,
+    requestId: "request-preview",
+    requestDigest: "c".repeat(64),
+    recipe: "review-until-clean",
+    goal: "Keep the review loop bounded.",
+    implementerInstructions: "Address the current review findings.",
+    reviewerInstructions: "Report issues or a clean verdict.",
+    lapCap: 3,
+    createdAt: timestamp,
+  };
+  const operation = {
+    schemaVersion: 1,
+    operationId: `op_${"d".repeat(64)}`,
+    runId: definition.runId,
+    requestId: "request-report",
+    requestDigest: "e".repeat(64),
+    kind: "report",
+    actorKind: "worker",
+    actorId: "agent-reviewer",
+    fromRevision: 1,
+    toRevision: 2,
+    reportId: "report-1",
+    transitionId: "transition-1",
+    createdAt: timestamp,
+  };
+  const report = {
+    schemaVersion: 1,
+    reportId: "report-1",
+    runId: "run-p1a",
+    requestId: "request-report",
+    requestDigest: "e".repeat(64),
+    fromRevision: 1,
+    toRevision: 2,
+    fromNode: "agent-reviewer",
+    receiver: "root-master",
+    type: "verdict",
+    verdict: "clean",
+    createdAt: timestamp,
+  };
+  const transition = {
+    schemaVersion: 1,
+    transitionId: "transition-1",
+    runId: "run-p1a",
+    kind: "succeed",
+    lap: 1,
+    createdAt: timestamp,
+  };
+  const binding = {
+    schemaVersion: 1,
+    bindingId: "binding-1",
+    runId: "run-p1a",
+    agentId: "agent-reviewer",
+    rootSessionId: "session-root",
+    method: "capability-token-v1",
+    tokenDigest: "a".repeat(64),
+    createdAt: timestamp,
+  };
+  assert.deepEqual(validateLoopDefinition(definition), []);
+  assert.deepEqual(validateLoopOperation(operation), []);
+  assert.deepEqual(validateLoopReport(report), []);
+  assert.deepEqual(validateLoopTransition(transition), []);
+  assert.deepEqual(validateLoopRun(loopState()), []);
+  assert.deepEqual(validateIdentityBinding(binding), []);
+  assert.ok(validateLoopReport({ ...report, verdict: "maybe" }).length > 0);
+  assert.ok(
+    validateLoopDefinition({ ...definition, lapCap: 7 }).length > 0,
+  );
+  assert.ok(
+    validateLoopOperation({
+      ...operation,
+      reportId: undefined,
+    }).length > 0,
+  );
+  assert.ok(
+    validateLoopOperation({
+      ...operation,
+      toRevision: 3,
+    }).length > 0,
+  );
+  assert.ok(
+    validateLoopReport({ ...report, verdict: undefined }).length > 0,
+  );
+  assert.ok(
+    validateLoopReport({ ...report, toRevision: 3 }).length > 0,
+  );
+  assert.ok(
+    validateLoopRun({
+      ...loopState(),
+      continuationLease: { granted: 2, consumed: 3 },
+    }).length > 0,
+  );
+  assert.ok(
+    validateIdentityBinding({ ...binding, tokenDigest: "raw-token" }).length >
+      0,
+  );
+  assert.ok(
+    validateIdentityBinding({ ...binding, tokenDigest: undefined }).length >
+      0,
+  );
+  assert.ok(
+    validateIdentityBinding({
+      ...binding,
+      method: "host-metadata-v1",
+      tokenDigest: undefined,
+      hostIdentityDigest: undefined,
+    }).length > 0,
+  );
+});
+
+test("all checked-in JSON schemas are parseable and versioned", async () => {
+  const schemas = [
+    "event.schema.json",
+    "definition.schema.json",
+    "operation.schema.json",
+    "report.schema.json",
+    "transition.schema.json",
+    "run.schema.json",
+    "identity-binding.schema.json",
+    "worker-observation.schema.json",
+    "graph-projection.schema.json",
+  ];
+  for (const name of schemas) {
+    const schema = JSON.parse(
+      await readFile(path.join(PLUGIN_ROOT, "schemas", name), "utf8"),
+    );
+    assert.match(schema.$schema, /2020-12/);
+    assert.equal(schema.type, "object");
+    assert.equal(schema.properties.schemaVersion.const, 1);
+  }
+  const reportSchema = JSON.parse(
+    await readFile(
+      path.join(PLUGIN_ROOT, "schemas", "report.schema.json"),
+      "utf8",
+    ),
+  );
+  assert.deepEqual(reportSchema.allOf[0].then.required, ["verdict"]);
+  const bindingSchema = JSON.parse(
+    await readFile(
+      path.join(
+        PLUGIN_ROOT,
+        "schemas",
+        "identity-binding.schema.json",
+      ),
+      "utf8",
+    ),
+  );
+  assert.deepEqual(
+    bindingSchema.allOf.map((rule) => rule.then.required[0]),
+    [
+      "tokenDigest",
+      "hostIdentityDigest",
+      "requestDigest",
+      "requestId",
+      "originEventId",
+      "observationId",
+      "role",
+    ],
+  );
+  assert.deepEqual(bindingSchema.allOf.at(-1).then.required, [
+    "role",
+    "requestId",
+    "requestDigest",
+    "observationId",
+    "originEventId",
+  ]);
+  const runSchema = JSON.parse(
+    await readFile(
+      path.join(PLUGIN_ROOT, "schemas", "run.schema.json"),
+      "utf8",
+    ),
+  );
+  assert.equal(
+    runSchema.properties.continuationLease.oneOf.length,
+    7,
+  );
+});
+
+test("schema fixtures agree with the runtime conditional contracts", async () => {
+  const fixtures = [
+    {
+      name: "governor-decision-valid.json",
+      validator: validateGovernorDecision,
+      valid: true,
+    },
+    {
+      name: "governor-decision-invalid-missing-lease.json",
+      validator: validateGovernorDecision,
+      valid: false,
+    },
+    {
+      name: "worker-observation-valid.json",
+      validator: validateWorkerObservation,
+      valid: true,
+    },
+    {
+      name: "worker-observation-invalid-duplicate.json",
+      validator: validateWorkerObservation,
+      valid: false,
+    },
+    {
+      name: "definition-valid.json",
+      validator: validateLoopDefinition,
+      valid: true,
+    },
+    {
+      name: "definition-invalid-lap-cap.json",
+      validator: validateLoopDefinition,
+      valid: false,
+    },
+    {
+      name: "operation-valid-report.json",
+      validator: validateLoopOperation,
+      valid: true,
+    },
+    {
+      name: "operation-invalid-missing-report.json",
+      validator: validateLoopOperation,
+      valid: false,
+    },
+    {
+      name: "report-valid.json",
+      validator: validateLoopReport,
+      valid: true,
+    },
+    {
+      name: "report-valid-product.json",
+      validator: validateLoopReport,
+      valid: true,
+    },
+    {
+      name: "report-invalid-missing-verdict.json",
+      validator: validateLoopReport,
+      valid: false,
+    },
+    {
+      name: "report-invalid-missing-revisions.json",
+      validator: validateLoopReport,
+      valid: false,
+    },
+    {
+      name: "identity-valid-capability.json",
+      validator: validateIdentityBinding,
+      valid: true,
+    },
+    {
+      name: "identity-invalid-missing-token.json",
+      validator: validateIdentityBinding,
+      valid: false,
+    },
+    {
+      name: "run-valid.json",
+      validator: validateLoopRun,
+      valid: true,
+    },
+    {
+      name: "run-invalid-consumed-over-granted.json",
+      validator: validateLoopRun,
+      valid: false,
+    },
+    {
+      name: "graph-projection-valid.json",
+      validator: validateGraphProjection,
+      valid: true,
+    },
+    {
+      name: "graph-projection-invalid-corrupt.json",
+      validator: validateGraphProjection,
+      valid: false,
+    },
+    {
+      name: "legacy-native-target-evidence-valid.json",
+      validator: validateLegacyNativeTargetEvidence,
+      valid: true,
+    },
+    {
+      name: "legacy-native-target-evidence-invalid-field.json",
+      validator: validateLegacyNativeTargetEvidence,
+      valid: false,
+    },
+    {
+      name: "legacy-quarantine-valid.json",
+      validator: validateLegacyQuarantineReceipt,
+      valid: true,
+    },
+    {
+      name: "legacy-quarantine-invalid-count.json",
+      validator: validateLegacyQuarantineReceipt,
+      valid: false,
+    },
+    {
+      name: "legacy-quarantine-invalid-adjacency.json",
+      validator: validateLegacyQuarantineReceipt,
+      valid: false,
+    },
+  ];
+  for (const fixture of fixtures) {
+    const value = JSON.parse(
+      await readFile(
+        path.join(
+          PLUGIN_ROOT,
+          "tests",
+          "fixtures",
+          "schema",
+          fixture.name,
+        ),
+        "utf8",
+      ),
+    );
+    const errors = fixture.validator(value);
+    assert.equal(
+      errors.length === 0,
+      fixture.valid,
+      `${fixture.name}: ${errors.join("; ")}`,
+    );
+  }
+});
diff --git a/plugins/looperators-agent-loop/tests/cooperative-loop.test.mjs b/plugins/looperators-agent-loop/tests/cooperative-loop.test.mjs
new file mode 100644
index 0000000..cf62e0d
--- /dev/null
+++ b/plugins/looperators-agent-loop/tests/cooperative-loop.test.mjs
@@ -0,0 +1,393 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, readdir, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { LoopController } from "../lib/control.mjs";
+import { resolveDataRoot } from "../lib/data-root.mjs";
+import { LoopStore } from "../lib/store.mjs";
+
+async function fixture(t) {
+  const root = await mkdtemp(
+    path.join(os.tmpdir(), "looperators-cooperative-loop-"),
+  );
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const rootInfo = await resolveDataRoot({
+    env: { LOOPERATORS_DATA_DIR: root },
+  });
+  const store = new LoopStore(rootInfo);
+  const context = {
+    rootSessionId: "cooperative-root",
+    turnId: "preview-turn",
+    threadSource: "user",
+  };
+  return { root, store, context };
+}
+
+async function jsonText(root) {
+  const output = [];
+  async function walk(directory) {
+    for (const entry of await readdir(directory, {
+      withFileTypes: true,
+    })) {
+      const target = path.join(directory, entry.name);
+      if (entry.isDirectory()) await walk(target);
+      if (entry.isFile() && entry.name.endsWith(".json")) {
+        output.push(await readFile(target, "utf8"));
+      }
+    }
+  }
+  await walk(root);
+  return output.join("\n");
+}
+
+async function startedRun(t) {
+  const value = await fixture(t);
+  const controller = new LoopController(value.store);
+  const preview = await controller.preview(value.context, {
+    requestId: "preview-1",
+    goal: "Review until clean without default hooks.",
+    implementerInstructions: "Implement the requested change.",
+    reviewerInstructions: "Return a typed clean or issues verdict.",
+    lapCap: 3,
+  });
+  const started = await controller.start(
+    { ...value.context, turnId: "confirmed-turn" },
+    { runId: preview.runId, requestId: "start-1" },
+  );
+  return { ...value, controller, preview, started };
+}
+
+test("confirmed start needs no hook and issues an action-scoped role capability", async (t) => {
+  const value = await startedRun(t);
+  assert.equal(value.started.status, "running");
+  assert.equal(value.started.roleCapability.role, "implementer");
+  assert.equal(
+    value.started.roleCapability.pendingTransitionId,
+    value.started.pendingTransitionId,
+  );
+  const bindings = await value.store.listIdentityBindings(
+    value.preview.runId,
+  );
+  assert.deepEqual(
+    bindings.facts
+      .map(({ agentId, role }) => ({ agentId, role }))
+      .sort((left, right) => left.role.localeCompare(right.role)),
+    [
+      { agentId: "role:implementer", role: "implementer" },
+      { agentId: "role:reviewer", role: "reviewer" },
+    ],
+  );
+  assert.doesNotMatch(
+    await jsonText(value.root),
+    new RegExp(value.started.roleCapability.capabilityToken),
+  );
+  const snapshot = await value.controller.getSnapshot(
+    { ...value.context, turnId: "logical-binding-snapshot" },
+    { runId: value.preview.runId },
+  );
+  assert.equal(
+    snapshot.nodes.some((node) => node.nativeAgentId !== undefined),
+    false,
+  );
+});
+
+test("typed reports advance only the current role and reject stale action tokens", async (t) => {
+  const value = await startedRun(t);
+  const implementerToken =
+    value.started.roleCapability.capabilityToken;
+  const implemented = await value.controller.report({
+    runId: value.preview.runId,
+    requestId: "report-implementer-1",
+    role: "implementer",
+    capabilityToken: implementerToken,
+    type: "info",
+    status: "done",
+    summary: "implementation complete",
+  });
+  assert.equal(implemented.status, "running");
+  const reviewerAction = await value.controller.getLoop(
+    { ...value.context, turnId: "governor-read-1" },
+    { runId: value.preview.runId },
+  );
+  assert.equal(reviewerAction.roleCapability.role, "reviewer");
+  await assert.rejects(
+    value.controller.report({
+      runId: value.preview.runId,
+      requestId: "stale-implementer",
+      role: "implementer",
+      capabilityToken: implementerToken,
+      type: "info",
+      status: "done",
+    }),
+    { code: "CAPABILITY_REJECTED" },
+  );
+  const completed = await value.controller.report({
+    runId: value.preview.runId,
+    requestId: "report-reviewer-clean",
+    role: "reviewer",
+    capabilityToken:
+      reviewerAction.roleCapability.capabilityToken,
+    type: "verdict",
+    verdict: "clean",
+    issues: [],
+    summary: "clean",
+  });
+  assert.equal(completed.status, "succeeded");
+});
+
+test("action capabilities work across independent MCP controller processes", async (t) => {
+  const value = await startedRun(t);
+  const implementerProcess = new LoopController(value.store);
+  const implemented = await implementerProcess.report({
+    runId: value.preview.runId,
+    requestId: "cross-process-implementer",
+    role: "implementer",
+    capabilityToken:
+      value.started.roleCapability.capabilityToken,
+    type: "info",
+    status: "done",
+    summary: "reported from an independent controller",
+  });
+  assert.equal(implemented.status, "running");
+
+  const reviewerAction = await value.controller.getLoop(
+    { ...value.context, turnId: "cross-process-reviewer-read" },
+    { runId: value.preview.runId },
+  );
+  const reviewerProcess = new LoopController(value.store);
+  const completed = await reviewerProcess.report({
+    runId: value.preview.runId,
+    requestId: "cross-process-reviewer",
+    role: "reviewer",
+    capabilityToken:
+      reviewerAction.roleCapability.capabilityToken,
+    type: "verdict",
+    verdict: "clean",
+    issues: [],
+  });
+  assert.equal(completed.status, "succeeded");
+});
+
+test("pause preserves the action, cancel revokes it, and restart rotates it", async (t) => {
+  const value = await startedRun(t);
+  const originalToken =
+    value.started.roleCapability.capabilityToken;
+  await value.controller.pause(
+    { ...value.context, turnId: "pause-turn" },
+    { runId: value.preview.runId, requestId: "pause-1" },
+  );
+  await assert.rejects(
+    value.controller.report({
+      runId: value.preview.runId,
+      requestId: "report-while-paused",
+      role: "implementer",
+      capabilityToken: originalToken,
+      type: "info",
+      status: "done",
+    }),
+    { code: "CAPABILITY_REJECTED" },
+  );
+  await value.controller.resume(
+    { ...value.context, turnId: "resume-turn" },
+    { runId: value.preview.runId, requestId: "resume-1" },
+  );
+  const restarted = new LoopController(value.store);
+  const resigned = await restarted.getLoop(
+    { ...value.context, turnId: "restart-read" },
+    { runId: value.preview.runId },
+  );
+  assert.equal(resigned.roleCapability.role, "implementer");
+  assert.notEqual(
+    resigned.roleCapability.capabilityToken,
+    originalToken,
+  );
+  await assert.rejects(
+    restarted.report({
+      runId: value.preview.runId,
+      requestId: "pre-rotation-report",
+      role: "implementer",
+      capabilityToken: originalToken,
+      type: "info",
+      status: "done",
+    }),
+    { code: "CAPABILITY_REJECTED" },
+  );
+  await restarted.cancel(
+    { ...value.context, turnId: "cancel-turn" },
+    { runId: value.preview.runId, requestId: "cancel-1" },
+  );
+  await assert.rejects(
+    restarted.report({
+      runId: value.preview.runId,
+      requestId: "report-after-cancel",
+      role: "implementer",
+      capabilityToken:
+        resigned.roleCapability.capabilityToken,
+      type: "info",
+      status: "done",
+    }),
+    { code: "CAPABILITY_REJECTED" },
+  );
+});
+
+test("start and report retries are idempotent but conflicting payloads fail", async (t) => {
+  const value = await startedRun(t);
+  const retriedStart = await value.controller.start(
+    { ...value.context, turnId: "retry-start-turn" },
+    { runId: value.preview.runId, requestId: "start-1" },
+  );
+  assert.equal(retriedStart.duplicate, true);
+  assert.equal(
+    retriedStart.roleCapability.capabilityToken,
+    value.started.roleCapability.capabilityToken,
+  );
+  const report = {
+    runId: value.preview.runId,
+    requestId: "idempotent-report",
+    role: "implementer",
+    capabilityToken:
+      value.started.roleCapability.capabilityToken,
+    type: "info",
+    status: "done",
+    summary: "done once",
+  };
+  const first = await value.controller.report(report);
+  assert.equal(first.duplicate, false);
+  const current = await value.controller.getLoop(
+    { ...value.context, turnId: "read-after-idempotent" },
+    { runId: value.preview.runId },
+  );
+  const duplicate = await value.controller.report(report);
+  assert.equal(duplicate.duplicate, true);
+  assert.equal(current.roleCapability.role, "reviewer");
+});
+
+test("concurrent reports serialize exactly one legal transition", async (t) => {
+  const value = await startedRun(t);
+  const base = {
+    runId: value.preview.runId,
+    role: "implementer",
+    capabilityToken:
+      value.started.roleCapability.capabilityToken,
+    type: "info",
+    status: "done",
+  };
+  const results = await Promise.allSettled([
+    value.controller.report({ ...base, requestId: "race-a" }),
+    value.controller.report({ ...base, requestId: "race-b" }),
+  ]);
+  assert.equal(
+    results.filter((result) => result.status === "fulfilled").length,
+    1,
+  );
+  assert.equal(
+    results.filter(
+      (result) =>
+        result.status === "rejected" &&
+        result.reason?.code === "CAPABILITY_REJECTED",
+    ).length,
+    1,
+  );
+  const state = await value.store.readState(value.preview.runId);
+  assert.equal(state.revision, 2);
+});
+
+test("issues loop reaches its finite lap cap and exposes verified snapshots", async (t) => {
+  const value = await fixture(t);
+  const controller = new LoopController(value.store);
+  const preview = await controller.preview(value.context, {
+    requestId: "cap-preview",
+    goal: "Reach a finite cap.",
+    implementerInstructions: "Return done.",
+    reviewerInstructions: "Return issues.",
+    lapCap: 1,
+  });
+  await controller.start(
+    { ...value.context, turnId: "cap-start" },
+    { runId: preview.runId, requestId: "cap-start" },
+  );
+  for (let lap = 0; lap < 2; lap += 1) {
+    const implementer = await controller.getLoop(
+      { ...value.context, turnId: `cap-read-i-${lap}` },
+      { runId: preview.runId },
+    );
+    await controller.report({
+      runId: preview.runId,
+      requestId: `cap-implementer-${lap}`,
+      role: "implementer",
+      capabilityToken:
+        implementer.roleCapability.capabilityToken,
+      type: "info",
+      status: "done",
+    });
+    const reviewer = await controller.getLoop(
+      { ...value.context, turnId: `cap-read-r-${lap}` },
+      { runId: preview.runId },
+    );
+    await controller.report({
+      runId: preview.runId,
+      requestId: `cap-reviewer-${lap}`,
+      role: "reviewer",
+      capabilityToken:
+        reviewer.roleCapability.capabilityToken,
+      type: "verdict",
+      verdict: "issues",
+      issues: [{ message: `blocking issue ${lap}` }],
+    });
+  }
+  const state = await controller.getLoop(
+    { ...value.context, turnId: "cap-final-read" },
+    { runId: preview.runId },
+  );
+  assert.equal(state.status, "capped");
+  assert.equal("roleCapability" in state, false);
+  const snapshot = await controller.getSnapshot(
+    { ...value.context, turnId: "cap-snapshot" },
+    { runId: preview.runId },
+  );
+  assert.equal(snapshot.integrity.status, "verified");
+  assert.equal(snapshot.status, "capped");
+  assert.deepEqual(
+    snapshot.nodes.map((node) => node.id),
+    ["root", "role:implementer", "role:reviewer"],
+  );
+  assert.doesNotMatch(JSON.stringify(snapshot), /native-agent/u);
+});
+
+test("a prepared start crash rolls forward on exact retry", async (t) => {
+  const value = await fixture(t);
+  let injected = false;
+  const crashing = new LoopController(value.store, {
+    fault: async (point) => {
+      if (!injected && point === "afterFacts") {
+        injected = true;
+        throw Object.assign(new Error("injected crash"), {
+          code: "INJECTED_CRASH",
+        });
+      }
+    },
+  });
+  const preview = await crashing.preview(value.context, {
+    requestId: "crash-preview",
+    goal: "Recover exact start.",
+    implementerInstructions: "Return done.",
+    reviewerInstructions: "Return clean.",
+    lapCap: 2,
+  });
+  await assert.rejects(
+    crashing.start(
+      { ...value.context, turnId: "crash-start" },
+      { runId: preview.runId, requestId: "crash-start" },
+    ),
+    { code: "INJECTED_CRASH" },
+  );
+  const recovered = new LoopController(value.store);
+  const result = await recovered.start(
+    { ...value.context, turnId: "crash-retry" },
+    { runId: preview.runId, requestId: "crash-start" },
+  );
+  assert.equal(result.status, "running");
+  assert.equal(result.duplicate, false);
+  assert.equal(result.roleCapability.role, "implementer");
+});
diff --git a/plugins/looperators-agent-loop/tests/cooperative-mcp-server.test.mjs b/plugins/looperators-agent-loop/tests/cooperative-mcp-server.test.mjs
new file mode 100644
index 0000000..e330db5
--- /dev/null
+++ b/plugins/looperators-agent-loop/tests/cooperative-mcp-server.test.mjs
@@ -0,0 +1,433 @@
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+const pluginRoot = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "..",
+);
+
+function startServer(t, dataRoot) {
+  const child = spawn(
+    process.execPath,
+    [path.join(pluginRoot, "mcp", "server.mjs")],
+    {
+      cwd: pluginRoot,
+      env: { ...process.env, LOOPERATORS_DATA_DIR: dataRoot },
+      stdio: ["pipe", "pipe", "pipe"],
+    },
+  );
+  let buffer = "";
+  let nextId = 1;
+  const pending = new Map();
+  child.stdout.on("data", (chunk) => {
+    buffer += chunk.toString("utf8");
+    while (buffer.includes("\n")) {
+      const index = buffer.indexOf("\n");
+      const line = buffer.slice(0, index);
+      buffer = buffer.slice(index + 1);
+      if (!line.trim()) continue;
+      const message = JSON.parse(line);
+      pending.get(message.id)?.(message);
+      pending.delete(message.id);
+    }
+  });
+  const request = (method, params = {}) => {
+    const id = nextId;
+    nextId += 1;
+    const response = new Promise((resolve) => pending.set(id, resolve));
+    child.stdin.write(
+      `${JSON.stringify({ jsonrpc: "2.0", id, method, params })}\n`,
+    );
+    return response;
+  };
+  t.after(() => {
+    if (!child.killed) child.kill("SIGTERM");
+  });
+  return { request };
+}
+
+function rootTool(name, args, turnId) {
+  return {
+    name,
+    arguments: args,
+    _meta: {
+      "x-codex-turn-metadata": {
+        session_id: "mcp-cooperative-root",
+        turn_id: turnId,
+        thread_source: "user",
+      },
+    },
+  };
+}
+
+function subagentTool(name, args, turnId) {
+  return {
+    name,
+    arguments: args,
+    _meta: {
+      "x-codex-turn-metadata": {
+        session_id: "mcp-cooperative-worker",
+        turn_id: turnId,
+        thread_source: "subagent",
+      },
+    },
+  };
+}
+
+test("default MCP surface is hook-free and runs the typed cooperative happy path across MCP processes", async (t) => {
+  const root = await mkdtemp(
+    path.join(os.tmpdir(), "looperators-cooperative-mcp-"),
+  );
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const server = startServer(t, root);
+  const implementerServer = startServer(t, root);
+  const reviewerServer = startServer(t, root);
+  const initialized = await server.request("initialize", {
+    protocolVersion: "2025-06-18",
+  });
+  await Promise.all([
+    implementerServer.request("initialize", {
+      protocolVersion: "2025-06-18",
+    }),
+    reviewerServer.request("initialize", {
+      protocolVersion: "2025-06-18",
+    }),
+  ]);
+  assert.equal(
+    initialized.result.serverInfo.name,
+    "looperators-agent-loop",
+  );
+  const listed = await server.request("tools/list");
+  assert.deepEqual(
+    listed.result.tools.map((tool) => tool.name),
+    [
+      "looperators_preview_loop",
+      "looperators_start_loop",
+      "looperators_pause_loop",
+      "looperators_resume_loop",
+      "looperators_cancel_loop",
+      "looperators_report",
+      "looperators_get_loop",
+      "looperators_get_snapshot",
+      "looperators_open_review_surface",
+      "looperators_close_review_surface",
+    ],
+  );
+  assert.equal(
+    listed.result.tools.some((tool) =>
+      /hook|probe|bind_worker|render_graph|legacy/u.test(tool.name),
+    ),
+    false,
+  );
+  const getLoopTool = listed.result.tools.find(
+    (tool) => tool.name === "looperators_get_loop",
+  );
+  assert.equal(getLoopTool.annotations.readOnlyHint, false);
+  const cancelTool = listed.result.tools.find(
+    (tool) => tool.name === "looperators_cancel_loop",
+  );
+  assert.equal(cancelTool.annotations.destructiveHint, true);
+
+  const rejectedSubagentPreview = await implementerServer.request(
+    "tools/call",
+    subagentTool(
+      "looperators_preview_loop",
+      {
+        requestId: "mcp-subagent-preview",
+        goal: "Attempt a nested loop.",
+        implementerInstructions: "Return done.",
+        reviewerInstructions: "Return clean.",
+        lapCap: 1,
+      },
+      "subagent-preview-turn",
+    ),
+  );
+  assert.equal(rejectedSubagentPreview.result.isError, true);
+  assert.match(
+    rejectedSubagentPreview.result.content[0].text,
+    /ROOT_ONLY_TOOL$/u,
+  );
+
+  const preview = await server.request(
+    "tools/call",
+    rootTool(
+      "looperators_preview_loop",
+      {
+        requestId: "mcp-preview-1",
+        goal: "Run one cooperative typed review.",
+        implementerInstructions: "Return done.",
+        reviewerInstructions: "Return clean.",
+        lapCap: 2,
+      },
+      "preview-turn",
+    ),
+  );
+  assert.equal(preview.result.isError, false);
+  assert.equal(preview.result.structuredContent.status, "draft");
+  const runId = preview.result.structuredContent.runId;
+
+  const started = await server.request(
+    "tools/call",
+    rootTool(
+      "looperators_start_loop",
+      { runId, requestId: "mcp-start-1" },
+      "confirmed-turn",
+    ),
+  );
+  assert.equal(started.result.isError, false);
+  assert.equal(
+    started.result.structuredContent.roleCapability.role,
+    "implementer",
+  );
+
+  const opened = await server.request(
+    "tools/call",
+    rootTool(
+      "looperators_open_review_surface",
+      { runId },
+      "open-surface-turn",
+    ),
+  );
+  assert.equal(opened.result.isError, false);
+  assert.equal(opened.result.structuredContent.status, "ready");
+  assert.match(
+    opened.result.structuredContent.reviewUrl,
+    /^http:\/\/127\.0\.0\.1:\d+\/runs\//u,
+  );
+  const login = await fetch(
+    opened.result.structuredContent.reviewUrl,
+    { redirect: "manual" },
+  );
+  assert.equal(login.status, 303);
+  const cookie = login.headers.get("set-cookie").split(";")[0];
+  const reviewPageUrl = new URL(
+    login.headers.get("location"),
+    opened.result.structuredContent.origin,
+  );
+  const page = await fetch(reviewPageUrl, {
+    headers: { Cookie: cookie },
+  });
+  assert.equal(page.status, 200);
+  const pageBody = await page.text();
+  assert.match(pageBody, /react-flow__node/u);
+  assert.match(pageBody, /Agent Loop relationship graph/u);
+  const envelope = JSON.parse(
+    pageBody.match(
+      /id="looperators-agent-loop-data">([^<]+)<\/script>/u,
+    )[1],
+  );
+  assert.equal(envelope.runId, runId);
+  assert.equal(envelope.mode, "sidecar");
+  assert.match(envelope.controlUrl, /\/control$/u);
+  assert.match(envelope.eventsUrl, /\/events$/u);
+  const replayed = await fetch(
+    opened.result.structuredContent.reviewUrl,
+    { redirect: "manual" },
+  );
+  assert.equal(replayed.status, 401);
+  assert.match(await replayed.text(), /Review link unavailable/u);
+
+  const forbiddenControl = await fetch(
+    new URL(envelope.controlUrl, opened.result.structuredContent.origin),
+    {
+      method: "POST",
+      headers: {
+        Cookie: cookie,
+        Origin: "http://attacker.invalid",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        action: "pause",
+        requestId: "surface-forbidden-1",
+      }),
+    },
+  );
+  assert.equal(forbiddenControl.status, 403);
+  assert.deepEqual(await forbiddenControl.json(), {
+    code: "CONTROL_FORBIDDEN",
+  });
+
+  const control = async (action, requestId) => {
+    const response = await fetch(
+      new URL(envelope.controlUrl, opened.result.structuredContent.origin),
+      {
+        method: "POST",
+        headers: {
+          Cookie: cookie,
+          Origin: opened.result.structuredContent.origin,
+          "Content-Type": "application/json",
+          "X-Looperators-CSRF": envelope.csrfToken,
+        },
+        body: JSON.stringify({ action, requestId }),
+      },
+    );
+    return { response, value: await response.json() };
+  };
+  const paused = await control("pause", "surface-pause-1");
+  assert.equal(paused.response.status, 200);
+  assert.equal(paused.value.status, "paused");
+  const resumed = await control("resume", "surface-resume-1");
+  assert.equal(resumed.response.status, 200);
+  assert.equal(resumed.value.status, "running");
+
+  const implemented = await implementerServer.request("tools/call", {
+    name: "looperators_report",
+    arguments: {
+      runId,
+      requestId: "mcp-implementer-report",
+      role: "implementer",
+      capabilityToken:
+        started.result.structuredContent.roleCapability.capabilityToken,
+      type: "info",
+      status: "done",
+    },
+  });
+  assert.equal(implemented.result.isError, false);
+
+  const current = await server.request(
+    "tools/call",
+    rootTool(
+      "looperators_get_loop",
+      { runId },
+      "governor-read",
+    ),
+  );
+  assert.equal(
+    current.result.structuredContent.roleCapability.role,
+    "reviewer",
+  );
+  const reviewed = await reviewerServer.request("tools/call", {
+    name: "looperators_report",
+    arguments: {
+      runId,
+      requestId: "mcp-reviewer-report",
+      role: "reviewer",
+      capabilityToken:
+        current.result.structuredContent.roleCapability.capabilityToken,
+      type: "verdict",
+      verdict: "clean",
+      issues: [],
+    },
+  });
+  assert.equal(reviewed.result.isError, false);
+  assert.equal(reviewed.result.structuredContent.status, "succeeded");
+
+  const closed = await server.request(
+    "tools/call",
+    rootTool(
+      "looperators_close_review_surface",
+      { runId },
+      "close-surface-turn",
+    ),
+  );
+  assert.equal(closed.result.isError, false);
+  assert.equal(closed.result.structuredContent.status, "closed");
+  await assert.rejects(fetch(reviewPageUrl));
+
+  const hidden = await server.request("tools/call", {
+    name: "looperators_render_graph",
+    arguments: {},
+  });
+  assert.equal(hidden.error.code, -32601);
+});
+
+test("a new Governor MCP process rotates the pending action token", async (t) => {
+  const root = await mkdtemp(
+    path.join(os.tmpdir(), "looperators-cooperative-restart-"),
+  );
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const originalRoot = startServer(t, root);
+  const restartedRoot = startServer(t, root);
+  const worker = startServer(t, root);
+  await Promise.all(
+    [originalRoot, restartedRoot, worker].map((server) =>
+      server.request("initialize", {
+        protocolVersion: "2025-06-18",
+      }),
+    ),
+  );
+
+  const preview = await originalRoot.request(
+    "tools/call",
+    rootTool(
+      "looperators_preview_loop",
+      {
+        requestId: "restart-preview",
+        goal: "Verify cross-process restart rotation.",
+        implementerInstructions: "Return done.",
+        reviewerInstructions: "Return clean.",
+        lapCap: 2,
+      },
+      "restart-preview-turn",
+    ),
+  );
+  const runId = preview.result.structuredContent.runId;
+  const started = await originalRoot.request(
+    "tools/call",
+    rootTool(
+      "looperators_start_loop",
+      { runId, requestId: "restart-start" },
+      "restart-start-turn",
+    ),
+  );
+  const oldToken =
+    started.result.structuredContent.roleCapability.capabilityToken;
+
+  const recovered = await restartedRoot.request(
+    "tools/call",
+    rootTool(
+      "looperators_get_loop",
+      { runId },
+      "restart-recovery-turn",
+    ),
+  );
+  const newToken =
+    recovered.result.structuredContent.roleCapability.capabilityToken;
+  assert.notEqual(newToken, oldToken);
+
+  const stale = await worker.request("tools/call", {
+    name: "looperators_report",
+    arguments: {
+      runId,
+      requestId: "restart-stale-report",
+      role: "implementer",
+      capabilityToken: oldToken,
+      type: "info",
+      status: "done",
+    },
+  });
+  assert.equal(stale.result.isError, true);
+  assert.match(
+    stale.result.content[0].text,
+    /CAPABILITY_REJECTED$/u,
+  );
+
+  const accepted = await worker.request("tools/call", {
+    name: "looperators_report",
+    arguments: {
+      runId,
+      requestId: "restart-current-report",
+      role: "implementer",
+      capabilityToken: newToken,
+      type: "info",
+      status: "done",
+    },
+  });
+  assert.equal(accepted.result.isError, false);
+  assert.equal(accepted.result.structuredContent.revision, 2);
+
+  const cancelled = await restartedRoot.request(
+    "tools/call",
+    rootTool(
+      "looperators_cancel_loop",
+      { runId, requestId: "restart-cancel" },
+      "restart-cancel-turn",
+    ),
+  );
+  assert.equal(cancelled.result.structuredContent.status, "cancelled");
+});
diff --git a/plugins/looperators-agent-loop/tests/data-root-and-identity.test.mjs b/plugins/looperators-agent-loop/tests/data-root-and-identity.test.mjs
new file mode 100644
index 0000000..64e4888
--- /dev/null
+++ b/plugins/looperators-agent-loop/tests/data-root-and-identity.test.mjs
@@ -0,0 +1,557 @@
+import assert from "node:assert/strict";
+import {
+  access,
+  chmod,
+  mkdir,
+  mkdtemp,
+  readFile,
+  realpath,
+  readdir,
+  rm,
+  stat,
+  writeFile,
+} from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import {
+  digestJson,
+  sha256,
+} from "../lib/canonical-json.mjs";
+import { normalizeHookEvent } from "../lib/contracts.mjs";
+import {
+  DataRootSplitError,
+  DataRootUnavailableError,
+  InvalidDataRootError,
+  defaultDataRoot,
+  resolveDataRoot,
+} from "../lib/data-root.mjs";
+import {
+  bindHostIdentity,
+  issueRunCapability,
+  summarizeMcpIdentity,
+  verifyRunCapability,
+} from "../lib/identity.mjs";
+import { loopState, tempStore } from "./helpers.mjs";
+
+test("explicit data root overrides PLUGIN_DATA and keeps a stable marker", async (t) => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "looperators-root-"));
+  const ignoredPluginRoot = path.join(root, "ignored-plugin-data");
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const first = await resolveDataRoot({
+    env: { LOOPERATORS_DATA_DIR: root },
+  });
+  const second = await resolveDataRoot({
+    env: {
+      LOOPERATORS_DATA_DIR: root,
+      PLUGIN_DATA: ignoredPluginRoot,
+    },
+    expectedInstanceId: first.marker.instanceId,
+  });
+  assert.equal(first.path, second.path);
+  assert.equal(first.source, "LOOPERATORS_DATA_DIR");
+  assert.equal(first.marker.instanceId, second.marker.instanceId);
+  assert.equal(first.instanceIdDigest, second.instanceIdDigest);
+  await assert.rejects(
+    resolveDataRoot({ env: {}, platform: "win32" }),
+    DataRootUnavailableError,
+  );
+  await assert.rejects(
+    resolveDataRoot({ env: { LOOPERATORS_DATA_DIR: "relative" } }),
+    InvalidDataRootError,
+  );
+});
+
+test("platform defaults are deterministic and use native path semantics", () => {
+  assert.equal(
+    defaultDataRoot({
+      platform: "darwin",
+      env: {
+        HOME: "/Users/example",
+        XDG_DATA_HOME: "/must/be/ignored",
+      },
+      pathImplementation: path.posix,
+    }),
+    "/Users/example/Library/Application Support/looperators/codex-agent-loop/v1",
+  );
+  assert.equal(
+    defaultDataRoot({
+      platform: "linux",
+      env: {
+        HOME: "/home/example",
+        XDG_DATA_HOME: "/var/example-data",
+      },
+      pathImplementation: path.posix,
+    }),
+    "/var/example-data/looperators/codex-agent-loop/v1",
+  );
+  assert.equal(
+    defaultDataRoot({
+      platform: "linux",
+      env: { HOME: "/home/example" },
+      pathImplementation: path.posix,
+    }),
+    "/home/example/.local/share/looperators/codex-agent-loop/v1",
+  );
+  assert.equal(
+    defaultDataRoot({
+      platform: "win32",
+      env: {
+        LOCALAPPDATA: "C:\\Users\\example\\AppData\\Local",
+      },
+      pathImplementation: path.win32,
+    }),
+    "C:\\Users\\example\\AppData\\Local\\looperators\\codex-agent-loop\\v1",
+  );
+  assert.throws(
+    () =>
+      defaultDataRoot({
+        platform: "linux",
+        env: {
+          HOME: "/home/example",
+          XDG_DATA_HOME: "relative-data",
+        },
+        pathImplementation: path.posix,
+      }),
+    DataRootUnavailableError,
+  );
+});
+
+test("platform defaults use the OS account home when Desktop omits HOME", () => {
+  let resolutions = 0;
+  const resolveSystemHome = () => {
+    resolutions += 1;
+    return "/Users/desktop-account";
+  };
+  assert.equal(
+    defaultDataRoot({
+      platform: "darwin",
+      env: {},
+      pathImplementation: path.posix,
+      systemHomeDirectory: resolveSystemHome,
+    }),
+    "/Users/desktop-account/Library/Application Support/looperators/codex-agent-loop/v1",
+  );
+  assert.equal(
+    defaultDataRoot({
+      platform: "linux",
+      env: {},
+      pathImplementation: path.posix,
+      systemHomeDirectory: () => "/home/desktop-account",
+    }),
+    "/home/desktop-account/.local/share/looperators/codex-agent-loop/v1",
+  );
+  assert.equal(resolutions, 1);
+  assert.throws(
+    () =>
+      defaultDataRoot({
+        platform: "darwin",
+        env: {},
+        pathImplementation: path.posix,
+        systemHomeDirectory: () => "relative-home",
+      }),
+    DataRootUnavailableError,
+  );
+});
+
+test("non-creating platform open never initializes a store", async (t) => {
+  const home = await mkdtemp(
+    path.join(os.tmpdir(), "looperators-platform-home-"),
+  );
+  t.after(() => rm(home, { recursive: true, force: true }));
+  const expected = defaultDataRoot({
+    platform: "darwin",
+    env: { HOME: home },
+  });
+  await assert.rejects(
+    resolveDataRoot({
+      env: { HOME: home },
+      platform: "darwin",
+      create: false,
+    }),
+    DataRootUnavailableError,
+  );
+  await assert.rejects(access(expected), { code: "ENOENT" });
+
+  const created = await resolveDataRoot({
+    env: {
+      HOME: home,
+      PLUGIN_DATA: path.join(home, "ignored-plugin-data"),
+    },
+    platform: "darwin",
+  });
+  assert.equal(created.path, await realpath(expected));
+  assert.equal(created.source, "looperators-platform-data");
+  assert.equal((await stat(expected)).mode & 0o777, 0o700);
+
+  const opened = await resolveDataRoot({
+    env: { HOME: home },
+    platform: "darwin",
+    create: false,
+  });
+  assert.equal(opened.marker.instanceId, created.marker.instanceId);
+  await chmod(expected, 0o755);
+  await resolveDataRoot({
+    env: { HOME: home },
+    platform: "darwin",
+  });
+  assert.equal(
+    (await stat(expected)).mode & 0o777,
+    0o755,
+    "opening an existing platform root does not rewrite permissions",
+  );
+
+  const markerless = path.join(home, "markerless");
+  await mkdir(markerless);
+  await assert.rejects(
+    resolveDataRoot({
+      env: { LOOPERATORS_DATA_DIR: markerless },
+      create: false,
+    }),
+    DataRootUnavailableError,
+  );
+  await assert.rejects(
+    access(path.join(markerless, ".looperators-store-v1.json")),
+    { code: "ENOENT" },
+  );
+});
+
+test("resolver detects expected marker mismatch without persisting paths", async (t) => {
+  const left = await mkdtemp(path.join(os.tmpdir(), "looperators-left-"));
+  const right = await mkdtemp(path.join(os.tmpdir(), "looperators-right-"));
+  t.after(async () => {
+    await Promise.all([
+      rm(left, { recursive: true, force: true }),
+      rm(right, { recursive: true, force: true }),
+    ]);
+  });
+  const leftInfo = await resolveDataRoot({
+    env: { LOOPERATORS_DATA_DIR: left },
+  });
+  await assert.rejects(
+    resolveDataRoot({
+      env: { LOOPERATORS_DATA_DIR: right },
+      expectedInstanceId: leftInfo.marker.instanceId,
+    }),
+    DataRootSplitError,
+  );
+  const diagnostics = await readdir(
+    path.join(right, "diagnostics", "data-root-split"),
+  );
+  assert.equal(diagnostics.length, 1);
+  const diagnostic = await readFile(
+    path.join(right, "diagnostics", "data-root-split", diagnostics[0]),
+    "utf8",
+  );
+  assert.match(diagnostic, /data_root_split/);
+  assert.doesNotMatch(diagnostic, new RegExp(left));
+  assert.doesNotMatch(diagnostic, new RegExp(right));
+});
+
+test("MCP identity summary trusts host metadata shape but not tool arguments", () => {
+  const summary = summarizeMcpIdentity({
+    method: "tools/call",
+    params: {
+      name: "looperators_identity_probe",
+      arguments: {
+        fromNode: "self-claimed-agent",
+        agent_id: "also-untrusted",
+      },
+      _meta: {
+        threadId: "thread-host",
+        "x-codex-turn-metadata": {
+          thread_id: "thread-host-metadata",
+          turn_id: "turn-host",
+          agent_id: "agent-host",
+        },
+        progressToken: "not-an-identity",
+      },
+    },
+  });
+  assert.equal(summary.classification, "host-metadata-v1");
+  assert.equal(summary.trustedIdentityAvailable, true);
+  assert.deepEqual(summary.untrustedArgumentIdentityClaims, [
+    "agent_id",
+    "fromNode",
+  ]);
+  assert.doesNotMatch(JSON.stringify(summary), /thread-host|agent-host/);
+
+  const arbitrary = summarizeMcpIdentity({
+    method: "tools/call",
+    params: {
+      arguments: {},
+      _meta: {
+        arbitrary_user_echo: {
+          thread_id: "thread-untrusted",
+          agent_id: "agent-untrusted",
+        },
+      },
+    },
+  });
+  assert.equal(
+    arbitrary.classification,
+    "trusted_identity_unavailable",
+  );
+
+  const unavailable = summarizeMcpIdentity({
+    method: "tools/call",
+    params: {
+      arguments: { fromNode: "claimed" },
+      _meta: { progressToken: 1 },
+    },
+  });
+  assert.equal(
+    unavailable.classification,
+    "trusted_identity_unavailable",
+  );
+});
+
+test("session opt-in bindings are validated against their durable location", async (t) => {
+  const { root, store } = await tempStore(t);
+  const state = loopState();
+  await store.initializeRun(state);
+  assert.equal(
+    await store.activeRunForSession(state.rootSessionId),
+    state.runId,
+  );
+  const bindingDirectory = path.join(
+    root,
+    "session-bindings",
+    sha256(state.rootSessionId),
+  );
+  const bindingPath = path.join(bindingDirectory, `${state.runId}.json`);
+  const binding = JSON.parse(await readFile(bindingPath, "utf8"));
+  await writeFile(
+    bindingPath,
+    `${JSON.stringify({
+      ...binding,
+      bindingId: `session_${"0".repeat(64)}`,
+    })}\n`,
+  );
+  await assert.rejects(
+    store.activeRunForSession(state.rootSessionId),
+    { code: "INVALID_CONTRACT" },
+  );
+});
+
+test("host identity binding requires an in-process host proof and observed lineage", async (t) => {
+  const { store } = await tempStore(t);
+  await store.initializeRun(loopState());
+  for (const [agentId, turnId] of [
+    ["agent-reviewer", "turn-reviewer"],
+    ["agent-other", "turn-other"],
+  ]) {
+    await store.putEvent(
+      "run-p1a",
+      normalizeHookEvent(
+        {
+          session_id: "session-root",
+          turn_id: turnId,
+          hook_event_name: "SubagentStart",
+          agent_id: agentId,
+          agent_type: "reviewer",
+        },
+        { observedAt: "2026-07-26T00:00:00.000Z" },
+      ),
+    );
+  }
+  const summary = summarizeMcpIdentity({
+    method: "tools/call",
+    params: {
+      arguments: {},
+      _meta: {
+        "x-codex-turn-metadata": {
+          thread_id: "child-session",
+          parent_thread_id: "session-root",
+          turn_id: "child-turn",
+          agent_id: "agent-reviewer",
+        },
+      },
+    },
+  });
+  assert.equal(summary.classification, "host-metadata-v1");
+  assert.equal(Object.isFrozen(summary), true);
+  assert.equal(Object.isFrozen(summary.candidateFields), true);
+
+  await assert.rejects(
+    bindHostIdentity(store, {
+      runId: "run-p1a",
+      agentId: "agent-reviewer",
+      rootSessionId: "session-root",
+    }),
+    { code: "TRUSTED_IDENTITY_UNAVAILABLE" },
+  );
+  await assert.rejects(
+    bindHostIdentity(store, {
+      runId: "run-p1a",
+      agentId: "agent-reviewer",
+      rootSessionId: "session-root",
+      identitySummary: JSON.parse(JSON.stringify(summary)),
+    }),
+    { code: "TRUSTED_IDENTITY_UNAVAILABLE" },
+  );
+  await assert.rejects(
+    bindHostIdentity(store, {
+      runId: "run-p1a",
+      agentId: "agent-reviewer",
+      rootSessionId: "wrong-root",
+      identitySummary: summary,
+    }),
+    { code: "AGENT_NOT_OBSERVED" },
+  );
+  await assert.rejects(
+    bindHostIdentity(store, {
+      runId: "run-p1a",
+      agentId: "agent-other",
+      rootSessionId: "session-root",
+      identitySummary: summary,
+    }),
+    { code: "HOST_IDENTITY_MISMATCH" },
+  );
+  const proofSymbol = Object.getOwnPropertySymbols(summary)[0];
+  const mutableSummary = {
+    ...summary,
+    candidateFields: summary.candidateFields.map((candidate) => ({
+      ...candidate,
+    })),
+  };
+  Object.defineProperty(mutableSummary, proofSymbol, {
+    value: summary[proofSymbol],
+  });
+  const racedBinding = bindHostIdentity(store, {
+    runId: "run-p1a",
+    agentId: "agent-other",
+    rootSessionId: "session-root",
+    identitySummary: mutableSummary,
+  });
+  const mutableAgentCandidate =
+    mutableSummary.candidateFields.find(
+      (candidate) => candidate.kind === "agent",
+    );
+  mutableAgentCandidate.valueDigest = digestJson({
+    key: mutableAgentCandidate.key,
+    value: "agent-other",
+  });
+  await assert.rejects(racedBinding, {
+    code: "HOST_IDENTITY_MISMATCH",
+  });
+  const binding = await bindHostIdentity(store, {
+    runId: "run-p1a",
+    agentId: "agent-reviewer",
+    rootSessionId: "session-root",
+    identitySummary: summary,
+    createdAt: "2026-07-26T00:00:01.000Z",
+  });
+  assert.equal(binding.method, "host-metadata-v1");
+  assert.equal(
+    (await store.readIdentityBinding(
+      "run-p1a",
+      "agent-reviewer",
+    )).hostIdentityDigest,
+    binding.hostIdentityDigest,
+  );
+});
+
+test("capability token is returned once, stored only as a digest, and verified", async (t) => {
+  const { root, store } = await tempStore(t);
+  await store.initializeRun(loopState());
+  await assert.rejects(
+    issueRunCapability(store, {
+      runId: "run-p1a",
+      agentId: "agent-reviewer",
+      rootSessionId: "session-root",
+    }),
+    { code: "AGENT_NOT_OBSERVED" },
+  );
+  await store.putEvent(
+    "run-p1a",
+    normalizeHookEvent(
+      {
+        session_id: "session-root",
+        turn_id: "turn-spawn",
+        hook_event_name: "SubagentStart",
+        agent_id: "agent-reviewer",
+        agent_type: "reviewer",
+      },
+      { observedAt: "2026-07-26T00:00:00.000Z" },
+    ),
+  );
+  const issued = await issueRunCapability(store, {
+    runId: "run-p1a",
+    agentId: "agent-reviewer",
+    rootSessionId: "session-root",
+    createdAt: "2026-07-26T00:00:00.000Z",
+  });
+  assert.ok(issued.token.length >= 32);
+  assert.equal(
+    await verifyRunCapability(store, {
+      runId: "run-p1a",
+      agentId: "agent-reviewer",
+      token: issued.token,
+    }),
+    true,
+  );
+  assert.equal(
+    await verifyRunCapability(store, {
+      runId: "run-p1a",
+      agentId: "agent-reviewer",
+      token: `${issued.token}wrong`,
+    }),
+    false,
+  );
+  const bindingPath = path.join(
+    root,
+    "runs",
+    "run-p1a",
+    "identity",
+    `binding_${sha256("agent-reviewer")}.json`,
+  );
+  const originalBinding = JSON.parse(
+    await readFile(bindingPath, "utf8"),
+  );
+  await writeFile(
+    bindingPath,
+    `${JSON.stringify({
+      ...originalBinding,
+      rootSessionId: "session-foreign",
+    })}\n`,
+  );
+  assert.equal(
+    await verifyRunCapability(store, {
+      runId: "run-p1a",
+      agentId: "agent-reviewer",
+      token: issued.token,
+    }),
+    false,
+  );
+  await writeFile(
+    bindingPath,
+    `${JSON.stringify(originalBinding)}\n`,
+  );
+  const bindingText = await readFile(
+    bindingPath,
+    "utf8",
+  );
+  assert.doesNotMatch(bindingText, new RegExp(issued.token));
+  await assert.rejects(
+    issueRunCapability(store, {
+      runId: "run-p1a",
+      agentId: "agent-reviewer",
+      rootSessionId: "session-root",
+    }),
+    { code: "CAPABILITY_ALREADY_ISSUED" },
+  );
+  const misplaced = JSON.parse(await readFile(bindingPath, "utf8"));
+  await writeFile(
+    bindingPath,
+    `${JSON.stringify({ ...misplaced, agentId: "agent-other" })}\n`,
+  );
+  await assert.rejects(
+    verifyRunCapability(store, {
+      runId: "run-p1a",
+      agentId: "agent-reviewer",
+      token: issued.token,
+    }),
+    { code: "INVALID_CONTRACT" },
+  );
+});
diff --git a/plugins/looperators-agent-loop/tests/fixtures/lock-worker.mjs b/plugins/looperators-agent-loop/tests/fixtures/lock-worker.mjs
new file mode 100644
index 0000000..f5c2088
--- /dev/null
+++ b/plugins/looperators-agent-loop/tests/fixtures/lock-worker.mjs
@@ -0,0 +1,34 @@
+import { open, unlink } from "node:fs/promises";
+import path from "node:path";
+import { withFileLock } from "../../lib/fs-utils.mjs";
+
+const [root, lockPath] = process.argv.slice(2);
+const sentinel = path.join(root, "locks", "critical-section.json");
+const result = await withFileLock(
+  lockPath,
+  async () => {
+    let handle;
+    try {
+      handle = await open(sentinel, "wx", 0o600);
+    } catch (error) {
+      if (error?.code === "EEXIST") {
+        return { overlap: true };
+      }
+      throw error;
+    }
+    try {
+      await new Promise((resolve) => setTimeout(resolve, 5));
+      return { overlap: false };
+    } finally {
+      await handle.close();
+      await unlink(sentinel);
+    }
+  },
+  {
+    root,
+    staleMs: 0,
+    timeoutMs: 5_000,
+    retryMs: 1,
+  },
+);
+process.stdout.write(`${JSON.stringify(result)}\n`);
diff --git a/plugins/looperators-agent-loop/tests/fixtures/put-event-worker.mjs b/plugins/looperators-agent-loop/tests/fixtures/put-event-worker.mjs
new file mode 100644
index 0000000..db2ca47
--- /dev/null
+++ b/plugins/looperators-agent-loop/tests/fixtures/put-event-worker.mjs
@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+import { resolveDataRoot } from "../../lib/data-root.mjs";
+import { LoopStore } from "../../lib/store.mjs";
+
+const [runId, encodedEvent] = process.argv.slice(2);
+const event = JSON.parse(Buffer.from(encodedEvent, "base64url").toString("utf8"));
+const rootInfo = await resolveDataRoot();
+const store = new LoopStore(rootInfo);
+const result = await store.putEvent(runId, event);
+process.stdout.write(`${JSON.stringify(result)}\n`);
diff --git a/plugins/looperators-agent-loop/tests/fixtures/schema/definition-invalid-lap-cap.json b/plugins/looperators-agent-loop/tests/fixtures/schema/definition-invalid-lap-cap.json
new file mode 100644
index 0000000..abb8d5c
--- /dev/null
+++ b/plugins/looperators-agent-loop/tests/fixtures/schema/definition-invalid-lap-cap.json
@@ -0,0 +1,13 @@
+{
+  "schemaVersion": 1,
+  "definitionId": "definition_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+  "runId": "run_bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+  "requestId": "request-preview",
+  "requestDigest": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
+  "recipe": "review-until-clean",
+  "goal": "Keep the review loop bounded.",
+  "implementerInstructions": "Address the current review findings.",
+  "reviewerInstructions": "Report issues or a clean verdict.",
+  "lapCap": 7,
+  "createdAt": "2026-07-26T00:00:00.000Z"
+}
diff --git a/plugins/looperators-agent-loop/tests/fixtures/schema/definition-valid.json b/plugins/looperators-agent-loop/tests/fixtures/schema/definition-valid.json
new file mode 100644
index 0000000..bfe27c0
--- /dev/null
+++ b/plugins/looperators-agent-loop/tests/fixtures/schema/definition-valid.json
@@ -0,0 +1,13 @@
+{
+  "schemaVersion": 1,
+  "definitionId": "definition_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+  "runId": "run_bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+  "requestId": "request-preview",
+  "requestDigest": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
+  "recipe": "review-until-clean",
+  "goal": "Keep the review loop bounded.",
+  "implementerInstructions": "Address the current review findings.",
+  "reviewerInstructions": "Report issues or a clean verdict.",
+  "lapCap": 3,
+  "createdAt": "2026-07-26T00:00:00.000Z"
+}
diff --git a/plugins/looperators-agent-loop/tests/fixtures/schema/governor-decision-invalid-missing-lease.json b/plugins/looperators-agent-loop/tests/fixtures/schema/governor-decision-invalid-missing-lease.json
new file mode 100644
index 0000000..0f53591
--- /dev/null
+++ b/plugins/looperators-agent-loop/tests/fixtures/schema/governor-decision-invalid-missing-lease.json
@@ -0,0 +1,17 @@
+{
+  "schemaVersion": 1,
+  "decisionId": "decision_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+  "runId": "run-p1a",
+  "obligationId": "transition-pending",
+  "originEventId": "evt_bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+  "hookEvent": "SubagentStop",
+  "rootSessionId": "session-root",
+  "turnId": "turn-worker",
+  "agentId": "agent-implementer",
+  "action": "block",
+  "reasonCode": "pending-worker-report",
+  "pendingTransitionId": "transition-pending",
+  "fromRevision": 1,
+  "toRevision": 2,
+  "createdAt": "2026-07-26T00:00:00.000Z"
+}
diff --git a/plugins/looperators-agent-loop/tests/fixtures/schema/governor-decision-valid.json b/plugins/looperators-agent-loop/tests/fixtures/schema/governor-decision-valid.json
new file mode 100644
index 0000000..85a5b6e
--- /dev/null
+++ b/plugins/looperators-agent-loop/tests/fixtures/schema/governor-decision-valid.json
@@ -0,0 +1,18 @@
+{
+  "schemaVersion": 1,
+  "decisionId": "decision_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+  "runId": "run-p1a",
+  "obligationId": "transition-pending",
+  "originEventId": "evt_bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+  "hookEvent": "SubagentStop",
+  "rootSessionId": "session-root",
+  "turnId": "turn-worker",
+  "agentId": "agent-implementer",
+  "action": "block",
+  "reasonCode": "pending-worker-report",
+  "pendingTransitionId": "transition-pending",
+  "fromRevision": 1,
+  "toRevision": 2,
+  "leaseEpoch": 1,
+  "createdAt": "2026-07-26T00:00:00.000Z"
+}
diff --git a/plugins/looperators-agent-loop/tests/fixtures/schema/graph-projection-invalid-corrupt.json b/plugins/looperators-agent-loop/tests/fixtures/schema/graph-projection-invalid-corrupt.json
new file mode 100644
index 0000000..899055a
--- /dev/null
+++ b/plugins/looperators-agent-loop/tests/fixtures/schema/graph-projection-invalid-corrupt.json
@@ -0,0 +1,93 @@
+{
+  "schemaVersion": 1,
+  "storeVersion": 1,
+  "projectionVersion": 3,
+  "runId": "run-projection-fixture",
+  "revision": 0,
+  "status": "draft",
+  "recipe": "review-until-clean",
+  "currentLap": 0,
+  "lapCap": 3,
+  "continuationLease": {
+    "granted": 3,
+    "consumed": 0
+  },
+  "cancelRequested": false,
+  "needsHuman": false,
+  "integrity": {
+    "status": "verified",
+    "verifiedRevision": 0
+  },
+  "eventWatermark": {
+    "eventCount": 0
+  },
+  "nodes": [
+    {
+      "id": "root",
+      "kind": "root",
+      "label": "Governor",
+      "state": "active"
+    },
+    {
+      "id": "role:implementer",
+      "kind": "worker-role",
+      "role": "implementer",
+      "label": "Implementer",
+      "state": "unbound"
+    },
+    {
+      "id": "role:reviewer",
+      "kind": "worker-role",
+      "role": "reviewer",
+      "label": "Reviewer",
+      "state": "unbound"
+    }
+  ],
+  "edges": [
+    {
+      "id": "root-governs-implementer",
+      "source": "root",
+      "target": "role:implementer",
+      "kind": "governs",
+      "active": false,
+      "reportCount": 0
+    },
+    {
+      "id": "implementer-handoff-reviewer",
+      "source": "role:implementer",
+      "target": "role:reviewer",
+      "kind": "handoff",
+      "active": false,
+      "reportCount": 0
+    },
+    {
+      "id": "reviewer-feedback-implementer",
+      "source": "role:reviewer",
+      "target": "role:implementer",
+      "kind": "feedback",
+      "active": false,
+      "reportCount": 0
+    },
+    {
+      "id": "reviewer-verdict-root",
+      "source": "role:reviewer",
+      "target": "root",
+      "kind": "verdict",
+      "active": false,
+      "reportCount": 0
+    }
+  ],
+  "counts": {
+    "events": 0,
+    "reports": 0,
+    "transitions": 0,
+    "operations": 0,
+    "governorDecisions": 0,
+    "recoveries": 0,
+    "diagnostics": 0,
+    "conflicts": 0,
+    "corrupt": 1
+  },
+  "timeline": [],
+  "projectionDigest": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
+}
diff --git a/plugins/looperators-agent-loop/tests/fixtures/schema/graph-projection-valid.json b/plugins/looperators-agent-loop/tests/fixtures/schema/graph-projection-valid.json
new file mode 100644
index 0000000..3ed11d6
--- /dev/null
+++ b/plugins/looperators-agent-loop/tests/fixtures/schema/graph-projection-valid.json
@@ -0,0 +1,93 @@
+{
+  "schemaVersion": 1,
+  "storeVersion": 1,
+  "projectionVersion": 3,
+  "runId": "run-projection-fixture",
+  "revision": 0,
+  "status": "draft",
+  "recipe": "review-until-clean",
+  "currentLap": 0,
+  "lapCap": 3,
+  "continuationLease": {
+    "granted": 3,
+    "consumed": 0
+  },
+  "cancelRequested": false,
+  "needsHuman": false,
+  "integrity": {
+    "status": "verified",
+    "verifiedRevision": 0
+  },
+  "eventWatermark": {
+    "eventCount": 0
+  },
+  "nodes": [
+    {
+      "id": "root",
+      "kind": "root",
+      "label": "Governor",
+      "state": "active"
+    },
+    {
+      "id": "role:implementer",
+      "kind": "worker-role",
+      "role": "implementer",
+      "label": "Implementer",
+      "state": "unbound"
+    },
+    {
+      "id": "role:reviewer",
+      "kind": "worker-role",
+      "role": "reviewer",
+      "label": "Reviewer",
+      "state": "unbound"
+    }
+  ],
+  "edges": [
+    {
+      "id": "root-governs-implementer",
+      "source": "root",
+      "target": "role:implementer",
+      "kind": "governs",
+      "active": false,
+      "reportCount": 0
+    },
+    {
+      "id": "implementer-handoff-reviewer",
+      "source": "role:implementer",
+      "target": "role:reviewer",
+      "kind": "handoff",
+      "active": false,
+      "reportCount": 0
+    },
+    {
+      "id": "reviewer-feedback-implementer",
+      "source": "role:reviewer",
+      "target": "role:implementer",
+      "kind": "feedback",
+      "active": false,
+      "reportCount": 0
+    },
+    {
+      "id": "reviewer-verdict-root",
+      "source": "role:reviewer",
+      "target": "root",
+      "kind": "verdict",
+      "active": false,
+      "reportCount": 0
+    }
+  ],
+  "counts": {
+    "events": 0,
+    "reports": 0,
+    "transitions": 0,
+    "operations": 0,
+    "governorDecisions": 0,
+    "recoveries": 0,
+    "diagnostics": 0,
+    "conflicts": 0,
+    "corrupt": 0
+  },
+  "timeline": [],
+  "projectionDigest": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
+}
diff --git a/plugins/looperators-agent-loop/tests/fixtures/schema/identity-invalid-missing-token.json b/plugins/looperators-agent-loop/tests/fixtures/schema/identity-invalid-missing-token.json
new file mode 100644
index 0000000..92a3c40
--- /dev/null
+++ b/plugins/looperators-agent-loop/tests/fixtures/schema/identity-invalid-missing-token.json
@@ -0,0 +1,9 @@
+{
+  "schemaVersion": 1,
+  "bindingId": "binding-schema-invalid",
+  "runId": "run-p1a",
+  "agentId": "agent-reviewer",
+  "rootSessionId": "session-root",
+  "method": "capability-token-v1",
+  "createdAt": "2026-07-26T00:00:00.000Z"
+}
diff --git a/plugins/looperators-agent-loop/tests/fixtures/schema/identity-valid-capability.json b/plugins/looperators-agent-loop/tests/fixtures/schema/identity-valid-capability.json
new file mode 100644
index 0000000..e0e14e2
--- /dev/null
+++ b/plugins/looperators-agent-loop/tests/fixtures/schema/identity-valid-capability.json
@@ -0,0 +1,10 @@
+{
+  "schemaVersion": 1,
+  "bindingId": "binding-schema-valid",
+  "runId": "run-p1a",
+  "agentId": "agent-reviewer",
+  "rootSessionId": "session-root",
+  "method": "capability-token-v1",
+  "tokenDigest": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+  "createdAt": "2026-07-26T00:00:00.000Z"
+}
diff --git a/plugins/looperators-agent-loop/tests/fixtures/schema/legacy-native-target-evidence-invalid-field.json b/plugins/looperators-agent-loop/tests/fixtures/schema/legacy-native-target-evidence-invalid-field.json
new file mode 100644
index 0000000..ebc2770
--- /dev/null
+++ b/plugins/looperators-agent-loop/tests/fixtures/schema/legacy-native-target-evidence-invalid-field.json
@@ -0,0 +1,19 @@
+{
+  "schemaVersion": 1,
+  "evidenceVersion": 1,
+  "runId": "legacy-run",
+  "stateRevision": 1,
+  "historyDigest": "1111111111111111111111111111111111111111111111111111111111111111",
+  "entries": [
+    {
+      "factKind": "transition",
+      "factId": "transition-legacy",
+      "factDigest": "2222222222222222222222222222222222222222222222222222222222222222",
+      "field": "routedToNode",
+      "role": "implementer",
+      "bindingId": "binding_3333333333333333333333333333333333333333333333333333333333333333",
+      "bindingDigest": "4444444444444444444444444444444444444444444444444444444444444444"
+    }
+  ],
+  "evidenceDigest": "d3cb0dd4c8d3670eccd30792890d20231aa38cac17b4d6f316f12975c565da3d"
+}
diff --git a/plugins/looperators-agent-loop/tests/fixtures/schema/legacy-native-target-evidence-valid.json b/plugins/looperators-agent-loop/tests/fixtures/schema/legacy-native-target-evidence-valid.json
new file mode 100644
index 0000000..111e0f6
--- /dev/null
+++ b/plugins/looperators-agent-loop/tests/fixtures/schema/legacy-native-target-evidence-valid.json
@@ -0,0 +1,19 @@
+{
+  "schemaVersion": 1,
+  "evidenceVersion": 1,
+  "runId": "legacy-run",
+  "stateRevision": 1,
+  "historyDigest": "1111111111111111111111111111111111111111111111111111111111111111",
+  "entries": [
+    {
+      "factKind": "transition",
+      "factId": "transition-legacy",
+      "factDigest": "2222222222222222222222222222222222222222222222222222222222222222",
+      "field": "toNode",
+      "role": "implementer",
+      "bindingId": "binding_3333333333333333333333333333333333333333333333333333333333333333",
+      "bindingDigest": "4444444444444444444444444444444444444444444444444444444444444444"
+    }
+  ],
+  "evidenceDigest": "d3cb0dd4c8d3670eccd30792890d20231aa38cac17b4d6f316f12975c565da3d"
+}
diff --git a/plugins/looperators-agent-loop/tests/fixtures/schema/legacy-quarantine-invalid-adjacency.json b/plugins/looperators-agent-loop/tests/fixtures/schema/legacy-quarantine-invalid-adjacency.json
new file mode 100644
index 0000000..c7e4b3b
--- /dev/null
+++ b/plugins/looperators-agent-loop/tests/fixtures/schema/legacy-quarantine-invalid-adjacency.json
@@ -0,0 +1,18 @@
+{
+  "schemaVersion": 1,
+  "recoveryVersion": 1,
+  "recoveryId": "recovery_5fb0eab389aac38caf7f0c9a9ef2d00404a1c540a83e3a493a80a1e7e64d9033",
+  "runId": "legacy-run",
+  "requestId": "recover-1",
+  "requestDigest": "e83fc4b2cf275e27553459c66931301d38b0f254cbd7ff00cb2834f18e67bc50",
+  "actorKind": "root",
+  "actorId": "root-session",
+  "reason": "unsupported-native-target-history",
+  "evidenceDigest": "5555555555555555555555555555555555555555555555555555555555555555",
+  "legacyFactCount": 1,
+  "priorStateDigest": "6666666666666666666666666666666666666666666666666666666666666666",
+  "terminalStateDigest": "7777777777777777777777777777777777777777777777777777777777777777",
+  "fromRevision": 1,
+  "toRevision": 3,
+  "createdAt": "2026-07-26T12:00:00.000Z"
+}
diff --git a/plugins/looperators-agent-loop/tests/fixtures/schema/legacy-quarantine-invalid-count.json b/plugins/looperators-agent-loop/tests/fixtures/schema/legacy-quarantine-invalid-count.json
new file mode 100644
index 0000000..19c7121
--- /dev/null
+++ b/plugins/looperators-agent-loop/tests/fixtures/schema/legacy-quarantine-invalid-count.json
@@ -0,0 +1,18 @@
+{
+  "schemaVersion": 1,
+  "recoveryVersion": 1,
+  "recoveryId": "recovery_5fb0eab389aac38caf7f0c9a9ef2d00404a1c540a83e3a493a80a1e7e64d9033",
+  "runId": "legacy-run",
+  "requestId": "recover-1",
+  "requestDigest": "e83fc4b2cf275e27553459c66931301d38b0f254cbd7ff00cb2834f18e67bc50",
+  "actorKind": "root",
+  "actorId": "root-session",
+  "reason": "unsupported-native-target-history",
+  "evidenceDigest": "5555555555555555555555555555555555555555555555555555555555555555",
+  "legacyFactCount": 0,
+  "priorStateDigest": "6666666666666666666666666666666666666666666666666666666666666666",
+  "terminalStateDigest": "7777777777777777777777777777777777777777777777777777777777777777",
+  "fromRevision": 1,
+  "toRevision": 2,
+  "createdAt": "2026-07-26T12:00:00.000Z"
+}
diff --git a/plugins/looperators-agent-loop/tests/fixtures/schema/legacy-quarantine-valid.json b/plugins/looperators-agent-loop/tests/fixtures/schema/legacy-quarantine-valid.json
new file mode 100644
index 0000000..6b40cd1
--- /dev/null
+++ b/plugins/looperators-agent-loop/tests/fixtures/schema/legacy-quarantine-valid.json
@@ -0,0 +1,18 @@
+{
+  "schemaVersion": 1,
+  "recoveryVersion": 1,
+  "recoveryId": "recovery_5fb0eab389aac38caf7f0c9a9ef2d00404a1c540a83e3a493a80a1e7e64d9033",
+  "runId": "legacy-run",
+  "requestId": "recover-1",
+  "requestDigest": "e83fc4b2cf275e27553459c66931301d38b0f254cbd7ff00cb2834f18e67bc50",
+  "actorKind": "root",
+  "actorId": "root-session",
+  "reason": "unsupported-native-target-history",
+  "evidenceDigest": "5555555555555555555555555555555555555555555555555555555555555555",
+  "legacyFactCount": 1,
+  "priorStateDigest": "6666666666666666666666666666666666666666666666666666666666666666",
+  "terminalStateDigest": "7777777777777777777777777777777777777777777777777777777777777777",
+  "fromRevision": 1,
+  "toRevision": 2,
+  "createdAt": "2026-07-26T12:00:00.000Z"
+}
diff --git a/plugins/looperators-agent-loop/tests/fixtures/schema/operation-invalid-missing-report.json b/plugins/looperators-agent-loop/tests/fixtures/schema/operation-invalid-missing-report.json
new file mode 100644
index 0000000..cccd455
--- /dev/null
+++ b/plugins/looperators-agent-loop/tests/fixtures/schema/operation-invalid-missing-report.json
@@ -0,0 +1,14 @@
+{
+  "schemaVersion": 1,
+  "operationId": "op_dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd",
+  "runId": "run_bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+  "requestId": "request-report",
+  "requestDigest": "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+  "kind": "report",
+  "actorKind": "worker",
+  "actorId": "agent-reviewer",
+  "fromRevision": 1,
+  "toRevision": 2,
+  "transitionId": "transition-1",
+  "createdAt": "2026-07-26T00:00:00.000Z"
+}
diff --git a/plugins/looperators-agent-loop/tests/fixtures/schema/operation-valid-report.json b/plugins/looperators-agent-loop/tests/fixtures/schema/operation-valid-report.json
new file mode 100644
index 0000000..db6da61
--- /dev/null
+++ b/plugins/looperators-agent-loop/tests/fixtures/schema/operation-valid-report.json
@@ -0,0 +1,15 @@
+{
+  "schemaVersion": 1,
+  "operationId": "op_dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd",
+  "runId": "run_bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+  "requestId": "request-report",
+  "requestDigest": "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+  "kind": "report",
+  "actorKind": "worker",
+  "actorId": "agent-reviewer",
+  "fromRevision": 1,
+  "toRevision": 2,
+  "reportId": "report-1",
+  "transitionId": "transition-1",
+  "createdAt": "2026-07-26T00:00:00.000Z"
+}
diff --git a/plugins/looperators-agent-loop/tests/fixtures/schema/report-invalid-missing-revisions.json b/plugins/looperators-agent-loop/tests/fixtures/schema/report-invalid-missing-revisions.json
new file mode 100644
index 0000000..9f945c6
--- /dev/null
+++ b/plugins/looperators-agent-loop/tests/fixtures/schema/report-invalid-missing-revisions.json
@@ -0,0 +1,12 @@
+{
+  "schemaVersion": 1,
+  "reportId": "report-schema-invalid-revisions",
+  "runId": "run-p1b",
+  "requestId": "request-report",
+  "requestDigest": "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+  "fromNode": "agent-reviewer",
+  "receiver": "root-master",
+  "type": "verdict",
+  "verdict": "clean",
+  "createdAt": "2026-07-26T00:00:00.000Z"
+}
diff --git a/plugins/looperators-agent-loop/tests/fixtures/schema/report-invalid-missing-verdict.json b/plugins/looperators-agent-loop/tests/fixtures/schema/report-invalid-missing-verdict.json
new file mode 100644
index 0000000..8380531
--- /dev/null
+++ b/plugins/looperators-agent-loop/tests/fixtures/schema/report-invalid-missing-verdict.json
@@ -0,0 +1,9 @@
+{
+  "schemaVersion": 1,
+  "reportId": "report-schema-invalid",
+  "runId": "run-p1a",
+  "fromNode": "agent-reviewer",
+  "receiver": "root-master",
+  "type": "verdict",
+  "createdAt": "2026-07-26T00:00:00.000Z"
+}
diff --git a/plugins/looperators-agent-loop/tests/fixtures/schema/report-valid-product.json b/plugins/looperators-agent-loop/tests/fixtures/schema/report-valid-product.json
new file mode 100644
index 0000000..72d6dda
--- /dev/null
+++ b/plugins/looperators-agent-loop/tests/fixtures/schema/report-valid-product.json
@@ -0,0 +1,14 @@
+{
+  "schemaVersion": 1,
+  "reportId": "report-schema-valid-product",
+  "runId": "run-p1b",
+  "requestId": "request-report",
+  "requestDigest": "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+  "fromRevision": 1,
+  "toRevision": 2,
+  "fromNode": "agent-reviewer",
+  "receiver": "root-master",
+  "type": "verdict",
+  "verdict": "clean",
+  "createdAt": "2026-07-26T00:00:00.000Z"
+}
diff --git a/plugins/looperators-agent-loop/tests/fixtures/schema/report-valid.json b/plugins/looperators-agent-loop/tests/fixtures/schema/report-valid.json
new file mode 100644
index 0000000..7cc7cd1
--- /dev/null
+++ b/plugins/looperators-agent-loop/tests/fixtures/schema/report-valid.json
@@ -0,0 +1,10 @@
+{
+  "schemaVersion": 1,
+  "reportId": "report-schema-valid",
+  "runId": "run-p1a",
+  "fromNode": "agent-reviewer",
+  "receiver": "root-master",
+  "type": "verdict",
+  "verdict": "clean",
+  "createdAt": "2026-07-26T00:00:00.000Z"
+}
diff --git a/plugins/looperators-agent-loop/tests/fixtures/schema/run-invalid-consumed-over-granted.json b/plugins/looperators-agent-loop/tests/fixtures/schema/run-invalid-consumed-over-granted.json
new file mode 100644
index 0000000..c49f8a6
--- /dev/null
+++ b/plugins/looperators-agent-loop/tests/fixtures/schema/run-invalid-consumed-over-granted.json
@@ -0,0 +1,21 @@
+{
+  "schemaVersion": 1,
+  "runId": "run-p1a",
+  "rootSessionId": "session-root",
+  "originatingTurnId": "turn-root",
+  "scope": {
+    "kind": "task"
+  },
+  "masterNode": "session-root",
+  "recipe": "review-until-clean",
+  "status": "running",
+  "currentLap": 0,
+  "continuationLease": {
+    "granted": 1,
+    "consumed": 2
+  },
+  "cancelRequested": false,
+  "revision": 0,
+  "createdAt": "2026-07-26T00:00:00.000Z",
+  "updatedAt": "2026-07-26T00:00:00.000Z"
+}
diff --git a/plugins/looperators-agent-loop/tests/fixtures/schema/run-valid.json b/plugins/looperators-agent-loop/tests/fixtures/schema/run-valid.json
new file mode 100644
index 0000000..bd56206
--- /dev/null
+++ b/plugins/looperators-agent-loop/tests/fixtures/schema/run-valid.json
@@ -0,0 +1,21 @@
+{
+  "schemaVersion": 1,
+  "runId": "run-p1a",
+  "rootSessionId": "session-root",
+  "originatingTurnId": "turn-root",
+  "scope": {
+    "kind": "task"
+  },
+  "masterNode": "session-root",
+  "recipe": "review-until-clean",
+  "status": "running",
+  "currentLap": 0,
+  "continuationLease": {
+    "granted": 2,
+    "consumed": 1
+  },
+  "cancelRequested": false,
+  "revision": 0,
+  "createdAt": "2026-07-26T00:00:00.000Z",
+  "updatedAt": "2026-07-26T00:00:00.000Z"
+}
diff --git a/plugins/looperators-agent-loop/tests/fixtures/schema/worker-observation-invalid-duplicate.json b/plugins/looperators-agent-loop/tests/fixtures/schema/worker-observation-invalid-duplicate.json
new file mode 100644
index 0000000..941fe62
--- /dev/null
+++ b/plugins/looperators-agent-loop/tests/fixtures/schema/worker-observation-invalid-duplicate.json
@@ -0,0 +1,17 @@
+{
+  "schemaVersion": 1,
+  "observationId": "observation_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+  "runId": "run-p1b",
+  "requestId": "prepare-implementer",
+  "requestDigest": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+  "rootSessionId": "session-root",
+  "role": "implementer",
+  "spawnToolUseIds": [
+    "spawn-1",
+    "spawn-1"
+  ],
+  "subagentStartEventIds": [],
+  "bindingIds": [],
+  "observationDigest": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
+  "createdAt": "2026-07-26T00:00:00.000Z"
+}
diff --git a/plugins/looperators-agent-loop/tests/fixtures/schema/worker-observation-valid.json b/plugins/looperators-agent-loop/tests/fixtures/schema/worker-observation-valid.json
new file mode 100644
index 0000000..69e3757
--- /dev/null
+++ b/plugins/looperators-agent-loop/tests/fixtures/schema/worker-observation-valid.json
@@ -0,0 +1,14 @@
+{
+  "schemaVersion": 1,
+  "observationId": "observation_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+  "runId": "run-p1b",
+  "requestId": "prepare-implementer",
+  "requestDigest": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+  "rootSessionId": "session-root",
+  "role": "implementer",
+  "spawnToolUseIds": [],
+  "subagentStartEventIds": [],
+  "bindingIds": [],
+  "observationDigest": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
+  "createdAt": "2026-07-26T00:00:00.000Z"
+}
diff --git a/plugins/looperators-agent-loop/tests/helpers.mjs b/plugins/looperators-agent-loop/tests/helpers.mjs
new file mode 100644
index 0000000..13d1a26
--- /dev/null
+++ b/plugins/looperators-agent-loop/tests/helpers.mjs
@@ -0,0 +1,76 @@
+import { spawn } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveDataRoot } from "../lib/data-root.mjs";
+import { LoopStore } from "../lib/store.mjs";
+
+export const PLUGIN_ROOT = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "..",
+);
+
+export async function tempStore(t, options = {}) {
+  const root = await mkdtemp(
+    path.join(os.tmpdir(), "looperators-agent-loop-p1a-test-"),
+  );
+  t.after(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+  const rootInfo = await resolveDataRoot({
+    env: { LOOPERATORS_DATA_DIR: root },
+  });
+  return {
+    root,
+    rootInfo,
+    store: new LoopStore(rootInfo, options.retention),
+  };
+}
+
+export function loopState(overrides = {}) {
+  const timestamp = "2026-07-26T00:00:00.000Z";
+  return {
+    schemaVersion: 1,
+    runId: "run-p1a",
+    rootSessionId: "session-root",
+    originatingTurnId: "turn-root",
+    scope: { kind: "task" },
+    masterNode: "session-root",
+    recipe: "review-until-clean",
+    status: "running",
+    currentLap: 0,
+    continuationLease: { granted: 3, consumed: 0 },
+    cancelRequested: false,
+    revision: 0,
+    createdAt: timestamp,
+    updatedAt: timestamp,
+    ...overrides,
+  };
+}
+
+export async function spawnNode(args, options = {}) {
+  const child = spawn(process.execPath, args, {
+    cwd: options.cwd ?? PLUGIN_ROOT,
+    env: options.env ?? process.env,
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+  if (options.stdin !== undefined) {
+    child.stdin.end(options.stdin);
+  } else {
+    child.stdin.end();
+  }
+  const stdout = [];
+  const stderr = [];
+  child.stdout.on("data", (chunk) => stdout.push(chunk));
+  child.stderr.on("data", (chunk) => stderr.push(chunk));
+  const exitCode = await new Promise((resolve, reject) => {
+    child.on("error", reject);
+    child.on("close", resolve);
+  });
+  return {
+    exitCode,
+    stdout: Buffer.concat(stdout).toString("utf8"),
+    stderr: Buffer.concat(stderr).toString("utf8"),
+  };
+}
diff --git a/plugins/looperators-agent-loop/tests/plugin-graph-ui.test.mjs b/plugins/looperators-agent-loop/tests/plugin-graph-ui.test.mjs
new file mode 100644
index 0000000..2b0388e
--- /dev/null
+++ b/plugins/looperators-agent-loop/tests/plugin-graph-ui.test.mjs
@@ -0,0 +1,155 @@
+import assert from "node:assert/strict";
+import { readFile, stat } from "node:fs/promises";
+import test from "node:test";
+import { digestJson } from "../lib/canonical-json.mjs";
+import {
+  renderSidecarDocument,
+} from "../lib/graph-view.mjs";
+import {
+  projectionToAgentGraphModel,
+} from "../lib/projection-to-graph-model.mjs";
+
+const assets = new URL("../ui/assets/", import.meta.url);
+
+async function pairedScenarios() {
+  return JSON.parse(
+    await readFile(
+      new URL("paired-scenarios.json", assets),
+      "utf8",
+    ),
+  );
+}
+
+async function validProjection() {
+  const fixture = JSON.parse(
+    await readFile(
+      new URL(
+        "fixtures/schema/graph-projection-valid.json",
+        import.meta.url,
+      ),
+      "utf8",
+    ),
+  );
+  const { projectionDigest: _ignored, ...base } = fixture;
+  return {
+    ...base,
+    projectionDigest: digestJson(base),
+  };
+}
+
+test("plugin adapter maps every shared paired fixture exactly", async () => {
+  const scenarios = await pairedScenarios();
+  assert.equal(scenarios.length, 7);
+  for (const scenario of scenarios) {
+    assert.deepEqual(
+      projectionToAgentGraphModel(scenario.projection, {
+        expectedProjectionDigest:
+          scenario.projection.projectionDigest,
+        expectedRunId: scenario.projection.runId,
+      }),
+      scenario.expectedModel,
+      scenario.name,
+    );
+  }
+});
+
+test("plugin adapter rejects unverified, invalid, drifted, and cross-run input", async () => {
+  const [{ projection }] = await pairedScenarios();
+  assert.throws(
+    () =>
+      projectionToAgentGraphModel({
+        ...projection,
+        integrity: {
+          ...projection.integrity,
+          status: "unverified",
+        },
+      }),
+    { code: "GRAPH_VIEW_PROJECTION_UNVERIFIED" },
+  );
+  assert.throws(
+    () =>
+      projectionToAgentGraphModel({
+        ...projection,
+        edges: projection.edges.slice(1),
+      }),
+    { code: "GRAPH_VIEW_PROJECTION_INVALID" },
+  );
+  assert.throws(
+    () =>
+      projectionToAgentGraphModel(projection, {
+        expectedProjectionDigest: "0".repeat(64),
+      }),
+    { code: "PROJECTION_DIGEST_MISMATCH" },
+  );
+  assert.throws(
+    () =>
+      projectionToAgentGraphModel(projection, {
+        expectedRunId: "run-other",
+      }),
+    { code: "SNAPSHOT_IDENTITY_MISMATCH" },
+  );
+});
+
+test("plugin sidecar ships the bounded shared ReactFlow production UI", async () => {
+  const projection = await validProjection();
+  const sidecar = renderSidecarDocument(projection, {
+    eventsUrl: "/runs/run-projection-fixture/events",
+    controlUrl: "/runs/run-projection-fixture/control",
+    csrfToken: "c".repeat(43),
+  });
+  const [script, style] = await Promise.all([
+    readFile(new URL("agent-loop-ui.iife.js", assets), "utf8"),
+    readFile(new URL("agent-loop-ui.css", assets), "utf8"),
+  ]);
+  const [scriptStat, styleStat] = await Promise.all([
+    stat(new URL("agent-loop-ui.iife.js", assets)),
+    stat(new URL("agent-loop-ui.css", assets)),
+  ]);
+
+  assert.ok(
+    Buffer.byteLength(sidecar, "utf8") < 2 * 1024 * 1024,
+  );
+  assert.ok(
+    scriptStat.size + styleStat.size < 1.5 * 1024 * 1024,
+  );
+  assert.match(sidecar, /looperators-agent-loop-root/u);
+  assert.match(sidecar, /looperators-agent-loop-fallback/u);
+  assert.match(sidecar, /looperatorsAgentLoopView/u);
+  assert.match(sidecar, /Agent Loop relationship graph/u);
+  assert.match(sidecar, /react-flow__node/u);
+  assert.match(sidecar, /\bResizeObserver\b/u);
+  assert.match(sidecar, /\bcreateRoot\b/u);
+  assert.match(sidecar, /new EventSource/u);
+  assert.match(sidecar, /fetch\(/u);
+  assert.doesNotMatch(sidecar, /looperators-inline-agent-graph/u);
+  assert.doesNotMatch(
+    sidecar,
+    /(?:src|href)\s*=\s*["']https?:/iu,
+  );
+  assert.doesNotMatch(style, /(^|\})\s*(?::root|\*|body)\s*\{/u);
+  assert.doesNotMatch(sidecar, /host\.callTool\s*=/u);
+  assert.doesNotMatch(script, /\bprocess\.env\b/u);
+  assert.equal(
+    JSON.parse(
+      sidecar.match(
+        /id="looperators-agent-loop-data">([^<]+)<\/script>/u,
+      )[1],
+    ).expectedProjectionDigest,
+    projection.projectionDigest,
+  );
+  assert.match(script, /react-flow__renderer/u);
+});
+
+test("default review skill uses only cooperative typed MCP product tools", async () => {
+  const skill = await readFile(
+    new URL("../skills/review-until-clean/SKILL.md", import.meta.url),
+    "utf8",
+  );
+  assert.match(skill, /`roleCapability`/u);
+  assert.match(skill, /Default looperators has no Hooks/u);
+  assert.doesNotMatch(
+    skill,
+    /looperators_(?:prepare_worker_spawn|bind_worker|render_graph)/u,
+  );
+  assert.doesNotMatch(skill, /codex-inline-vis/u);
+});
diff --git a/plugins/looperators-agent-loop/tests/projection-and-view.test.mjs b/plugins/looperators-agent-loop/tests/projection-and-view.test.mjs
new file mode 100644
index 0000000..9ceaf82
--- /dev/null
+++ b/plugins/looperators-agent-loop/tests/projection-and-view.test.mjs
@@ -0,0 +1,751 @@
+import assert from "node:assert/strict";
+import http from "node:http";
+import test from "node:test";
+import {
+  canonicalJson,
+  digestJson,
+} from "../lib/canonical-json.mjs";
+import {
+  normalizeHookEvent,
+  validateGraphProjection,
+} from "../lib/contracts.mjs";
+import { LoopController } from "../lib/control.mjs";
+import { renderSidecarDocument } from "../lib/graph-view.mjs";
+import {
+  buildAgentLoopProjection,
+  canonicalProjectionBytes,
+} from "../lib/projection.mjs";
+import { startSidecar } from "../scripts/sidecar-server.mjs";
+import {
+  loopState,
+  tempStore,
+} from "./helpers.mjs";
+
+function definition(overrides = {}) {
+  return {
+    schemaVersion: 1,
+    definitionId: `definition_${"a".repeat(64)}`,
+    runId: "run-projection",
+    requestId: "projection-preview",
+    requestDigest: "b".repeat(64),
+    recipe: "review-until-clean",
+    goal: "Synthetic projection goal.",
+    implementerInstructions: "Implement.",
+    reviewerInstructions: "Review.",
+    lapCap: 3,
+    createdAt: "2026-07-26T00:00:00.000Z",
+    ...overrides,
+  };
+}
+
+function projectionState(overrides = {}) {
+  return {
+    schemaVersion: 1,
+    runId: "run-projection",
+    rootSessionId: "session-projection",
+    originatingTurnId: "turn-projection",
+    scope: { kind: "task" },
+    masterNode: "session-projection",
+    recipe: "review-until-clean",
+    status: "draft",
+    currentLap: 0,
+    continuationLease: { granted: 3, consumed: 0 },
+    cancelRequested: false,
+    revision: 0,
+    createdAt: "2026-07-26T00:00:00.000Z",
+    updatedAt: "2026-07-26T00:00:00.000Z",
+    ...overrides,
+  };
+}
+
+function hookEvent(overrides = {}) {
+  return normalizeHookEvent(
+    {
+      session_id: "session-projection",
+      turn_id: "turn-projection",
+      hook_event_name: "PreToolUse",
+      tool_use_id: "tool-projection",
+      tool_name: "collaborationspawn_agent",
+      tool_input: { task_name: "redacted" },
+      ...overrides,
+    },
+    {
+      observedAt:
+        overrides.observedAt ??
+        "2026-07-26T00:00:01.000Z",
+    },
+  );
+}
+
+function draftProjection(options = {}) {
+  return buildAgentLoopProjection({
+    state: projectionState(options.state),
+    definition: definition(options.definition),
+    bindings: options.bindings ?? [],
+    events: options.events ?? [],
+    reports: options.reports ?? [],
+    transitions: options.transitions ?? [],
+    operations: options.operations ?? [],
+    governorDecisions: options.governorDecisions ?? [],
+    recoveries: options.recoveries ?? [],
+    diagnostics: options.diagnostics ?? [],
+  });
+}
+
+function request({
+  port,
+  pathname,
+  method = "GET",
+  headers = {},
+}) {
+  return new Promise((resolve, reject) => {
+    const outgoing = http.request(
+      {
+        host: "127.0.0.1",
+        port,
+        path: pathname,
+        method,
+        headers,
+      },
+      (response) => {
+        const chunks = [];
+        response.on("data", (chunk) => chunks.push(chunk));
+        response.on("end", () => {
+          resolve({
+            status: response.statusCode,
+            headers: response.headers,
+            body: Buffer.concat(chunks).toString("utf8"),
+          });
+        });
+      },
+    );
+    outgoing.on("error", reject);
+    outgoing.end();
+  });
+}
+
+function openEventStream({ port, cookie, pathname, headers = {} }) {
+  return new Promise((resolve, reject) => {
+    const state = {
+      text: "",
+      waiters: new Set(),
+    };
+    const outgoing = http.request(
+      {
+        host: "127.0.0.1",
+        port,
+        path: pathname,
+        headers: {
+          Cookie: cookie,
+          Origin: `http://127.0.0.1:${port}`,
+          ...headers,
+        },
+      },
+      (response) => {
+        response.setEncoding("utf8");
+        response.on("data", (chunk) => {
+          state.text += chunk;
+          for (const waiter of [...state.waiters]) {
+            if (waiter.predicate(state.text)) {
+              state.waiters.delete(waiter);
+              clearTimeout(waiter.timer);
+              waiter.resolve(state.text);
+            }
+          }
+        });
+        resolve({
+          response,
+          outgoing,
+          text: () => state.text,
+          waitFor(predicate, timeoutMs = 2_000) {
+            if (predicate(state.text)) {
+              return Promise.resolve(state.text);
+            }
+            return new Promise((waitResolve, waitReject) => {
+              const waiter = {
+                predicate,
+                resolve: waitResolve,
+                timer: setTimeout(() => {
+                  state.waiters.delete(waiter);
+                  waitReject(
+                    new Error(
+                      `timed out waiting for SSE: ${state.text}`,
+                    ),
+                  );
+                }, timeoutMs),
+              };
+              state.waiters.add(waiter);
+            });
+          },
+          close() {
+            response.destroy();
+            outgoing.destroy();
+          },
+        });
+      },
+    );
+    outgoing.on("error", reject);
+    outgoing.end();
+  });
+}
+
+test("graph-projection-v3 is deterministic, bounded, and role-stable", () => {
+  const eventA = hookEvent();
+  const eventB = hookEvent({
+    tool_name: "collaboration.spawn_agent",
+  });
+  const left = draftProjection({
+    events: [eventA, eventB],
+  });
+  const right = draftProjection({
+    events: [eventB, eventA],
+  });
+  assert.equal(left.projectionVersion, 3);
+  assert.equal(left.integrity.status, "verified");
+  assert.deepEqual(
+    left.nodes.map((node) => node.id),
+    ["root", "role:implementer", "role:reviewer"],
+  );
+  assert.equal(left.edges.length, 4);
+  assert.equal(left.counts.events, 1);
+  assert.equal(left.counts.conflicts, 1);
+  assert.equal(left.eventWatermark.eventCount, 2);
+  assert.equal(
+    left.projectionDigest,
+    right.projectionDigest,
+  );
+  assert.equal(
+    canonicalProjectionBytes(left),
+    canonicalProjectionBytes(right),
+  );
+  assert.equal(
+    left.eventWatermark.lastEventId,
+    [eventA.eventId, eventB.eventId].sort().at(-1),
+  );
+  assert.notEqual(
+    left.projectionDigest,
+    draftProjection({ events: [eventA] })
+      .projectionDigest,
+  );
+  assert.deepEqual(validateGraphProjection(left), []);
+  assert.ok(
+    validateGraphProjection({
+      ...left,
+      nodes: [{ ...left.nodes[0], id: "agent-native" }],
+    }).length > 0,
+  );
+});
+
+test("graph-projection-v3 renders one bounded recovery receipt without native targets", () => {
+  const recoveryId = `recovery_${"d".repeat(64)}`;
+  const projection = draftProjection({
+    state: {
+      status: "failed",
+      revision: 1,
+      needsHuman: true,
+      latestRecoveryId: recoveryId,
+      updatedAt: "2026-07-26T00:00:02.000Z",
+    },
+    recoveries: [
+      {
+        recoveryId,
+        toRevision: 1,
+        createdAt: "2026-07-26T00:00:02.000Z",
+      },
+    ],
+  });
+  assert.equal(projection.counts.recoveries, 1);
+  assert.deepEqual(projection.recovery, {
+    recoveryId,
+    reason: "legacy-history-quarantined",
+  });
+  assert.equal(
+    projection.timeline.at(-1).kind,
+    "recovery",
+  );
+  assert.equal(
+    projection.nodes.every(
+      (node) => node.state === "terminal",
+    ),
+    true,
+  );
+  assert.deepEqual(validateGraphProjection(projection), []);
+});
+
+test("projection size stays O(roles) across long receipt histories", () => {
+  const bindings = [
+    {
+      method: "capability-token-v1",
+      rootSessionId: "session-projection",
+      role: "implementer",
+      agentId: "native-implementer",
+    },
+    {
+      method: "capability-token-v1",
+      rootSessionId: "session-projection",
+      role: "reviewer",
+      agentId: "native-reviewer",
+    },
+  ];
+  const operations = [];
+  const transitions = [];
+  const reports = [];
+  for (let revision = 0; revision < 100; revision += 1) {
+    const implementer = revision % 2 === 0;
+    const transitionId = `transition-${revision}`;
+    const reportId =
+      revision === 0 ? undefined : `report-${revision}`;
+    operations.push({
+      operationId: `operation-${revision}`,
+      transitionId,
+      ...(reportId ? { reportId } : {}),
+      toRevision: revision + 1,
+    });
+    transitions.push({
+      transitionId,
+      kind: implementer
+        ? "activate-implementer"
+        : "activate-reviewer",
+      lap: Math.floor(revision / 2),
+      createdAt: new Date(
+        Date.UTC(2026, 6, 26, 0, 0, revision),
+      ).toISOString(),
+    });
+    if (reportId) {
+      reports.push({
+        reportId,
+        fromNode: implementer
+          ? "native-reviewer"
+          : "native-implementer",
+        type: implementer ? "verdict" : "info",
+        ...(implementer
+          ? {
+              verdict: "issues",
+              issues: [{ message: "Synthetic issue." }],
+            }
+          : { status: "done" }),
+        createdAt: new Date(
+          Date.UTC(2026, 6, 26, 0, 0, revision),
+        ).toISOString(),
+      });
+    }
+  }
+  const projection = draftProjection({
+    state: {
+      status: "running",
+      revision: 100,
+      currentLap: 6,
+      pendingTransitionId: "transition-99",
+      latestReportId: "report-99",
+      updatedAt: "2026-07-26T00:01:40.000Z",
+    },
+    definition: { lapCap: 6 },
+    bindings,
+    operations,
+    transitions,
+    reports,
+  });
+  assert.equal(projection.nodes.length, 3);
+  assert.equal(projection.edges.length, 4);
+  assert.equal(projection.timeline.length, 32);
+  assert.equal(projection.counts.operations, 100);
+  assert.equal(projection.counts.reports, 99);
+  assert.ok(
+    Buffer.byteLength(
+      canonicalProjectionBytes(projection),
+      "utf8",
+    ) < 64 * 1024,
+  );
+});
+
+test("sidecar enforces one-time auth, exact loopback headers, and live canonical SSE", async (t) => {
+  const { store } = await tempStore(t);
+  await store.initializeRun(
+    loopState({
+      runId: "run-projection",
+      status: "draft",
+    }),
+  );
+  let current = draftProjection();
+  let busy = false;
+  const controller = {
+    async snapshotForRun() {
+      if (busy) {
+        const error = new Error("busy");
+        error.code = "SNAPSHOT_BUSY";
+        throw error;
+      }
+      return current;
+    },
+  };
+  const token = "t".repeat(32);
+  let sidecar;
+  try {
+    sidecar = await startSidecar({
+      runId: "run-projection",
+      host: "127.0.0.1",
+      port: 0,
+      token,
+      store,
+      controller,
+      heartbeatMs: 500,
+    });
+  } catch (error) {
+    if (error?.code === "EPERM") {
+      t.skip("sandbox does not permit a loopback listener");
+      return;
+    }
+    throw error;
+  }
+  t.after(() => sidecar.close());
+  assert.equal(sidecar.host, "127.0.0.1");
+  assert.match(
+    sidecar.loginUrl,
+    /^http:\/\/127\.0\.0\.1:\d+\/runs\/run-projection\?ticket=/u,
+  );
+
+  const unauthorized = await request({
+    port: sidecar.port,
+    pathname: `${sidecar.basePath}/snapshot`,
+  });
+  assert.equal(unauthorized.status, 401);
+  const badHost = await request({
+    port: sidecar.port,
+    pathname: "/",
+    headers: { Host: `localhost:${sidecar.port}` },
+  });
+  assert.equal(badHost.status, 421);
+  const login = await request({
+    port: sidecar.port,
+    pathname: `${sidecar.basePath}?ticket=${encodeURIComponent(token)}`,
+  });
+  assert.equal(login.status, 303);
+  assert.equal(login.headers.location, sidecar.basePath);
+  const cookie = login.headers["set-cookie"][0].split(";")[0];
+  assert.match(cookie, /^looperators_loop_[a-f0-9]{12}=/u);
+  assert.notEqual(cookie.split("=")[1], token);
+  assert.match(
+    login.headers["set-cookie"][0],
+    new RegExp(
+      `HttpOnly; SameSite=Strict; Path=${sidecar.basePath}`,
+      "u",
+    ),
+  );
+  const replay = await request({
+    port: sidecar.port,
+    pathname: `${sidecar.basePath}?ticket=${encodeURIComponent(token)}`,
+  });
+  assert.equal(replay.status, 401);
+
+  const snapshot = await request({
+    port: sidecar.port,
+    pathname: `${sidecar.basePath}/snapshot`,
+    headers: { Cookie: cookie },
+  });
+  assert.equal(snapshot.status, 200);
+  assert.equal(
+    snapshot.body,
+    `${canonicalProjectionBytes(current)}\n`,
+  );
+  assert.equal(
+    snapshot.headers["cache-control"],
+    "no-store",
+  );
+  assert.equal(
+    snapshot.headers["x-content-type-options"],
+    "nosniff",
+  );
+  const page = await request({
+    port: sidecar.port,
+    pathname: sidecar.basePath,
+    headers: { Cookie: cookie },
+  });
+  assert.equal(page.status, 200);
+  assert.match(page.body, /<!doctype html>/iu);
+  assert.match(page.body, /new EventSource/u);
+  assert.match(page.body, new RegExp(`${sidecar.basePath}/events`, "u"));
+  assert.match(page.body, /react-flow__node/u);
+  assert.match(
+    page.headers["content-security-policy"],
+    /frame-ancestors 'none'/u,
+  );
+  const mutation = await request({
+    port: sidecar.port,
+    pathname: `${sidecar.basePath}/control`,
+    method: "POST",
+    headers: { Cookie: cookie },
+  });
+  assert.equal(mutation.status, 503);
+  const absentMutationRoute = await request({
+    port: sidecar.port,
+    pathname: `${sidecar.basePath}/missing`,
+    headers: { Cookie: cookie },
+  });
+  assert.equal(absentMutationRoute.status, 404);
+  const badOrigin = await request({
+    port: sidecar.port,
+    pathname: `${sidecar.basePath}/events`,
+    headers: {
+      Cookie: cookie,
+      Origin: "http://attacker.invalid",
+    },
+  });
+  assert.equal(badOrigin.status, 403);
+
+  const stream = await openEventStream({
+    port: sidecar.port,
+    cookie,
+    pathname: `${sidecar.basePath}/events`,
+  });
+  t.after(() => stream.close());
+  await stream.waitFor((text) =>
+    text.includes(`id: ${current.projectionDigest}`),
+  );
+  assert.match(stream.text(), /event: snapshot/u);
+  const originalDigest = current.projectionDigest;
+  current = draftProjection({ events: [hookEvent()] });
+  await sidecar.refresh();
+  await stream.waitFor(
+    (text) =>
+      text.includes(`id: ${current.projectionDigest}`) &&
+      text.match(/event: snapshot/gu)?.length >= 2,
+  );
+  assert.notEqual(current.projectionDigest, originalDigest);
+  assert.equal(
+    canonicalJson(sidecar.projection()),
+    canonicalJson(current),
+  );
+  const beforeUnchanged = sidecar.stats().unchanged;
+  await sidecar.refresh();
+  assert.equal(
+    sidecar.stats().unchanged,
+    beforeUnchanged + 1,
+  );
+  busy = true;
+  const beforeBusy = sidecar.stats().busySkips;
+  await sidecar.refresh();
+  busy = false;
+  assert.equal(
+    sidecar.stats().busySkips,
+    beforeBusy + 1,
+  );
+
+  const extraStreams = [];
+  for (let index = 0; index < 7; index += 1) {
+    const extra = await openEventStream({
+      port: sidecar.port,
+      cookie,
+      pathname: `${sidecar.basePath}/events`,
+    });
+    extraStreams.push(extra);
+    await extra.waitFor((text) =>
+      text.includes("event: snapshot"),
+    );
+  }
+  const overCapacity = await request({
+    port: sidecar.port,
+    pathname: `${sidecar.basePath}/events`,
+    headers: {
+      Cookie: cookie,
+      Origin: `http://127.0.0.1:${sidecar.port}`,
+    },
+  });
+  assert.equal(overCapacity.status, 503);
+  for (const extra of extraStreams) {
+    extra.close();
+  }
+  for (
+    let attempt = 0;
+    attempt < 100 && sidecar.stats().clients !== 1;
+    attempt += 1
+  ) {
+    await new Promise((resolve) => setTimeout(resolve, 5));
+  }
+  assert.equal(sidecar.stats().clients, 1);
+
+  const resumed = await openEventStream({
+    port: sidecar.port,
+    cookie,
+    pathname: `${sidecar.basePath}/events`,
+    headers: {
+      "Last-Event-ID": current.projectionDigest,
+    },
+  });
+  t.after(() => resumed.close());
+  await resumed.waitFor((text) => text.includes(": current"));
+  assert.doesNotMatch(resumed.text(), /event: snapshot/u);
+  const closedPort = sidecar.port;
+  await sidecar.close();
+  await assert.rejects(
+    request({
+      port: closedPort,
+      pathname: sidecar.basePath,
+    }),
+    (error) =>
+      ["ECONNREFUSED", "ECONNRESET"].includes(error?.code),
+  );
+
+  const randomSidecar = await startSidecar({
+    runId: "run-projection",
+    host: "127.0.0.1",
+    port: 0,
+    store,
+    controller,
+  });
+  assert.ok(
+    Buffer.byteLength(
+      randomSidecar.loginToken,
+      "utf8",
+    ) >= 32,
+  );
+  assert.match(
+    randomSidecar.loginUrl,
+    new RegExp(
+      encodeURIComponent(randomSidecar.loginToken),
+      "u",
+    ),
+  );
+  await randomSidecar.close();
+});
+
+test("sidecar watches the real run directory and refreshes through authoritative replay", async (t) => {
+  const { store } = await tempStore(t);
+  const controller = new LoopController(store, {
+    now: (() => {
+      let second = 0;
+      return () => {
+        const value = new Date(
+          Date.UTC(2026, 6, 26, 23, 30, second),
+        ).toISOString();
+        second += 1;
+        return value;
+      };
+    })(),
+  });
+  const context = {
+    rootSessionId: "sidecar-real-root",
+    turnId: "sidecar-real-turn",
+    threadSource: "user",
+  };
+  const preview = await controller.preview(context, {
+    requestId: "sidecar-real-preview",
+    goal: "Verify the real sidecar watcher.",
+    implementerInstructions: "Return done.",
+    reviewerInstructions: "Return a verdict.",
+    lapCap: 2,
+  });
+  const startContext = {
+    ...context,
+    turnId: "sidecar-real-confirmed-turn",
+  };
+  await controller.start(startContext, {
+    runId: preview.runId,
+    requestId: "sidecar-real-start",
+  });
+  let sidecar;
+  try {
+    sidecar = await startSidecar({
+      runId: preview.runId,
+      host: "127.0.0.1",
+      port: 0,
+      token: "w".repeat(32),
+      store,
+      controller,
+      heartbeatMs: 500,
+    });
+  } catch (error) {
+    if (error?.code === "EPERM") {
+      t.skip("sandbox does not permit a loopback listener");
+      return;
+    }
+    throw error;
+  }
+  t.after(() => sidecar.close());
+  const login = await request({
+    port: sidecar.port,
+    pathname:
+      `${sidecar.basePath}?ticket=${"w".repeat(32)}`,
+  });
+  const cookie = login.headers["set-cookie"][0].split(";")[0];
+  const stream = await openEventStream({
+    port: sidecar.port,
+    cookie,
+    pathname: `${sidecar.basePath}/events`,
+  });
+  t.after(() => stream.close());
+  const initialDigest = sidecar.projection().projectionDigest;
+  await stream.waitFor((text) =>
+    text.includes(`id: ${initialDigest}`),
+  );
+  const observed = normalizeHookEvent(
+    {
+      session_id: context.rootSessionId,
+      turn_id: context.turnId,
+      hook_event_name: "PreToolUse",
+      tool_use_id: "sidecar-real-tool",
+      tool_name: "functions.exec",
+      tool_input: { command: "redacted" },
+    },
+    {
+      observedAt: "2026-07-26T23:31:00.000Z",
+    },
+  );
+  await store.putEvent(preview.runId, observed);
+  await stream.waitFor(
+    (text) =>
+      text.match(/event: snapshot/gu)?.length >= 2,
+    3_000,
+  );
+  const refreshed = sidecar.projection();
+  assert.notEqual(
+    refreshed.projectionDigest,
+    initialDigest,
+  );
+  const eventIds = (
+    await store.listEvents(preview.runId)
+  ).facts.map((event) => event.eventId);
+  assert.equal(refreshed.eventWatermark.eventCount, 1);
+  assert.equal(
+    refreshed.eventWatermark.lastEventId,
+    eventIds.sort().at(-1),
+  );
+  assert.equal(
+    refreshed.projectionDigest,
+    (
+      await controller.snapshotForRun(preview.runId)
+    ).projectionDigest,
+  );
+  await sidecar.close();
+});
+
+test("sidecar and view reject unsafe configuration without binding", async () => {
+  await assert.rejects(
+    startSidecar({
+      runId: "run-projection",
+      host: "0.0.0.0",
+      port: 0,
+    }),
+    { code: "SIDECAR_HOST_REJECTED" },
+  );
+  await assert.rejects(
+    startSidecar({
+      runId: "run-projection",
+      host: "127.0.0.1",
+      port: 0,
+      token: "short",
+    }),
+    { code: "SIDECAR_TOKEN_REJECTED" },
+  );
+  const projection = draftProjection();
+  const sidecar = renderSidecarDocument(projection, {
+    eventsUrl: "/runs/run-projection/events",
+  });
+  assert.match(sidecar, /new EventSource/u);
+  assert.match(sidecar, /\/runs\/run-projection\/events/u);
+  assert.equal(
+    digestJson(
+      JSON.parse(canonicalProjectionBytes(projection)),
+    ),
+    digestJson(projection),
+  );
+});
diff --git a/plugins/looperators-agent-loop/tests/store.test.mjs b/plugins/looperators-agent-loop/tests/store.test.mjs
new file mode 100644
index 0000000..0c092fa
--- /dev/null
+++ b/plugins/looperators-agent-loop/tests/store.test.mjs
@@ -0,0 +1,1233 @@
+import assert from "node:assert/strict";
+import {
+  access,
+  mkdtemp,
+  mkdir,
+  open,
+  readFile,
+  readdir,
+  rm,
+  symlink,
+  unlink,
+  writeFile,
+} from "node:fs/promises";
+import path from "node:path";
+import test from "node:test";
+import {
+  canonicalJson,
+  sha256,
+} from "../lib/canonical-json.mjs";
+import { normalizeHookEvent } from "../lib/contracts.mjs";
+import { withFileLock } from "../lib/fs-utils.mjs";
+import { LoopStore } from "../lib/store.mjs";
+import {
+  createLegacyQuarantineReceipt,
+  terminalStateForRecovery,
+} from "../lib/recovery.mjs";
+import {
+  PLUGIN_ROOT,
+  loopState,
+  spawnNode,
+  tempStore,
+} from "./helpers.mjs";
+
+function eventInput(overrides = {}) {
+  return {
+    session_id: "session-root",
+    turn_id: "turn-root",
+    hook_event_name: "PreToolUse",
+    tool_use_id: "call-1",
+    tool_name: "Bash",
+    tool_input: { command: "redacted" },
+    ...overrides,
+  };
+}
+
+function event(overrides = {}, observedAt = "2026-07-26T00:00:01.000Z") {
+  return normalizeHookEvent(eventInput(overrides), { observedAt });
+}
+
+function governorDecision(overrides = {}) {
+  const runId = overrides.runId ?? "run-p1a";
+  const obligationId =
+    overrides.obligationId ?? "transition-pending";
+  const action = overrides.action ?? "block";
+  const kind =
+    action === "block"
+      ? "continuation-block"
+      : action === "cap"
+        ? "continuation-cap"
+        : "resume-interrupt";
+  const identity =
+    action === "interrupt"
+      ? {
+          runId,
+          sessionStartEventId:
+            overrides.originEventId ??
+            `evt_${"b".repeat(64)}`,
+          stateRevision: overrides.fromRevision ?? 0,
+          kind,
+        }
+      : { runId, obligationId, kind };
+  return {
+    schemaVersion: 1,
+    decisionId: `decision_${sha256(
+      canonicalJson(identity),
+    )}`,
+    runId,
+    obligationId,
+    originEventId:
+      overrides.originEventId ?? `evt_${"b".repeat(64)}`,
+    hookEvent: "Stop",
+    rootSessionId: "session-root",
+    turnId: "turn-root",
+    action,
+    reasonCode:
+      action === "block"
+        ? "pending-root-transition"
+        : action === "cap"
+          ? "lease-exhausted"
+          : "resume-in-flight",
+    pendingTransitionId: obligationId,
+    fromRevision: 0,
+    toRevision: 1,
+    ...(action === "block" ? { leaseEpoch: 1 } : {}),
+    createdAt: "2026-07-26T00:00:02.000Z",
+    ...overrides,
+  };
+}
+
+function legacyRecovery(state, overrides = {}) {
+  return createLegacyQuarantineReceipt({
+    state,
+    requestId: overrides.requestId ?? "recover-store-1",
+    actorId: state.rootSessionId,
+    evidence: {
+      evidenceDigest:
+        overrides.evidenceDigest ?? "a".repeat(64),
+      entries: [
+        {
+          factKind: "transition",
+          factId: "synthetic-transition",
+        },
+      ],
+    },
+    createdAt:
+      overrides.createdAt ??
+      "2026-07-26T00:00:02.000Z",
+  });
+}
+
+test("duplicate events are idempotent and semantic conflicts are diagnosed deterministically", async (t) => {
+  const { root, store } = await tempStore(t);
+  await store.initializeRun(loopState());
+  const first = event();
+  const duplicate = event({}, "2026-07-26T00:10:00.000Z");
+  const conflict = event({ tool_name: "functions.exec" });
+  assert.equal((await store.putEvent("run-p1a", first)).status, "created");
+  assert.equal(
+    (await store.putEvent("run-p1a", duplicate)).status,
+    "duplicate",
+  );
+  assert.equal((await store.putEvent("run-p1a", conflict)).status, "created");
+  const projections = [];
+  for (let index = 0; index < 3; index += 1) {
+    projections.push(await store.foldRun("run-p1a"));
+  }
+  assert.equal(
+    new Set(projections.map((item) => item.projectionDigest)).size,
+    1,
+  );
+  assert.equal(projections[0].counts.events, 1);
+  assert.equal(projections[0].counts.eventCandidates, 2);
+  assert.equal(projections[0].counts.conflicts, 1);
+  assert.equal(projections[0].counts.diagnostics, 1);
+  const projectionText = await readFile(
+    path.join(root, "runs", "run-p1a", "projection.json"),
+    "utf8",
+  );
+  assert.match(projectionText, new RegExp(projections[0].projectionDigest));
+});
+
+test("independent concurrent writers converge on one immutable event", async (t) => {
+  const { root, store } = await tempStore(t);
+  await store.initializeRun(loopState());
+  const value = event();
+  const encoded = Buffer.from(JSON.stringify(value)).toString("base64url");
+  const worker = path.join(
+    PLUGIN_ROOT,
+    "tests",
+    "fixtures",
+    "put-event-worker.mjs",
+  );
+  const results = await Promise.all(
+    Array.from({ length: 24 }, () =>
+      spawnNode([worker, "run-p1a", encoded], {
+        env: {
+          ...process.env,
+          LOOPERATORS_DATA_DIR: root,
+        },
+      }),
+    ),
+  );
+  assert.ok(
+    results.every((result) => result.exitCode === 0),
+    JSON.stringify(results),
+  );
+  const statuses = results.map(
+    (result) => JSON.parse(result.stdout.trim()).status,
+  );
+  assert.equal(
+    statuses.filter((status) => status === "created").length,
+    1,
+  );
+  assert.equal(
+    statuses.filter((status) => status === "duplicate").length,
+    23,
+  );
+  const projection = await store.foldRun("run-p1a");
+  assert.equal(projection.counts.events, 1);
+  assert.equal(projection.counts.eventCandidates, 1);
+});
+
+test("governor decisions are immutable, location-bound, and projected", async (t) => {
+  const { root, store } = await tempStore(t);
+  await store.initializeRun(loopState());
+  const decision = governorDecision();
+  assert.equal(
+    (await store.putGovernorDecision("run-p1a", decision))
+      .status,
+    "created",
+  );
+  assert.equal(
+    (await store.putGovernorDecision("run-p1a", decision))
+      .status,
+    "duplicate",
+  );
+  assert.equal(
+    (
+      await store.putGovernorDecision("run-p1a", {
+        ...decision,
+        originEventId: `evt_${"c".repeat(64)}`,
+      })
+    ).status,
+    "conflict",
+  );
+  assert.deepEqual(
+    await store.readGovernorDecision(
+      "run-p1a",
+      decision.decisionId,
+    ),
+    decision,
+  );
+  const projection = await store.foldRun("run-p1a");
+  assert.equal(projection.counts.governorDecisions, 1);
+  assert.ok(
+    projection.timeline.some(
+      (item) =>
+        item.kind === "governor-decision" &&
+        item.id === decision.decisionId,
+    ),
+  );
+
+  const file = path.join(
+    root,
+    "runs",
+    "run-p1a",
+    "governor-decisions",
+    `${decision.decisionId}.json`,
+  );
+  await writeFile(
+    file,
+    `${JSON.stringify({
+      ...decision,
+      obligationId: "transition-forged",
+      pendingTransitionId: "transition-forged",
+    })}\n`,
+  );
+  await assert.rejects(
+    store.readGovernorDecision(
+      "run-p1a",
+      decision.decisionId,
+    ),
+    { code: "INVALID_CONTRACT" },
+  );
+  const listed = await store.listGovernorDecisions(
+    "run-p1a",
+  );
+  assert.equal(listed.facts.length, 0);
+  assert.equal(listed.corrupt.length, 1);
+});
+
+test("fold ignores temp residues and rebuilds corrupt state without losing facts", async (t) => {
+  const { root, store } = await tempStore(t);
+  await store.initializeRun(loopState());
+  await store.putEvent("run-p1a", event());
+  const runDirectory = path.join(root, "runs", "run-p1a");
+  const indexDirectory = path.join(runDirectory, "indexes", "events");
+  await mkdir(indexDirectory, { recursive: true });
+  await writeFile(
+    path.join(runDirectory, "events", ".partial.tmp-crash"),
+    "{\"partial\":",
+  );
+  await writeFile(path.join(runDirectory, "events", "bad.json"), "{\"bad\":");
+  const danglingIndex = path.join(indexDirectory, "dangling.json");
+  await writeFile(
+    danglingIndex,
+    `${JSON.stringify({
+      schemaVersion: 1,
+      canonicalEventId: "evt_missing",
+    })}\n`,
+  );
+  await writeFile(path.join(runDirectory, "state.json"), "{\"revision\":");
+  const projection = await store.foldRun("run-p1a");
+  assert.equal(projection.status, "interrupted");
+  assert.equal(projection.needsHuman, true);
+  assert.equal(projection.counts.events, 1);
+  assert.equal(projection.counts.corrupt, 1);
+  assert.ok(projection.counts.diagnostics >= 2);
+  await assert.rejects(access(danglingIndex), { code: "ENOENT" });
+  const rebuilt = await store.readState("run-p1a");
+  assert.equal(rebuilt.status, "interrupted");
+});
+
+test("state location is part of the validated run identity", async (t) => {
+  const { root, store } = await tempStore(t);
+  await store.initializeRun(loopState());
+  await writeFile(
+    path.join(root, "runs", "run-p1a", "state.json"),
+    `${JSON.stringify(loopState({ runId: "run-other" }))}\n`,
+  );
+  await assert.rejects(store.readState("run-p1a"), {
+    code: "INVALID_CONTRACT",
+  });
+  const rebuilt = await store.foldRun("run-p1a");
+  assert.equal(rebuilt.runId, "run-p1a");
+  assert.equal(rebuilt.status, "interrupted");
+});
+
+test("session initialization publishes binding first and allows only one active run", async (t) => {
+  const { root, store } = await tempStore(t);
+  const first = loopState({
+    runId: "run-session-first",
+  });
+  const second = loopState({
+    runId: "run-session-second",
+  });
+  const initialized = await Promise.allSettled([
+    store.initializeRun(first),
+    store.initializeRun(second),
+  ]);
+  assert.equal(
+    initialized.filter((result) => result.status === "fulfilled").length,
+    1,
+  );
+  const rejected = initialized.find(
+    (result) => result.status === "rejected",
+  );
+  assert.equal(rejected.reason.code, "SESSION_BINDING_CONFLICT");
+  const active = await store.activeRunForSession("session-root");
+  assert.ok(
+    ["run-session-first", "run-session-second"].includes(active),
+  );
+
+  const retryState = loopState({
+    runId: "run-binding-first-retry",
+    rootSessionId: "session-retry",
+    masterNode: "session-retry",
+  });
+  const bindingDirectory = path.join(
+    root,
+    "session-bindings",
+    sha256(retryState.rootSessionId),
+  );
+  await mkdir(bindingDirectory, { recursive: true });
+  const binding = {
+    schemaVersion: 1,
+    bindingId: `session_${sha256(
+      canonicalJson({
+        runId: retryState.runId,
+        rootSessionId: retryState.rootSessionId,
+      }),
+    )}`,
+    runId: retryState.runId,
+    rootSessionId: retryState.rootSessionId,
+    createdAt: retryState.createdAt,
+  };
+  await writeFile(
+    path.join(bindingDirectory, `${retryState.runId}.json`),
+    `${JSON.stringify(binding)}\n`,
+  );
+  await store.initializeRun(retryState);
+  assert.equal(
+    await store.activeRunForSession(retryState.rootSessionId),
+    retryState.runId,
+  );
+});
+
+test("cross-task run-id collisions do not publish a poisoned session binding", async (t) => {
+  const { store } = await tempStore(t);
+  const first = loopState({
+    runId: "run-shared-id",
+    rootSessionId: "session-a",
+    masterNode: "session-a",
+  });
+  await store.initializeRun(first);
+  const collision = loopState({
+    runId: "run-shared-id",
+    rootSessionId: "session-b",
+    masterNode: "session-b",
+  });
+  await assert.rejects(store.initializeRun(collision), {
+    code: "RUN_ID_CONFLICT",
+  });
+  await assert.rejects(
+    access(
+      store.sessionBindingPath(
+        collision.runId,
+        collision.rootSessionId,
+      ),
+    ),
+    { code: "ENOENT" },
+  );
+  const fresh = loopState({
+    runId: "run-session-b-fresh",
+    rootSessionId: "session-b",
+    masterNode: "session-b",
+  });
+  await store.initializeRun(fresh);
+  assert.equal(
+    await store.activeRunForSession("session-a"),
+    first.runId,
+  );
+  assert.equal(
+    await store.activeRunForSession("session-b"),
+    fresh.runId,
+  );
+});
+
+test("store writes reject symlinked run directories", async (t) => {
+  const { root, store } = await tempStore(t);
+  const victim = await mkdtemp(
+    path.join(path.dirname(root), "looperators-p1a-victim-"),
+  );
+  t.after(() => rm(victim, { recursive: true, force: true }));
+  await mkdir(path.join(root, "runs"), { recursive: true });
+  await symlink(victim, path.join(root, "runs", "run-p1a"), "dir");
+  await assert.rejects(store.initializeRun(loopState()), {
+    code: "UNSAFE_STORE_FILE",
+  });
+  await assert.rejects(access(path.join(victim, "state.json")), {
+    code: "ENOENT",
+  });
+});
+
+test("store rejects a contract-valid report above its UTF-8 read limit", async (t) => {
+  const { root, store } = await tempStore(t);
+  await store.initializeRun(loopState());
+  const report = {
+    schemaVersion: 1,
+    reportId: "report-too-large",
+    runId: "run-p1a",
+    fromNode: "agent-reviewer",
+    receiver: "root-master",
+    type: "verdict",
+    verdict: "issues",
+    issues: Array.from({ length: 200 }, () => ({
+      message: "界".repeat(4_000),
+      file: "路".repeat(2_000),
+    })),
+    createdAt: "2026-07-26T00:00:01.000Z",
+  };
+  await assert.rejects(store.putReport("run-p1a", report), {
+    code: "STORE_FILE_TOO_LARGE",
+  });
+  let reportFiles = [];
+  try {
+    reportFiles = await readdir(
+      path.join(root, "runs", "run-p1a", "reports"),
+    );
+  } catch (error) {
+    assert.equal(error.code, "ENOENT");
+  }
+  assert.deepEqual(reportFiles, []);
+  const projection = await store.foldRun("run-p1a");
+  assert.equal(projection.counts.reports, 0);
+  assert.equal(projection.counts.corrupt, 0);
+});
+
+test("state compare-and-swap rejects stale revisions and lock timeouts", async (t) => {
+  const { root, store } = await tempStore(t);
+  const state = loopState();
+  await store.initializeRun(state);
+  const updated = await store.compareAndSwapState("run-p1a", 0, {
+    ...state,
+    revision: 1,
+    currentLap: 1,
+    updatedAt: "2026-07-26T00:01:00.000Z",
+  });
+  assert.equal(updated.revision, 1);
+  await assert.rejects(
+    store.compareAndSwapState("run-p1a", 0, {
+      ...updated,
+      revision: 1,
+    }),
+    { code: "REVISION_CONFLICT" },
+  );
+  await assert.rejects(
+    store.compareAndSwapState("run-p1a", 1, {
+      ...updated,
+      rootSessionId: "session-other",
+      revision: 2,
+      updatedAt: "2026-07-26T00:01:30.000Z",
+    }),
+    { code: "INVALID_STATE_TRANSITION" },
+  );
+  await assert.rejects(
+    store.compareAndSwapState("run-p1a", 1, {
+      ...updated,
+      continuationLease: { granted: 4, consumed: 0 },
+      revision: 2,
+      updatedAt: "2026-07-26T00:01:30.000Z",
+    }),
+    { code: "INVALID_STATE_TRANSITION" },
+  );
+  const lockPath = path.join(
+    root,
+    "runs",
+    "run-p1a",
+    "locks",
+    "state.lock",
+  );
+  const handle = await open(lockPath, "wx", 0o600);
+  await handle.writeFile(
+    `${JSON.stringify({
+      schemaVersion: 1,
+      token: "held-lock",
+      acquiredAt: new Date().toISOString(),
+    })}\n`,
+  );
+  await handle.close();
+  await assert.rejects(
+    store.compareAndSwapState(
+      "run-p1a",
+      1,
+      {
+        ...updated,
+        revision: 2,
+        updatedAt: "2026-07-26T00:02:00.000Z",
+      },
+      { timeoutMs: 20, staleMs: 60_000, retryMs: 2 },
+    ),
+    { code: "STORE_LOCK_TIMEOUT" },
+  );
+});
+
+test("file locks preserve callback failures and remain reusable after cleanup", async (t) => {
+  const { root } = await tempStore(t);
+  const lockPath = path.join(root, "locks", "callback.lock");
+  const callbackError = new Error("callback failed");
+  await assert.rejects(
+    withFileLock(lockPath, async () => {
+      throw callbackError;
+    }),
+    (error) => error === callbackError,
+  );
+  await assert.rejects(access(lockPath), { code: "ENOENT" });
+  assert.equal(
+    await withFileLock(lockPath, async () => "reacquired"),
+    "reacquired",
+  );
+});
+
+test("stale lock recovery never steals a lock from a live owner", async (t) => {
+  const { root } = await tempStore(t);
+  const lockPath = path.join(root, "locks", "owner.lock");
+  await mkdir(path.dirname(lockPath), { recursive: true });
+  await writeFile(
+    lockPath,
+    `${JSON.stringify({
+      schemaVersion: 1,
+      token: "live-owner",
+      pid: process.pid,
+      acquiredAt: "2026-07-26T00:00:00.000Z",
+    })}\n`,
+  );
+  await assert.rejects(
+    withFileLock(lockPath, async () => "stolen", {
+      staleMs: 0,
+      timeoutMs: 20,
+      retryMs: 2,
+    }),
+    { code: "STORE_LOCK_TIMEOUT" },
+  );
+  await unlink(lockPath);
+  await writeFile(
+    lockPath,
+    `${JSON.stringify({
+      schemaVersion: 1,
+      token: "dead-owner",
+      pid: 2_147_483_647,
+      acquiredAt: "2026-07-26T00:00:00.000Z",
+    })}\n`,
+  );
+  assert.equal(
+    await withFileLock(lockPath, async () => "recovered", {
+      staleMs: 0,
+      timeoutMs: 100,
+      retryMs: 2,
+    }),
+    "recovered",
+  );
+});
+
+test("concurrent stale-lock reclaimers preserve mutual exclusion", async (t) => {
+  const { root } = await tempStore(t);
+  const lockPath = path.join(root, "locks", "contended-stale.lock");
+  await mkdir(path.dirname(lockPath), { recursive: true });
+  await writeFile(
+    lockPath,
+    `${JSON.stringify({
+      schemaVersion: 1,
+      token: "dead-owner",
+      pid: 2_147_483_647,
+      acquiredAt: "2026-07-26T00:00:00.000Z",
+    })}\n`,
+  );
+  await new Promise((resolve) => setTimeout(resolve, 2));
+  let inside = 0;
+  let maximumInside = 0;
+  const results = await Promise.all(
+    Array.from({ length: 16 }, (_, index) =>
+      withFileLock(
+        lockPath,
+        async () => {
+          inside += 1;
+          maximumInside = Math.max(maximumInside, inside);
+          await new Promise((resolve) => setTimeout(resolve, 3));
+          inside -= 1;
+          return index;
+        },
+        {
+          root,
+          staleMs: 0,
+          timeoutMs: 2_000,
+          retryMs: 1,
+        },
+      ),
+    ),
+  );
+  assert.equal(new Set(results).size, 16);
+  assert.equal(maximumInside, 1);
+});
+
+test("stale lock recovery reclaims an abandoned guard but preserves a live guard", async (t) => {
+  const { root } = await tempStore(t);
+  const lockPath = path.join(root, "locks", "guarded-stale.lock");
+  const guardPath = `${lockPath}.reclaim`;
+  await mkdir(path.dirname(lockPath), { recursive: true });
+  const lock = {
+    schemaVersion: 1,
+    token: "dead-lock-owner",
+    pid: 2_147_483_647,
+    acquiredAt: "2026-07-26T00:00:00.000Z",
+  };
+  await writeFile(lockPath, `${JSON.stringify(lock)}\n`);
+  await writeFile(
+    guardPath,
+    `${JSON.stringify({
+      schemaVersion: 1,
+      token: "dead-reclaimer",
+      pid: 2_147_483_647,
+      acquiredAt: "2026-07-26T00:00:00.000Z",
+    })}\n`,
+  );
+  await new Promise((resolve) => setTimeout(resolve, 2));
+  assert.equal(
+    await withFileLock(lockPath, async () => "guard-recovered", {
+      root,
+      staleMs: 0,
+      timeoutMs: 500,
+      retryMs: 1,
+    }),
+    "guard-recovered",
+  );
+  await assert.rejects(access(guardPath), { code: "ENOENT" });
+
+  await writeFile(lockPath, `${JSON.stringify(lock)}\n`);
+  await writeFile(
+    guardPath,
+    `${JSON.stringify({
+      schemaVersion: 1,
+      token: "live-reclaimer",
+      pid: process.pid,
+      acquiredAt: "2026-07-26T00:00:00.000Z",
+    })}\n`,
+  );
+  await new Promise((resolve) => setTimeout(resolve, 2));
+  await assert.rejects(
+    withFileLock(lockPath, async () => "guard-stolen", {
+      root,
+      staleMs: 0,
+      timeoutMs: 20,
+      retryMs: 1,
+    }),
+    { code: "STORE_LOCK_TIMEOUT" },
+  );
+});
+
+test("independent processes recover an abandoned guard without overlapping", async (t) => {
+  const { root } = await tempStore(t);
+  const lockPath = path.join(root, "locks", "process-stale.lock");
+  const guardPath = `${lockPath}.reclaim`;
+  await mkdir(path.dirname(lockPath), { recursive: true });
+  for (const [target, token] of [
+    [lockPath, "dead-lock-owner"],
+    [guardPath, "dead-reclaimer"],
+  ]) {
+    await writeFile(
+      target,
+      `${JSON.stringify({
+        schemaVersion: 1,
+        token,
+        pid: 2_147_483_647,
+        acquiredAt: "2026-07-26T00:00:00.000Z",
+      })}\n`,
+    );
+  }
+  await new Promise((resolve) => setTimeout(resolve, 2));
+  const worker = path.join(
+    PLUGIN_ROOT,
+    "tests",
+    "fixtures",
+    "lock-worker.mjs",
+  );
+  const results = await Promise.all(
+    Array.from({ length: 12 }, () =>
+      spawnNode([worker, root, lockPath]),
+    ),
+  );
+  assert.ok(
+    results.every((result) => result.exitCode === 0),
+    JSON.stringify(results),
+  );
+  assert.ok(
+    results.every(
+      (result) => JSON.parse(result.stdout).overlap === false,
+    ),
+    JSON.stringify(results),
+  );
+  await assert.rejects(access(guardPath), { code: "ENOENT" });
+});
+
+test("diagnostics obey the active hard cap without mutating control state", async (t) => {
+  const { root, store } = await tempStore(t, {
+    retention: {
+      diagnostics: 1,
+      activeMultiplier: 2,
+    },
+  });
+  await store.initializeRun(loopState());
+  const results = [];
+  for (let index = 0; index < 5; index += 1) {
+    results.push(
+      await store.writeDiagnostic(
+        "run-p1a",
+        "synthetic",
+        { index },
+      ),
+    );
+  }
+  const files = await readdir(
+    path.join(root, "runs", "run-p1a", "diagnostics"),
+  );
+  assert.equal(files.filter((name) => name.endsWith(".json")).length, 2);
+  assert.equal(results.at(-1).status, "limit");
+  const state = await store.readState("run-p1a");
+  assert.equal(state.status, "running");
+  assert.equal(state.revision, 0);
+  assert.equal(state.needsHuman, undefined);
+  const projection = await store.foldRun("run-p1a");
+  assert.equal(projection.counts.diagnostics, 2);
+});
+
+test("active hard limits report capacity without creating an unreceipted revision", async (t) => {
+  const { store } = await tempStore(t, {
+    retention: {
+      events: 2,
+      reports: 2,
+      transitions: 2,
+      diagnostics: 4,
+      activeMultiplier: 2,
+      terminalBytes: 1_000_000,
+    },
+  });
+  const state = loopState();
+  await store.initializeRun(state);
+  for (let index = 0; index < 4; index += 1) {
+    const result = await store.putEvent(
+      "run-p1a",
+      event(
+        {
+          turn_id: `turn-${index}`,
+          tool_use_id: `call-${index}`,
+        },
+        `2026-07-26T00:00:0${index}.000Z`,
+      ),
+    );
+    assert.equal(result.status, "created");
+  }
+  const limited = await store.putEvent(
+    "run-p1a",
+    event(
+      { turn_id: "turn-5", tool_use_id: "call-5" },
+      "2026-07-26T00:00:05.000Z",
+    ),
+  );
+  assert.equal(limited.status, "limit");
+  const active = await store.readState("run-p1a");
+  assert.equal(active.status, "running");
+  assert.equal(active.revision, 0);
+  assert.equal(active.needsHuman, undefined);
+  const terminal = {
+    ...active,
+    status: "succeeded",
+    revision: active.revision + 1,
+    updatedAt: "2026-07-26T00:10:00.000Z",
+  };
+  await store.compareAndSwapState(
+    "run-p1a",
+    active.revision,
+    terminal,
+  );
+  const retention = await store.enforceRetention("run-p1a");
+  assert.equal(retention.status, "pruned");
+  assert.equal(
+    retention.removed.filter((item) => item.kind === "events").length,
+    2,
+  );
+  const projection = await store.foldRun("run-p1a");
+  assert.equal(projection.counts.events, 2);
+});
+
+test("terminal retention preserves state-referenced report and transition facts", async (t) => {
+  const { root, store } = await tempStore(t, {
+    retention: {
+      events: 2,
+      reports: 1,
+      transitions: 1,
+      diagnostics: 4,
+      terminalBytes: 1_000_000,
+    },
+  });
+  const state = loopState();
+  await store.initializeRun(state);
+  const reports = [
+    {
+      schemaVersion: 1,
+      reportId: "report-protected",
+      runId: "run-p1a",
+      fromNode: "agent-reviewer",
+      receiver: "root-master",
+      type: "verdict",
+      verdict: "clean",
+      createdAt: "2026-07-26T00:00:01.000Z",
+    },
+    {
+      schemaVersion: 1,
+      reportId: "report-removable",
+      runId: "run-p1a",
+      fromNode: "agent-reviewer",
+      receiver: "root-master",
+      type: "info",
+      createdAt: "2026-07-26T00:00:02.000Z",
+    },
+  ];
+  const transitions = [
+    {
+      schemaVersion: 1,
+      transitionId: "transition-protected",
+      runId: "run-p1a",
+      kind: "succeed",
+      lap: 1,
+      createdAt: "2026-07-26T00:00:01.000Z",
+    },
+    {
+      schemaVersion: 1,
+      transitionId: "transition-removable",
+      runId: "run-p1a",
+      kind: "interrupt",
+      lap: 1,
+      createdAt: "2026-07-26T00:00:02.000Z",
+    },
+  ];
+  for (const report of reports) {
+    assert.equal((await store.putReport("run-p1a", report)).status, "created");
+  }
+  for (const transition of transitions) {
+    assert.equal(
+      (await store.putTransition("run-p1a", transition)).status,
+      "created",
+    );
+  }
+  await store.compareAndSwapState("run-p1a", 0, {
+    ...state,
+    status: "succeeded",
+    latestReportId: "report-protected",
+    pendingTransitionId: "transition-protected",
+    revision: 1,
+    updatedAt: "2026-07-26T00:00:03.000Z",
+  });
+  const retention = await store.enforceRetention("run-p1a");
+  assert.deepEqual(
+    retention.removed
+      .map(({ kind, id }) => `${kind}:${id}`)
+      .sort(),
+    [
+      "reports:report-removable",
+      "transitions:transition-removable",
+    ],
+  );
+  await access(
+    path.join(
+      root,
+      "runs",
+      "run-p1a",
+      "reports",
+      "report-protected.json",
+    ),
+  );
+  await access(
+    path.join(
+      root,
+      "runs",
+      "run-p1a",
+      "transitions",
+      "transition-protected.json",
+    ),
+  );
+});
+
+test("terminal retention preserves governor receipts and their origin events", async (t) => {
+  const { rootInfo, store } = await tempStore(t);
+  const initial = loopState();
+  await store.initializeRun(initial);
+  const events = [
+    normalizeHookEvent(
+      {
+        session_id: "session-root",
+        turn_id: "turn-governor-retention-1",
+        hook_event_name: "Stop",
+        stop_hook_active: false,
+      },
+      { observedAt: "2026-07-26T00:00:01.000Z" },
+    ),
+    normalizeHookEvent(
+      {
+        session_id: "session-root",
+        turn_id: "turn-governor-retention-2",
+        hook_event_name: "Stop",
+        stop_hook_active: true,
+      },
+      { observedAt: "2026-07-26T00:00:02.000Z" },
+    ),
+  ];
+  const decisions = events.map((origin, index) =>
+    governorDecision({
+      obligationId: `transition-retention-${index + 1}`,
+      originEventId: origin.eventId,
+      turnId: origin.turnId,
+      fromRevision: index,
+      toRevision: index + 1,
+      leaseEpoch: index + 1,
+      createdAt: `2026-07-26T00:00:0${index + 3}.000Z`,
+    }),
+  );
+  for (const origin of events) {
+    await store.putEvent("run-p1a", origin);
+  }
+  for (const decision of decisions) {
+    await store.putGovernorDecision(
+      "run-p1a",
+      decision,
+    );
+  }
+  const afterFirst =
+    await store.compareAndSwapState("run-p1a", 0, {
+      ...initial,
+      continuationLease: { granted: 3, consumed: 1 },
+      latestGovernorDecisionId: decisions[0].decisionId,
+      revision: 1,
+      updatedAt: "2026-07-26T00:00:04.000Z",
+    });
+  await store.compareAndSwapState("run-p1a", 1, {
+    ...afterFirst,
+    status: "capped",
+    continuationLease: { granted: 3, consumed: 2 },
+    latestGovernorDecisionId:
+      decisions.at(-1).decisionId,
+    revision: 2,
+    updatedAt: "2026-07-26T00:00:05.000Z",
+  });
+  const constrained = new LoopStore(rootInfo, {
+    events: 1,
+    "governor-decisions": 1,
+    diagnostics: 4,
+    terminalBytes: 1_000_000,
+  });
+  const retention =
+    await constrained.enforceRetention("run-p1a");
+  assert.equal(retention.status, "pruned");
+  assert.equal(
+    retention.removed.filter(
+      ({ kind }) =>
+        kind === "events" ||
+        kind === "governor-decisions",
+    ).length,
+    0,
+  );
+  assert.equal(
+    (await constrained.listEvents("run-p1a")).facts.length,
+    2,
+  );
+  assert.equal(
+    (
+      await constrained.listGovernorDecisions(
+        "run-p1a",
+      )
+    ).facts.length,
+    2,
+  );
+});
+
+test("terminal retention participates in the state CAS lock protocol", async (t) => {
+  const { root, store } = await tempStore(t, {
+    retention: {
+      events: 1,
+      diagnostics: 4,
+      terminalBytes: 1_000_000,
+    },
+  });
+  const initial = loopState();
+  await store.initializeRun(initial);
+  for (let index = 0; index < 4; index += 1) {
+    await store.putEvent(
+      "run-p1a",
+      event(
+        {
+          turn_id: `turn-retention-${index}`,
+          tool_use_id: `call-retention-${index}`,
+        },
+        `2026-07-26T00:00:0${index}.000Z`,
+      ),
+    );
+  }
+  const terminal = {
+    ...initial,
+    status: "succeeded",
+    revision: 1,
+    updatedAt: "2026-07-26T00:01:00.000Z",
+  };
+  await store.compareAndSwapState("run-p1a", 0, terminal);
+  const lockPath = path.join(
+    root,
+    "runs",
+    "run-p1a",
+    "locks",
+    "state.lock",
+  );
+  let retentionSettled = false;
+  let resumeSettled = false;
+  let retentionPromise;
+  let resumePromise;
+  await withFileLock(
+    lockPath,
+    async () => {
+      retentionPromise = store
+        .enforceRetention("run-p1a", {
+          timeoutMs: 2_000,
+          retryMs: 1,
+        })
+        .finally(() => {
+          retentionSettled = true;
+        });
+      resumePromise = store
+        .compareAndSwapState(
+          "run-p1a",
+          1,
+          {
+            ...terminal,
+            status: "running",
+            revision: 2,
+            updatedAt: "2026-07-26T00:02:00.000Z",
+          },
+          { timeoutMs: 2_000, retryMs: 1 },
+        )
+        .finally(() => {
+          resumeSettled = true;
+        });
+      await new Promise((resolve) => setTimeout(resolve, 30));
+      assert.equal(retentionSettled, false);
+      assert.equal(resumeSettled, false);
+    },
+    { root, timeoutMs: 2_000 },
+  );
+  await Promise.all([
+    retentionPromise,
+    assert.rejects(resumePromise, {
+      code: "INVALID_STATE_TRANSITION",
+    }),
+  ]);
+  assert.equal((await store.readState("run-p1a")).status, "succeeded");
+  const remainingEvents = await readdir(
+    path.join(root, "runs", "run-p1a", "events"),
+  );
+  assert.equal(
+    remainingEvents.filter((name) => name.endsWith(".json")).length,
+    1,
+  );
+});
+
+test("legacy recovery receipts are atomic, immutable, and corrupt finals are never overwritten", async (t) => {
+  const { store } = await tempStore(t);
+  const state = loopState({
+    runId: "run-recovery-store",
+    revision: 1,
+  });
+  await store.initializeRun(state);
+  const receipt = legacyRecovery(state);
+  assert.equal(
+    (await store.putRecovery(state.runId, receipt)).status,
+    "created",
+  );
+  assert.equal(
+    (await store.putRecovery(state.runId, receipt)).status,
+    "duplicate",
+  );
+  assert.deepEqual(
+    await store.readRecovery(
+      state.runId,
+      receipt.recoveryId,
+    ),
+    receipt,
+  );
+  assert.equal(
+    (await store.listRecoveries(state.runId)).facts.length,
+    1,
+  );
+  assert.equal(
+    (
+      await store.putRecovery(state.runId, {
+        ...receipt,
+        terminalStateDigest: "b".repeat(64),
+      })
+    ).status,
+    "conflict",
+  );
+
+  const file = path.join(
+    store.factDirectory(state.runId, "recoveries"),
+    `${receipt.recoveryId}.json`,
+  );
+  await writeFile(file, "{\"schemaVersion\":1");
+  const corruptBytes = await readFile(file, "utf8");
+  await assert.rejects(
+    store.putRecovery(state.runId, receipt),
+  );
+  assert.equal(await readFile(file, "utf8"), corruptBytes);
+  const listed = await store.listRecoveries(state.runId);
+  assert.equal(listed.facts.length, 0);
+  assert.equal(listed.corrupt.length, 1);
+});
+
+test("legacy recovery storage rejects schema-valid semantic forgery and wrong locations", async (t) => {
+  const { store } = await tempStore(t);
+  const state = loopState({
+    runId: "run-recovery-semantic-integrity",
+    revision: 1,
+  });
+  await store.initializeRun(state);
+  const receipt = legacyRecovery(state, {
+    requestId: "recover-semantic-integrity",
+  });
+  await assert.rejects(
+    store.putRecovery(state.runId, {
+      ...receipt,
+      requestDigest: "f".repeat(64),
+    }),
+    { code: "INVALID_CONTRACT" },
+  );
+  assert.deepEqual(
+    await store.listRecoveries(state.runId),
+    { facts: [], corrupt: [] },
+  );
+
+  await store.putRecovery(state.runId, receipt);
+  const file = path.join(
+    store.factDirectory(state.runId, "recoveries"),
+    `${receipt.recoveryId}.json`,
+  );
+  await writeFile(
+    file,
+    `${JSON.stringify({
+      ...receipt,
+      requestDigest: "f".repeat(64),
+    })}\n`,
+  );
+  await assert.rejects(
+    store.readRecovery(
+      state.runId,
+      receipt.recoveryId,
+    ),
+    { code: "INVALID_CONTRACT" },
+  );
+  let listed = await store.listRecoveries(state.runId);
+  assert.equal(listed.facts.length, 0);
+  assert.equal(listed.corrupt.length, 1);
+
+  await writeFile(file, `${JSON.stringify(receipt)}\n`);
+  const wrongLocation = path.join(
+    store.factDirectory(state.runId, "recoveries"),
+    `recovery_${"f".repeat(64)}.json`,
+  );
+  await writeFile(
+    wrongLocation,
+    `${JSON.stringify(receipt)}\n`,
+  );
+  listed = await store.listRecoveries(state.runId);
+  assert.equal(listed.facts.length, 1);
+  assert.equal(listed.corrupt.length, 1);
+});
+
+test("terminal retention permanently protects an applied recovery receipt", async (t) => {
+  const { store } = await tempStore(t);
+  const state = loopState({
+    runId: "run-recovery-retention",
+    revision: 1,
+  });
+  await store.initializeRun(state);
+  const receipt = legacyRecovery(state, {
+    requestId: "recover-retention-1",
+  });
+  await store.putRecovery(state.runId, receipt);
+  await store.compareAndSwapState(
+    state.runId,
+    state.revision,
+    terminalStateForRecovery(state, receipt),
+  );
+  store.retention.recoveries = 0;
+  const result = await store.enforceRetention(state.runId);
+  assert.equal(
+    result.removed.some(
+      (item) => item.id === receipt.recoveryId,
+    ),
+    false,
+  );
+  assert.deepEqual(
+    await store.readRecovery(
+      state.runId,
+      receipt.recoveryId,
+    ),
+    receipt,
+  );
+});
diff --git a/plugins/looperators-agent-loop/ui/assets/agent-loop-ui.css b/plugins/looperators-agent-loop/ui/assets/agent-loop-ui.css
new file mode 100644
index 0000000..3654152
--- /dev/null
+++ b/plugins/looperators-agent-loop/ui/assets/agent-loop-ui.css
@@ -0,0 +1,2 @@
+@keyframes dashdraw{0%{stroke-dashoffset:10px}}.react-flow__resize-control.handle.top.left,.react-flow__resize-control.handle.bottom.left{left:0}.react-flow__resize-control.handle.top.right,.react-flow__resize-control.handle.bottom.right{left:100%}.react-flow{--xy-edge-stroke-default:#b1b1b7;--xy-edge-stroke-width-default:1;--xy-edge-stroke-selected-default:#555;--xy-connectionline-stroke-default:#b1b1b7;--xy-connectionline-stroke-width-default:1;--xy-attribution-background-color-default:#ffffff80;--xy-minimap-background-color-default:#fff;--xy-minimap-mask-background-color-default:#f0f0f099;--xy-minimap-mask-stroke-color-default:transparent;--xy-minimap-mask-stroke-width-default:1;--xy-minimap-node-background-color-default:#e2e2e2;--xy-minimap-node-stroke-color-default:transparent;--xy-minimap-node-stroke-width-default:2;--xy-background-color-default:transparent;--xy-background-pattern-dots-color-default:#91919a;--xy-background-pattern-lines-color-default:#eee;--xy-background-pattern-cross-color-default:#e2e2e2;background-color:var(--xy-background-color,var(--xy-background-color-default));--xy-node-color-default:inherit;--xy-node-border-default:1px solid #1a192b;--xy-node-background-color-default:#fff;--xy-node-group-background-color-default:#f0f0f040;--xy-node-boxshadow-hover-default:0 1px 4px 1px #00000014;--xy-node-boxshadow-selected-default:0 0 0 .5px #1a192b;--xy-node-border-radius-default:3px;--xy-handle-background-color-default:#1a192b;--xy-handle-border-color-default:#fff;--xy-selection-background-color-default:#0059dc14;--xy-selection-border-default:1px dotted #0059dccc;--xy-controls-button-background-color-default:#fefefe;--xy-controls-button-background-color-hover-default:#f4f4f4;--xy-controls-button-color-default:inherit;--xy-controls-button-color-hover-default:inherit;--xy-controls-button-border-color-default:#eee;--xy-controls-box-shadow-default:0 0 2px 1px #00000014;--xy-edge-label-background-color-default:#fff;--xy-edge-label-color-default:inherit;--xy-resize-background-color-default:#3367d9;direction:ltr}.react-flow.dark{--xy-edge-stroke-default:#3e3e3e;--xy-edge-stroke-width-default:1;--xy-edge-stroke-selected-default:#727272;--xy-connectionline-stroke-default:#b1b1b7;--xy-connectionline-stroke-width-default:1;--xy-attribution-background-color-default:#96969640;--xy-minimap-background-color-default:#141414;--xy-minimap-mask-background-color-default:#3c3c3c99;--xy-minimap-mask-stroke-color-default:transparent;--xy-minimap-mask-stroke-width-default:1;--xy-minimap-node-background-color-default:#2b2b2b;--xy-minimap-node-stroke-color-default:transparent;--xy-minimap-node-stroke-width-default:2;--xy-background-color-default:#141414;--xy-background-pattern-dots-color-default:#777;--xy-background-pattern-lines-color-default:#777;--xy-background-pattern-cross-color-default:#777;--xy-node-color-default:#f8f8f8;--xy-node-border-default:1px solid #3c3c3c;--xy-node-background-color-default:#1e1e1e;--xy-node-group-background-color-default:#f0f0f040;--xy-node-boxshadow-hover-default:0 1px 4px 1px #ffffff14;--xy-node-boxshadow-selected-default:0 0 0 .5px #999;--xy-handle-background-color-default:#bebebe;--xy-handle-border-color-default:#1e1e1e;--xy-selection-background-color-default:#c8c8dc14;--xy-selection-border-default:1px dotted #c8c8dccc;--xy-controls-button-background-color-default:#2b2b2b;--xy-controls-button-background-color-hover-default:#3e3e3e;--xy-controls-button-color-default:#f8f8f8;--xy-controls-button-color-hover-default:#fff;--xy-controls-button-border-color-default:#5b5b5b;--xy-controls-box-shadow-default:0 0 2px 1px #00000014;--xy-edge-label-background-color-default:#141414;--xy-edge-label-color-default:#f8f8f8}.react-flow__background{background-color:var(--xy-background-color-props,var(--xy-background-color,var(--xy-background-color-default)));pointer-events:none;z-index:-1}.react-flow__container{width:100%;height:100%;position:absolute;top:0;left:0}.react-flow__pane{z-index:1;touch-action:none}.react-flow__pane.draggable{cursor:grab}.react-flow__pane.dragging{cursor:grabbing}.react-flow__pane.selection{cursor:pointer}.react-flow__viewport{transform-origin:0 0;z-index:2;pointer-events:none}.react-flow__renderer{z-index:4}.react-flow__selection{z-index:6}.react-flow__nodesselection-rect:focus,.react-flow__nodesselection-rect:focus-visible{outline:none}.react-flow__edge-path{stroke:var(--xy-edge-stroke,var(--xy-edge-stroke-default));stroke-width:var(--xy-edge-stroke-width,var(--xy-edge-stroke-width-default));fill:none}.react-flow__connection-path{stroke:var(--xy-connectionline-stroke,var(--xy-connectionline-stroke-default));stroke-width:var(--xy-connectionline-stroke-width,var(--xy-connectionline-stroke-width-default));fill:none}.react-flow .react-flow__edges{position:absolute}.react-flow .react-flow__edges svg{pointer-events:none;position:absolute;overflow:visible}.react-flow__edge{pointer-events:visibleStroke}.react-flow__edge.selectable{cursor:pointer}.react-flow__edge.animated path{stroke-dasharray:5;animation:.5s linear infinite dashdraw}.react-flow__edge.animated path.react-flow__edge-interaction{stroke-dasharray:none;animation:none}.react-flow__edge.inactive{pointer-events:none}.react-flow__edge.selected,.react-flow__edge:focus,.react-flow__edge:focus-visible{outline:none}.react-flow__edge.selected .react-flow__edge-path,.react-flow__edge.selectable:focus .react-flow__edge-path,.react-flow__edge.selectable:focus-visible .react-flow__edge-path{stroke:var(--xy-edge-stroke-selected,var(--xy-edge-stroke-selected-default))}.react-flow__edge-textwrapper{pointer-events:all}.react-flow__edge .react-flow__edge-text{pointer-events:none;-webkit-user-select:none;user-select:none}.react-flow__arrowhead polyline{stroke:var(--xy-edge-stroke,var(--xy-edge-stroke-default))}.react-flow__arrowhead polyline.arrowclosed{fill:var(--xy-edge-stroke,var(--xy-edge-stroke-default))}.react-flow__connection{pointer-events:none}.react-flow__connection .animated{stroke-dasharray:5;animation:.5s linear infinite dashdraw}svg.react-flow__connectionline{z-index:1001;position:absolute;overflow:visible}.react-flow__nodes{pointer-events:none;transform-origin:0 0}.react-flow__node{-webkit-user-select:none;user-select:none;pointer-events:all;transform-origin:0 0;box-sizing:border-box;cursor:default;position:absolute}.react-flow__node.selectable{cursor:pointer}.react-flow__node.draggable{cursor:grab;pointer-events:all}.react-flow__node.draggable.dragging{cursor:grabbing}.react-flow__nodesselection{z-index:3;transform-origin:0 0;pointer-events:none}.react-flow__nodesselection-rect{pointer-events:all;cursor:grab;position:absolute}.react-flow__handle{pointer-events:none;background-color:var(--xy-handle-background-color,var(--xy-handle-background-color-default));border:1px solid var(--xy-handle-border-color,var(--xy-handle-border-color-default));border-radius:100%;width:6px;min-width:5px;height:6px;min-height:5px;position:absolute}.react-flow__handle.connectingfrom{pointer-events:all}.react-flow__handle.connectionindicator{pointer-events:all;cursor:crosshair}.react-flow__handle-bottom{top:auto;bottom:0;left:50%;transform:translate(-50%,50%)}.react-flow__handle-top{top:0;left:50%;transform:translate(-50%,-50%)}.react-flow__handle-left{top:50%;left:0;transform:translate(-50%,-50%)}.react-flow__handle-right{top:50%;right:0;transform:translate(50%,-50%)}.react-flow__edgeupdater{cursor:move;pointer-events:all}.react-flow__pane.selection .react-flow__panel{pointer-events:none}.react-flow__panel{z-index:5;margin:15px;position:absolute}.react-flow__panel.top{top:0}.react-flow__panel.bottom{bottom:0}.react-flow__panel.top.center,.react-flow__panel.bottom.center{left:50%;transform:translate(-15px)translate(-50%)}.react-flow__panel.left{left:0}.react-flow__panel.right{right:0}.react-flow__panel.left.center,.react-flow__panel.right.center{top:50%;transform:translateY(-15px)translateY(-50%)}.react-flow__attribution{background:var(--xy-attribution-background-color,var(--xy-attribution-background-color-default));margin:0;padding:2px 3px;font-size:10px}.react-flow__attribution a{color:#999;text-decoration:none}.react-flow__edgelabel-renderer{pointer-events:none;-webkit-user-select:none;user-select:none;width:100%;height:100%;position:absolute;top:0;left:0}.react-flow__viewport-portal{-webkit-user-select:none;user-select:none;width:100%;height:100%;position:absolute;top:0;left:0}.react-flow__minimap{background:var(--xy-minimap-background-color-props,var(--xy-minimap-background-color,var(--xy-minimap-background-color-default)))}.react-flow__minimap-svg{display:block}.react-flow__minimap-mask{fill:var(--xy-minimap-mask-background-color-props,var(--xy-minimap-mask-background-color,var(--xy-minimap-mask-background-color-default)));stroke:var(--xy-minimap-mask-stroke-color-props,var(--xy-minimap-mask-stroke-color,var(--xy-minimap-mask-stroke-color-default)));stroke-width:var(--xy-minimap-mask-stroke-width-props,var(--xy-minimap-mask-stroke-width,var(--xy-minimap-mask-stroke-width-default)))}.react-flow__minimap-node{fill:var(--xy-minimap-node-background-color-props,var(--xy-minimap-node-background-color,var(--xy-minimap-node-background-color-default)));stroke:var(--xy-minimap-node-stroke-color-props,var(--xy-minimap-node-stroke-color,var(--xy-minimap-node-stroke-color-default)));stroke-width:var(--xy-minimap-node-stroke-width-props,var(--xy-minimap-node-stroke-width,var(--xy-minimap-node-stroke-width-default)))}.react-flow__background-pattern.dots{fill:var(--xy-background-pattern-color-props,var(--xy-background-pattern-color,var(--xy-background-pattern-dots-color-default)))}.react-flow__background-pattern.lines{stroke:var(--xy-background-pattern-color-props,var(--xy-background-pattern-color,var(--xy-background-pattern-lines-color-default)))}.react-flow__background-pattern.cross{stroke:var(--xy-background-pattern-color-props,var(--xy-background-pattern-color,var(--xy-background-pattern-cross-color-default)))}.react-flow__controls{box-shadow:var(--xy-controls-box-shadow,var(--xy-controls-box-shadow-default));flex-direction:column;display:flex}.react-flow__controls.horizontal{flex-direction:row}.react-flow__controls-button{background:var(--xy-controls-button-background-color,var(--xy-controls-button-background-color-default));border:none;border-bottom:1px solid var(--xy-controls-button-border-color-props,var(--xy-controls-button-border-color,var(--xy-controls-button-border-color-default)));width:26px;height:26px;color:var(--xy-controls-button-color-props,var(--xy-controls-button-color,var(--xy-controls-button-color-default)));cursor:pointer;-webkit-user-select:none;user-select:none;justify-content:center;align-items:center;padding:4px;display:flex}.react-flow__controls-button svg{fill:currentColor;width:100%;max-width:12px;max-height:12px}.react-flow__edge.updating .react-flow__edge-path{stroke:#777}.react-flow__edge-text{font-size:10px}.react-flow__node.selectable:focus,.react-flow__node.selectable:focus-visible{outline:none}.react-flow__node-input,.react-flow__node-default,.react-flow__node-output,.react-flow__node-group{border-radius:var(--xy-node-border-radius,var(--xy-node-border-radius-default));width:150px;color:var(--xy-node-color,var(--xy-node-color-default));text-align:center;border:var(--xy-node-border,var(--xy-node-border-default));background-color:var(--xy-node-background-color,var(--xy-node-background-color-default));padding:10px;font-size:12px}.react-flow__node-input.selectable:hover,.react-flow__node-default.selectable:hover,.react-flow__node-output.selectable:hover,.react-flow__node-group.selectable:hover{box-shadow:var(--xy-node-boxshadow-hover,var(--xy-node-boxshadow-hover-default))}.react-flow__node-input.selectable.selected,.react-flow__node-input.selectable:focus,.react-flow__node-input.selectable:focus-visible,.react-flow__node-default.selectable.selected,.react-flow__node-default.selectable:focus,.react-flow__node-default.selectable:focus-visible,.react-flow__node-output.selectable.selected,.react-flow__node-output.selectable:focus,.react-flow__node-output.selectable:focus-visible,.react-flow__node-group.selectable.selected,.react-flow__node-group.selectable:focus,.react-flow__node-group.selectable:focus-visible{box-shadow:var(--xy-node-boxshadow-selected,var(--xy-node-boxshadow-selected-default))}.react-flow__node-group{background-color:var(--xy-node-group-background-color,var(--xy-node-group-background-color-default))}.react-flow__nodesselection-rect,.react-flow__selection{background:var(--xy-selection-background-color,var(--xy-selection-background-color-default));border:var(--xy-selection-border,var(--xy-selection-border-default))}.react-flow__nodesselection-rect:focus,.react-flow__nodesselection-rect:focus-visible,.react-flow__selection:focus,.react-flow__selection:focus-visible{outline:none}.react-flow__controls-button:hover{background:var(--xy-controls-button-background-color-hover-props,var(--xy-controls-button-background-color-hover,var(--xy-controls-button-background-color-hover-default)));color:var(--xy-controls-button-color-hover-props,var(--xy-controls-button-color-hover,var(--xy-controls-button-color-hover-default)))}.react-flow__controls-button:disabled{pointer-events:none}.react-flow__controls-button:disabled svg{fill-opacity:.4}.react-flow__controls-button:last-child{border-bottom:none}.react-flow__controls.horizontal .react-flow__controls-button{border-bottom:none;border-right:1px solid var(--xy-controls-button-border-color-props,var(--xy-controls-button-border-color,var(--xy-controls-button-border-color-default)))}.react-flow__controls.horizontal .react-flow__controls-button:last-child{border-right:none}.react-flow__resize-control{position:absolute}.react-flow__resize-control.left,.react-flow__resize-control.right{cursor:ew-resize}.react-flow__resize-control.top,.react-flow__resize-control.bottom{cursor:ns-resize}.react-flow__resize-control.top.left,.react-flow__resize-control.bottom.right{cursor:nwse-resize}.react-flow__resize-control.bottom.left,.react-flow__resize-control.top.right{cursor:nesw-resize}.react-flow__resize-control.handle{background-color:var(--xy-resize-background-color,var(--xy-resize-background-color-default));border:1px solid #fff;border-radius:1px;width:5px;height:5px;translate:-50% -50%}.react-flow__resize-control.handle.left{top:50%;left:0}.react-flow__resize-control.handle.right{top:50%;left:100%}.react-flow__resize-control.handle.top{top:0;left:50%}.react-flow__resize-control.handle.bottom{top:100%;left:50%}.react-flow__resize-control.handle.top.left,.react-flow__resize-control.handle.bottom.left{left:0}.react-flow__resize-control.handle.top.right,.react-flow__resize-control.handle.bottom.right{left:100%}.react-flow__resize-control.line{border-color:var(--xy-resize-background-color,var(--xy-resize-background-color-default));border-style:solid;border-width:0}.react-flow__resize-control.line.left,.react-flow__resize-control.line.right{width:1px;height:100%;top:0;transform:translate(-50%)}.react-flow__resize-control.line.left{border-left-width:1px;left:0}.react-flow__resize-control.line.right{border-right-width:1px;left:100%}.react-flow__resize-control.line.top,.react-flow__resize-control.line.bottom{width:100%;height:1px;left:0;transform:translateY(-50%)}.react-flow__resize-control.line.top{border-top-width:1px;top:0}.react-flow__resize-control.line.bottom{border-bottom-width:1px;top:100%}.react-flow__edge-textbg{fill:var(--xy-edge-label-background-color,var(--xy-edge-label-background-color-default))}.react-flow__edge-text{fill:var(--xy-edge-label-color,var(--xy-edge-label-color-default))}.looperators-agent-graph,.looperators-agent-graph *{box-sizing:border-box}.looperators-agent-graph{--lag-background:var(--background,#f8fafc);--lag-card:var(--card,#fff);--lag-card-muted:var(--muted,#f1f3f5);--lag-foreground:var(--foreground,#171a1f);--lag-muted:var(--muted-foreground,#606772);--lag-border:var(--border,#171a1f24);--lag-accent:var(--term-accent-hi,#65a30d);--lag-governor:var(--term-amber,#b45309);--lag-worker:var(--term-cyan,#0e7490);--lag-success:var(--term-emerald,#047857);--lag-danger:var(--term-rose,#e11d48);--lag-font:ui-sans-serif, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;--lag-mono:ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;width:100%;min-width:0;color:var(--lag-foreground);font:14px/1.45 var(--lag-font);gap:12px;display:grid}.lag-header{flex-wrap:wrap;justify-content:space-between;align-items:flex-start;gap:16px;display:flex}.lag-header h2,.lag-inspector h3{letter-spacing:-.01em;margin:0;font-size:16px}.lag-eyebrow{color:var(--lag-muted);font:10px/1.2 var(--lag-mono);letter-spacing:.12em;text-transform:uppercase;margin:0 0 2px}.lag-badges{flex-wrap:wrap;justify-content:flex-end;align-items:center;gap:6px;display:flex}.lag-badge,.lag-state-pill{border:1px solid var(--lag-border);background:color-mix(in srgb, var(--lag-card) 88%, transparent);min-height:24px;color:var(--lag-muted);font:10px/1 var(--lag-mono);white-space:nowrap;border-radius:999px;align-items:center;padding:2px 8px;display:inline-flex}.lag-badge[data-tone=active]{border-color:color-mix(in srgb, var(--lag-accent) 50%, var(--lag-border));color:var(--lag-accent)}.lag-badge[data-tone=success],.lag-verified{border-color:color-mix(in srgb, var(--lag-success) 45%, var(--lag-border));color:var(--lag-success)}.lag-badge[data-tone=warning]{border-color:color-mix(in srgb, var(--lag-governor) 50%, var(--lag-border));color:var(--lag-governor)}.lag-badge[data-tone=danger]{border-color:color-mix(in srgb, var(--lag-danger) 45%, var(--lag-border));color:var(--lag-danger)}.lag-alert,.lag-embed-error{border:1px solid color-mix(in srgb, var(--lag-governor) 45%, var(--lag-border));background:color-mix(in srgb, var(--lag-governor) 8%, var(--lag-card));color:var(--lag-governor);border-radius:10px;margin:0;padding:8px 10px;font-size:12px}.lag-embed-error{border-color:color-mix(in srgb, var(--lag-danger) 45%, var(--lag-border));color:var(--lag-danger);margin-bottom:10px}.lag-flow{border:1px solid var(--lag-border);background:radial-gradient(circle at 15% -10%, color-mix(in srgb, var(--lag-accent) 10%, transparent), transparent 42%), var(--lag-background);border-radius:14px;width:100%;height:390px;min-height:320px;overflow:hidden}.lag-workspace{grid-template-columns:minmax(0,1fr);gap:12px;min-width:0;display:grid}.lag-workspace[data-panel-open=true]{grid-template-columns:minmax(520px,1fr) 360px}.lag-canvas-stack{gap:8px;min-width:0;display:grid}.lag-loop-badge{border:1px solid var(--lag-border);background:color-mix(in srgb, var(--lag-card) 94%, transparent);width:min(360px,100%);color:var(--lag-foreground);font:10px/1.25 var(--lag-mono);text-align:left;cursor:pointer;border-radius:11px;grid-template-columns:auto minmax(0,1fr) auto;align-items:center;gap:9px;padding:8px 10px;display:grid;box-shadow:0 4px 14px #00000012}.lag-loop-badge:hover,.lag-loop-badge:focus-visible{border-color:color-mix(in srgb, var(--lag-accent) 55%, var(--lag-border))}.lag-loop-badge[data-tone=active]{color:var(--lag-accent)}.lag-loop-badge[data-tone=success]{color:var(--lag-success)}.lag-loop-badge[data-tone=warning]{color:var(--lag-governor)}.lag-loop-badge[data-tone=danger]{color:var(--lag-danger)}.lag-loop-badge-icon{font-size:17px}.lag-loop-badge-copy{min-width:0;display:grid}.lag-loop-badge-copy strong,.lag-loop-badge-copy small{text-overflow:ellipsis;white-space:nowrap;overflow:hidden}.lag-loop-badge-copy small{color:var(--lag-muted);font-family:var(--lag-font);margin-top:2px}.lag-loop-badge-lap{border:1px solid;border-radius:999px;padding:3px 7px;font-weight:700}.lag-flow[data-orientation=vertical]{height:720px}.lag-flow .react-flow__background{color:color-mix(in srgb, var(--lag-muted) 32%, transparent)}.lag-flow .react-flow__controls{border:1px solid var(--lag-border);box-shadow:none;border-radius:10px;overflow:hidden}.lag-flow .react-flow__controls-button{border-bottom-color:var(--lag-border);background:color-mix(in srgb, var(--lag-card) 94%, transparent);color:var(--lag-foreground)}.lag-flow .react-flow__controls-button:hover{background:var(--lag-card-muted)}.lag-flow .react-flow__controls-button svg{fill:currentColor}.lag-node{border:1px solid var(--lag-border);background:color-mix(in srgb, var(--lag-card) 96%, transparent);width:276px;min-height:154px;font-family:var(--lag-mono);border-radius:14px;transition:border-color .14s,box-shadow .14s,opacity .14s;display:grid;position:relative;overflow:visible;box-shadow:0 10px 24px #00000012}.lag-node[data-role=root]{border-color:color-mix(in srgb, var(--lag-governor) 48%, var(--lag-border))}.lag-node[data-role=implementer],.lag-node[data-role=reviewer]{border-color:color-mix(in srgb, var(--lag-worker) 42%, var(--lag-border))}.lag-node[data-state=active]{box-shadow:0 0 0 1px color-mix(in srgb, var(--lag-accent) 50%, transparent), 0 12px 32px color-mix(in srgb, var(--lag-accent) 14%, transparent)}.lag-node[data-state=terminal]{opacity:.72}.lag-node[data-selected=true]{border-color:var(--lag-accent);box-shadow:0 0 0 2px color-mix(in srgb, var(--lag-accent) 32%, transparent), 0 12px 32px color-mix(in srgb, var(--lag-accent) 14%, transparent)}.lag-node-header{align-items:center;gap:10px;padding:12px 12px 9px;display:flex}.lag-node-glyph{border:1px solid color-mix(in srgb, currentColor 28%, var(--lag-border));background:color-mix(in srgb, currentColor 8%, var(--lag-card));width:34px;height:34px;color:var(--lag-worker);border-radius:10px;flex:none;place-items:center;font-size:13px;font-weight:700;display:grid}.lag-node[data-role=root] .lag-node-glyph{color:var(--lag-governor)}.lag-node-heading{flex:1;min-width:0;display:grid}.lag-node-heading strong{color:var(--lag-foreground);text-overflow:ellipsis;white-space:nowrap;font-size:12px;overflow:hidden}.lag-node-heading small{color:var(--lag-muted);text-overflow:ellipsis;white-space:nowrap;margin-top:2px;font-size:9px;overflow:hidden}.lag-state-pill{min-height:20px;padding:2px 7px;font-size:9px}.lag-node-body{min-height:60px;padding:0 12px 10px}.lag-node-description{border:1px solid var(--lag-border);background:color-mix(in srgb, var(--lag-card-muted) 70%, transparent);color:var(--lag-muted);font:10px/1.45 var(--lag-font);border-radius:9px;margin:0;padding:8px}.lag-verdict{border:1px solid var(--lag-border);background:color-mix(in srgb, var(--lag-card-muted) 70%, transparent);color:var(--lag-muted);border-radius:9px;justify-content:space-between;align-items:center;gap:8px;padding:8px;font-size:10px;display:flex}.lag-verdict[data-verdict=issues]{border-color:color-mix(in srgb, var(--lag-governor) 40%, var(--lag-border));color:var(--lag-governor)}.lag-verdict[data-verdict=clean]{border-color:color-mix(in srgb, var(--lag-success) 40%, var(--lag-border));color:var(--lag-success)}.lag-node-footer{border-top:1px solid var(--lag-border);color:var(--lag-muted);justify-content:space-between;align-items:center;gap:8px;padding:7px 12px;font-size:8.5px;display:flex}.lag-node-footer span{text-overflow:ellipsis;white-space:nowrap;overflow:hidden}.lag-node-activity{gap:4px;display:inline-flex}.lag-report-summary{color:var(--lag-muted);font:10px/1.4 var(--lag-font);text-overflow:ellipsis;white-space:nowrap;margin:6px 0 0;overflow:hidden}.lag-handle{opacity:.86;border:2px solid var(--lag-card)!important;background:var(--lag-accent)!important;width:8px!important;height:8px!important}.lag-handle-upper:is(.react-flow__handle-left,.react-flow__handle-right){top:38%!important}.lag-handle-lower:is(.react-flow__handle-left,.react-flow__handle-right){top:68%!important}.lag-handle-source{transform:translate(-50%,-50%)scale(.86)}.lag-edge-path{stroke:var(--lag-muted);transition:stroke .14s,opacity .14s}.lag-edge-path[data-kind=governs]{stroke:var(--lag-governor)}.lag-edge-path[data-kind=handoff]{stroke:var(--lag-success)}.lag-edge-path[data-kind=feedback]{stroke:var(--lag-governor);stroke-dasharray:7 5}.lag-edge-path[data-kind=verdict]{stroke:var(--lag-worker);stroke-dasharray:3 4}.lag-edge-path[data-active=false]{opacity:.58}.lag-edge-path[data-pending=true]{animation:1.8s ease-in-out infinite lag-edge-pulse}.lag-edge-label[data-recent=true]{box-shadow:0 0 0 1px color-mix(in srgb, var(--lag-accent) 26%, transparent), 0 4px 12px #00000012}@keyframes lag-edge-pulse{50%{opacity:.45}}.lag-edge-label{z-index:20;border:1px solid var(--lag-border);background:color-mix(in srgb, var(--lag-card) 92%, transparent);color:var(--lag-muted);font:8.5px/1 var(--lag-mono);pointer-events:all;white-space:nowrap;border-radius:999px;align-items:center;gap:5px;padding:4px 7px;display:flex;position:absolute;box-shadow:0 4px 12px #00000012}.lag-edge-label[data-active=true]{border-color:color-mix(in srgb, var(--lag-accent) 50%, var(--lag-border));color:var(--lag-accent)}.lag-edge-label[data-selected=true]{border-color:var(--lag-accent);box-shadow:0 0 0 2px color-mix(in srgb, var(--lag-accent) 25%, transparent), 0 4px 12px #00000012}.lag-edge-label:focus-visible,.lag-actions button:focus-visible,.lag-timeline summary:focus-visible{outline:2px solid var(--lag-accent);outline-offset:2px}.lag-inspector{border:1px solid var(--lag-border);background:color-mix(in srgb, var(--lag-card) 92%, transparent);border-radius:12px;grid-template-columns:minmax(220px,1fr) auto;align-items:center;gap:12px 18px;padding:11px 12px;display:grid}.lag-inspector-copy p:last-child{color:var(--lag-muted);font:10px/1.4 var(--lag-mono);margin:4px 0 0}.lag-actions{flex-wrap:wrap;justify-content:flex-end;align-items:center;gap:7px;display:flex}.lag-actions button,.lag-demo-toolbar select{border:1px solid var(--lag-border);background:var(--lag-card);min-height:31px;color:var(--lag-foreground);font:10px/1 var(--lag-font);cursor:pointer;border-radius:9px;padding:5px 9px}.lag-actions button:disabled{cursor:not-allowed;opacity:.45}.lag-follow-up-status{color:var(--lag-muted);grid-column:1/-1;margin:0;font-size:10px}.lag-relationship-inspector,.lag-loop-panel{border:1px solid var(--lag-border);background:color-mix(in srgb, var(--lag-background) 96%, transparent);min-width:0;color:var(--lag-foreground);border-radius:13px;overflow:hidden;box-shadow:0 12px 30px #0000001a}.lag-relationship-inspector>header,.lag-loop-panel>header{border-bottom:1px solid var(--lag-border);grid-template-columns:auto minmax(0,1fr) auto;align-items:center;gap:9px;min-height:52px;padding:8px 10px;display:grid}.lag-relationship-inspector h3,.lag-loop-panel h3,.lag-loop-panel p{margin:0}.lag-loop-panel>header p{color:var(--lag-muted);font:9px/1.2 var(--lag-mono);margin-top:2px}.lag-panel-icon{border:1px solid color-mix(in srgb, var(--lag-accent) 35%, var(--lag-border));width:28px;height:28px;color:var(--lag-accent);border-radius:9px;place-items:center;display:grid}.lag-panel-icon[data-active=true]{animation:3s linear infinite lag-spin}@keyframes lag-spin{to{transform:rotate(360deg)}}.lag-icon-button{width:28px;height:28px;color:var(--lag-muted);cursor:pointer;background:0 0;border:0;border-radius:8px;place-items:center;font-size:18px;display:grid}.lag-icon-button:hover{background:var(--lag-card-muted)}.lag-relationship-grid{border:1px solid var(--lag-border);background:var(--lag-card);border-radius:10px;grid-template-columns:88px minmax(0,1fr);gap:7px 10px;margin:10px;padding:10px;font-size:10px;display:grid}.lag-relationship-grid dt{color:var(--lag-muted)}.lag-relationship-grid dd{overflow-wrap:anywhere;margin:0}.lag-panel-note{border:1px solid var(--lag-border);background:var(--lag-card-muted);color:var(--lag-muted);border-radius:9px;margin:0 10px 10px;padding:9px;font-size:10px}.lag-danger-button{border:1px solid color-mix(in srgb, var(--lag-danger) 45%, var(--lag-border));background:color-mix(in srgb, var(--lag-danger) 8%, var(--lag-card));width:calc(100% - 20px);color:var(--lag-danger);cursor:pointer;border-radius:9px;margin:0 10px 10px;padding:8px;font-size:10px}.lag-danger-button:disabled{cursor:not-allowed;opacity:.45}.lag-loop-panel-body{gap:10px;max-height:640px;padding:10px;display:grid;overflow-y:auto}.lag-stop-confirm,.lag-loop-summary,.lag-blocking-issues,.lag-lap-card,.lag-diagnostics{border:1px solid var(--lag-border);background:var(--lag-card);border-radius:10px;padding:10px}.lag-stop-confirm{border-color:color-mix(in srgb, var(--lag-governor) 45%, var(--lag-border));background:color-mix(in srgb, var(--lag-governor) 8%, var(--lag-card));color:var(--lag-governor);font-size:10px}.lag-stop-confirm p{color:var(--lag-foreground);margin-top:5px}.lag-stop-confirm>div{justify-content:flex-end;gap:6px;margin-top:8px;display:flex}.lag-stop-confirm button,.lag-loop-summary button{border:1px solid var(--lag-border);background:var(--lag-card);color:var(--lag-foreground);cursor:pointer;border-radius:8px;padding:6px 8px;font-size:9px}.lag-loop-summary h4,.lag-blocking-issues h4{margin:0;font-size:11px}.lag-loop-summary>p{color:var(--lag-muted);margin-top:5px;font-size:10px}.lag-loop-summary dl{border-top:1px solid var(--lag-border);grid-template-columns:repeat(2,minmax(0,1fr));gap:7px;margin:9px 0;padding-top:8px;display:grid}.lag-loop-summary dl div{min-width:0}.lag-loop-summary dt{color:var(--lag-muted);font-size:8px}.lag-loop-summary dd{overflow-wrap:anywhere;font:9px/1.3 var(--lag-mono);margin:2px 0 0}.lag-loop-summary>small{color:var(--lag-muted);margin-top:8px;display:block}.lag-issue-list,.lag-lap-list{gap:7px;margin:7px 0 0;padding:0;list-style:none;display:grid}.lag-issue-list li{gap:2px;font-size:9px;display:grid}.lag-issue-list strong{color:var(--lag-danger);text-transform:uppercase}.lag-issue-list small{color:var(--lag-muted);font-family:var(--lag-mono)}.lag-lap-card>header{justify-content:space-between;gap:8px;display:flex}.lag-lap-card p{color:var(--lag-muted);gap:2px;margin-top:7px;font-size:9px;display:grid}.lag-lap-card p b{color:var(--lag-foreground)}.lag-lap-card time{color:var(--lag-muted);font:8px/1 var(--lag-mono);margin-top:7px;display:block}.lag-diagnostics{color:var(--lag-muted);font:8px/1.45 var(--lag-mono);overflow-wrap:anywhere}.lag-diagnostics summary{color:var(--lag-foreground);cursor:pointer}.lag-timeline{border:1px solid var(--lag-border);background:color-mix(in srgb, var(--lag-card) 90%, transparent);border-radius:12px}.lag-timeline summary{color:var(--lag-foreground);font:11px/1 var(--lag-mono);cursor:pointer;justify-content:space-between;align-items:center;padding:10px 12px;display:flex}.lag-timeline ol{gap:6px;margin:0;padding:0 12px 12px 32px;display:grid}.lag-timeline li{color:var(--lag-muted);font-size:10px}.lag-timeline li time{font-family:var(--lag-mono);margin-right:8px}.lag-timeline li small{color:var(--lag-worker);margin-left:6px}@media (max-width:719px){.lag-workspace[data-panel-open=true],.lag-inspector{grid-template-columns:1fr}.lag-actions{justify-content:flex-start}}@media (prefers-color-scheme:dark){.looperators-agent-graph{--lag-background:var(--background,#07090a);--lag-card:var(--card,#0d120e);--lag-card-muted:var(--muted,#0f1511);--lag-foreground:var(--foreground,#e5e7eb);--lag-muted:var(--muted-foreground,#9ca3af);--lag-border:var(--border,#ffffff1c);--lag-accent:var(--term-accent-hi,#a3e635);--lag-governor:var(--term-amber,#fcd34d);--lag-worker:var(--term-cyan,#67e8f9);--lag-success:var(--term-emerald,#6ee7b7);--lag-danger:var(--term-rose,#fb7185)}}@media (prefers-reduced-motion:reduce){.looperators-agent-graph *,.looperators-agent-graph :before,.looperators-agent-graph :after{scroll-behavior:auto!important;transition-duration:.01ms!important;animation-duration:.01ms!important;animation-iteration-count:1!important}}
+/*$vite$:1*/
\ No newline at end of file
diff --git a/plugins/looperators-agent-loop/ui/assets/agent-loop-ui.iife.js b/plugins/looperators-agent-loop/ui/assets/agent-loop-ui.iife.js
new file mode 100644
index 0000000..17b7905
--- /dev/null
+++ b/plugins/looperators-agent-loop/ui/assets/agent-loop-ui.iife.js
@@ -0,0 +1,16 @@
+(function(){var e=Object.create,t=Object.defineProperty,n=Object.getOwnPropertyDescriptor,r=Object.getOwnPropertyNames,i=Object.getPrototypeOf,a=Object.prototype.hasOwnProperty,o=(e,t)=>()=>(t||(e((t={exports:{}}).exports,t),e=null),t.exports),s=(e,i,o,s)=>{if(i&&typeof i==`object`||typeof i==`function`)for(var c=r(i),l=0,u=c.length,d;l<u;l++)d=c[l],!a.call(e,d)&&d!==o&&t(e,d,{get:(e=>i[e]).bind(null,d),enumerable:!(s=n(i,d))||s.enumerable});return e},c=(n,r,a)=>(a=n==null?{}:e(i(n)),s(r||!n||!n.__esModule?t(a,`default`,{value:n,enumerable:!0}):a,n)),l=o((e=>{var t=Symbol.for(`react.transitional.element`),n=Symbol.for(`react.portal`),r=Symbol.for(`react.fragment`),i=Symbol.for(`react.strict_mode`),a=Symbol.for(`react.profiler`),o=Symbol.for(`react.consumer`),s=Symbol.for(`react.context`),c=Symbol.for(`react.forward_ref`),l=Symbol.for(`react.suspense`),u=Symbol.for(`react.memo`),d=Symbol.for(`react.lazy`),f=Symbol.for(`react.activity`),p=Symbol.iterator;function m(e){return typeof e!=`object`||!e?null:(e=p&&e[p]||e[`@@iterator`],typeof e==`function`?e:null)}var h={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},g=Object.assign,_={};function v(e,t,n){this.props=e,this.context=t,this.refs=_,this.updater=n||h}v.prototype.isReactComponent={},v.prototype.setState=function(e,t){if(typeof e!=`object`&&typeof e!=`function`&&e!=null)throw Error(`takes an object of state variables to update or a function which returns an object of state variables.`);this.updater.enqueueSetState(this,e,t,`setState`)},v.prototype.forceUpdate=function(e){this.updater.enqueueForceUpdate(this,e,`forceUpdate`)};function y(){}y.prototype=v.prototype;function b(e,t,n){this.props=e,this.context=t,this.refs=_,this.updater=n||h}var x=b.prototype=new y;x.constructor=b,g(x,v.prototype),x.isPureReactComponent=!0;var S=Array.isArray;function C(){}var w={H:null,A:null,T:null,S:null},T=Object.prototype.hasOwnProperty;function E(e,n,r){var i=r.ref;return{$$typeof:t,type:e,key:n,ref:i===void 0?null:i,props:r}}function D(e,t){return E(e.type,t,e.props)}function O(e){return typeof e==`object`&&!!e&&e.$$typeof===t}function k(e){var t={"=":`=0`,":":`=2`};return`$`+e.replace(/[=:]/g,function(e){return t[e]})}var A=/\/+/g;function j(e,t){return typeof e==`object`&&e&&e.key!=null?k(``+e.key):t.toString(36)}function M(e){switch(e.status){case`fulfilled`:return e.value;case`rejected`:throw e.reason;default:switch(typeof e.status==`string`?e.then(C,C):(e.status=`pending`,e.then(function(t){e.status===`pending`&&(e.status=`fulfilled`,e.value=t)},function(t){e.status===`pending`&&(e.status=`rejected`,e.reason=t)})),e.status){case`fulfilled`:return e.value;case`rejected`:throw e.reason}}throw e}function N(e,r,i,a,o){var s=typeof e;(s===`undefined`||s===`boolean`)&&(e=null);var c=!1;if(e===null)c=!0;else switch(s){case`bigint`:case`string`:case`number`:c=!0;break;case`object`:switch(e.$$typeof){case t:case n:c=!0;break;case d:return c=e._init,N(c(e._payload),r,i,a,o)}}if(c)return o=o(e),c=a===``?`.`+j(e,0):a,S(o)?(i=``,c!=null&&(i=c.replace(A,`$&/`)+`/`),N(o,r,i,``,function(e){return e})):o!=null&&(O(o)&&(o=D(o,i+(o.key==null||e&&e.key===o.key?``:(``+o.key).replace(A,`$&/`)+`/`)+c)),r.push(o)),1;c=0;var l=a===``?`.`:a+`:`;if(S(e))for(var u=0;u<e.length;u++)a=e[u],s=l+j(a,u),c+=N(a,r,i,s,o);else if(u=m(e),typeof u==`function`)for(e=u.call(e),u=0;!(a=e.next()).done;)a=a.value,s=l+j(a,u++),c+=N(a,r,i,s,o);else if(s===`object`){if(typeof e.then==`function`)return N(M(e),r,i,a,o);throw r=String(e),Error(`Objects are not valid as a React child (found: `+(r===`[object Object]`?`object with keys {`+Object.keys(e).join(`, `)+`}`:r)+`). If you meant to render a collection of children, use an array instead.`)}return c}function P(e,t,n){if(e==null)return e;var r=[],i=0;return N(e,r,``,``,function(e){return t.call(n,e,i++)}),r}function ee(e){if(e._status===-1){var t=e._result;t=t(),t.then(function(t){(e._status===0||e._status===-1)&&(e._status=1,e._result=t)},function(t){(e._status===0||e._status===-1)&&(e._status=2,e._result=t)}),e._status===-1&&(e._status=0,e._result=t)}if(e._status===1)return e._result.default;throw e._result}var F=typeof reportError==`function`?reportError:function(e){if(typeof window==`object`&&typeof window.ErrorEvent==`function`){var t=new window.ErrorEvent(`error`,{bubbles:!0,cancelable:!0,message:typeof e==`object`&&e&&typeof e.message==`string`?String(e.message):String(e),error:e});if(!window.dispatchEvent(t))return}else if(typeof process==`object`&&typeof process.emit==`function`){process.emit(`uncaughtException`,e);return}console.error(e)},I={map:P,forEach:function(e,t,n){P(e,function(){t.apply(this,arguments)},n)},count:function(e){var t=0;return P(e,function(){t++}),t},toArray:function(e){return P(e,function(e){return e})||[]},only:function(e){if(!O(e))throw Error(`React.Children.only expected to receive a single React element child.`);return e}};e.Activity=f,e.Children=I,e.Component=v,e.Fragment=r,e.Profiler=a,e.PureComponent=b,e.StrictMode=i,e.Suspense=l,e.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE=w,e.__COMPILER_RUNTIME={__proto__:null,c:function(e){return w.H.useMemoCache(e)}},e.cache=function(e){return function(){return e.apply(null,arguments)}},e.cacheSignal=function(){return null},e.cloneElement=function(e,t,n){if(e==null)throw Error(`The argument must be a React element, but you passed `+e+`.`);var r=g({},e.props),i=e.key;if(t!=null)for(a in t.key!==void 0&&(i=``+t.key),t)!T.call(t,a)||a===`key`||a===`__self`||a===`__source`||a===`ref`&&t.ref===void 0||(r[a]=t[a]);var a=arguments.length-2;if(a===1)r.children=n;else if(1<a){for(var o=Array(a),s=0;s<a;s++)o[s]=arguments[s+2];r.children=o}return E(e.type,i,r)},e.createContext=function(e){return e={$$typeof:s,_currentValue:e,_currentValue2:e,_threadCount:0,Provider:null,Consumer:null},e.Provider=e,e.Consumer={$$typeof:o,_context:e},e},e.createElement=function(e,t,n){var r,i={},a=null;if(t!=null)for(r in t.key!==void 0&&(a=``+t.key),t)T.call(t,r)&&r!==`key`&&r!==`__self`&&r!==`__source`&&(i[r]=t[r]);var o=arguments.length-2;if(o===1)i.children=n;else if(1<o){for(var s=Array(o),c=0;c<o;c++)s[c]=arguments[c+2];i.children=s}if(e&&e.defaultProps)for(r in o=e.defaultProps,o)i[r]===void 0&&(i[r]=o[r]);return E(e,a,i)},e.createRef=function(){return{current:null}},e.forwardRef=function(e){return{$$typeof:c,render:e}},e.isValidElement=O,e.lazy=function(e){return{$$typeof:d,_payload:{_status:-1,_result:e},_init:ee}},e.memo=function(e,t){return{$$typeof:u,type:e,compare:t===void 0?null:t}},e.startTransition=function(e){var t=w.T,n={};w.T=n;try{var r=e(),i=w.S;i!==null&&i(n,r),typeof r==`object`&&r&&typeof r.then==`function`&&r.then(C,F)}catch(e){F(e)}finally{t!==null&&n.types!==null&&(t.types=n.types),w.T=t}},e.unstable_useCacheRefresh=function(){return w.H.useCacheRefresh()},e.use=function(e){return w.H.use(e)},e.useActionState=function(e,t,n){return w.H.useActionState(e,t,n)},e.useCallback=function(e,t){return w.H.useCallback(e,t)},e.useContext=function(e){return w.H.useContext(e)},e.useDebugValue=function(){},e.useDeferredValue=function(e,t){return w.H.useDeferredValue(e,t)},e.useEffect=function(e,t){return w.H.useEffect(e,t)},e.useEffectEvent=function(e){return w.H.useEffectEvent(e)},e.useId=function(){return w.H.useId()},e.useImperativeHandle=function(e,t,n){return w.H.useImperativeHandle(e,t,n)},e.useInsertionEffect=function(e,t){return w.H.useInsertionEffect(e,t)},e.useLayoutEffect=function(e,t){return w.H.useLayoutEffect(e,t)},e.useMemo=function(e,t){return w.H.useMemo(e,t)},e.useOptimistic=function(e,t){return w.H.useOptimistic(e,t)},e.useReducer=function(e,t,n){return w.H.useReducer(e,t,n)},e.useRef=function(e){return w.H.useRef(e)},e.useState=function(e){return w.H.useState(e)},e.useSyncExternalStore=function(e,t,n){return w.H.useSyncExternalStore(e,t,n)},e.useTransition=function(){return w.H.useTransition()},e.version=`19.2.7`})),u=o(((e,t)=>{t.exports=l()})),d=o((e=>{function t(e,t){var n=e.length;e.push(t);a:for(;0<n;){var r=n-1>>>1,a=e[r];if(0<i(a,t))e[r]=t,e[n]=a,n=r;else break a}}function n(e){return e.length===0?null:e[0]}function r(e){if(e.length===0)return null;var t=e[0],n=e.pop();if(n!==t){e[0]=n;a:for(var r=0,a=e.length,o=a>>>1;r<o;){var s=2*(r+1)-1,c=e[s],l=s+1,u=e[l];if(0>i(c,n))l<a&&0>i(u,c)?(e[r]=u,e[l]=n,r=l):(e[r]=c,e[s]=n,r=s);else if(l<a&&0>i(u,n))e[r]=u,e[l]=n,r=l;else break a}}return t}function i(e,t){var n=e.sortIndex-t.sortIndex;return n===0?e.id-t.id:n}if(e.unstable_now=void 0,typeof performance==`object`&&typeof performance.now==`function`){var a=performance;e.unstable_now=function(){return a.now()}}else{var o=Date,s=o.now();e.unstable_now=function(){return o.now()-s}}var c=[],l=[],u=1,d=null,f=3,p=!1,m=!1,h=!1,g=!1,_=typeof setTimeout==`function`?setTimeout:null,v=typeof clearTimeout==`function`?clearTimeout:null,y=typeof setImmediate<`u`?setImmediate:null;function b(e){for(var i=n(l);i!==null;){if(i.callback===null)r(l);else if(i.startTime<=e)r(l),i.sortIndex=i.expirationTime,t(c,i);else break;i=n(l)}}function x(e){if(h=!1,b(e),!m)if(n(c)!==null)m=!0,S||(S=!0,O());else{var t=n(l);t!==null&&j(x,t.startTime-e)}}var S=!1,C=-1,w=5,T=-1;function E(){return g?!0:!(e.unstable_now()-T<w)}function D(){if(g=!1,S){var t=e.unstable_now();T=t;var i=!0;try{a:{m=!1,h&&(h=!1,v(C),C=-1),p=!0;var a=f;try{b:{for(b(t),d=n(c);d!==null&&!(d.expirationTime>t&&E());){var o=d.callback;if(typeof o==`function`){d.callback=null,f=d.priorityLevel;var s=o(d.expirationTime<=t);if(t=e.unstable_now(),typeof s==`function`){d.callback=s,b(t),i=!0;break b}d===n(c)&&r(c),b(t)}else r(c);d=n(c)}if(d!==null)i=!0;else{var u=n(l);u!==null&&j(x,u.startTime-t),i=!1}}break a}finally{d=null,f=a,p=!1}i=void 0}}finally{i?O():S=!1}}}var O;if(typeof y==`function`)O=function(){y(D)};else if(typeof MessageChannel<`u`){var k=new MessageChannel,A=k.port2;k.port1.onmessage=D,O=function(){A.postMessage(null)}}else O=function(){_(D,0)};function j(t,n){C=_(function(){t(e.unstable_now())},n)}e.unstable_IdlePriority=5,e.unstable_ImmediatePriority=1,e.unstable_LowPriority=4,e.unstable_NormalPriority=3,e.unstable_Profiling=null,e.unstable_UserBlockingPriority=2,e.unstable_cancelCallback=function(e){e.callback=null},e.unstable_forceFrameRate=function(e){0>e||125<e?console.error(`forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported`):w=0<e?Math.floor(1e3/e):5},e.unstable_getCurrentPriorityLevel=function(){return f},e.unstable_next=function(e){switch(f){case 1:case 2:case 3:var t=3;break;default:t=f}var n=f;f=t;try{return e()}finally{f=n}},e.unstable_requestPaint=function(){g=!0},e.unstable_runWithPriority=function(e,t){switch(e){case 1:case 2:case 3:case 4:case 5:break;default:e=3}var n=f;f=e;try{return t()}finally{f=n}},e.unstable_scheduleCallback=function(r,i,a){var o=e.unstable_now();switch(typeof a==`object`&&a?(a=a.delay,a=typeof a==`number`&&0<a?o+a:o):a=o,r){case 1:var s=-1;break;case 2:s=250;break;case 5:s=1073741823;break;case 4:s=1e4;break;default:s=5e3}return s=a+s,r={id:u++,callback:i,priorityLevel:r,startTime:a,expirationTime:s,sortIndex:-1},a>o?(r.sortIndex=a,t(l,r),n(c)===null&&r===n(l)&&(h?(v(C),C=-1):h=!0,j(x,a-o))):(r.sortIndex=s,t(c,r),m||p||(m=!0,S||(S=!0,O()))),r},e.unstable_shouldYield=E,e.unstable_wrapCallback=function(e){var t=f;return function(){var n=f;f=t;try{return e.apply(this,arguments)}finally{f=n}}}})),f=o(((e,t)=>{t.exports=d()})),p=o((e=>{var t=u();function n(e){var t=`https://react.dev/errors/`+e;if(1<arguments.length){t+=`?args[]=`+encodeURIComponent(arguments[1]);for(var n=2;n<arguments.length;n++)t+=`&args[]=`+encodeURIComponent(arguments[n])}return`Minified React error #`+e+`; visit `+t+` for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`}function r(){}var i={d:{f:r,r:function(){throw Error(n(522))},D:r,C:r,L:r,m:r,X:r,S:r,M:r},p:0,findDOMNode:null},a=Symbol.for(`react.portal`);function o(e,t,n){var r=3<arguments.length&&arguments[3]!==void 0?arguments[3]:null;return{$$typeof:a,key:r==null?null:``+r,children:e,containerInfo:t,implementation:n}}var s=t.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;function c(e,t){if(e===`font`)return``;if(typeof t==`string`)return t===`use-credentials`?t:``}e.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE=i,e.createPortal=function(e,t){var r=2<arguments.length&&arguments[2]!==void 0?arguments[2]:null;if(!t||t.nodeType!==1&&t.nodeType!==9&&t.nodeType!==11)throw Error(n(299));return o(e,t,null,r)},e.flushSync=function(e){var t=s.T,n=i.p;try{if(s.T=null,i.p=2,e)return e()}finally{s.T=t,i.p=n,i.d.f()}},e.preconnect=function(e,t){typeof e==`string`&&(t?(t=t.crossOrigin,t=typeof t==`string`?t===`use-credentials`?t:``:void 0):t=null,i.d.C(e,t))},e.prefetchDNS=function(e){typeof e==`string`&&i.d.D(e)},e.preinit=function(e,t){if(typeof e==`string`&&t&&typeof t.as==`string`){var n=t.as,r=c(n,t.crossOrigin),a=typeof t.integrity==`string`?t.integrity:void 0,o=typeof t.fetchPriority==`string`?t.fetchPriority:void 0;n===`style`?i.d.S(e,typeof t.precedence==`string`?t.precedence:void 0,{crossOrigin:r,integrity:a,fetchPriority:o}):n===`script`&&i.d.X(e,{crossOrigin:r,integrity:a,fetchPriority:o,nonce:typeof t.nonce==`string`?t.nonce:void 0})}},e.preinitModule=function(e,t){if(typeof e==`string`)if(typeof t==`object`&&t){if(t.as==null||t.as===`script`){var n=c(t.as,t.crossOrigin);i.d.M(e,{crossOrigin:n,integrity:typeof t.integrity==`string`?t.integrity:void 0,nonce:typeof t.nonce==`string`?t.nonce:void 0})}}else t??i.d.M(e)},e.preload=function(e,t){if(typeof e==`string`&&typeof t==`object`&&t&&typeof t.as==`string`){var n=t.as,r=c(n,t.crossOrigin);i.d.L(e,n,{crossOrigin:r,integrity:typeof t.integrity==`string`?t.integrity:void 0,nonce:typeof t.nonce==`string`?t.nonce:void 0,type:typeof t.type==`string`?t.type:void 0,fetchPriority:typeof t.fetchPriority==`string`?t.fetchPriority:void 0,referrerPolicy:typeof t.referrerPolicy==`string`?t.referrerPolicy:void 0,imageSrcSet:typeof t.imageSrcSet==`string`?t.imageSrcSet:void 0,imageSizes:typeof t.imageSizes==`string`?t.imageSizes:void 0,media:typeof t.media==`string`?t.media:void 0})}},e.preloadModule=function(e,t){if(typeof e==`string`)if(t){var n=c(t.as,t.crossOrigin);i.d.m(e,{as:typeof t.as==`string`&&t.as!==`script`?t.as:void 0,crossOrigin:n,integrity:typeof t.integrity==`string`?t.integrity:void 0})}else i.d.m(e)},e.requestFormReset=function(e){i.d.r(e)},e.unstable_batchedUpdates=function(e,t){return e(t)},e.useFormState=function(e,t,n){return s.H.useFormState(e,t,n)},e.useFormStatus=function(){return s.H.useHostTransitionStatus()},e.version=`19.2.7`})),m=o(((e,t)=>{function n(){if(!(typeof __REACT_DEVTOOLS_GLOBAL_HOOK__>`u`||typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE!=`function`))try{__REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(n)}catch(e){console.error(e)}}n(),t.exports=p()})),h=o((e=>{var t=f(),n=u(),r=m();function i(e){var t=`https://react.dev/errors/`+e;if(1<arguments.length){t+=`?args[]=`+encodeURIComponent(arguments[1]);for(var n=2;n<arguments.length;n++)t+=`&args[]=`+encodeURIComponent(arguments[n])}return`Minified React error #`+e+`; visit `+t+` for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`}function a(e){return!(!e||e.nodeType!==1&&e.nodeType!==9&&e.nodeType!==11)}function o(e){var t=e,n=e;if(e.alternate)for(;t.return;)t=t.return;else{e=t;do t=e,t.flags&4098&&(n=t.return),e=t.return;while(e)}return t.tag===3?n:null}function s(e){if(e.tag===13){var t=e.memoizedState;if(t===null&&(e=e.alternate,e!==null&&(t=e.memoizedState)),t!==null)return t.dehydrated}return null}function c(e){if(e.tag===31){var t=e.memoizedState;if(t===null&&(e=e.alternate,e!==null&&(t=e.memoizedState)),t!==null)return t.dehydrated}return null}function l(e){if(o(e)!==e)throw Error(i(188))}function d(e){var t=e.alternate;if(!t){if(t=o(e),t===null)throw Error(i(188));return t===e?e:null}for(var n=e,r=t;;){var a=n.return;if(a===null)break;var s=a.alternate;if(s===null){if(r=a.return,r!==null){n=r;continue}break}if(a.child===s.child){for(s=a.child;s;){if(s===n)return l(a),e;if(s===r)return l(a),t;s=s.sibling}throw Error(i(188))}if(n.return!==r.return)n=a,r=s;else{for(var c=!1,u=a.child;u;){if(u===n){c=!0,n=a,r=s;break}if(u===r){c=!0,r=a,n=s;break}u=u.sibling}if(!c){for(u=s.child;u;){if(u===n){c=!0,n=s,r=a;break}if(u===r){c=!0,r=s,n=a;break}u=u.sibling}if(!c)throw Error(i(189))}}if(n.alternate!==r)throw Error(i(190))}if(n.tag!==3)throw Error(i(188));return n.stateNode.current===n?e:t}function p(e){var t=e.tag;if(t===5||t===26||t===27||t===6)return e;for(e=e.child;e!==null;){if(t=p(e),t!==null)return t;e=e.sibling}return null}var h=Object.assign,g=Symbol.for(`react.element`),_=Symbol.for(`react.transitional.element`),v=Symbol.for(`react.portal`),y=Symbol.for(`react.fragment`),b=Symbol.for(`react.strict_mode`),x=Symbol.for(`react.profiler`),S=Symbol.for(`react.consumer`),C=Symbol.for(`react.context`),w=Symbol.for(`react.forward_ref`),T=Symbol.for(`react.suspense`),E=Symbol.for(`react.suspense_list`),D=Symbol.for(`react.memo`),O=Symbol.for(`react.lazy`),k=Symbol.for(`react.activity`),A=Symbol.for(`react.memo_cache_sentinel`),j=Symbol.iterator;function M(e){return typeof e!=`object`||!e?null:(e=j&&e[j]||e[`@@iterator`],typeof e==`function`?e:null)}var N=Symbol.for(`react.client.reference`);function P(e){if(e==null)return null;if(typeof e==`function`)return e.$$typeof===N?null:e.displayName||e.name||null;if(typeof e==`string`)return e;switch(e){case y:return`Fragment`;case x:return`Profiler`;case b:return`StrictMode`;case T:return`Suspense`;case E:return`SuspenseList`;case k:return`Activity`}if(typeof e==`object`)switch(e.$$typeof){case v:return`Portal`;case C:return e.displayName||`Context`;case S:return(e._context.displayName||`Context`)+`.Consumer`;case w:var t=e.render;return e=e.displayName,e||=(e=t.displayName||t.name||``,e===``?`ForwardRef`:`ForwardRef(`+e+`)`),e;case D:return t=e.displayName||null,t===null?P(e.type)||`Memo`:t;case O:t=e._payload,e=e._init;try{return P(e(t))}catch{}}return null}var ee=Array.isArray,F=n.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,I=r.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,te={pending:!1,data:null,method:null,action:null},ne=[],L=-1;function R(e){return{current:e}}function z(e){0>L||(e.current=ne[L],ne[L]=null,L--)}function B(e,t){L++,ne[L]=e.current,e.current=t}var re=R(null),ie=R(null),ae=R(null),oe=R(null);function se(e,t){switch(B(ae,t),B(ie,e),B(re,null),t.nodeType){case 9:case 11:e=(e=t.documentElement)&&(e=e.namespaceURI)?Vd(e):0;break;default:if(e=t.tagName,t=t.namespaceURI)t=Vd(t),e=Hd(t,e);else switch(e){case`svg`:e=1;break;case`math`:e=2;break;default:e=0}}z(re),B(re,e)}function ce(){z(re),z(ie),z(ae)}function le(e){e.memoizedState!==null&&B(oe,e);var t=re.current,n=Hd(t,e.type);t!==n&&(B(ie,e),B(re,n))}function ue(e){ie.current===e&&(z(re),z(ie)),oe.current===e&&(z(oe),Qf._currentValue=te)}var de,fe;function pe(e){if(de===void 0)try{throw Error()}catch(e){var t=e.stack.trim().match(/\n( *(at )?)/);de=t&&t[1]||``,fe=-1<e.stack.indexOf(`
+    at`)?` (<anonymous>)`:-1<e.stack.indexOf(`@`)?`@unknown:0:0`:``}return`
+`+de+e+fe}var me=!1;function he(e,t){if(!e||me)return``;me=!0;var n=Error.prepareStackTrace;Error.prepareStackTrace=void 0;try{var r={DetermineComponentFrameRoot:function(){try{if(t){var n=function(){throw Error()};if(Object.defineProperty(n.prototype,"props",{set:function(){throw Error()}}),typeof Reflect==`object`&&Reflect.construct){try{Reflect.construct(n,[])}catch(e){var r=e}Reflect.construct(e,[],n)}else{try{n.call()}catch(e){r=e}e.call(n.prototype)}}else{try{throw Error()}catch(e){r=e}(n=e())&&typeof n.catch==`function`&&n.catch(function(){})}}catch(e){if(e&&r&&typeof e.stack==`string`)return[e.stack,r.stack]}return[null,null]}};r.DetermineComponentFrameRoot.displayName=`DetermineComponentFrameRoot`;var i=Object.getOwnPropertyDescriptor(r.DetermineComponentFrameRoot,`name`);i&&i.configurable&&Object.defineProperty(r.DetermineComponentFrameRoot,"name",{value:`DetermineComponentFrameRoot`});var a=r.DetermineComponentFrameRoot(),o=a[0],s=a[1];if(o&&s){var c=o.split(`
+`),l=s.split(`
+`);for(i=r=0;r<c.length&&!c[r].includes(`DetermineComponentFrameRoot`);)r++;for(;i<l.length&&!l[i].includes(`DetermineComponentFrameRoot`);)i++;if(r===c.length||i===l.length)for(r=c.length-1,i=l.length-1;1<=r&&0<=i&&c[r]!==l[i];)i--;for(;1<=r&&0<=i;r--,i--)if(c[r]!==l[i]){if(r!==1||i!==1)do if(r--,i--,0>i||c[r]!==l[i]){var u=`
+`+c[r].replace(` at new `,` at `);return e.displayName&&u.includes(`<anonymous>`)&&(u=u.replace(`<anonymous>`,e.displayName)),u}while(1<=r&&0<=i);break}}}finally{me=!1,Error.prepareStackTrace=n}return(n=e?e.displayName||e.name:``)?pe(n):``}function ge(e,t){switch(e.tag){case 26:case 27:case 5:return pe(e.type);case 16:return pe(`Lazy`);case 13:return e.child!==t&&t!==null?pe(`Suspense Fallback`):pe(`Suspense`);case 19:return pe(`SuspenseList`);case 0:case 15:return he(e.type,!1);case 11:return he(e.type.render,!1);case 1:return he(e.type,!0);case 31:return pe(`Activity`);default:return``}}function _e(e){try{var t=``,n=null;do t+=ge(e,n),n=e,e=e.return;while(e);return t}catch(e){return`
+Error generating stack: `+e.message+`
+`+e.stack}}var ve=Object.prototype.hasOwnProperty,ye=t.unstable_scheduleCallback,be=t.unstable_cancelCallback,xe=t.unstable_shouldYield,Se=t.unstable_requestPaint,Ce=t.unstable_now,we=t.unstable_getCurrentPriorityLevel,Te=t.unstable_ImmediatePriority,Ee=t.unstable_UserBlockingPriority,De=t.unstable_NormalPriority,Oe=t.unstable_LowPriority,ke=t.unstable_IdlePriority,Ae=t.log,je=t.unstable_setDisableYieldValue,Me=null,Ne=null;function Pe(e){if(typeof Ae==`function`&&je(e),Ne&&typeof Ne.setStrictMode==`function`)try{Ne.setStrictMode(Me,e)}catch{}}var Fe=Math.clz32?Math.clz32:Re,Ie=Math.log,Le=Math.LN2;function Re(e){return e>>>=0,e===0?32:31-(Ie(e)/Le|0)|0}var ze=256,Be=262144,Ve=4194304;function He(e){var t=e&42;if(t!==0)return t;switch(e&-e){case 1:return 1;case 2:return 2;case 4:return 4;case 8:return 8;case 16:return 16;case 32:return 32;case 64:return 64;case 128:return 128;case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:return e&261888;case 262144:case 524288:case 1048576:case 2097152:return e&3932160;case 4194304:case 8388608:case 16777216:case 33554432:return e&62914560;case 67108864:return 67108864;case 134217728:return 134217728;case 268435456:return 268435456;case 536870912:return 536870912;case 1073741824:return 0;default:return e}}function Ue(e,t,n){var r=e.pendingLanes;if(r===0)return 0;var i=0,a=e.suspendedLanes,o=e.pingedLanes;e=e.warmLanes;var s=r&134217727;return s===0?(s=r&~a,s===0?o===0?n||(n=r&~e,n!==0&&(i=He(n))):i=He(o):i=He(s)):(r=s&~a,r===0?(o&=s,o===0?n||(n=s&~e,n!==0&&(i=He(n))):i=He(o)):i=He(r)),i===0?0:t!==0&&t!==i&&(t&a)===0&&(a=i&-i,n=t&-t,a>=n||a===32&&n&4194048)?t:i}function We(e,t){return(e.pendingLanes&~(e.suspendedLanes&~e.pingedLanes)&t)===0}function Ge(e,t){switch(e){case 1:case 2:case 4:case 8:case 64:return t+250;case 16:case 32:case 128:case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:return t+5e3;case 4194304:case 8388608:case 16777216:case 33554432:return-1;case 67108864:case 134217728:case 268435456:case 536870912:case 1073741824:return-1;default:return-1}}function Ke(){var e=Ve;return Ve<<=1,!(Ve&62914560)&&(Ve=4194304),e}function qe(e){for(var t=[],n=0;31>n;n++)t.push(e);return t}function Je(e,t){e.pendingLanes|=t,t!==268435456&&(e.suspendedLanes=0,e.pingedLanes=0,e.warmLanes=0)}function Ye(e,t,n,r,i,a){var o=e.pendingLanes;e.pendingLanes=n,e.suspendedLanes=0,e.pingedLanes=0,e.warmLanes=0,e.expiredLanes&=n,e.entangledLanes&=n,e.errorRecoveryDisabledLanes&=n,e.shellSuspendCounter=0;var s=e.entanglements,c=e.expirationTimes,l=e.hiddenUpdates;for(n=o&~n;0<n;){var u=31-Fe(n),d=1<<u;s[u]=0,c[u]=-1;var f=l[u];if(f!==null)for(l[u]=null,u=0;u<f.length;u++){var p=f[u];p!==null&&(p.lane&=-536870913)}n&=~d}r!==0&&Xe(e,r,0),a!==0&&i===0&&e.tag!==0&&(e.suspendedLanes|=a&~(o&~t))}function Xe(e,t,n){e.pendingLanes|=t,e.suspendedLanes&=~t;var r=31-Fe(t);e.entangledLanes|=t,e.entanglements[r]=e.entanglements[r]|1073741824|n&261930}function Ze(e,t){var n=e.entangledLanes|=t;for(e=e.entanglements;n;){var r=31-Fe(n),i=1<<r;i&t|e[r]&t&&(e[r]|=t),n&=~i}}function Qe(e,t){var n=t&-t;return n=n&42?1:$e(n),(n&(e.suspendedLanes|t))===0?n:0}function $e(e){switch(e){case 2:e=1;break;case 8:e=4;break;case 32:e=16;break;case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:case 4194304:case 8388608:case 16777216:case 33554432:e=128;break;case 268435456:e=134217728;break;default:e=0}return e}function et(e){return e&=-e,2<e?8<e?e&134217727?32:268435456:8:2}function tt(){var e=I.p;return e===0?(e=window.event,e===void 0?32:mp(e.type)):e}function nt(e,t){var n=I.p;try{return I.p=e,t()}finally{I.p=n}}var rt=Math.random().toString(36).slice(2),it=`__reactFiber$`+rt,at=`__reactProps$`+rt,ot=`__reactContainer$`+rt,st=`__reactEvents$`+rt,ct=`__reactListeners$`+rt,lt=`__reactHandles$`+rt,ut=`__reactResources$`+rt,dt=`__reactMarker$`+rt;function ft(e){delete e[it],delete e[at],delete e[st],delete e[ct],delete e[lt]}function pt(e){var t=e[it];if(t)return t;for(var n=e.parentNode;n;){if(t=n[ot]||n[it]){if(n=t.alternate,t.child!==null||n!==null&&n.child!==null)for(e=df(e);e!==null;){if(n=e[it])return n;e=df(e)}return t}e=n,n=e.parentNode}return null}function mt(e){if(e=e[it]||e[ot]){var t=e.tag;if(t===5||t===6||t===13||t===31||t===26||t===27||t===3)return e}return null}function ht(e){var t=e.tag;if(t===5||t===26||t===27||t===6)return e.stateNode;throw Error(i(33))}function gt(e){var t=e[ut];return t||=e[ut]={hoistableStyles:new Map,hoistableScripts:new Map},t}function _t(e){e[dt]=!0}var vt=new Set,yt={};function bt(e,t){xt(e,t),xt(e+`Capture`,t)}function xt(e,t){for(yt[e]=t,e=0;e<t.length;e++)vt.add(t[e])}var St=RegExp(`^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$`),Ct={},wt={};function Tt(e){return ve.call(wt,e)?!0:ve.call(Ct,e)?!1:St.test(e)?wt[e]=!0:(Ct[e]=!0,!1)}function Et(e,t,n){if(Tt(t))if(n===null)e.removeAttribute(t);else{switch(typeof n){case`undefined`:case`function`:case`symbol`:e.removeAttribute(t);return;case`boolean`:var r=t.toLowerCase().slice(0,5);if(r!==`data-`&&r!==`aria-`){e.removeAttribute(t);return}}e.setAttribute(t,``+n)}}function Dt(e,t,n){if(n===null)e.removeAttribute(t);else{switch(typeof n){case`undefined`:case`function`:case`symbol`:case`boolean`:e.removeAttribute(t);return}e.setAttribute(t,``+n)}}function Ot(e,t,n,r){if(r===null)e.removeAttribute(n);else{switch(typeof r){case`undefined`:case`function`:case`symbol`:case`boolean`:e.removeAttribute(n);return}e.setAttributeNS(t,n,``+r)}}function kt(e){switch(typeof e){case`bigint`:case`boolean`:case`number`:case`string`:case`undefined`:return e;case`object`:return e;default:return``}}function At(e){var t=e.type;return(e=e.nodeName)&&e.toLowerCase()===`input`&&(t===`checkbox`||t===`radio`)}function jt(e,t,n){var r=Object.getOwnPropertyDescriptor(e.constructor.prototype,t);if(!e.hasOwnProperty(t)&&r!==void 0&&typeof r.get==`function`&&typeof r.set==`function`){var i=r.get,a=r.set;return Object.defineProperty(e,t,{configurable:!0,get:function(){return i.call(this)},set:function(e){n=``+e,a.call(this,e)}}),Object.defineProperty(e,t,{enumerable:r.enumerable}),{getValue:function(){return n},setValue:function(e){n=``+e},stopTracking:function(){e._valueTracker=null,delete e[t]}}}}function Mt(e){if(!e._valueTracker){var t=At(e)?`checked`:`value`;e._valueTracker=jt(e,t,``+e[t])}}function Nt(e){if(!e)return!1;var t=e._valueTracker;if(!t)return!0;var n=t.getValue(),r=``;return e&&(r=At(e)?e.checked?`true`:`false`:e.value),e=r,e===n?!1:(t.setValue(e),!0)}function Pt(e){if(e||=typeof document<`u`?document:void 0,e===void 0)return null;try{return e.activeElement||e.body}catch{return e.body}}var Ft=/[\n"\\]/g;function It(e){return e.replace(Ft,function(e){return`\\`+e.charCodeAt(0).toString(16)+` `})}function Lt(e,t,n,r,i,a,o,s){e.name=``,o!=null&&typeof o!=`function`&&typeof o!=`symbol`&&typeof o!=`boolean`?e.type=o:e.removeAttribute(`type`),t==null?o!==`submit`&&o!==`reset`||e.removeAttribute(`value`):o===`number`?(t===0&&e.value===``||e.value!=t)&&(e.value=``+kt(t)):e.value!==``+kt(t)&&(e.value=``+kt(t)),t==null?n==null?r!=null&&e.removeAttribute(`value`):zt(e,o,kt(n)):zt(e,o,kt(t)),i==null&&a!=null&&(e.defaultChecked=!!a),i!=null&&(e.checked=i&&typeof i!=`function`&&typeof i!=`symbol`),s!=null&&typeof s!=`function`&&typeof s!=`symbol`&&typeof s!=`boolean`?e.name=``+kt(s):e.removeAttribute(`name`)}function Rt(e,t,n,r,i,a,o,s){if(a!=null&&typeof a!=`function`&&typeof a!=`symbol`&&typeof a!=`boolean`&&(e.type=a),t!=null||n!=null){if(!(a!==`submit`&&a!==`reset`||t!=null)){Mt(e);return}n=n==null?``:``+kt(n),t=t==null?n:``+kt(t),s||t===e.value||(e.value=t),e.defaultValue=t}r??=i,r=typeof r!=`function`&&typeof r!=`symbol`&&!!r,e.checked=s?e.checked:!!r,e.defaultChecked=!!r,o!=null&&typeof o!=`function`&&typeof o!=`symbol`&&typeof o!=`boolean`&&(e.name=o),Mt(e)}function zt(e,t,n){t===`number`&&Pt(e.ownerDocument)===e||e.defaultValue===``+n||(e.defaultValue=``+n)}function Bt(e,t,n,r){if(e=e.options,t){t={};for(var i=0;i<n.length;i++)t[`$`+n[i]]=!0;for(n=0;n<e.length;n++)i=t.hasOwnProperty(`$`+e[n].value),e[n].selected!==i&&(e[n].selected=i),i&&r&&(e[n].defaultSelected=!0)}else{for(n=``+kt(n),t=null,i=0;i<e.length;i++){if(e[i].value===n){e[i].selected=!0,r&&(e[i].defaultSelected=!0);return}t!==null||e[i].disabled||(t=e[i])}t!==null&&(t.selected=!0)}}function Vt(e,t,n){if(t!=null&&(t=``+kt(t),t!==e.value&&(e.value=t),n==null)){e.defaultValue!==t&&(e.defaultValue=t);return}e.defaultValue=n==null?``:``+kt(n)}function Ht(e,t,n,r){if(t==null){if(r!=null){if(n!=null)throw Error(i(92));if(ee(r)){if(1<r.length)throw Error(i(93));r=r[0]}n=r}n??=``,t=n}n=kt(t),e.defaultValue=n,r=e.textContent,r===n&&r!==``&&r!==null&&(e.value=r),Mt(e)}function Ut(e,t){if(t){var n=e.firstChild;if(n&&n===e.lastChild&&n.nodeType===3){n.nodeValue=t;return}}e.textContent=t}var Wt=new Set(`animationIterationCount aspectRatio borderImageOutset borderImageSlice borderImageWidth boxFlex boxFlexGroup boxOrdinalGroup columnCount columns flex flexGrow flexPositive flexShrink flexNegative flexOrder gridArea gridRow gridRowEnd gridRowSpan gridRowStart gridColumn gridColumnEnd gridColumnSpan gridColumnStart fontWeight lineClamp lineHeight opacity order orphans scale tabSize widows zIndex zoom fillOpacity floodOpacity stopOpacity strokeDasharray strokeDashoffset strokeMiterlimit strokeOpacity strokeWidth MozAnimationIterationCount MozBoxFlex MozBoxFlexGroup MozLineClamp msAnimationIterationCount msFlex msZoom msFlexGrow msFlexNegative msFlexOrder msFlexPositive msFlexShrink msGridColumn msGridColumnSpan msGridRow msGridRowSpan WebkitAnimationIterationCount WebkitBoxFlex WebKitBoxFlexGroup WebkitBoxOrdinalGroup WebkitColumnCount WebkitColumns WebkitFlex WebkitFlexGrow WebkitFlexPositive WebkitFlexShrink WebkitLineClamp`.split(` `));function Gt(e,t,n){var r=t.indexOf(`--`)===0;n==null||typeof n==`boolean`||n===``?r?e.setProperty(t,``):t===`float`?e.cssFloat=``:e[t]=``:r?e.setProperty(t,n):typeof n!=`number`||n===0||Wt.has(t)?t===`float`?e.cssFloat=n:e[t]=(``+n).trim():e[t]=n+`px`}function Kt(e,t,n){if(t!=null&&typeof t!=`object`)throw Error(i(62));if(e=e.style,n!=null){for(var r in n)!n.hasOwnProperty(r)||t!=null&&t.hasOwnProperty(r)||(r.indexOf(`--`)===0?e.setProperty(r,``):r===`float`?e.cssFloat=``:e[r]=``);for(var a in t)r=t[a],t.hasOwnProperty(a)&&n[a]!==r&&Gt(e,a,r)}else for(var o in t)t.hasOwnProperty(o)&&Gt(e,o,t[o])}function qt(e){if(e.indexOf(`-`)===-1)return!1;switch(e){case`annotation-xml`:case`color-profile`:case`font-face`:case`font-face-src`:case`font-face-uri`:case`font-face-format`:case`font-face-name`:case`missing-glyph`:return!1;default:return!0}}var Jt=new Map([[`acceptCharset`,`accept-charset`],[`htmlFor`,`for`],[`httpEquiv`,`http-equiv`],[`crossOrigin`,`crossorigin`],[`accentHeight`,`accent-height`],[`alignmentBaseline`,`alignment-baseline`],[`arabicForm`,`arabic-form`],[`baselineShift`,`baseline-shift`],[`capHeight`,`cap-height`],[`clipPath`,`clip-path`],[`clipRule`,`clip-rule`],[`colorInterpolation`,`color-interpolation`],[`colorInterpolationFilters`,`color-interpolation-filters`],[`colorProfile`,`color-profile`],[`colorRendering`,`color-rendering`],[`dominantBaseline`,`dominant-baseline`],[`enableBackground`,`enable-background`],[`fillOpacity`,`fill-opacity`],[`fillRule`,`fill-rule`],[`floodColor`,`flood-color`],[`floodOpacity`,`flood-opacity`],[`fontFamily`,`font-family`],[`fontSize`,`font-size`],[`fontSizeAdjust`,`font-size-adjust`],[`fontStretch`,`font-stretch`],[`fontStyle`,`font-style`],[`fontVariant`,`font-variant`],[`fontWeight`,`font-weight`],[`glyphName`,`glyph-name`],[`glyphOrientationHorizontal`,`glyph-orientation-horizontal`],[`glyphOrientationVertical`,`glyph-orientation-vertical`],[`horizAdvX`,`horiz-adv-x`],[`horizOriginX`,`horiz-origin-x`],[`imageRendering`,`image-rendering`],[`letterSpacing`,`letter-spacing`],[`lightingColor`,`lighting-color`],[`markerEnd`,`marker-end`],[`markerMid`,`marker-mid`],[`markerStart`,`marker-start`],[`overlinePosition`,`overline-position`],[`overlineThickness`,`overline-thickness`],[`paintOrder`,`paint-order`],[`panose-1`,`panose-1`],[`pointerEvents`,`pointer-events`],[`renderingIntent`,`rendering-intent`],[`shapeRendering`,`shape-rendering`],[`stopColor`,`stop-color`],[`stopOpacity`,`stop-opacity`],[`strikethroughPosition`,`strikethrough-position`],[`strikethroughThickness`,`strikethrough-thickness`],[`strokeDasharray`,`stroke-dasharray`],[`strokeDashoffset`,`stroke-dashoffset`],[`strokeLinecap`,`stroke-linecap`],[`strokeLinejoin`,`stroke-linejoin`],[`strokeMiterlimit`,`stroke-miterlimit`],[`strokeOpacity`,`stroke-opacity`],[`strokeWidth`,`stroke-width`],[`textAnchor`,`text-anchor`],[`textDecoration`,`text-decoration`],[`textRendering`,`text-rendering`],[`transformOrigin`,`transform-origin`],[`underlinePosition`,`underline-position`],[`underlineThickness`,`underline-thickness`],[`unicodeBidi`,`unicode-bidi`],[`unicodeRange`,`unicode-range`],[`unitsPerEm`,`units-per-em`],[`vAlphabetic`,`v-alphabetic`],[`vHanging`,`v-hanging`],[`vIdeographic`,`v-ideographic`],[`vMathematical`,`v-mathematical`],[`vectorEffect`,`vector-effect`],[`vertAdvY`,`vert-adv-y`],[`vertOriginX`,`vert-origin-x`],[`vertOriginY`,`vert-origin-y`],[`wordSpacing`,`word-spacing`],[`writingMode`,`writing-mode`],[`xmlnsXlink`,`xmlns:xlink`],[`xHeight`,`x-height`]]),Yt=/^[\u0000-\u001F ]*j[\r\n\t]*a[\r\n\t]*v[\r\n\t]*a[\r\n\t]*s[\r\n\t]*c[\r\n\t]*r[\r\n\t]*i[\r\n\t]*p[\r\n\t]*t[\r\n\t]*:/i;function Xt(e){return Yt.test(``+e)?`javascript:throw new Error('React has blocked a javascript: URL as a security precaution.')`:e}function Zt(){}var Qt=null;function $t(e){return e=e.target||e.srcElement||window,e.correspondingUseElement&&(e=e.correspondingUseElement),e.nodeType===3?e.parentNode:e}var en=null,tn=null;function nn(e){var t=mt(e);if(t&&(e=t.stateNode)){var n=e[at]||null;a:switch(e=t.stateNode,t.type){case`input`:if(Lt(e,n.value,n.defaultValue,n.defaultValue,n.checked,n.defaultChecked,n.type,n.name),t=n.name,n.type===`radio`&&t!=null){for(n=e;n.parentNode;)n=n.parentNode;for(n=n.querySelectorAll(`input[name="`+It(``+t)+`"][type="radio"]`),t=0;t<n.length;t++){var r=n[t];if(r!==e&&r.form===e.form){var a=r[at]||null;if(!a)throw Error(i(90));Lt(r,a.value,a.defaultValue,a.defaultValue,a.checked,a.defaultChecked,a.type,a.name)}}for(t=0;t<n.length;t++)r=n[t],r.form===e.form&&Nt(r)}break a;case`textarea`:Vt(e,n.value,n.defaultValue);break a;case`select`:t=n.value,t!=null&&Bt(e,!!n.multiple,t,!1)}}}var rn=!1;function an(e,t,n){if(rn)return e(t,n);rn=!0;try{return e(t)}finally{if(rn=!1,(en!==null||tn!==null)&&(bu(),en&&(t=en,e=tn,tn=en=null,nn(t),e)))for(t=0;t<e.length;t++)nn(e[t])}}function on(e,t){var n=e.stateNode;if(n===null)return null;var r=n[at]||null;if(r===null)return null;n=r[t];a:switch(t){case`onClick`:case`onClickCapture`:case`onDoubleClick`:case`onDoubleClickCapture`:case`onMouseDown`:case`onMouseDownCapture`:case`onMouseMove`:case`onMouseMoveCapture`:case`onMouseUp`:case`onMouseUpCapture`:case`onMouseEnter`:(r=!r.disabled)||(e=e.type,r=!(e===`button`||e===`input`||e===`select`||e===`textarea`)),e=!r;break a;default:e=!1}if(e)return null;if(n&&typeof n!=`function`)throw Error(i(231,t,typeof n));return n}var sn=!(typeof window>`u`||window.document===void 0||window.document.createElement===void 0),cn=!1;if(sn)try{var ln={};Object.defineProperty(ln,"passive",{get:function(){cn=!0}}),window.addEventListener(`test`,ln,ln),window.removeEventListener(`test`,ln,ln)}catch{cn=!1}var un=null,dn=null,fn=null;function pn(){if(fn)return fn;var e,t=dn,n=t.length,r,i=`value`in un?un.value:un.textContent,a=i.length;for(e=0;e<n&&t[e]===i[e];e++);var o=n-e;for(r=1;r<=o&&t[n-r]===i[a-r];r++);return fn=i.slice(e,1<r?1-r:void 0)}function mn(e){var t=e.keyCode;return`charCode`in e?(e=e.charCode,e===0&&t===13&&(e=13)):e=t,e===10&&(e=13),32<=e||e===13?e:0}function hn(){return!0}function gn(){return!1}function _n(e){function t(t,n,r,i,a){for(var o in this._reactName=t,this._targetInst=r,this.type=n,this.nativeEvent=i,this.target=a,this.currentTarget=null,e)e.hasOwnProperty(o)&&(t=e[o],this[o]=t?t(i):i[o]);return this.isDefaultPrevented=(i.defaultPrevented==null?!1===i.returnValue:i.defaultPrevented)?hn:gn,this.isPropagationStopped=gn,this}return h(t.prototype,{preventDefault:function(){this.defaultPrevented=!0;var e=this.nativeEvent;e&&(e.preventDefault?e.preventDefault():typeof e.returnValue!=`unknown`&&(e.returnValue=!1),this.isDefaultPrevented=hn)},stopPropagation:function(){var e=this.nativeEvent;e&&(e.stopPropagation?e.stopPropagation():typeof e.cancelBubble!=`unknown`&&(e.cancelBubble=!0),this.isPropagationStopped=hn)},persist:function(){},isPersistent:hn}),t}var vn={eventPhase:0,bubbles:0,cancelable:0,timeStamp:function(e){return e.timeStamp||Date.now()},defaultPrevented:0,isTrusted:0},yn=_n(vn),bn=h({},vn,{view:0,detail:0}),xn=_n(bn),Sn,Cn,wn,Tn=h({},bn,{screenX:0,screenY:0,clientX:0,clientY:0,pageX:0,pageY:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,getModifierState:In,button:0,buttons:0,relatedTarget:function(e){return e.relatedTarget===void 0?e.fromElement===e.srcElement?e.toElement:e.fromElement:e.relatedTarget},movementX:function(e){return`movementX`in e?e.movementX:(e!==wn&&(wn&&e.type===`mousemove`?(Sn=e.screenX-wn.screenX,Cn=e.screenY-wn.screenY):Cn=Sn=0,wn=e),Sn)},movementY:function(e){return`movementY`in e?e.movementY:Cn}}),En=_n(Tn),Dn=_n(h({},Tn,{dataTransfer:0})),On=_n(h({},bn,{relatedTarget:0})),kn=_n(h({},vn,{animationName:0,elapsedTime:0,pseudoElement:0})),An=_n(h({},vn,{clipboardData:function(e){return`clipboardData`in e?e.clipboardData:window.clipboardData}})),jn=_n(h({},vn,{data:0})),Mn={Esc:`Escape`,Spacebar:` `,Left:`ArrowLeft`,Up:`ArrowUp`,Right:`ArrowRight`,Down:`ArrowDown`,Del:`Delete`,Win:`OS`,Menu:`ContextMenu`,Apps:`ContextMenu`,Scroll:`ScrollLock`,MozPrintableKey:`Unidentified`},Nn={8:`Backspace`,9:`Tab`,12:`Clear`,13:`Enter`,16:`Shift`,17:`Control`,18:`Alt`,19:`Pause`,20:`CapsLock`,27:`Escape`,32:` `,33:`PageUp`,34:`PageDown`,35:`End`,36:`Home`,37:`ArrowLeft`,38:`ArrowUp`,39:`ArrowRight`,40:`ArrowDown`,45:`Insert`,46:`Delete`,112:`F1`,113:`F2`,114:`F3`,115:`F4`,116:`F5`,117:`F6`,118:`F7`,119:`F8`,120:`F9`,121:`F10`,122:`F11`,123:`F12`,144:`NumLock`,145:`ScrollLock`,224:`Meta`},Pn={Alt:`altKey`,Control:`ctrlKey`,Meta:`metaKey`,Shift:`shiftKey`};function Fn(e){var t=this.nativeEvent;return t.getModifierState?t.getModifierState(e):(e=Pn[e])?!!t[e]:!1}function In(){return Fn}var Ln=_n(h({},bn,{key:function(e){if(e.key){var t=Mn[e.key]||e.key;if(t!==`Unidentified`)return t}return e.type===`keypress`?(e=mn(e),e===13?`Enter`:String.fromCharCode(e)):e.type===`keydown`||e.type===`keyup`?Nn[e.keyCode]||`Unidentified`:``},code:0,location:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,repeat:0,locale:0,getModifierState:In,charCode:function(e){return e.type===`keypress`?mn(e):0},keyCode:function(e){return e.type===`keydown`||e.type===`keyup`?e.keyCode:0},which:function(e){return e.type===`keypress`?mn(e):e.type===`keydown`||e.type===`keyup`?e.keyCode:0}})),Rn=_n(h({},Tn,{pointerId:0,width:0,height:0,pressure:0,tangentialPressure:0,tiltX:0,tiltY:0,twist:0,pointerType:0,isPrimary:0})),zn=_n(h({},bn,{touches:0,targetTouches:0,changedTouches:0,altKey:0,metaKey:0,ctrlKey:0,shiftKey:0,getModifierState:In})),Bn=_n(h({},vn,{propertyName:0,elapsedTime:0,pseudoElement:0})),Vn=_n(h({},Tn,{deltaX:function(e){return`deltaX`in e?e.deltaX:`wheelDeltaX`in e?-e.wheelDeltaX:0},deltaY:function(e){return`deltaY`in e?e.deltaY:`wheelDeltaY`in e?-e.wheelDeltaY:`wheelDelta`in e?-e.wheelDelta:0},deltaZ:0,deltaMode:0})),Hn=_n(h({},vn,{newState:0,oldState:0})),Un=[9,13,27,32],Wn=sn&&`CompositionEvent`in window,Gn=null;sn&&`documentMode`in document&&(Gn=document.documentMode);var Kn=sn&&`TextEvent`in window&&!Gn,qn=sn&&(!Wn||Gn&&8<Gn&&11>=Gn),Jn=` `,Yn=!1;function Xn(e,t){switch(e){case`keyup`:return Un.indexOf(t.keyCode)!==-1;case`keydown`:return t.keyCode!==229;case`keypress`:case`mousedown`:case`focusout`:return!0;default:return!1}}function Zn(e){return e=e.detail,typeof e==`object`&&`data`in e?e.data:null}var Qn=!1;function $n(e,t){switch(e){case`compositionend`:return Zn(t);case`keypress`:return t.which===32?(Yn=!0,Jn):null;case`textInput`:return e=t.data,e===Jn&&Yn?null:e;default:return null}}function er(e,t){if(Qn)return e===`compositionend`||!Wn&&Xn(e,t)?(e=pn(),fn=dn=un=null,Qn=!1,e):null;switch(e){case`paste`:return null;case`keypress`:if(!(t.ctrlKey||t.altKey||t.metaKey)||t.ctrlKey&&t.altKey){if(t.char&&1<t.char.length)return t.char;if(t.which)return String.fromCharCode(t.which)}return null;case`compositionend`:return qn&&t.locale!==`ko`?null:t.data;default:return null}}var tr={color:!0,date:!0,datetime:!0,"datetime-local":!0,email:!0,month:!0,number:!0,password:!0,range:!0,search:!0,tel:!0,text:!0,time:!0,url:!0,week:!0};function nr(e){var t=e&&e.nodeName&&e.nodeName.toLowerCase();return t===`input`?!!tr[e.type]:t===`textarea`}function rr(e,t,n,r){en?tn?tn.push(r):tn=[r]:en=r,t=Ed(t,`onChange`),0<t.length&&(n=new yn(`onChange`,`change`,null,n,r),e.push({event:n,listeners:t}))}var ir=null,ar=null;function or(e){yd(e,0)}function sr(e){if(Nt(ht(e)))return e}function cr(e,t){if(e===`change`)return t}var lr=!1;if(sn){var ur;if(sn){var dr=`oninput`in document;if(!dr){var fr=document.createElement(`div`);fr.setAttribute(`oninput`,`return;`),dr=typeof fr.oninput==`function`}ur=dr}else ur=!1;lr=ur&&(!document.documentMode||9<document.documentMode)}function pr(){ir&&(ir.detachEvent(`onpropertychange`,mr),ar=ir=null)}function mr(e){if(e.propertyName===`value`&&sr(ar)){var t=[];rr(t,ar,e,$t(e)),an(or,t)}}function hr(e,t,n){e===`focusin`?(pr(),ir=t,ar=n,ir.attachEvent(`onpropertychange`,mr)):e===`focusout`&&pr()}function gr(e){if(e===`selectionchange`||e===`keyup`||e===`keydown`)return sr(ar)}function _r(e,t){if(e===`click`)return sr(t)}function vr(e,t){if(e===`input`||e===`change`)return sr(t)}function yr(e,t){return e===t&&(e!==0||1/e==1/t)||e!==e&&t!==t}var br=typeof Object.is==`function`?Object.is:yr;function xr(e,t){if(br(e,t))return!0;if(typeof e!=`object`||!e||typeof t!=`object`||!t)return!1;var n=Object.keys(e),r=Object.keys(t);if(n.length!==r.length)return!1;for(r=0;r<n.length;r++){var i=n[r];if(!ve.call(t,i)||!br(e[i],t[i]))return!1}return!0}function Sr(e){for(;e&&e.firstChild;)e=e.firstChild;return e}function Cr(e,t){var n=Sr(e);e=0;for(var r;n;){if(n.nodeType===3){if(r=e+n.textContent.length,e<=t&&r>=t)return{node:n,offset:t-e};e=r}a:{for(;n;){if(n.nextSibling){n=n.nextSibling;break a}n=n.parentNode}n=void 0}n=Sr(n)}}function wr(e,t){return e&&t?e===t?!0:e&&e.nodeType===3?!1:t&&t.nodeType===3?wr(e,t.parentNode):`contains`in e?e.contains(t):e.compareDocumentPosition?!!(e.compareDocumentPosition(t)&16):!1:!1}function Tr(e){e=e!=null&&e.ownerDocument!=null&&e.ownerDocument.defaultView!=null?e.ownerDocument.defaultView:window;for(var t=Pt(e.document);t instanceof e.HTMLIFrameElement;){try{var n=typeof t.contentWindow.location.href==`string`}catch{n=!1}if(n)e=t.contentWindow;else break;t=Pt(e.document)}return t}function Er(e){var t=e&&e.nodeName&&e.nodeName.toLowerCase();return t&&(t===`input`&&(e.type===`text`||e.type===`search`||e.type===`tel`||e.type===`url`||e.type===`password`)||t===`textarea`||e.contentEditable===`true`)}var Dr=sn&&`documentMode`in document&&11>=document.documentMode,Or=null,kr=null,Ar=null,jr=!1;function Mr(e,t,n){var r=n.window===n?n.document:n.nodeType===9?n:n.ownerDocument;jr||Or==null||Or!==Pt(r)||(r=Or,`selectionStart`in r&&Er(r)?r={start:r.selectionStart,end:r.selectionEnd}:(r=(r.ownerDocument&&r.ownerDocument.defaultView||window).getSelection(),r={anchorNode:r.anchorNode,anchorOffset:r.anchorOffset,focusNode:r.focusNode,focusOffset:r.focusOffset}),Ar&&xr(Ar,r)||(Ar=r,r=Ed(kr,`onSelect`),0<r.length&&(t=new yn(`onSelect`,`select`,null,t,n),e.push({event:t,listeners:r}),t.target=Or)))}function Nr(e,t){var n={};return n[e.toLowerCase()]=t.toLowerCase(),n[`Webkit`+e]=`webkit`+t,n[`Moz`+e]=`moz`+t,n}var Pr={animationend:Nr(`Animation`,`AnimationEnd`),animationiteration:Nr(`Animation`,`AnimationIteration`),animationstart:Nr(`Animation`,`AnimationStart`),transitionrun:Nr(`Transition`,`TransitionRun`),transitionstart:Nr(`Transition`,`TransitionStart`),transitioncancel:Nr(`Transition`,`TransitionCancel`),transitionend:Nr(`Transition`,`TransitionEnd`)},Fr={},Ir={};sn&&(Ir=document.createElement(`div`).style,`AnimationEvent`in window||(delete Pr.animationend.animation,delete Pr.animationiteration.animation,delete Pr.animationstart.animation),`TransitionEvent`in window||delete Pr.transitionend.transition);function Lr(e){if(Fr[e])return Fr[e];if(!Pr[e])return e;var t=Pr[e],n;for(n in t)if(t.hasOwnProperty(n)&&n in Ir)return Fr[e]=t[n];return e}var Rr=Lr(`animationend`),zr=Lr(`animationiteration`),Br=Lr(`animationstart`),Vr=Lr(`transitionrun`),Hr=Lr(`transitionstart`),Ur=Lr(`transitioncancel`),Wr=Lr(`transitionend`),Gr=new Map,Kr=`abort auxClick beforeToggle cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel`.split(` `);Kr.push(`scrollEnd`);function qr(e,t){Gr.set(e,t),bt(t,[e])}var Jr=typeof reportError==`function`?reportError:function(e){if(typeof window==`object`&&typeof window.ErrorEvent==`function`){var t=new window.ErrorEvent(`error`,{bubbles:!0,cancelable:!0,message:typeof e==`object`&&e&&typeof e.message==`string`?String(e.message):String(e),error:e});if(!window.dispatchEvent(t))return}else if(typeof process==`object`&&typeof process.emit==`function`){process.emit(`uncaughtException`,e);return}console.error(e)},Yr=[],Xr=0,Zr=0;function Qr(){for(var e=Xr,t=Zr=Xr=0;t<e;){var n=Yr[t];Yr[t++]=null;var r=Yr[t];Yr[t++]=null;var i=Yr[t];Yr[t++]=null;var a=Yr[t];if(Yr[t++]=null,r!==null&&i!==null){var o=r.pending;o===null?i.next=i:(i.next=o.next,o.next=i),r.pending=i}a!==0&&ni(n,i,a)}}function $r(e,t,n,r){Yr[Xr++]=e,Yr[Xr++]=t,Yr[Xr++]=n,Yr[Xr++]=r,Zr|=r,e.lanes|=r,e=e.alternate,e!==null&&(e.lanes|=r)}function ei(e,t,n,r){return $r(e,t,n,r),ri(e)}function ti(e,t){return $r(e,null,null,t),ri(e)}function ni(e,t,n){e.lanes|=n;var r=e.alternate;r!==null&&(r.lanes|=n);for(var i=!1,a=e.return;a!==null;)a.childLanes|=n,r=a.alternate,r!==null&&(r.childLanes|=n),a.tag===22&&(e=a.stateNode,e===null||e._visibility&1||(i=!0)),e=a,a=a.return;return e.tag===3?(a=e.stateNode,i&&t!==null&&(i=31-Fe(n),e=a.hiddenUpdates,r=e[i],r===null?e[i]=[t]:r.push(t),t.lane=n|536870912),a):null}function ri(e){if(50<du)throw du=0,fu=null,Error(i(185));for(var t=e.return;t!==null;)e=t,t=e.return;return e.tag===3?e.stateNode:null}var ii={};function ai(e,t,n,r){this.tag=e,this.key=n,this.sibling=this.child=this.return=this.stateNode=this.type=this.elementType=null,this.index=0,this.refCleanup=this.ref=null,this.pendingProps=t,this.dependencies=this.memoizedState=this.updateQueue=this.memoizedProps=null,this.mode=r,this.subtreeFlags=this.flags=0,this.deletions=null,this.childLanes=this.lanes=0,this.alternate=null}function oi(e,t,n,r){return new ai(e,t,n,r)}function si(e){return e=e.prototype,!(!e||!e.isReactComponent)}function ci(e,t){var n=e.alternate;return n===null?(n=oi(e.tag,t,e.key,e.mode),n.elementType=e.elementType,n.type=e.type,n.stateNode=e.stateNode,n.alternate=e,e.alternate=n):(n.pendingProps=t,n.type=e.type,n.flags=0,n.subtreeFlags=0,n.deletions=null),n.flags=e.flags&65011712,n.childLanes=e.childLanes,n.lanes=e.lanes,n.child=e.child,n.memoizedProps=e.memoizedProps,n.memoizedState=e.memoizedState,n.updateQueue=e.updateQueue,t=e.dependencies,n.dependencies=t===null?null:{lanes:t.lanes,firstContext:t.firstContext},n.sibling=e.sibling,n.index=e.index,n.ref=e.ref,n.refCleanup=e.refCleanup,n}function li(e,t){e.flags&=65011714;var n=e.alternate;return n===null?(e.childLanes=0,e.lanes=t,e.child=null,e.subtreeFlags=0,e.memoizedProps=null,e.memoizedState=null,e.updateQueue=null,e.dependencies=null,e.stateNode=null):(e.childLanes=n.childLanes,e.lanes=n.lanes,e.child=n.child,e.subtreeFlags=0,e.deletions=null,e.memoizedProps=n.memoizedProps,e.memoizedState=n.memoizedState,e.updateQueue=n.updateQueue,e.type=n.type,t=n.dependencies,e.dependencies=t===null?null:{lanes:t.lanes,firstContext:t.firstContext}),e}function ui(e,t,n,r,a,o){var s=0;if(r=e,typeof e==`function`)si(e)&&(s=1);else if(typeof e==`string`)s=Uf(e,n,re.current)?26:e===`html`||e===`head`||e===`body`?27:5;else a:switch(e){case k:return e=oi(31,n,t,a),e.elementType=k,e.lanes=o,e;case y:return di(n.children,a,o,t);case b:s=8,a|=24;break;case x:return e=oi(12,n,t,a|2),e.elementType=x,e.lanes=o,e;case T:return e=oi(13,n,t,a),e.elementType=T,e.lanes=o,e;case E:return e=oi(19,n,t,a),e.elementType=E,e.lanes=o,e;default:if(typeof e==`object`&&e)switch(e.$$typeof){case C:s=10;break a;case S:s=9;break a;case w:s=11;break a;case D:s=14;break a;case O:s=16,r=null;break a}s=29,n=Error(i(130,e===null?`null`:typeof e,``)),r=null}return t=oi(s,n,t,a),t.elementType=e,t.type=r,t.lanes=o,t}function di(e,t,n,r){return e=oi(7,e,r,t),e.lanes=n,e}function fi(e,t,n){return e=oi(6,e,null,t),e.lanes=n,e}function pi(e){var t=oi(18,null,null,0);return t.stateNode=e,t}function mi(e,t,n){return t=oi(4,e.children===null?[]:e.children,e.key,t),t.lanes=n,t.stateNode={containerInfo:e.containerInfo,pendingChildren:null,implementation:e.implementation},t}var hi=new WeakMap;function gi(e,t){if(typeof e==`object`&&e){var n=hi.get(e);return n===void 0?(t={value:e,source:t,stack:_e(t)},hi.set(e,t),t):n}return{value:e,source:t,stack:_e(t)}}var _i=[],vi=0,yi=null,bi=0,xi=[],Si=0,Ci=null,wi=1,Ti=``;function Ei(e,t){_i[vi++]=bi,_i[vi++]=yi,yi=e,bi=t}function Di(e,t,n){xi[Si++]=wi,xi[Si++]=Ti,xi[Si++]=Ci,Ci=e;var r=wi;e=Ti;var i=32-Fe(r)-1;r&=~(1<<i),n+=1;var a=32-Fe(t)+i;if(30<a){var o=i-i%5;a=(r&(1<<o)-1).toString(32),r>>=o,i-=o,wi=1<<32-Fe(t)+i|n<<i|r,Ti=a+e}else wi=1<<a|n<<i|r,Ti=e}function Oi(e){e.return!==null&&(Ei(e,1),Di(e,1,0))}function ki(e){for(;e===yi;)yi=_i[--vi],_i[vi]=null,bi=_i[--vi],_i[vi]=null;for(;e===Ci;)Ci=xi[--Si],xi[Si]=null,Ti=xi[--Si],xi[Si]=null,wi=xi[--Si],xi[Si]=null}function Ai(e,t){xi[Si++]=wi,xi[Si++]=Ti,xi[Si++]=Ci,wi=t.id,Ti=t.overflow,Ci=e}var ji=null,Mi=null,V=!1,Ni=null,Pi=!1,Fi=Error(i(519));function Ii(e){throw Hi(gi(Error(i(418,1<arguments.length&&arguments[1]!==void 0&&arguments[1]?`text`:`HTML`,``)),e)),Fi}function Li(e){var t=e.stateNode,n=e.type,r=e.memoizedProps;switch(t[it]=e,t[at]=r,n){case`dialog`:Q(`cancel`,t),Q(`close`,t);break;case`iframe`:case`object`:case`embed`:Q(`load`,t);break;case`video`:case`audio`:for(n=0;n<_d.length;n++)Q(_d[n],t);break;case`source`:Q(`error`,t);break;case`img`:case`image`:case`link`:Q(`error`,t),Q(`load`,t);break;case`details`:Q(`toggle`,t);break;case`input`:Q(`invalid`,t),Rt(t,r.value,r.defaultValue,r.checked,r.defaultChecked,r.type,r.name,!0);break;case`select`:Q(`invalid`,t);break;case`textarea`:Q(`invalid`,t),Ht(t,r.value,r.defaultValue,r.children)}n=r.children,typeof n!=`string`&&typeof n!=`number`&&typeof n!=`bigint`||t.textContent===``+n||!0===r.suppressHydrationWarning||Md(t.textContent,n)?(r.popover!=null&&(Q(`beforetoggle`,t),Q(`toggle`,t)),r.onScroll!=null&&Q(`scroll`,t),r.onScrollEnd!=null&&Q(`scrollend`,t),r.onClick!=null&&(t.onclick=Zt),t=!0):t=!1,t||Ii(e,!0)}function Ri(e){for(ji=e.return;ji;)switch(ji.tag){case 5:case 31:case 13:Pi=!1;return;case 27:case 3:Pi=!0;return;default:ji=ji.return}}function zi(e){if(e!==ji)return!1;if(!V)return Ri(e),V=!0,!1;var t=e.tag,n;if((n=t!==3&&t!==27)&&((n=t===5)&&(n=e.type,n=!(n!==`form`&&n!==`button`)||Ud(e.type,e.memoizedProps)),n=!n),n&&Mi&&Ii(e),Ri(e),t===13){if(e=e.memoizedState,e=e===null?null:e.dehydrated,!e)throw Error(i(317));Mi=uf(e)}else if(t===31){if(e=e.memoizedState,e=e===null?null:e.dehydrated,!e)throw Error(i(317));Mi=uf(e)}else t===27?(t=Mi,Zd(e.type)?(e=lf,lf=null,Mi=e):Mi=t):Mi=ji?cf(e.stateNode.nextSibling):null;return!0}function Bi(){Mi=ji=null,V=!1}function Vi(){var e=Ni;return e!==null&&(Zl===null?Zl=e:Zl.push.apply(Zl,e),Ni=null),e}function Hi(e){Ni===null?Ni=[e]:Ni.push(e)}var Ui=R(null),Wi=null,Gi=null;function Ki(e,t,n){B(Ui,t._currentValue),t._currentValue=n}function qi(e){e._currentValue=Ui.current,z(Ui)}function Ji(e,t,n){for(;e!==null;){var r=e.alternate;if((e.childLanes&t)===t?r!==null&&(r.childLanes&t)!==t&&(r.childLanes|=t):(e.childLanes|=t,r!==null&&(r.childLanes|=t)),e===n)break;e=e.return}}function Yi(e,t,n,r){var a=e.child;for(a!==null&&(a.return=e);a!==null;){var o=a.dependencies;if(o!==null){var s=a.child;o=o.firstContext;a:for(;o!==null;){var c=o;o=a;for(var l=0;l<t.length;l++)if(c.context===t[l]){o.lanes|=n,c=o.alternate,c!==null&&(c.lanes|=n),Ji(o.return,n,e),r||(s=null);break a}o=c.next}}else if(a.tag===18){if(s=a.return,s===null)throw Error(i(341));s.lanes|=n,o=s.alternate,o!==null&&(o.lanes|=n),Ji(s,n,e),s=null}else s=a.child;if(s!==null)s.return=a;else for(s=a;s!==null;){if(s===e){s=null;break}if(a=s.sibling,a!==null){a.return=s.return,s=a;break}s=s.return}a=s}}function Xi(e,t,n,r){e=null;for(var a=t,o=!1;a!==null;){if(!o){if(a.flags&524288)o=!0;else if(a.flags&262144)break}if(a.tag===10){var s=a.alternate;if(s===null)throw Error(i(387));if(s=s.memoizedProps,s!==null){var c=a.type;br(a.pendingProps.value,s.value)||(e===null?e=[c]:e.push(c))}}else if(a===oe.current){if(s=a.alternate,s===null)throw Error(i(387));s.memoizedState.memoizedState!==a.memoizedState.memoizedState&&(e===null?e=[Qf]:e.push(Qf))}a=a.return}e!==null&&Yi(t,e,n,r),t.flags|=262144}function Zi(e){for(e=e.firstContext;e!==null;){if(!br(e.context._currentValue,e.memoizedValue))return!0;e=e.next}return!1}function Qi(e){Wi=e,Gi=null,e=e.dependencies,e!==null&&(e.firstContext=null)}function $i(e){return ta(Wi,e)}function ea(e,t){return Wi===null&&Qi(e),ta(e,t)}function ta(e,t){var n=t._currentValue;if(t={context:t,memoizedValue:n,next:null},Gi===null){if(e===null)throw Error(i(308));Gi=t,e.dependencies={lanes:0,firstContext:t},e.flags|=524288}else Gi=Gi.next=t;return n}var na=typeof AbortController<`u`?AbortController:function(){var e=[],t=this.signal={aborted:!1,addEventListener:function(t,n){e.push(n)}};this.abort=function(){t.aborted=!0,e.forEach(function(e){return e()})}},ra=t.unstable_scheduleCallback,ia=t.unstable_NormalPriority,aa={$$typeof:C,Consumer:null,Provider:null,_currentValue:null,_currentValue2:null,_threadCount:0};function oa(){return{controller:new na,data:new Map,refCount:0}}function sa(e){e.refCount--,e.refCount===0&&ra(ia,function(){e.controller.abort()})}var ca=null,la=0,ua=0,da=null;function fa(e,t){if(ca===null){var n=ca=[];la=0,ua=dd(),da={status:`pending`,value:void 0,then:function(e){n.push(e)}}}return la++,t.then(pa,pa),t}function pa(){if(--la===0&&ca!==null){da!==null&&(da.status=`fulfilled`);var e=ca;ca=null,ua=0,da=null;for(var t=0;t<e.length;t++)(0,e[t])()}}function ma(e,t){var n=[],r={status:`pending`,value:null,reason:null,then:function(e){n.push(e)}};return e.then(function(){r.status=`fulfilled`,r.value=t;for(var e=0;e<n.length;e++)(0,n[e])(t)},function(e){for(r.status=`rejected`,r.reason=e,e=0;e<n.length;e++)(0,n[e])(void 0)}),r}var ha=F.S;F.S=function(e,t){eu=Ce(),typeof t==`object`&&t&&typeof t.then==`function`&&fa(e,t),ha!==null&&ha(e,t)};var ga=R(null);function _a(){var e=ga.current;return e===null?q.pooledCache:e}function va(e,t){t===null?B(ga,ga.current):B(ga,t.pool)}function ya(){var e=_a();return e===null?null:{parent:aa._currentValue,pool:e}}var ba=Error(i(460)),xa=Error(i(474)),Sa=Error(i(542)),Ca={then:function(){}};function wa(e){return e=e.status,e===`fulfilled`||e===`rejected`}function Ta(e,t,n){switch(n=e[n],n===void 0?e.push(t):n!==t&&(t.then(Zt,Zt),t=n),t.status){case`fulfilled`:return t.value;case`rejected`:throw e=t.reason,H(e),e;default:if(typeof t.status==`string`)t.then(Zt,Zt);else{if(e=q,e!==null&&100<e.shellSuspendCounter)throw Error(i(482));e=t,e.status=`pending`,e.then(function(e){if(t.status===`pending`){var n=t;n.status=`fulfilled`,n.value=e}},function(e){if(t.status===`pending`){var n=t;n.status=`rejected`,n.reason=e}})}switch(t.status){case`fulfilled`:return t.value;case`rejected`:throw e=t.reason,H(e),e}throw Da=t,ba}}function Ea(e){try{var t=e._init;return t(e._payload)}catch(e){throw typeof e==`object`&&e&&typeof e.then==`function`?(Da=e,ba):e}}var Da=null;function Oa(){if(Da===null)throw Error(i(459));var e=Da;return Da=null,e}function H(e){if(e===ba||e===Sa)throw Error(i(483))}var ka=null,Aa=0;function ja(e){var t=Aa;return Aa+=1,ka===null&&(ka=[]),Ta(ka,e,t)}function Ma(e,t){t=t.props.ref,e.ref=t===void 0?null:t}function Na(e,t){throw t.$$typeof===g?Error(i(525)):(e=Object.prototype.toString.call(t),Error(i(31,e===`[object Object]`?`object with keys {`+Object.keys(t).join(`, `)+`}`:e)))}function Pa(e){function t(t,n){if(e){var r=t.deletions;r===null?(t.deletions=[n],t.flags|=16):r.push(n)}}function n(n,r){if(!e)return null;for(;r!==null;)t(n,r),r=r.sibling;return null}function r(e){for(var t=new Map;e!==null;)e.key===null?t.set(e.index,e):t.set(e.key,e),e=e.sibling;return t}function a(e,t){return e=ci(e,t),e.index=0,e.sibling=null,e}function o(t,n,r){return t.index=r,e?(r=t.alternate,r===null?(t.flags|=67108866,n):(r=r.index,r<n?(t.flags|=67108866,n):r)):(t.flags|=1048576,n)}function s(t){return e&&t.alternate===null&&(t.flags|=67108866),t}function c(e,t,n,r){return t===null||t.tag!==6?(t=fi(n,e.mode,r),t.return=e,t):(t=a(t,n),t.return=e,t)}function l(e,t,n,r){var i=n.type;return i===y?d(e,t,n.props.children,r,n.key):t!==null&&(t.elementType===i||typeof i==`object`&&i&&i.$$typeof===O&&Ea(i)===t.type)?(t=a(t,n.props),Ma(t,n),t.return=e,t):(t=ui(n.type,n.key,n.props,null,e.mode,r),Ma(t,n),t.return=e,t)}function u(e,t,n,r){return t===null||t.tag!==4||t.stateNode.containerInfo!==n.containerInfo||t.stateNode.implementation!==n.implementation?(t=mi(n,e.mode,r),t.return=e,t):(t=a(t,n.children||[]),t.return=e,t)}function d(e,t,n,r,i){return t===null||t.tag!==7?(t=di(n,e.mode,r,i),t.return=e,t):(t=a(t,n),t.return=e,t)}function f(e,t,n){if(typeof t==`string`&&t!==``||typeof t==`number`||typeof t==`bigint`)return t=fi(``+t,e.mode,n),t.return=e,t;if(typeof t==`object`&&t){switch(t.$$typeof){case _:return n=ui(t.type,t.key,t.props,null,e.mode,n),Ma(n,t),n.return=e,n;case v:return t=mi(t,e.mode,n),t.return=e,t;case O:return t=Ea(t),f(e,t,n)}if(ee(t)||M(t))return t=di(t,e.mode,n,null),t.return=e,t;if(typeof t.then==`function`)return f(e,ja(t),n);if(t.$$typeof===C)return f(e,ea(e,t),n);Na(e,t)}return null}function p(e,t,n,r){var i=t===null?null:t.key;if(typeof n==`string`&&n!==``||typeof n==`number`||typeof n==`bigint`)return i===null?c(e,t,``+n,r):null;if(typeof n==`object`&&n){switch(n.$$typeof){case _:return n.key===i?l(e,t,n,r):null;case v:return n.key===i?u(e,t,n,r):null;case O:return n=Ea(n),p(e,t,n,r)}if(ee(n)||M(n))return i===null?d(e,t,n,r,null):null;if(typeof n.then==`function`)return p(e,t,ja(n),r);if(n.$$typeof===C)return p(e,t,ea(e,n),r);Na(e,n)}return null}function m(e,t,n,r,i){if(typeof r==`string`&&r!==``||typeof r==`number`||typeof r==`bigint`)return e=e.get(n)||null,c(t,e,``+r,i);if(typeof r==`object`&&r){switch(r.$$typeof){case _:return e=e.get(r.key===null?n:r.key)||null,l(t,e,r,i);case v:return e=e.get(r.key===null?n:r.key)||null,u(t,e,r,i);case O:return r=Ea(r),m(e,t,n,r,i)}if(ee(r)||M(r))return e=e.get(n)||null,d(t,e,r,i,null);if(typeof r.then==`function`)return m(e,t,n,ja(r),i);if(r.$$typeof===C)return m(e,t,n,ea(t,r),i);Na(t,r)}return null}function h(i,a,s,c){for(var l=null,u=null,d=a,h=a=0,g=null;d!==null&&h<s.length;h++){d.index>h?(g=d,d=null):g=d.sibling;var _=p(i,d,s[h],c);if(_===null){d===null&&(d=g);break}e&&d&&_.alternate===null&&t(i,d),a=o(_,a,h),u===null?l=_:u.sibling=_,u=_,d=g}if(h===s.length)return n(i,d),V&&Ei(i,h),l;if(d===null){for(;h<s.length;h++)d=f(i,s[h],c),d!==null&&(a=o(d,a,h),u===null?l=d:u.sibling=d,u=d);return V&&Ei(i,h),l}for(d=r(d);h<s.length;h++)g=m(d,i,h,s[h],c),g!==null&&(e&&g.alternate!==null&&d.delete(g.key===null?h:g.key),a=o(g,a,h),u===null?l=g:u.sibling=g,u=g);return e&&d.forEach(function(e){return t(i,e)}),V&&Ei(i,h),l}function g(a,s,c,l){if(c==null)throw Error(i(151));for(var u=null,d=null,h=s,g=s=0,_=null,v=c.next();h!==null&&!v.done;g++,v=c.next()){h.index>g?(_=h,h=null):_=h.sibling;var y=p(a,h,v.value,l);if(y===null){h===null&&(h=_);break}e&&h&&y.alternate===null&&t(a,h),s=o(y,s,g),d===null?u=y:d.sibling=y,d=y,h=_}if(v.done)return n(a,h),V&&Ei(a,g),u;if(h===null){for(;!v.done;g++,v=c.next())v=f(a,v.value,l),v!==null&&(s=o(v,s,g),d===null?u=v:d.sibling=v,d=v);return V&&Ei(a,g),u}for(h=r(h);!v.done;g++,v=c.next())v=m(h,a,g,v.value,l),v!==null&&(e&&v.alternate!==null&&h.delete(v.key===null?g:v.key),s=o(v,s,g),d===null?u=v:d.sibling=v,d=v);return e&&h.forEach(function(e){return t(a,e)}),V&&Ei(a,g),u}function b(e,r,o,c){if(typeof o==`object`&&o&&o.type===y&&o.key===null&&(o=o.props.children),typeof o==`object`&&o){switch(o.$$typeof){case _:a:{for(var l=o.key;r!==null;){if(r.key===l){if(l=o.type,l===y){if(r.tag===7){n(e,r.sibling),c=a(r,o.props.children),c.return=e,e=c;break a}}else if(r.elementType===l||typeof l==`object`&&l&&l.$$typeof===O&&Ea(l)===r.type){n(e,r.sibling),c=a(r,o.props),Ma(c,o),c.return=e,e=c;break a}n(e,r);break}else t(e,r);r=r.sibling}o.type===y?(c=di(o.props.children,e.mode,c,o.key),c.return=e,e=c):(c=ui(o.type,o.key,o.props,null,e.mode,c),Ma(c,o),c.return=e,e=c)}return s(e);case v:a:{for(l=o.key;r!==null;){if(r.key===l)if(r.tag===4&&r.stateNode.containerInfo===o.containerInfo&&r.stateNode.implementation===o.implementation){n(e,r.sibling),c=a(r,o.children||[]),c.return=e,e=c;break a}else{n(e,r);break}else t(e,r);r=r.sibling}c=mi(o,e.mode,c),c.return=e,e=c}return s(e);case O:return o=Ea(o),b(e,r,o,c)}if(ee(o))return h(e,r,o,c);if(M(o)){if(l=M(o),typeof l!=`function`)throw Error(i(150));return o=l.call(o),g(e,r,o,c)}if(typeof o.then==`function`)return b(e,r,ja(o),c);if(o.$$typeof===C)return b(e,r,ea(e,o),c);Na(e,o)}return typeof o==`string`&&o!==``||typeof o==`number`||typeof o==`bigint`?(o=``+o,r!==null&&r.tag===6?(n(e,r.sibling),c=a(r,o),c.return=e,e=c):(n(e,r),c=fi(o,e.mode,c),c.return=e,e=c),s(e)):n(e,r)}return function(e,t,n,r){try{Aa=0;var i=b(e,t,n,r);return ka=null,i}catch(t){if(t===ba||t===Sa)throw t;var a=oi(29,t,null,e.mode);return a.lanes=r,a.return=e,a}}}var Fa=Pa(!0),Ia=Pa(!1),La=!1;function Ra(e){e.updateQueue={baseState:e.memoizedState,firstBaseUpdate:null,lastBaseUpdate:null,shared:{pending:null,lanes:0,hiddenCallbacks:null},callbacks:null}}function za(e,t){e=e.updateQueue,t.updateQueue===e&&(t.updateQueue={baseState:e.baseState,firstBaseUpdate:e.firstBaseUpdate,lastBaseUpdate:e.lastBaseUpdate,shared:e.shared,callbacks:null})}function Ba(e){return{lane:e,tag:0,payload:null,callback:null,next:null}}function Va(e,t,n){var r=e.updateQueue;if(r===null)return null;if(r=r.shared,K&2){var i=r.pending;return i===null?t.next=t:(t.next=i.next,i.next=t),r.pending=t,t=ri(e),ni(e,null,n),t}return $r(e,r,t,n),ri(e)}function Ha(e,t,n){if(t=t.updateQueue,t!==null&&(t=t.shared,n&4194048)){var r=t.lanes;r&=e.pendingLanes,n|=r,t.lanes=n,Ze(e,n)}}function Ua(e,t){var n=e.updateQueue,r=e.alternate;if(r!==null&&(r=r.updateQueue,n===r)){var i=null,a=null;if(n=n.firstBaseUpdate,n!==null){do{var o={lane:n.lane,tag:n.tag,payload:n.payload,callback:null,next:null};a===null?i=a=o:a=a.next=o,n=n.next}while(n!==null);a===null?i=a=t:a=a.next=t}else i=a=t;n={baseState:r.baseState,firstBaseUpdate:i,lastBaseUpdate:a,shared:r.shared,callbacks:r.callbacks},e.updateQueue=n;return}e=n.lastBaseUpdate,e===null?n.firstBaseUpdate=t:e.next=t,n.lastBaseUpdate=t}var Wa=!1;function Ga(){if(Wa){var e=da;if(e!==null)throw e}}function Ka(e,t,n,r){Wa=!1;var i=e.updateQueue;La=!1;var a=i.firstBaseUpdate,o=i.lastBaseUpdate,s=i.shared.pending;if(s!==null){i.shared.pending=null;var c=s,l=c.next;c.next=null,o===null?a=l:o.next=l,o=c;var u=e.alternate;u!==null&&(u=u.updateQueue,s=u.lastBaseUpdate,s!==o&&(s===null?u.firstBaseUpdate=l:s.next=l,u.lastBaseUpdate=c))}if(a!==null){var d=i.baseState;o=0,u=l=c=null,s=a;do{var f=s.lane&-536870913,p=f!==s.lane;if(p?(Y&f)===f:(r&f)===f){f!==0&&f===ua&&(Wa=!0),u!==null&&(u=u.next={lane:0,tag:s.tag,payload:s.payload,callback:null,next:null});a:{var m=e,g=s;f=t;var _=n;switch(g.tag){case 1:if(m=g.payload,typeof m==`function`){d=m.call(_,d,f);break a}d=m;break a;case 3:m.flags=m.flags&-65537|128;case 0:if(m=g.payload,f=typeof m==`function`?m.call(_,d,f):m,f==null)break a;d=h({},d,f);break a;case 2:La=!0}}f=s.callback,f!==null&&(e.flags|=64,p&&(e.flags|=8192),p=i.callbacks,p===null?i.callbacks=[f]:p.push(f))}else p={lane:f,tag:s.tag,payload:s.payload,callback:s.callback,next:null},u===null?(l=u=p,c=d):u=u.next=p,o|=f;if(s=s.next,s===null){if(s=i.shared.pending,s===null)break;p=s,s=p.next,p.next=null,i.lastBaseUpdate=p,i.shared.pending=null}}while(1);u===null&&(c=d),i.baseState=c,i.firstBaseUpdate=l,i.lastBaseUpdate=u,a===null&&(i.shared.lanes=0),Gl|=o,e.lanes=o,e.memoizedState=d}}function qa(e,t){if(typeof e!=`function`)throw Error(i(191,e));e.call(t)}function Ja(e,t){var n=e.callbacks;if(n!==null)for(e.callbacks=null,e=0;e<n.length;e++)qa(n[e],t)}var Ya=R(null),Xa=R(0);function Za(e,t){e=Ul,B(Xa,e),B(Ya,t),Ul=e|t.baseLanes}function Qa(){B(Xa,Ul),B(Ya,Ya.current)}function $a(){Ul=Xa.current,z(Ya),z(Xa)}var eo=R(null),to=null;function no(e){var t=e.alternate;B(so,so.current&1),B(eo,e),to===null&&(t===null||Ya.current!==null||t.memoizedState!==null)&&(to=e)}function ro(e){B(so,so.current),B(eo,e),to===null&&(to=e)}function io(e){e.tag===22?(B(so,so.current),B(eo,e),to===null&&(to=e)):ao(e)}function ao(){B(so,so.current),B(eo,eo.current)}function oo(e){z(eo),to===e&&(to=null),z(so)}var so=R(0);function co(e){for(var t=e;t!==null;){if(t.tag===13){var n=t.memoizedState;if(n!==null&&(n=n.dehydrated,n===null||af(n)||of(n)))return t}else if(t.tag===19&&(t.memoizedProps.revealOrder===`forwards`||t.memoizedProps.revealOrder===`backwards`||t.memoizedProps.revealOrder===`unstable_legacy-backwards`||t.memoizedProps.revealOrder===`together`)){if(t.flags&128)return t}else if(t.child!==null){t.child.return=t,t=t.child;continue}if(t===e)break;for(;t.sibling===null;){if(t.return===null||t.return===e)return null;t=t.return}t.sibling.return=t.return,t=t.sibling}return null}var lo=0,U=null,W=null,uo=null,fo=!1,po=!1,mo=!1,ho=0,go=0,_o=null,vo=0;function yo(){throw Error(i(321))}function bo(e,t){if(t===null)return!1;for(var n=0;n<t.length&&n<e.length;n++)if(!br(e[n],t[n]))return!1;return!0}function xo(e,t,n,r,i,a){return lo=a,U=t,t.memoizedState=null,t.updateQueue=null,t.lanes=0,F.H=e===null||e.memoizedState===null?Rs:zs,mo=!1,a=n(r,i),mo=!1,po&&(a=Co(t,n,r,i)),So(e),a}function So(e){F.H=Ls;var t=W!==null&&W.next!==null;if(lo=0,uo=W=U=null,fo=!1,go=0,_o=null,t)throw Error(i(300));e===null||nc||(e=e.dependencies,e!==null&&Zi(e)&&(nc=!0))}function Co(e,t,n,r){U=e;var a=0;do{if(po&&(_o=null),go=0,po=!1,25<=a)throw Error(i(301));if(a+=1,uo=W=null,e.updateQueue!=null){var o=e.updateQueue;o.lastEffect=null,o.events=null,o.stores=null,o.memoCache!=null&&(o.memoCache.index=0)}F.H=Bs,o=t(n,r)}while(po);return o}function wo(){var e=F.H,t=e.useState()[0];return t=typeof t.then==`function`?jo(t):t,e=e.useState()[0],(W===null?null:W.memoizedState)!==e&&(U.flags|=1024),t}function To(){var e=ho!==0;return ho=0,e}function Eo(e,t,n){t.updateQueue=e.updateQueue,t.flags&=-2053,e.lanes&=~n}function Do(e){if(fo){for(e=e.memoizedState;e!==null;){var t=e.queue;t!==null&&(t.pending=null),e=e.next}fo=!1}lo=0,uo=W=U=null,po=!1,go=ho=0,_o=null}function Oo(){var e={memoizedState:null,baseState:null,baseQueue:null,queue:null,next:null};return uo===null?U.memoizedState=uo=e:uo=uo.next=e,uo}function ko(){if(W===null){var e=U.alternate;e=e===null?null:e.memoizedState}else e=W.next;var t=uo===null?U.memoizedState:uo.next;if(t!==null)uo=t,W=e;else{if(e===null)throw U.alternate===null?Error(i(467)):Error(i(310));W=e,e={memoizedState:W.memoizedState,baseState:W.baseState,baseQueue:W.baseQueue,queue:W.queue,next:null},uo===null?U.memoizedState=uo=e:uo=uo.next=e}return uo}function Ao(){return{lastEffect:null,events:null,stores:null,memoCache:null}}function jo(e){var t=go;return go+=1,_o===null&&(_o=[]),e=Ta(_o,e,t),t=U,(uo===null?t.memoizedState:uo.next)===null&&(t=t.alternate,F.H=t===null||t.memoizedState===null?Rs:zs),e}function Mo(e){if(typeof e==`object`&&e){if(typeof e.then==`function`)return jo(e);if(e.$$typeof===C)return $i(e)}throw Error(i(438,String(e)))}function No(e){var t=null,n=U.updateQueue;if(n!==null&&(t=n.memoCache),t==null){var r=U.alternate;r!==null&&(r=r.updateQueue,r!==null&&(r=r.memoCache,r!=null&&(t={data:r.data.map(function(e){return e.slice()}),index:0})))}if(t??={data:[],index:0},n===null&&(n=Ao(),U.updateQueue=n),n.memoCache=t,n=t.data[t.index],n===void 0)for(n=t.data[t.index]=Array(e),r=0;r<e;r++)n[r]=A;return t.index++,n}function Po(e,t){return typeof t==`function`?t(e):t}function Fo(e){return Io(ko(),W,e)}function Io(e,t,n){var r=e.queue;if(r===null)throw Error(i(311));r.lastRenderedReducer=n;var a=e.baseQueue,o=r.pending;if(o!==null){if(a!==null){var s=a.next;a.next=o.next,o.next=s}t.baseQueue=a=o,r.pending=null}if(o=e.baseState,a===null)e.memoizedState=o;else{t=a.next;var c=s=null,l=null,u=t,d=!1;do{var f=u.lane&-536870913;if(f===u.lane?(lo&f)===f:(Y&f)===f){var p=u.revertLane;if(p===0)l!==null&&(l=l.next={lane:0,revertLane:0,gesture:null,action:u.action,hasEagerState:u.hasEagerState,eagerState:u.eagerState,next:null}),f===ua&&(d=!0);else if((lo&p)===p){u=u.next,p===ua&&(d=!0);continue}else f={lane:0,revertLane:u.revertLane,gesture:null,action:u.action,hasEagerState:u.hasEagerState,eagerState:u.eagerState,next:null},l===null?(c=l=f,s=o):l=l.next=f,U.lanes|=p,Gl|=p;f=u.action,mo&&n(o,f),o=u.hasEagerState?u.eagerState:n(o,f)}else p={lane:f,revertLane:u.revertLane,gesture:u.gesture,action:u.action,hasEagerState:u.hasEagerState,eagerState:u.eagerState,next:null},l===null?(c=l=p,s=o):l=l.next=p,U.lanes|=f,Gl|=f;u=u.next}while(u!==null&&u!==t);if(l===null?s=o:l.next=c,!br(o,e.memoizedState)&&(nc=!0,d&&(n=da,n!==null)))throw n;e.memoizedState=o,e.baseState=s,e.baseQueue=l,r.lastRenderedState=o}return a===null&&(r.lanes=0),[e.memoizedState,r.dispatch]}function Lo(e){var t=ko(),n=t.queue;if(n===null)throw Error(i(311));n.lastRenderedReducer=e;var r=n.dispatch,a=n.pending,o=t.memoizedState;if(a!==null){n.pending=null;var s=a=a.next;do o=e(o,s.action),s=s.next;while(s!==a);br(o,t.memoizedState)||(nc=!0),t.memoizedState=o,t.baseQueue===null&&(t.baseState=o),n.lastRenderedState=o}return[o,r]}function Ro(e,t,n){var r=U,a=ko(),o=V;if(o){if(n===void 0)throw Error(i(407));n=n()}else n=t();var s=!br((W||a).memoizedState,n);if(s&&(a.memoizedState=n,nc=!0),a=a.queue,ls(Vo.bind(null,r,a,e),[e]),a.getSnapshot!==t||s||uo!==null&&uo.memoizedState.tag&1){if(r.flags|=2048,is(9,{destroy:void 0},Bo.bind(null,r,a,n,t),null),q===null)throw Error(i(349));o||lo&127||zo(r,t,n)}return n}function zo(e,t,n){e.flags|=16384,e={getSnapshot:t,value:n},t=U.updateQueue,t===null?(t=Ao(),U.updateQueue=t,t.stores=[e]):(n=t.stores,n===null?t.stores=[e]:n.push(e))}function Bo(e,t,n,r){t.value=n,t.getSnapshot=r,Ho(t)&&Uo(e)}function Vo(e,t,n){return n(function(){Ho(t)&&Uo(e)})}function Ho(e){var t=e.getSnapshot;e=e.value;try{var n=t();return!br(e,n)}catch{return!0}}function Uo(e){var t=ti(e,2);t!==null&&hu(t,e,2)}function Wo(e){var t=Oo();if(typeof e==`function`){var n=e;if(e=n(),mo){Pe(!0);try{n()}finally{Pe(!1)}}}return t.memoizedState=t.baseState=e,t.queue={pending:null,lanes:0,dispatch:null,lastRenderedReducer:Po,lastRenderedState:e},t}function Go(e,t,n,r){return e.baseState=n,Io(e,W,typeof r==`function`?r:Po)}function Ko(e,t,n,r,a){if(Ps(e))throw Error(i(485));if(e=t.action,e!==null){var o={payload:a,action:e,next:null,isTransition:!0,status:`pending`,value:null,reason:null,listeners:[],then:function(e){o.listeners.push(e)}};F.T===null?o.isTransition=!1:n(!0),r(o),n=t.pending,n===null?(o.next=t.pending=o,qo(t,o)):(o.next=n.next,t.pending=n.next=o)}}function qo(e,t){var n=t.action,r=t.payload,i=e.state;if(t.isTransition){var a=F.T,o={};F.T=o;try{var s=n(i,r),c=F.S;c!==null&&c(o,s),Jo(e,t,s)}catch(n){Xo(e,t,n)}finally{a!==null&&o.types!==null&&(a.types=o.types),F.T=a}}else try{a=n(i,r),Jo(e,t,a)}catch(n){Xo(e,t,n)}}function Jo(e,t,n){typeof n==`object`&&n&&typeof n.then==`function`?n.then(function(n){Yo(e,t,n)},function(n){return Xo(e,t,n)}):Yo(e,t,n)}function Yo(e,t,n){t.status=`fulfilled`,t.value=n,Zo(t),e.state=n,t=e.pending,t!==null&&(n=t.next,n===t?e.pending=null:(n=n.next,t.next=n,qo(e,n)))}function Xo(e,t,n){var r=e.pending;if(e.pending=null,r!==null){r=r.next;do t.status=`rejected`,t.reason=n,Zo(t),t=t.next;while(t!==r)}e.action=null}function Zo(e){e=e.listeners;for(var t=0;t<e.length;t++)(0,e[t])()}function Qo(e,t){return t}function $o(e,t){if(V){var n=q.formState;if(n!==null){a:{var r=U;if(V){if(Mi){b:{for(var i=Mi,a=Pi;i.nodeType!==8;){if(!a){i=null;break b}if(i=cf(i.nextSibling),i===null){i=null;break b}}a=i.data,i=a===`F!`||a===`F`?i:null}if(i){Mi=cf(i.nextSibling),r=i.data===`F!`;break a}}Ii(r)}r=!1}r&&(t=n[0])}}return n=Oo(),n.memoizedState=n.baseState=t,r={pending:null,lanes:0,dispatch:null,lastRenderedReducer:Qo,lastRenderedState:t},n.queue=r,n=js.bind(null,U,r),r.dispatch=n,r=Wo(!1),a=Ns.bind(null,U,!1,r.queue),r=Oo(),i={state:t,dispatch:null,action:e,pending:null},r.queue=i,n=Ko.bind(null,U,i,a,n),i.dispatch=n,r.memoizedState=e,[t,n,!1]}function es(e){return ts(ko(),W,e)}function ts(e,t,n){if(t=Io(e,t,Qo)[0],e=Fo(Po)[0],typeof t==`object`&&t&&typeof t.then==`function`)try{var r=jo(t)}catch(e){throw e===ba?Sa:e}else r=t;t=ko();var i=t.queue,a=i.dispatch;return n!==t.memoizedState&&(U.flags|=2048,is(9,{destroy:void 0},ns.bind(null,i,n),null)),[r,a,e]}function ns(e,t){e.action=t}function rs(e){var t=ko(),n=W;if(n!==null)return ts(t,n,e);ko(),t=t.memoizedState,n=ko();var r=n.queue.dispatch;return n.memoizedState=e,[t,r,!1]}function is(e,t,n,r){return e={tag:e,create:n,deps:r,inst:t,next:null},t=U.updateQueue,t===null&&(t=Ao(),U.updateQueue=t),n=t.lastEffect,n===null?t.lastEffect=e.next=e:(r=n.next,n.next=e,e.next=r,t.lastEffect=e),e}function as(){return ko().memoizedState}function os(e,t,n,r){var i=Oo();U.flags|=e,i.memoizedState=is(1|t,{destroy:void 0},n,r===void 0?null:r)}function ss(e,t,n,r){var i=ko();r=r===void 0?null:r;var a=i.memoizedState.inst;W!==null&&r!==null&&bo(r,W.memoizedState.deps)?i.memoizedState=is(t,a,n,r):(U.flags|=e,i.memoizedState=is(1|t,a,n,r))}function cs(e,t){os(8390656,8,e,t)}function ls(e,t){ss(2048,8,e,t)}function us(e){U.flags|=4;var t=U.updateQueue;if(t===null)t=Ao(),U.updateQueue=t,t.events=[e];else{var n=t.events;n===null?t.events=[e]:n.push(e)}}function ds(e){var t=ko().memoizedState;return us({ref:t,nextImpl:e}),function(){if(K&2)throw Error(i(440));return t.impl.apply(void 0,arguments)}}function fs(e,t){return ss(4,2,e,t)}function ps(e,t){return ss(4,4,e,t)}function ms(e,t){if(typeof t==`function`){e=e();var n=t(e);return function(){typeof n==`function`?n():t(null)}}if(t!=null)return e=e(),t.current=e,function(){t.current=null}}function hs(e,t,n){n=n==null?null:n.concat([e]),ss(4,4,ms.bind(null,t,e),n)}function gs(){}function _s(e,t){var n=ko();t=t===void 0?null:t;var r=n.memoizedState;return t!==null&&bo(t,r[1])?r[0]:(n.memoizedState=[e,t],e)}function vs(e,t){var n=ko();t=t===void 0?null:t;var r=n.memoizedState;if(t!==null&&bo(t,r[1]))return r[0];if(r=e(),mo){Pe(!0);try{e()}finally{Pe(!1)}}return n.memoizedState=[r,t],r}function ys(e,t,n){return n===void 0||lo&1073741824&&!(Y&261930)?e.memoizedState=t:(e.memoizedState=n,e=mu(),U.lanes|=e,Gl|=e,n)}function bs(e,t,n,r){return br(n,t)?n:Ya.current===null?!(lo&42)||lo&1073741824&&!(Y&261930)?(nc=!0,e.memoizedState=n):(e=mu(),U.lanes|=e,Gl|=e,t):(e=ys(e,n,r),br(e,t)||(nc=!0),e)}function xs(e,t,n,r,i){var a=I.p;I.p=a!==0&&8>a?a:8;var o=F.T,s={};F.T=s,Ns(e,!1,t,n);try{var c=i(),l=F.S;l!==null&&l(s,c),typeof c==`object`&&c&&typeof c.then==`function`?Ms(e,t,ma(c,r),pu(e)):Ms(e,t,r,pu(e))}catch(n){Ms(e,t,{then:function(){},status:`rejected`,reason:n},pu())}finally{I.p=a,o!==null&&s.types!==null&&(o.types=s.types),F.T=o}}function Ss(){}function Cs(e,t,n,r){if(e.tag!==5)throw Error(i(476));var a=ws(e).queue;xs(e,a,t,te,n===null?Ss:function(){return Ts(e),n(r)})}function ws(e){var t=e.memoizedState;if(t!==null)return t;t={memoizedState:te,baseState:te,baseQueue:null,queue:{pending:null,lanes:0,dispatch:null,lastRenderedReducer:Po,lastRenderedState:te},next:null};var n={};return t.next={memoizedState:n,baseState:n,baseQueue:null,queue:{pending:null,lanes:0,dispatch:null,lastRenderedReducer:Po,lastRenderedState:n},next:null},e.memoizedState=t,e=e.alternate,e!==null&&(e.memoizedState=t),t}function Ts(e){var t=ws(e);t.next===null&&(t=e.alternate.memoizedState),Ms(e,t.next.queue,{},pu())}function Es(){return $i(Qf)}function Ds(){return ko().memoizedState}function Os(){return ko().memoizedState}function ks(e){for(var t=e.return;t!==null;){switch(t.tag){case 24:case 3:var n=pu();e=Ba(n);var r=Va(t,e,n);r!==null&&(hu(r,t,n),Ha(r,t,n)),t={cache:oa()},e.payload=t;return}t=t.return}}function As(e,t,n){var r=pu();n={lane:r,revertLane:0,gesture:null,action:n,hasEagerState:!1,eagerState:null,next:null},Ps(e)?Fs(t,n):(n=ei(e,t,n,r),n!==null&&(hu(n,e,r),Is(n,t,r)))}function js(e,t,n){Ms(e,t,n,pu())}function Ms(e,t,n,r){var i={lane:r,revertLane:0,gesture:null,action:n,hasEagerState:!1,eagerState:null,next:null};if(Ps(e))Fs(t,i);else{var a=e.alternate;if(e.lanes===0&&(a===null||a.lanes===0)&&(a=t.lastRenderedReducer,a!==null))try{var o=t.lastRenderedState,s=a(o,n);if(i.hasEagerState=!0,i.eagerState=s,br(s,o))return $r(e,t,i,0),q===null&&Qr(),!1}catch{}if(n=ei(e,t,i,r),n!==null)return hu(n,e,r),Is(n,t,r),!0}return!1}function Ns(e,t,n,r){if(r={lane:2,revertLane:dd(),gesture:null,action:r,hasEagerState:!1,eagerState:null,next:null},Ps(e)){if(t)throw Error(i(479))}else t=ei(e,n,r,2),t!==null&&hu(t,e,2)}function Ps(e){var t=e.alternate;return e===U||t!==null&&t===U}function Fs(e,t){po=fo=!0;var n=e.pending;n===null?t.next=t:(t.next=n.next,n.next=t),e.pending=t}function Is(e,t,n){if(n&4194048){var r=t.lanes;r&=e.pendingLanes,n|=r,t.lanes=n,Ze(e,n)}}var Ls={readContext:$i,use:Mo,useCallback:yo,useContext:yo,useEffect:yo,useImperativeHandle:yo,useLayoutEffect:yo,useInsertionEffect:yo,useMemo:yo,useReducer:yo,useRef:yo,useState:yo,useDebugValue:yo,useDeferredValue:yo,useTransition:yo,useSyncExternalStore:yo,useId:yo,useHostTransitionStatus:yo,useFormState:yo,useActionState:yo,useOptimistic:yo,useMemoCache:yo,useCacheRefresh:yo};Ls.useEffectEvent=yo;var Rs={readContext:$i,use:Mo,useCallback:function(e,t){return Oo().memoizedState=[e,t===void 0?null:t],e},useContext:$i,useEffect:cs,useImperativeHandle:function(e,t,n){n=n==null?null:n.concat([e]),os(4194308,4,ms.bind(null,t,e),n)},useLayoutEffect:function(e,t){return os(4194308,4,e,t)},useInsertionEffect:function(e,t){os(4,2,e,t)},useMemo:function(e,t){var n=Oo();t=t===void 0?null:t;var r=e();if(mo){Pe(!0);try{e()}finally{Pe(!1)}}return n.memoizedState=[r,t],r},useReducer:function(e,t,n){var r=Oo();if(n!==void 0){var i=n(t);if(mo){Pe(!0);try{n(t)}finally{Pe(!1)}}}else i=t;return r.memoizedState=r.baseState=i,e={pending:null,lanes:0,dispatch:null,lastRenderedReducer:e,lastRenderedState:i},r.queue=e,e=e.dispatch=As.bind(null,U,e),[r.memoizedState,e]},useRef:function(e){var t=Oo();return e={current:e},t.memoizedState=e},useState:function(e){e=Wo(e);var t=e.queue,n=js.bind(null,U,t);return t.dispatch=n,[e.memoizedState,n]},useDebugValue:gs,useDeferredValue:function(e,t){return ys(Oo(),e,t)},useTransition:function(){var e=Wo(!1);return e=xs.bind(null,U,e.queue,!0,!1),Oo().memoizedState=e,[!1,e]},useSyncExternalStore:function(e,t,n){var r=U,a=Oo();if(V){if(n===void 0)throw Error(i(407));n=n()}else{if(n=t(),q===null)throw Error(i(349));Y&127||zo(r,t,n)}a.memoizedState=n;var o={value:n,getSnapshot:t};return a.queue=o,cs(Vo.bind(null,r,o,e),[e]),r.flags|=2048,is(9,{destroy:void 0},Bo.bind(null,r,o,n,t),null),n},useId:function(){var e=Oo(),t=q.identifierPrefix;if(V){var n=Ti,r=wi;n=(r&~(1<<32-Fe(r)-1)).toString(32)+n,t=`_`+t+`R_`+n,n=ho++,0<n&&(t+=`H`+n.toString(32)),t+=`_`}else n=vo++,t=`_`+t+`r_`+n.toString(32)+`_`;return e.memoizedState=t},useHostTransitionStatus:Es,useFormState:$o,useActionState:$o,useOptimistic:function(e){var t=Oo();t.memoizedState=t.baseState=e;var n={pending:null,lanes:0,dispatch:null,lastRenderedReducer:null,lastRenderedState:null};return t.queue=n,t=Ns.bind(null,U,!0,n),n.dispatch=t,[e,t]},useMemoCache:No,useCacheRefresh:function(){return Oo().memoizedState=ks.bind(null,U)},useEffectEvent:function(e){var t=Oo(),n={impl:e};return t.memoizedState=n,function(){if(K&2)throw Error(i(440));return n.impl.apply(void 0,arguments)}}},zs={readContext:$i,use:Mo,useCallback:_s,useContext:$i,useEffect:ls,useImperativeHandle:hs,useInsertionEffect:fs,useLayoutEffect:ps,useMemo:vs,useReducer:Fo,useRef:as,useState:function(){return Fo(Po)},useDebugValue:gs,useDeferredValue:function(e,t){return bs(ko(),W.memoizedState,e,t)},useTransition:function(){var e=Fo(Po)[0],t=ko().memoizedState;return[typeof e==`boolean`?e:jo(e),t]},useSyncExternalStore:Ro,useId:Ds,useHostTransitionStatus:Es,useFormState:es,useActionState:es,useOptimistic:function(e,t){return Go(ko(),W,e,t)},useMemoCache:No,useCacheRefresh:Os};zs.useEffectEvent=ds;var Bs={readContext:$i,use:Mo,useCallback:_s,useContext:$i,useEffect:ls,useImperativeHandle:hs,useInsertionEffect:fs,useLayoutEffect:ps,useMemo:vs,useReducer:Lo,useRef:as,useState:function(){return Lo(Po)},useDebugValue:gs,useDeferredValue:function(e,t){var n=ko();return W===null?ys(n,e,t):bs(n,W.memoizedState,e,t)},useTransition:function(){var e=Lo(Po)[0],t=ko().memoizedState;return[typeof e==`boolean`?e:jo(e),t]},useSyncExternalStore:Ro,useId:Ds,useHostTransitionStatus:Es,useFormState:rs,useActionState:rs,useOptimistic:function(e,t){var n=ko();return W===null?(n.baseState=e,[e,n.queue.dispatch]):Go(n,W,e,t)},useMemoCache:No,useCacheRefresh:Os};Bs.useEffectEvent=ds;function Vs(e,t,n,r){t=e.memoizedState,n=n(r,t),n=n==null?t:h({},t,n),e.memoizedState=n,e.lanes===0&&(e.updateQueue.baseState=n)}var Hs={enqueueSetState:function(e,t,n){e=e._reactInternals;var r=pu(),i=Ba(r);i.payload=t,n!=null&&(i.callback=n),t=Va(e,i,r),t!==null&&(hu(t,e,r),Ha(t,e,r))},enqueueReplaceState:function(e,t,n){e=e._reactInternals;var r=pu(),i=Ba(r);i.tag=1,i.payload=t,n!=null&&(i.callback=n),t=Va(e,i,r),t!==null&&(hu(t,e,r),Ha(t,e,r))},enqueueForceUpdate:function(e,t){e=e._reactInternals;var n=pu(),r=Ba(n);r.tag=2,t!=null&&(r.callback=t),t=Va(e,r,n),t!==null&&(hu(t,e,n),Ha(t,e,n))}};function Us(e,t,n,r,i,a,o){return e=e.stateNode,typeof e.shouldComponentUpdate==`function`?e.shouldComponentUpdate(r,a,o):t.prototype&&t.prototype.isPureReactComponent?!xr(n,r)||!xr(i,a):!0}function Ws(e,t,n,r){e=t.state,typeof t.componentWillReceiveProps==`function`&&t.componentWillReceiveProps(n,r),typeof t.UNSAFE_componentWillReceiveProps==`function`&&t.UNSAFE_componentWillReceiveProps(n,r),t.state!==e&&Hs.enqueueReplaceState(t,t.state,null)}function Gs(e,t){var n=t;if(`ref`in t)for(var r in n={},t)r!==`ref`&&(n[r]=t[r]);if(e=e.defaultProps)for(var i in n===t&&(n=h({},n)),e)n[i]===void 0&&(n[i]=e[i]);return n}function Ks(e){Jr(e)}function qs(e){console.error(e)}function Js(e){Jr(e)}function Ys(e,t){try{var n=e.onUncaughtError;n(t.value,{componentStack:t.stack})}catch(e){setTimeout(function(){throw e})}}function Xs(e,t,n){try{var r=e.onCaughtError;r(n.value,{componentStack:n.stack,errorBoundary:t.tag===1?t.stateNode:null})}catch(e){setTimeout(function(){throw e})}}function Zs(e,t,n){return n=Ba(n),n.tag=3,n.payload={element:null},n.callback=function(){Ys(e,t)},n}function Qs(e){return e=Ba(e),e.tag=3,e}function $s(e,t,n,r){var i=n.type.getDerivedStateFromError;if(typeof i==`function`){var a=r.value;e.payload=function(){return i(a)},e.callback=function(){Xs(t,n,r)}}var o=n.stateNode;o!==null&&typeof o.componentDidCatch==`function`&&(e.callback=function(){Xs(t,n,r),typeof i!=`function`&&(ru===null?ru=new Set([this]):ru.add(this));var e=r.stack;this.componentDidCatch(r.value,{componentStack:e===null?``:e})})}function ec(e,t,n,r,a){if(n.flags|=32768,typeof r==`object`&&r&&typeof r.then==`function`){if(t=n.alternate,t!==null&&Xi(t,n,a,!0),n=eo.current,n!==null){switch(n.tag){case 31:case 13:return to===null?Du():n.alternate===null&&Wl===0&&(Wl=3),n.flags&=-257,n.flags|=65536,n.lanes=a,r===Ca?n.flags|=16384:(t=n.updateQueue,t===null?n.updateQueue=new Set([r]):t.add(r),Gu(e,r,a)),!1;case 22:return n.flags|=65536,r===Ca?n.flags|=16384:(t=n.updateQueue,t===null?(t={transitions:null,markerInstances:null,retryQueue:new Set([r])},n.updateQueue=t):(n=t.retryQueue,n===null?t.retryQueue=new Set([r]):n.add(r)),Gu(e,r,a)),!1}throw Error(i(435,n.tag))}return Gu(e,r,a),Du(),!1}if(V)return t=eo.current,t===null?(r!==Fi&&(t=Error(i(423),{cause:r}),Hi(gi(t,n))),e=e.current.alternate,e.flags|=65536,a&=-a,e.lanes|=a,r=gi(r,n),a=Zs(e.stateNode,r,a),Ua(e,a),Wl!==4&&(Wl=2)):(!(t.flags&65536)&&(t.flags|=256),t.flags|=65536,t.lanes=a,r!==Fi&&(e=Error(i(422),{cause:r}),Hi(gi(e,n)))),!1;var o=Error(i(520),{cause:r});if(o=gi(o,n),Xl===null?Xl=[o]:Xl.push(o),Wl!==4&&(Wl=2),t===null)return!0;r=gi(r,n),n=t;do{switch(n.tag){case 3:return n.flags|=65536,e=a&-a,n.lanes|=e,e=Zs(n.stateNode,r,e),Ua(n,e),!1;case 1:if(t=n.type,o=n.stateNode,!(n.flags&128)&&(typeof t.getDerivedStateFromError==`function`||o!==null&&typeof o.componentDidCatch==`function`&&(ru===null||!ru.has(o))))return n.flags|=65536,a&=-a,n.lanes|=a,a=Qs(a),$s(a,e,n,r),Ua(n,a),!1}n=n.return}while(n!==null);return!1}var tc=Error(i(461)),nc=!1;function rc(e,t,n,r){t.child=e===null?Ia(t,null,n,r):Fa(t,e.child,n,r)}function ic(e,t,n,r,i){n=n.render;var a=t.ref;if(`ref`in r){var o={};for(var s in r)s!==`ref`&&(o[s]=r[s])}else o=r;return Qi(t),r=xo(e,t,n,o,a,i),s=To(),e!==null&&!nc?(Eo(e,t,i),Dc(e,t,i)):(V&&s&&Oi(t),t.flags|=1,rc(e,t,r,i),t.child)}function ac(e,t,n,r,i){if(e===null){var a=n.type;return typeof a==`function`&&!si(a)&&a.defaultProps===void 0&&n.compare===null?(t.tag=15,t.type=a,oc(e,t,a,r,i)):(e=ui(n.type,null,r,t,t.mode,i),e.ref=t.ref,e.return=t,t.child=e)}if(a=e.child,!Oc(e,i)){var o=a.memoizedProps;if(n=n.compare,n=n===null?xr:n,n(o,r)&&e.ref===t.ref)return Dc(e,t,i)}return t.flags|=1,e=ci(a,r),e.ref=t.ref,e.return=t,t.child=e}function oc(e,t,n,r,i){if(e!==null){var a=e.memoizedProps;if(xr(a,r)&&e.ref===t.ref)if(nc=!1,t.pendingProps=r=a,Oc(e,i))e.flags&131072&&(nc=!0);else return t.lanes=e.lanes,Dc(e,t,i)}return mc(e,t,n,r,i)}function sc(e,t,n,r){var i=r.children,a=e===null?null:e.memoizedState;if(e===null&&t.stateNode===null&&(t.stateNode={_visibility:1,_pendingMarkers:null,_retryCache:null,_transitions:null}),r.mode===`hidden`){if(t.flags&128){if(a=a===null?n:a.baseLanes|n,e!==null){for(r=t.child=e.child,i=0;r!==null;)i=i|r.lanes|r.childLanes,r=r.sibling;r=i&~a}else r=0,t.child=null;return lc(e,t,a,n,r)}if(n&536870912)t.memoizedState={baseLanes:0,cachePool:null},e!==null&&va(t,a===null?null:a.cachePool),a===null?Qa():Za(t,a),io(t);else return r=t.lanes=536870912,lc(e,t,a===null?n:a.baseLanes|n,n,r)}else a===null?(e!==null&&va(t,null),Qa(),ao(t)):(va(t,a.cachePool),Za(t,a),ao(t),t.memoizedState=null);return rc(e,t,i,n),t.child}function cc(e,t){return e!==null&&e.tag===22||t.stateNode!==null||(t.stateNode={_visibility:1,_pendingMarkers:null,_retryCache:null,_transitions:null}),t.sibling}function lc(e,t,n,r,i){var a=_a();return a=a===null?null:{parent:aa._currentValue,pool:a},t.memoizedState={baseLanes:n,cachePool:a},e!==null&&va(t,null),Qa(),io(t),e!==null&&Xi(e,t,r,!0),t.childLanes=i,null}function uc(e,t){return t=Sc({mode:t.mode,children:t.children},e.mode),t.ref=e.ref,e.child=t,t.return=e,t}function dc(e,t,n){return Fa(t,e.child,null,n),e=uc(t,t.pendingProps),e.flags|=2,oo(t),t.memoizedState=null,e}function fc(e,t,n){var r=t.pendingProps,a=(t.flags&128)!=0;if(t.flags&=-129,e===null){if(V){if(r.mode===`hidden`)return e=uc(t,r),t.lanes=536870912,cc(null,e);if(ro(t),(e=Mi)?(e=rf(e,Pi),e=e!==null&&e.data===`&`?e:null,e!==null&&(t.memoizedState={dehydrated:e,treeContext:Ci===null?null:{id:wi,overflow:Ti},retryLane:536870912,hydrationErrors:null},n=pi(e),n.return=t,t.child=n,ji=t,Mi=null)):e=null,e===null)throw Ii(t);return t.lanes=536870912,null}return uc(t,r)}var o=e.memoizedState;if(o!==null){var s=o.dehydrated;if(ro(t),a)if(t.flags&256)t.flags&=-257,t=dc(e,t,n);else if(t.memoizedState!==null)t.child=e.child,t.flags|=128,t=null;else throw Error(i(558));else if(nc||Xi(e,t,n,!1),a=(n&e.childLanes)!==0,nc||a){if(r=q,r!==null&&(s=Qe(r,n),s!==0&&s!==o.retryLane))throw o.retryLane=s,ti(e,s),hu(r,e,s),tc;Du(),t=dc(e,t,n)}else e=o.treeContext,Mi=cf(s.nextSibling),ji=t,V=!0,Ni=null,Pi=!1,e!==null&&Ai(t,e),t=uc(t,r),t.flags|=4096;return t}return e=ci(e.child,{mode:r.mode,children:r.children}),e.ref=t.ref,t.child=e,e.return=t,e}function pc(e,t){var n=t.ref;if(n===null)e!==null&&e.ref!==null&&(t.flags|=4194816);else{if(typeof n!=`function`&&typeof n!=`object`)throw Error(i(284));(e===null||e.ref!==n)&&(t.flags|=4194816)}}function mc(e,t,n,r,i){return Qi(t),n=xo(e,t,n,r,void 0,i),r=To(),e!==null&&!nc?(Eo(e,t,i),Dc(e,t,i)):(V&&r&&Oi(t),t.flags|=1,rc(e,t,n,i),t.child)}function hc(e,t,n,r,i,a){return Qi(t),t.updateQueue=null,n=Co(t,r,n,i),So(e),r=To(),e!==null&&!nc?(Eo(e,t,a),Dc(e,t,a)):(V&&r&&Oi(t),t.flags|=1,rc(e,t,n,a),t.child)}function gc(e,t,n,r,i){if(Qi(t),t.stateNode===null){var a=ii,o=n.contextType;typeof o==`object`&&o&&(a=$i(o)),a=new n(r,a),t.memoizedState=a.state!==null&&a.state!==void 0?a.state:null,a.updater=Hs,t.stateNode=a,a._reactInternals=t,a=t.stateNode,a.props=r,a.state=t.memoizedState,a.refs={},Ra(t),o=n.contextType,a.context=typeof o==`object`&&o?$i(o):ii,a.state=t.memoizedState,o=n.getDerivedStateFromProps,typeof o==`function`&&(Vs(t,n,o,r),a.state=t.memoizedState),typeof n.getDerivedStateFromProps==`function`||typeof a.getSnapshotBeforeUpdate==`function`||typeof a.UNSAFE_componentWillMount!=`function`&&typeof a.componentWillMount!=`function`||(o=a.state,typeof a.componentWillMount==`function`&&a.componentWillMount(),typeof a.UNSAFE_componentWillMount==`function`&&a.UNSAFE_componentWillMount(),o!==a.state&&Hs.enqueueReplaceState(a,a.state,null),Ka(t,r,a,i),Ga(),a.state=t.memoizedState),typeof a.componentDidMount==`function`&&(t.flags|=4194308),r=!0}else if(e===null){a=t.stateNode;var s=t.memoizedProps,c=Gs(n,s);a.props=c;var l=a.context,u=n.contextType;o=ii,typeof u==`object`&&u&&(o=$i(u));var d=n.getDerivedStateFromProps;u=typeof d==`function`||typeof a.getSnapshotBeforeUpdate==`function`,s=t.pendingProps!==s,u||typeof a.UNSAFE_componentWillReceiveProps!=`function`&&typeof a.componentWillReceiveProps!=`function`||(s||l!==o)&&Ws(t,a,r,o),La=!1;var f=t.memoizedState;a.state=f,Ka(t,r,a,i),Ga(),l=t.memoizedState,s||f!==l||La?(typeof d==`function`&&(Vs(t,n,d,r),l=t.memoizedState),(c=La||Us(t,n,c,r,f,l,o))?(u||typeof a.UNSAFE_componentWillMount!=`function`&&typeof a.componentWillMount!=`function`||(typeof a.componentWillMount==`function`&&a.componentWillMount(),typeof a.UNSAFE_componentWillMount==`function`&&a.UNSAFE_componentWillMount()),typeof a.componentDidMount==`function`&&(t.flags|=4194308)):(typeof a.componentDidMount==`function`&&(t.flags|=4194308),t.memoizedProps=r,t.memoizedState=l),a.props=r,a.state=l,a.context=o,r=c):(typeof a.componentDidMount==`function`&&(t.flags|=4194308),r=!1)}else{a=t.stateNode,za(e,t),o=t.memoizedProps,u=Gs(n,o),a.props=u,d=t.pendingProps,f=a.context,l=n.contextType,c=ii,typeof l==`object`&&l&&(c=$i(l)),s=n.getDerivedStateFromProps,(l=typeof s==`function`||typeof a.getSnapshotBeforeUpdate==`function`)||typeof a.UNSAFE_componentWillReceiveProps!=`function`&&typeof a.componentWillReceiveProps!=`function`||(o!==d||f!==c)&&Ws(t,a,r,c),La=!1,f=t.memoizedState,a.state=f,Ka(t,r,a,i),Ga();var p=t.memoizedState;o!==d||f!==p||La||e!==null&&e.dependencies!==null&&Zi(e.dependencies)?(typeof s==`function`&&(Vs(t,n,s,r),p=t.memoizedState),(u=La||Us(t,n,u,r,f,p,c)||e!==null&&e.dependencies!==null&&Zi(e.dependencies))?(l||typeof a.UNSAFE_componentWillUpdate!=`function`&&typeof a.componentWillUpdate!=`function`||(typeof a.componentWillUpdate==`function`&&a.componentWillUpdate(r,p,c),typeof a.UNSAFE_componentWillUpdate==`function`&&a.UNSAFE_componentWillUpdate(r,p,c)),typeof a.componentDidUpdate==`function`&&(t.flags|=4),typeof a.getSnapshotBeforeUpdate==`function`&&(t.flags|=1024)):(typeof a.componentDidUpdate!=`function`||o===e.memoizedProps&&f===e.memoizedState||(t.flags|=4),typeof a.getSnapshotBeforeUpdate!=`function`||o===e.memoizedProps&&f===e.memoizedState||(t.flags|=1024),t.memoizedProps=r,t.memoizedState=p),a.props=r,a.state=p,a.context=c,r=u):(typeof a.componentDidUpdate!=`function`||o===e.memoizedProps&&f===e.memoizedState||(t.flags|=4),typeof a.getSnapshotBeforeUpdate!=`function`||o===e.memoizedProps&&f===e.memoizedState||(t.flags|=1024),r=!1)}return a=r,pc(e,t),r=(t.flags&128)!=0,a||r?(a=t.stateNode,n=r&&typeof n.getDerivedStateFromError!=`function`?null:a.render(),t.flags|=1,e!==null&&r?(t.child=Fa(t,e.child,null,i),t.child=Fa(t,null,n,i)):rc(e,t,n,i),t.memoizedState=a.state,e=t.child):e=Dc(e,t,i),e}function _c(e,t,n,r){return Bi(),t.flags|=256,rc(e,t,n,r),t.child}var vc={dehydrated:null,treeContext:null,retryLane:0,hydrationErrors:null};function yc(e){return{baseLanes:e,cachePool:ya()}}function bc(e,t,n){return e=e===null?0:e.childLanes&~n,t&&(e|=Jl),e}function G(e,t,n){var r=t.pendingProps,a=!1,o=(t.flags&128)!=0,s;if((s=o)||(s=e!==null&&e.memoizedState===null?!1:(so.current&2)!=0),s&&(a=!0,t.flags&=-129),s=(t.flags&32)!=0,t.flags&=-33,e===null){if(V){if(a?no(t):ao(t),(e=Mi)?(e=rf(e,Pi),e=e!==null&&e.data!==`&`?e:null,e!==null&&(t.memoizedState={dehydrated:e,treeContext:Ci===null?null:{id:wi,overflow:Ti},retryLane:536870912,hydrationErrors:null},n=pi(e),n.return=t,t.child=n,ji=t,Mi=null)):e=null,e===null)throw Ii(t);return of(e)?t.lanes=32:t.lanes=536870912,null}var c=r.children;return r=r.fallback,a?(ao(t),a=t.mode,c=Sc({mode:`hidden`,children:c},a),r=di(r,a,n,null),c.return=t,r.return=t,c.sibling=r,t.child=c,r=t.child,r.memoizedState=yc(n),r.childLanes=bc(e,s,n),t.memoizedState=vc,cc(null,r)):(no(t),xc(t,c))}var l=e.memoizedState;if(l!==null&&(c=l.dehydrated,c!==null)){if(o)t.flags&256?(no(t),t.flags&=-257,t=Cc(e,t,n)):t.memoizedState===null?(ao(t),c=r.fallback,a=t.mode,r=Sc({mode:`visible`,children:r.children},a),c=di(c,a,n,null),c.flags|=2,r.return=t,c.return=t,r.sibling=c,t.child=r,Fa(t,e.child,null,n),r=t.child,r.memoizedState=yc(n),r.childLanes=bc(e,s,n),t.memoizedState=vc,t=cc(null,r)):(ao(t),t.child=e.child,t.flags|=128,t=null);else if(no(t),of(c)){if(s=c.nextSibling&&c.nextSibling.dataset,s)var u=s.dgst;s=u,r=Error(i(419)),r.stack=``,r.digest=s,Hi({value:r,source:null,stack:null}),t=Cc(e,t,n)}else if(nc||Xi(e,t,n,!1),s=(n&e.childLanes)!==0,nc||s){if(s=q,s!==null&&(r=Qe(s,n),r!==0&&r!==l.retryLane))throw l.retryLane=r,ti(e,r),hu(s,e,r),tc;af(c)||Du(),t=Cc(e,t,n)}else af(c)?(t.flags|=192,t.child=e.child,t=null):(e=l.treeContext,Mi=cf(c.nextSibling),ji=t,V=!0,Ni=null,Pi=!1,e!==null&&Ai(t,e),t=xc(t,r.children),t.flags|=4096);return t}return a?(ao(t),c=r.fallback,a=t.mode,l=e.child,u=l.sibling,r=ci(l,{mode:`hidden`,children:r.children}),r.subtreeFlags=l.subtreeFlags&65011712,u===null?(c=di(c,a,n,null),c.flags|=2):c=ci(u,c),c.return=t,r.return=t,r.sibling=c,t.child=r,cc(null,r),r=t.child,c=e.child.memoizedState,c===null?c=yc(n):(a=c.cachePool,a===null?a=ya():(l=aa._currentValue,a=a.parent===l?a:{parent:l,pool:l}),c={baseLanes:c.baseLanes|n,cachePool:a}),r.memoizedState=c,r.childLanes=bc(e,s,n),t.memoizedState=vc,cc(e.child,r)):(no(t),n=e.child,e=n.sibling,n=ci(n,{mode:`visible`,children:r.children}),n.return=t,n.sibling=null,e!==null&&(s=t.deletions,s===null?(t.deletions=[e],t.flags|=16):s.push(e)),t.child=n,t.memoizedState=null,n)}function xc(e,t){return t=Sc({mode:`visible`,children:t},e.mode),t.return=e,e.child=t}function Sc(e,t){return e=oi(22,e,null,t),e.lanes=0,e}function Cc(e,t,n){return Fa(t,e.child,null,n),e=xc(t,t.pendingProps.children),e.flags|=2,t.memoizedState=null,e}function wc(e,t,n){e.lanes|=t;var r=e.alternate;r!==null&&(r.lanes|=t),Ji(e.return,t,n)}function Tc(e,t,n,r,i,a){var o=e.memoizedState;o===null?e.memoizedState={isBackwards:t,rendering:null,renderingStartTime:0,last:r,tail:n,tailMode:i,treeForkCount:a}:(o.isBackwards=t,o.rendering=null,o.renderingStartTime=0,o.last=r,o.tail=n,o.tailMode=i,o.treeForkCount=a)}function Ec(e,t,n){var r=t.pendingProps,i=r.revealOrder,a=r.tail;r=r.children;var o=so.current,s=(o&2)!=0;if(s?(o=o&1|2,t.flags|=128):o&=1,B(so,o),rc(e,t,r,n),r=V?bi:0,!s&&e!==null&&e.flags&128)a:for(e=t.child;e!==null;){if(e.tag===13)e.memoizedState!==null&&wc(e,n,t);else if(e.tag===19)wc(e,n,t);else if(e.child!==null){e.child.return=e,e=e.child;continue}if(e===t)break a;for(;e.sibling===null;){if(e.return===null||e.return===t)break a;e=e.return}e.sibling.return=e.return,e=e.sibling}switch(i){case`forwards`:for(n=t.child,i=null;n!==null;)e=n.alternate,e!==null&&co(e)===null&&(i=n),n=n.sibling;n=i,n===null?(i=t.child,t.child=null):(i=n.sibling,n.sibling=null),Tc(t,!1,i,n,a,r);break;case`backwards`:case`unstable_legacy-backwards`:for(n=null,i=t.child,t.child=null;i!==null;){if(e=i.alternate,e!==null&&co(e)===null){t.child=i;break}e=i.sibling,i.sibling=n,n=i,i=e}Tc(t,!0,n,null,a,r);break;case`together`:Tc(t,!1,null,null,void 0,r);break;default:t.memoizedState=null}return t.child}function Dc(e,t,n){if(e!==null&&(t.dependencies=e.dependencies),Gl|=t.lanes,(n&t.childLanes)===0)if(e!==null){if(Xi(e,t,n,!1),(n&t.childLanes)===0)return null}else return null;if(e!==null&&t.child!==e.child)throw Error(i(153));if(t.child!==null){for(e=t.child,n=ci(e,e.pendingProps),t.child=n,n.return=t;e.sibling!==null;)e=e.sibling,n=n.sibling=ci(e,e.pendingProps),n.return=t;n.sibling=null}return t.child}function Oc(e,t){return(e.lanes&t)===0?(e=e.dependencies,!!(e!==null&&Zi(e))):!0}function kc(e,t,n){switch(t.tag){case 3:se(t,t.stateNode.containerInfo),Ki(t,aa,e.memoizedState.cache),Bi();break;case 27:case 5:le(t);break;case 4:se(t,t.stateNode.containerInfo);break;case 10:Ki(t,t.type,t.memoizedProps.value);break;case 31:if(t.memoizedState!==null)return t.flags|=128,ro(t),null;break;case 13:var r=t.memoizedState;if(r!==null)return r.dehydrated===null?(n&t.child.childLanes)===0?(no(t),e=Dc(e,t,n),e===null?null:e.sibling):G(e,t,n):(no(t),t.flags|=128,null);no(t);break;case 19:var i=(e.flags&128)!=0;if(r=(n&t.childLanes)!==0,r||=(Xi(e,t,n,!1),(n&t.childLanes)!==0),i){if(r)return Ec(e,t,n);t.flags|=128}if(i=t.memoizedState,i!==null&&(i.rendering=null,i.tail=null,i.lastEffect=null),B(so,so.current),r)break;return null;case 22:return t.lanes=0,sc(e,t,n,t.pendingProps);case 24:Ki(t,aa,e.memoizedState.cache)}return Dc(e,t,n)}function Ac(e,t,n){if(e!==null)if(e.memoizedProps!==t.pendingProps)nc=!0;else{if(!Oc(e,n)&&!(t.flags&128))return nc=!1,kc(e,t,n);nc=!!(e.flags&131072)}else nc=!1,V&&t.flags&1048576&&Di(t,bi,t.index);switch(t.lanes=0,t.tag){case 16:a:{var r=t.pendingProps;if(e=Ea(t.elementType),t.type=e,typeof e==`function`)si(e)?(r=Gs(e,r),t.tag=1,t=gc(null,t,e,r,n)):(t.tag=0,t=mc(null,t,e,r,n));else{if(e!=null){var a=e.$$typeof;if(a===w){t.tag=11,t=ic(null,t,e,r,n);break a}else if(a===D){t.tag=14,t=ac(null,t,e,r,n);break a}}throw t=P(e)||e,Error(i(306,t,``))}}return t;case 0:return mc(e,t,t.type,t.pendingProps,n);case 1:return r=t.type,a=Gs(r,t.pendingProps),gc(e,t,r,a,n);case 3:a:{if(se(t,t.stateNode.containerInfo),e===null)throw Error(i(387));r=t.pendingProps;var o=t.memoizedState;a=o.element,za(e,t),Ka(t,r,null,n);var s=t.memoizedState;if(r=s.cache,Ki(t,aa,r),r!==o.cache&&Yi(t,[aa],n,!0),Ga(),r=s.element,o.isDehydrated)if(o={element:r,isDehydrated:!1,cache:s.cache},t.updateQueue.baseState=o,t.memoizedState=o,t.flags&256){t=_c(e,t,r,n);break a}else if(r!==a){a=gi(Error(i(424)),t),Hi(a),t=_c(e,t,r,n);break a}else{switch(e=t.stateNode.containerInfo,e.nodeType){case 9:e=e.body;break;default:e=e.nodeName===`HTML`?e.ownerDocument.body:e}for(Mi=cf(e.firstChild),ji=t,V=!0,Ni=null,Pi=!0,n=Ia(t,null,r,n),t.child=n;n;)n.flags=n.flags&-3|4096,n=n.sibling}else{if(Bi(),r===a){t=Dc(e,t,n);break a}rc(e,t,r,n)}t=t.child}return t;case 26:return pc(e,t),e===null?(n=kf(t.type,null,t.pendingProps,null))?t.memoizedState=n:V||(n=t.type,e=t.pendingProps,r=Bd(ae.current).createElement(n),r[it]=t,r[at]=e,Pd(r,n,e),_t(r),t.stateNode=r):t.memoizedState=kf(t.type,e.memoizedProps,t.pendingProps,e.memoizedState),null;case 27:return le(t),e===null&&V&&(r=t.stateNode=ff(t.type,t.pendingProps,ae.current),ji=t,Pi=!0,a=Mi,Zd(t.type)?(lf=a,Mi=cf(r.firstChild)):Mi=a),rc(e,t,t.pendingProps.children,n),pc(e,t),e===null&&(t.flags|=4194304),t.child;case 5:return e===null&&V&&((a=r=Mi)&&(r=tf(r,t.type,t.pendingProps,Pi),r===null?a=!1:(t.stateNode=r,ji=t,Mi=cf(r.firstChild),Pi=!1,a=!0)),a||Ii(t)),le(t),a=t.type,o=t.pendingProps,s=e===null?null:e.memoizedProps,r=o.children,Ud(a,o)?r=null:s!==null&&Ud(a,s)&&(t.flags|=32),t.memoizedState!==null&&(a=xo(e,t,wo,null,null,n),Qf._currentValue=a),pc(e,t),rc(e,t,r,n),t.child;case 6:return e===null&&V&&((e=n=Mi)&&(n=nf(n,t.pendingProps,Pi),n===null?e=!1:(t.stateNode=n,ji=t,Mi=null,e=!0)),e||Ii(t)),null;case 13:return G(e,t,n);case 4:return se(t,t.stateNode.containerInfo),r=t.pendingProps,e===null?t.child=Fa(t,null,r,n):rc(e,t,r,n),t.child;case 11:return ic(e,t,t.type,t.pendingProps,n);case 7:return rc(e,t,t.pendingProps,n),t.child;case 8:return rc(e,t,t.pendingProps.children,n),t.child;case 12:return rc(e,t,t.pendingProps.children,n),t.child;case 10:return r=t.pendingProps,Ki(t,t.type,r.value),rc(e,t,r.children,n),t.child;case 9:return a=t.type._context,r=t.pendingProps.children,Qi(t),a=$i(a),r=r(a),t.flags|=1,rc(e,t,r,n),t.child;case 14:return ac(e,t,t.type,t.pendingProps,n);case 15:return oc(e,t,t.type,t.pendingProps,n);case 19:return Ec(e,t,n);case 31:return fc(e,t,n);case 22:return sc(e,t,n,t.pendingProps);case 24:return Qi(t),r=$i(aa),e===null?(a=_a(),a===null&&(a=q,o=oa(),a.pooledCache=o,o.refCount++,o!==null&&(a.pooledCacheLanes|=n),a=o),t.memoizedState={parent:r,cache:a},Ra(t),Ki(t,aa,a)):((e.lanes&n)!==0&&(za(e,t),Ka(t,null,null,n),Ga()),a=e.memoizedState,o=t.memoizedState,a.parent===r?(r=o.cache,Ki(t,aa,r),r!==a.cache&&Yi(t,[aa],n,!0)):(a={parent:r,cache:r},t.memoizedState=a,t.lanes===0&&(t.memoizedState=t.updateQueue.baseState=a),Ki(t,aa,r))),rc(e,t,t.pendingProps.children,n),t.child;case 29:throw t.pendingProps}throw Error(i(156,t.tag))}function jc(e){e.flags|=4}function Mc(e,t,n,r,i){if((t=(e.mode&32)!=0)&&(t=!1),t){if(e.flags|=16777216,(i&335544128)===i)if(e.stateNode.complete)e.flags|=8192;else if(wu())e.flags|=8192;else throw Da=Ca,xa}else e.flags&=-16777217}function Nc(e,t){if(t.type!==`stylesheet`||t.state.loading&4)e.flags&=-16777217;else if(e.flags|=16777216,!Wf(t))if(wu())e.flags|=8192;else throw Da=Ca,xa}function Pc(e,t){t!==null&&(e.flags|=4),e.flags&16384&&(t=e.tag===22?536870912:Ke(),e.lanes|=t,Yl|=t)}function Fc(e,t){if(!V)switch(e.tailMode){case`hidden`:t=e.tail;for(var n=null;t!==null;)t.alternate!==null&&(n=t),t=t.sibling;n===null?e.tail=null:n.sibling=null;break;case`collapsed`:n=e.tail;for(var r=null;n!==null;)n.alternate!==null&&(r=n),n=n.sibling;r===null?t||e.tail===null?e.tail=null:e.tail.sibling=null:r.sibling=null}}function Ic(e){var t=e.alternate!==null&&e.alternate.child===e.child,n=0,r=0;if(t)for(var i=e.child;i!==null;)n|=i.lanes|i.childLanes,r|=i.subtreeFlags&65011712,r|=i.flags&65011712,i.return=e,i=i.sibling;else for(i=e.child;i!==null;)n|=i.lanes|i.childLanes,r|=i.subtreeFlags,r|=i.flags,i.return=e,i=i.sibling;return e.subtreeFlags|=r,e.childLanes=n,t}function Lc(e,t,n){var r=t.pendingProps;switch(ki(t),t.tag){case 16:case 15:case 0:case 11:case 7:case 8:case 12:case 9:case 14:return Ic(t),null;case 1:return Ic(t),null;case 3:return n=t.stateNode,r=null,e!==null&&(r=e.memoizedState.cache),t.memoizedState.cache!==r&&(t.flags|=2048),qi(aa),ce(),n.pendingContext&&(n.context=n.pendingContext,n.pendingContext=null),(e===null||e.child===null)&&(zi(t)?jc(t):e===null||e.memoizedState.isDehydrated&&!(t.flags&256)||(t.flags|=1024,Vi())),Ic(t),null;case 26:var a=t.type,o=t.memoizedState;return e===null?(jc(t),o===null?(Ic(t),Mc(t,a,null,r,n)):(Ic(t),Nc(t,o))):o?o===e.memoizedState?(Ic(t),t.flags&=-16777217):(jc(t),Ic(t),Nc(t,o)):(e=e.memoizedProps,e!==r&&jc(t),Ic(t),Mc(t,a,e,r,n)),null;case 27:if(ue(t),n=ae.current,a=t.type,e!==null&&t.stateNode!=null)e.memoizedProps!==r&&jc(t);else{if(!r){if(t.stateNode===null)throw Error(i(166));return Ic(t),null}e=re.current,zi(t)?Li(t,e):(e=ff(a,r,n),t.stateNode=e,jc(t))}return Ic(t),null;case 5:if(ue(t),a=t.type,e!==null&&t.stateNode!=null)e.memoizedProps!==r&&jc(t);else{if(!r){if(t.stateNode===null)throw Error(i(166));return Ic(t),null}if(o=re.current,zi(t))Li(t,o);else{var s=Bd(ae.current);switch(o){case 1:o=s.createElementNS(`http://www.w3.org/2000/svg`,a);break;case 2:o=s.createElementNS(`http://www.w3.org/1998/Math/MathML`,a);break;default:switch(a){case`svg`:o=s.createElementNS(`http://www.w3.org/2000/svg`,a);break;case`math`:o=s.createElementNS(`http://www.w3.org/1998/Math/MathML`,a);break;case`script`:o=s.createElement(`div`),o.innerHTML=`<script><\/script>`,o=o.removeChild(o.firstChild);break;case`select`:o=typeof r.is==`string`?s.createElement(`select`,{is:r.is}):s.createElement(`select`),r.multiple?o.multiple=!0:r.size&&(o.size=r.size);break;default:o=typeof r.is==`string`?s.createElement(a,{is:r.is}):s.createElement(a)}}o[it]=t,o[at]=r;a:for(s=t.child;s!==null;){if(s.tag===5||s.tag===6)o.appendChild(s.stateNode);else if(s.tag!==4&&s.tag!==27&&s.child!==null){s.child.return=s,s=s.child;continue}if(s===t)break a;for(;s.sibling===null;){if(s.return===null||s.return===t)break a;s=s.return}s.sibling.return=s.return,s=s.sibling}t.stateNode=o;a:switch(Pd(o,a,r),a){case`button`:case`input`:case`select`:case`textarea`:r=!!r.autoFocus;break a;case`img`:r=!0;break a;default:r=!1}r&&jc(t)}}return Ic(t),Mc(t,t.type,e===null?null:e.memoizedProps,t.pendingProps,n),null;case 6:if(e&&t.stateNode!=null)e.memoizedProps!==r&&jc(t);else{if(typeof r!=`string`&&t.stateNode===null)throw Error(i(166));if(e=ae.current,zi(t)){if(e=t.stateNode,n=t.memoizedProps,r=null,a=ji,a!==null)switch(a.tag){case 27:case 5:r=a.memoizedProps}e[it]=t,e=!!(e.nodeValue===n||r!==null&&!0===r.suppressHydrationWarning||Md(e.nodeValue,n)),e||Ii(t,!0)}else e=Bd(e).createTextNode(r),e[it]=t,t.stateNode=e}return Ic(t),null;case 31:if(n=t.memoizedState,e===null||e.memoizedState!==null){if(r=zi(t),n!==null){if(e===null){if(!r)throw Error(i(318));if(e=t.memoizedState,e=e===null?null:e.dehydrated,!e)throw Error(i(557));e[it]=t}else Bi(),!(t.flags&128)&&(t.memoizedState=null),t.flags|=4;Ic(t),e=!1}else n=Vi(),e!==null&&e.memoizedState!==null&&(e.memoizedState.hydrationErrors=n),e=!0;if(!e)return t.flags&256?(oo(t),t):(oo(t),null);if(t.flags&128)throw Error(i(558))}return Ic(t),null;case 13:if(r=t.memoizedState,e===null||e.memoizedState!==null&&e.memoizedState.dehydrated!==null){if(a=zi(t),r!==null&&r.dehydrated!==null){if(e===null){if(!a)throw Error(i(318));if(a=t.memoizedState,a=a===null?null:a.dehydrated,!a)throw Error(i(317));a[it]=t}else Bi(),!(t.flags&128)&&(t.memoizedState=null),t.flags|=4;Ic(t),a=!1}else a=Vi(),e!==null&&e.memoizedState!==null&&(e.memoizedState.hydrationErrors=a),a=!0;if(!a)return t.flags&256?(oo(t),t):(oo(t),null)}return oo(t),t.flags&128?(t.lanes=n,t):(n=r!==null,e=e!==null&&e.memoizedState!==null,n&&(r=t.child,a=null,r.alternate!==null&&r.alternate.memoizedState!==null&&r.alternate.memoizedState.cachePool!==null&&(a=r.alternate.memoizedState.cachePool.pool),o=null,r.memoizedState!==null&&r.memoizedState.cachePool!==null&&(o=r.memoizedState.cachePool.pool),o!==a&&(r.flags|=2048)),n!==e&&n&&(t.child.flags|=8192),Pc(t,t.updateQueue),Ic(t),null);case 4:return ce(),e===null&&Sd(t.stateNode.containerInfo),Ic(t),null;case 10:return qi(t.type),Ic(t),null;case 19:if(z(so),r=t.memoizedState,r===null)return Ic(t),null;if(a=(t.flags&128)!=0,o=r.rendering,o===null)if(a)Fc(r,!1);else{if(Wl!==0||e!==null&&e.flags&128)for(e=t.child;e!==null;){if(o=co(e),o!==null){for(t.flags|=128,Fc(r,!1),e=o.updateQueue,t.updateQueue=e,Pc(t,e),t.subtreeFlags=0,e=n,n=t.child;n!==null;)li(n,e),n=n.sibling;return B(so,so.current&1|2),V&&Ei(t,r.treeForkCount),t.child}e=e.sibling}r.tail!==null&&Ce()>tu&&(t.flags|=128,a=!0,Fc(r,!1),t.lanes=4194304)}else{if(!a)if(e=co(o),e!==null){if(t.flags|=128,a=!0,e=e.updateQueue,t.updateQueue=e,Pc(t,e),Fc(r,!0),r.tail===null&&r.tailMode===`hidden`&&!o.alternate&&!V)return Ic(t),null}else 2*Ce()-r.renderingStartTime>tu&&n!==536870912&&(t.flags|=128,a=!0,Fc(r,!1),t.lanes=4194304);r.isBackwards?(o.sibling=t.child,t.child=o):(e=r.last,e===null?t.child=o:e.sibling=o,r.last=o)}return r.tail===null?(Ic(t),null):(e=r.tail,r.rendering=e,r.tail=e.sibling,r.renderingStartTime=Ce(),e.sibling=null,n=so.current,B(so,a?n&1|2:n&1),V&&Ei(t,r.treeForkCount),e);case 22:case 23:return oo(t),$a(),r=t.memoizedState!==null,e===null?r&&(t.flags|=8192):e.memoizedState!==null!==r&&(t.flags|=8192),r?n&536870912&&!(t.flags&128)&&(Ic(t),t.subtreeFlags&6&&(t.flags|=8192)):Ic(t),n=t.updateQueue,n!==null&&Pc(t,n.retryQueue),n=null,e!==null&&e.memoizedState!==null&&e.memoizedState.cachePool!==null&&(n=e.memoizedState.cachePool.pool),r=null,t.memoizedState!==null&&t.memoizedState.cachePool!==null&&(r=t.memoizedState.cachePool.pool),r!==n&&(t.flags|=2048),e!==null&&z(ga),null;case 24:return n=null,e!==null&&(n=e.memoizedState.cache),t.memoizedState.cache!==n&&(t.flags|=2048),qi(aa),Ic(t),null;case 25:return null;case 30:return null}throw Error(i(156,t.tag))}function Rc(e,t){switch(ki(t),t.tag){case 1:return e=t.flags,e&65536?(t.flags=e&-65537|128,t):null;case 3:return qi(aa),ce(),e=t.flags,e&65536&&!(e&128)?(t.flags=e&-65537|128,t):null;case 26:case 27:case 5:return ue(t),null;case 31:if(t.memoizedState!==null){if(oo(t),t.alternate===null)throw Error(i(340));Bi()}return e=t.flags,e&65536?(t.flags=e&-65537|128,t):null;case 13:if(oo(t),e=t.memoizedState,e!==null&&e.dehydrated!==null){if(t.alternate===null)throw Error(i(340));Bi()}return e=t.flags,e&65536?(t.flags=e&-65537|128,t):null;case 19:return z(so),null;case 4:return ce(),null;case 10:return qi(t.type),null;case 22:case 23:return oo(t),$a(),e!==null&&z(ga),e=t.flags,e&65536?(t.flags=e&-65537|128,t):null;case 24:return qi(aa),null;case 25:return null;default:return null}}function zc(e,t){switch(ki(t),t.tag){case 3:qi(aa),ce();break;case 26:case 27:case 5:ue(t);break;case 4:ce();break;case 31:t.memoizedState!==null&&oo(t);break;case 13:oo(t);break;case 19:z(so);break;case 10:qi(t.type);break;case 22:case 23:oo(t),$a(),e!==null&&z(ga);break;case 24:qi(aa)}}function Bc(e,t){try{var n=t.updateQueue,r=n===null?null:n.lastEffect;if(r!==null){var i=r.next;n=i;do{if((n.tag&e)===e){r=void 0;var a=n.create,o=n.inst;r=a(),o.destroy=r}n=n.next}while(n!==i)}}catch(e){Z(t,t.return,e)}}function Vc(e,t,n){try{var r=t.updateQueue,i=r===null?null:r.lastEffect;if(i!==null){var a=i.next;r=a;do{if((r.tag&e)===e){var o=r.inst,s=o.destroy;if(s!==void 0){o.destroy=void 0,i=t;var c=n,l=s;try{l()}catch(e){Z(i,c,e)}}}r=r.next}while(r!==a)}}catch(e){Z(t,t.return,e)}}function Hc(e){var t=e.updateQueue;if(t!==null){var n=e.stateNode;try{Ja(t,n)}catch(t){Z(e,e.return,t)}}}function Uc(e,t,n){n.props=Gs(e.type,e.memoizedProps),n.state=e.memoizedState;try{n.componentWillUnmount()}catch(n){Z(e,t,n)}}function Wc(e,t){try{var n=e.ref;if(n!==null){switch(e.tag){case 26:case 27:case 5:var r=e.stateNode;break;case 30:r=e.stateNode;break;default:r=e.stateNode}typeof n==`function`?e.refCleanup=n(r):n.current=r}}catch(n){Z(e,t,n)}}function Gc(e,t){var n=e.ref,r=e.refCleanup;if(n!==null)if(typeof r==`function`)try{r()}catch(n){Z(e,t,n)}finally{e.refCleanup=null,e=e.alternate,e!=null&&(e.refCleanup=null)}else if(typeof n==`function`)try{n(null)}catch(n){Z(e,t,n)}else n.current=null}function Kc(e){var t=e.type,n=e.memoizedProps,r=e.stateNode;try{a:switch(t){case`button`:case`input`:case`select`:case`textarea`:n.autoFocus&&r.focus();break a;case`img`:n.src?r.src=n.src:n.srcSet&&(r.srcset=n.srcSet)}}catch(t){Z(e,e.return,t)}}function qc(e,t,n){try{var r=e.stateNode;Fd(r,e.type,n,t),r[at]=t}catch(t){Z(e,e.return,t)}}function Jc(e){return e.tag===5||e.tag===3||e.tag===26||e.tag===27&&Zd(e.type)||e.tag===4}function Yc(e){a:for(;;){for(;e.sibling===null;){if(e.return===null||Jc(e.return))return null;e=e.return}for(e.sibling.return=e.return,e=e.sibling;e.tag!==5&&e.tag!==6&&e.tag!==18;){if(e.tag===27&&Zd(e.type)||e.flags&2||e.child===null||e.tag===4)continue a;e.child.return=e,e=e.child}if(!(e.flags&2))return e.stateNode}}function Xc(e,t,n){var r=e.tag;if(r===5||r===6)e=e.stateNode,t?(n.nodeType===9?n.body:n.nodeName===`HTML`?n.ownerDocument.body:n).insertBefore(e,t):(t=n.nodeType===9?n.body:n.nodeName===`HTML`?n.ownerDocument.body:n,t.appendChild(e),n=n._reactRootContainer,n!=null||t.onclick!==null||(t.onclick=Zt));else if(r!==4&&(r===27&&Zd(e.type)&&(n=e.stateNode,t=null),e=e.child,e!==null))for(Xc(e,t,n),e=e.sibling;e!==null;)Xc(e,t,n),e=e.sibling}function Zc(e,t,n){var r=e.tag;if(r===5||r===6)e=e.stateNode,t?n.insertBefore(e,t):n.appendChild(e);else if(r!==4&&(r===27&&Zd(e.type)&&(n=e.stateNode),e=e.child,e!==null))for(Zc(e,t,n),e=e.sibling;e!==null;)Zc(e,t,n),e=e.sibling}function Qc(e){var t=e.stateNode,n=e.memoizedProps;try{for(var r=e.type,i=t.attributes;i.length;)t.removeAttributeNode(i[0]);Pd(t,r,n),t[it]=e,t[at]=n}catch(t){Z(e,e.return,t)}}var $c=!1,el=!1,tl=!1,nl=typeof WeakSet==`function`?WeakSet:Set,rl=null;function il(e,t){if(e=e.containerInfo,Rd=sp,e=Tr(e),Er(e)){if(`selectionStart`in e)var n={start:e.selectionStart,end:e.selectionEnd};else a:{n=(n=e.ownerDocument)&&n.defaultView||window;var r=n.getSelection&&n.getSelection();if(r&&r.rangeCount!==0){n=r.anchorNode;var a=r.anchorOffset,o=r.focusNode;r=r.focusOffset;try{n.nodeType,o.nodeType}catch{n=null;break a}var s=0,c=-1,l=-1,u=0,d=0,f=e,p=null;b:for(;;){for(var m;f!==n||a!==0&&f.nodeType!==3||(c=s+a),f!==o||r!==0&&f.nodeType!==3||(l=s+r),f.nodeType===3&&(s+=f.nodeValue.length),(m=f.firstChild)!==null;)p=f,f=m;for(;;){if(f===e)break b;if(p===n&&++u===a&&(c=s),p===o&&++d===r&&(l=s),(m=f.nextSibling)!==null)break;f=p,p=f.parentNode}f=m}n=c===-1||l===-1?null:{start:c,end:l}}else n=null}n||={start:0,end:0}}else n=null;for(zd={focusedElem:e,selectionRange:n},sp=!1,rl=t;rl!==null;)if(t=rl,e=t.child,t.subtreeFlags&1028&&e!==null)e.return=t,rl=e;else for(;rl!==null;){switch(t=rl,o=t.alternate,e=t.flags,t.tag){case 0:if(e&4&&(e=t.updateQueue,e=e===null?null:e.events,e!==null))for(n=0;n<e.length;n++)a=e[n],a.ref.impl=a.nextImpl;break;case 11:case 15:break;case 1:if(e&1024&&o!==null){e=void 0,n=t,a=o.memoizedProps,o=o.memoizedState,r=n.stateNode;try{var h=Gs(n.type,a);e=r.getSnapshotBeforeUpdate(h,o),r.__reactInternalSnapshotBeforeUpdate=e}catch(e){Z(n,n.return,e)}}break;case 3:if(e&1024){if(e=t.stateNode.containerInfo,n=e.nodeType,n===9)ef(e);else if(n===1)switch(e.nodeName){case`HEAD`:case`HTML`:case`BODY`:ef(e);break;default:e.textContent=``}}break;case 5:case 26:case 27:case 6:case 4:case 17:break;default:if(e&1024)throw Error(i(163))}if(e=t.sibling,e!==null){e.return=t.return,rl=e;break}rl=t.return}}function al(e,t,n){var r=n.flags;switch(n.tag){case 0:case 11:case 15:bl(e,n),r&4&&Bc(5,n);break;case 1:if(bl(e,n),r&4)if(e=n.stateNode,t===null)try{e.componentDidMount()}catch(e){Z(n,n.return,e)}else{var i=Gs(n.type,t.memoizedProps);t=t.memoizedState;try{e.componentDidUpdate(i,t,e.__reactInternalSnapshotBeforeUpdate)}catch(e){Z(n,n.return,e)}}r&64&&Hc(n),r&512&&Wc(n,n.return);break;case 3:if(bl(e,n),r&64&&(e=n.updateQueue,e!==null)){if(t=null,n.child!==null)switch(n.child.tag){case 27:case 5:t=n.child.stateNode;break;case 1:t=n.child.stateNode}try{Ja(e,t)}catch(e){Z(n,n.return,e)}}break;case 27:t===null&&r&4&&Qc(n);case 26:case 5:bl(e,n),t===null&&r&4&&Kc(n),r&512&&Wc(n,n.return);break;case 12:bl(e,n);break;case 31:bl(e,n),r&4&&dl(e,n);break;case 13:bl(e,n),r&4&&fl(e,n),r&64&&(e=n.memoizedState,e!==null&&(e=e.dehydrated,e!==null&&(n=Ju.bind(null,n),sf(e,n))));break;case 22:if(r=n.memoizedState!==null||$c,!r){t=t!==null&&t.memoizedState!==null||el,i=$c;var a=el;$c=r,(el=t)&&!a?Sl(e,n,(n.subtreeFlags&8772)!=0):bl(e,n),$c=i,el=a}break;case 30:break;default:bl(e,n)}}function ol(e){var t=e.alternate;t!==null&&(e.alternate=null,ol(t)),e.child=null,e.deletions=null,e.sibling=null,e.tag===5&&(t=e.stateNode,t!==null&&ft(t)),e.stateNode=null,e.return=null,e.dependencies=null,e.memoizedProps=null,e.memoizedState=null,e.pendingProps=null,e.stateNode=null,e.updateQueue=null}var sl=null,cl=!1;function ll(e,t,n){for(n=n.child;n!==null;)ul(e,t,n),n=n.sibling}function ul(e,t,n){if(Ne&&typeof Ne.onCommitFiberUnmount==`function`)try{Ne.onCommitFiberUnmount(Me,n)}catch{}switch(n.tag){case 26:el||Gc(n,t),ll(e,t,n),n.memoizedState?n.memoizedState.count--:n.stateNode&&(n=n.stateNode,n.parentNode.removeChild(n));break;case 27:el||Gc(n,t);var r=sl,i=cl;Zd(n.type)&&(sl=n.stateNode,cl=!1),ll(e,t,n),pf(n.stateNode),sl=r,cl=i;break;case 5:el||Gc(n,t);case 6:if(r=sl,i=cl,sl=null,ll(e,t,n),sl=r,cl=i,sl!==null)if(cl)try{(sl.nodeType===9?sl.body:sl.nodeName===`HTML`?sl.ownerDocument.body:sl).removeChild(n.stateNode)}catch(e){Z(n,t,e)}else try{sl.removeChild(n.stateNode)}catch(e){Z(n,t,e)}break;case 18:sl!==null&&(cl?(e=sl,Qd(e.nodeType===9?e.body:e.nodeName===`HTML`?e.ownerDocument.body:e,n.stateNode),Np(e)):Qd(sl,n.stateNode));break;case 4:r=sl,i=cl,sl=n.stateNode.containerInfo,cl=!0,ll(e,t,n),sl=r,cl=i;break;case 0:case 11:case 14:case 15:Vc(2,n,t),el||Vc(4,n,t),ll(e,t,n);break;case 1:el||(Gc(n,t),r=n.stateNode,typeof r.componentWillUnmount==`function`&&Uc(n,t,r)),ll(e,t,n);break;case 21:ll(e,t,n);break;case 22:el=(r=el)||n.memoizedState!==null,ll(e,t,n),el=r;break;default:ll(e,t,n)}}function dl(e,t){if(t.memoizedState===null&&(e=t.alternate,e!==null&&(e=e.memoizedState,e!==null))){e=e.dehydrated;try{Np(e)}catch(e){Z(t,t.return,e)}}}function fl(e,t){if(t.memoizedState===null&&(e=t.alternate,e!==null&&(e=e.memoizedState,e!==null&&(e=e.dehydrated,e!==null))))try{Np(e)}catch(e){Z(t,t.return,e)}}function pl(e){switch(e.tag){case 31:case 13:case 19:var t=e.stateNode;return t===null&&(t=e.stateNode=new nl),t;case 22:return e=e.stateNode,t=e._retryCache,t===null&&(t=e._retryCache=new nl),t;default:throw Error(i(435,e.tag))}}function ml(e,t){var n=pl(e);t.forEach(function(t){if(!n.has(t)){n.add(t);var r=Yu.bind(null,e,t);t.then(r,r)}})}function hl(e,t){var n=t.deletions;if(n!==null)for(var r=0;r<n.length;r++){var a=n[r],o=e,s=t,c=s;a:for(;c!==null;){switch(c.tag){case 27:if(Zd(c.type)){sl=c.stateNode,cl=!1;break a}break;case 5:sl=c.stateNode,cl=!1;break a;case 3:case 4:sl=c.stateNode.containerInfo,cl=!0;break a}c=c.return}if(sl===null)throw Error(i(160));ul(o,s,a),sl=null,cl=!1,o=a.alternate,o!==null&&(o.return=null),a.return=null}if(t.subtreeFlags&13886)for(t=t.child;t!==null;)_l(t,e),t=t.sibling}var gl=null;function _l(e,t){var n=e.alternate,r=e.flags;switch(e.tag){case 0:case 11:case 14:case 15:hl(t,e),vl(e),r&4&&(Vc(3,e,e.return),Bc(3,e),Vc(5,e,e.return));break;case 1:hl(t,e),vl(e),r&512&&(el||n===null||Gc(n,n.return)),r&64&&$c&&(e=e.updateQueue,e!==null&&(r=e.callbacks,r!==null&&(n=e.shared.hiddenCallbacks,e.shared.hiddenCallbacks=n===null?r:n.concat(r))));break;case 26:var a=gl;if(hl(t,e),vl(e),r&512&&(el||n===null||Gc(n,n.return)),r&4){var o=n===null?null:n.memoizedState;if(r=e.memoizedState,n===null)if(r===null)if(e.stateNode===null){a:{r=e.type,n=e.memoizedProps,a=a.ownerDocument||a;b:switch(r){case`title`:o=a.getElementsByTagName(`title`)[0],(!o||o[dt]||o[it]||o.namespaceURI===`http://www.w3.org/2000/svg`||o.hasAttribute(`itemprop`))&&(o=a.createElement(r),a.head.insertBefore(o,a.querySelector(`head > title`))),Pd(o,r,n),o[it]=e,_t(o),r=o;break a;case`link`:var s=Vf(`link`,`href`,a).get(r+(n.href||``));if(s){for(var c=0;c<s.length;c++)if(o=s[c],o.getAttribute(`href`)===(n.href==null||n.href===``?null:n.href)&&o.getAttribute(`rel`)===(n.rel==null?null:n.rel)&&o.getAttribute(`title`)===(n.title==null?null:n.title)&&o.getAttribute(`crossorigin`)===(n.crossOrigin==null?null:n.crossOrigin)){s.splice(c,1);break b}}o=a.createElement(r),Pd(o,r,n),a.head.appendChild(o);break;case`meta`:if(s=Vf(`meta`,`content`,a).get(r+(n.content||``))){for(c=0;c<s.length;c++)if(o=s[c],o.getAttribute(`content`)===(n.content==null?null:``+n.content)&&o.getAttribute(`name`)===(n.name==null?null:n.name)&&o.getAttribute(`property`)===(n.property==null?null:n.property)&&o.getAttribute(`http-equiv`)===(n.httpEquiv==null?null:n.httpEquiv)&&o.getAttribute(`charset`)===(n.charSet==null?null:n.charSet)){s.splice(c,1);break b}}o=a.createElement(r),Pd(o,r,n),a.head.appendChild(o);break;default:throw Error(i(468,r))}o[it]=e,_t(o),r=o}e.stateNode=r}else Hf(a,e.type,e.stateNode);else e.stateNode=If(a,r,e.memoizedProps);else o===r?r===null&&e.stateNode!==null&&qc(e,e.memoizedProps,n.memoizedProps):(o===null?n.stateNode!==null&&(n=n.stateNode,n.parentNode.removeChild(n)):o.count--,r===null?Hf(a,e.type,e.stateNode):If(a,r,e.memoizedProps))}break;case 27:hl(t,e),vl(e),r&512&&(el||n===null||Gc(n,n.return)),n!==null&&r&4&&qc(e,e.memoizedProps,n.memoizedProps);break;case 5:if(hl(t,e),vl(e),r&512&&(el||n===null||Gc(n,n.return)),e.flags&32){a=e.stateNode;try{Ut(a,``)}catch(t){Z(e,e.return,t)}}r&4&&e.stateNode!=null&&(a=e.memoizedProps,qc(e,a,n===null?a:n.memoizedProps)),r&1024&&(tl=!0);break;case 6:if(hl(t,e),vl(e),r&4){if(e.stateNode===null)throw Error(i(162));r=e.memoizedProps,n=e.stateNode;try{n.nodeValue=r}catch(t){Z(e,e.return,t)}}break;case 3:if(Bf=null,a=gl,gl=gf(t.containerInfo),hl(t,e),gl=a,vl(e),r&4&&n!==null&&n.memoizedState.isDehydrated)try{Np(t.containerInfo)}catch(t){Z(e,e.return,t)}tl&&(tl=!1,yl(e));break;case 4:r=gl,gl=gf(e.stateNode.containerInfo),hl(t,e),vl(e),gl=r;break;case 12:hl(t,e),vl(e);break;case 31:hl(t,e),vl(e),r&4&&(r=e.updateQueue,r!==null&&(e.updateQueue=null,ml(e,r)));break;case 13:hl(t,e),vl(e),e.child.flags&8192&&e.memoizedState!==null!=(n!==null&&n.memoizedState!==null)&&($l=Ce()),r&4&&(r=e.updateQueue,r!==null&&(e.updateQueue=null,ml(e,r)));break;case 22:a=e.memoizedState!==null;var l=n!==null&&n.memoizedState!==null,u=$c,d=el;if($c=u||a,el=d||l,hl(t,e),el=d,$c=u,vl(e),r&8192)a:for(t=e.stateNode,t._visibility=a?t._visibility&-2:t._visibility|1,a&&(n===null||l||$c||el||xl(e)),n=null,t=e;;){if(t.tag===5||t.tag===26){if(n===null){l=n=t;try{if(o=l.stateNode,a)s=o.style,typeof s.setProperty==`function`?s.setProperty(`display`,`none`,`important`):s.display=`none`;else{c=l.stateNode;var f=l.memoizedProps.style,p=f!=null&&f.hasOwnProperty(`display`)?f.display:null;c.style.display=p==null||typeof p==`boolean`?``:(``+p).trim()}}catch(e){Z(l,l.return,e)}}}else if(t.tag===6){if(n===null){l=t;try{l.stateNode.nodeValue=a?``:l.memoizedProps}catch(e){Z(l,l.return,e)}}}else if(t.tag===18){if(n===null){l=t;try{var m=l.stateNode;a?$d(m,!0):$d(l.stateNode,!1)}catch(e){Z(l,l.return,e)}}}else if((t.tag!==22&&t.tag!==23||t.memoizedState===null||t===e)&&t.child!==null){t.child.return=t,t=t.child;continue}if(t===e)break a;for(;t.sibling===null;){if(t.return===null||t.return===e)break a;n===t&&(n=null),t=t.return}n===t&&(n=null),t.sibling.return=t.return,t=t.sibling}r&4&&(r=e.updateQueue,r!==null&&(n=r.retryQueue,n!==null&&(r.retryQueue=null,ml(e,n))));break;case 19:hl(t,e),vl(e),r&4&&(r=e.updateQueue,r!==null&&(e.updateQueue=null,ml(e,r)));break;case 30:break;case 21:break;default:hl(t,e),vl(e)}}function vl(e){var t=e.flags;if(t&2){try{for(var n,r=e.return;r!==null;){if(Jc(r)){n=r;break}r=r.return}if(n==null)throw Error(i(160));switch(n.tag){case 27:var a=n.stateNode;Zc(e,Yc(e),a);break;case 5:var o=n.stateNode;n.flags&32&&(Ut(o,``),n.flags&=-33),Zc(e,Yc(e),o);break;case 3:case 4:var s=n.stateNode.containerInfo;Xc(e,Yc(e),s);break;default:throw Error(i(161))}}catch(t){Z(e,e.return,t)}e.flags&=-3}t&4096&&(e.flags&=-4097)}function yl(e){if(e.subtreeFlags&1024)for(e=e.child;e!==null;){var t=e;yl(t),t.tag===5&&t.flags&1024&&t.stateNode.reset(),e=e.sibling}}function bl(e,t){if(t.subtreeFlags&8772)for(t=t.child;t!==null;)al(e,t.alternate,t),t=t.sibling}function xl(e){for(e=e.child;e!==null;){var t=e;switch(t.tag){case 0:case 11:case 14:case 15:Vc(4,t,t.return),xl(t);break;case 1:Gc(t,t.return);var n=t.stateNode;typeof n.componentWillUnmount==`function`&&Uc(t,t.return,n),xl(t);break;case 27:pf(t.stateNode);case 26:case 5:Gc(t,t.return),xl(t);break;case 22:t.memoizedState===null&&xl(t);break;case 30:xl(t);break;default:xl(t)}e=e.sibling}}function Sl(e,t,n){for(n&&=(t.subtreeFlags&8772)!=0,t=t.child;t!==null;){var r=t.alternate,i=e,a=t,o=a.flags;switch(a.tag){case 0:case 11:case 15:Sl(i,a,n),Bc(4,a);break;case 1:if(Sl(i,a,n),r=a,i=r.stateNode,typeof i.componentDidMount==`function`)try{i.componentDidMount()}catch(e){Z(r,r.return,e)}if(r=a,i=r.updateQueue,i!==null){var s=r.stateNode;try{var c=i.shared.hiddenCallbacks;if(c!==null)for(i.shared.hiddenCallbacks=null,i=0;i<c.length;i++)qa(c[i],s)}catch(e){Z(r,r.return,e)}}n&&o&64&&Hc(a),Wc(a,a.return);break;case 27:Qc(a);case 26:case 5:Sl(i,a,n),n&&r===null&&o&4&&Kc(a),Wc(a,a.return);break;case 12:Sl(i,a,n);break;case 31:Sl(i,a,n),n&&o&4&&dl(i,a);break;case 13:Sl(i,a,n),n&&o&4&&fl(i,a);break;case 22:a.memoizedState===null&&Sl(i,a,n),Wc(a,a.return);break;case 30:break;default:Sl(i,a,n)}t=t.sibling}}function Cl(e,t){var n=null;e!==null&&e.memoizedState!==null&&e.memoizedState.cachePool!==null&&(n=e.memoizedState.cachePool.pool),e=null,t.memoizedState!==null&&t.memoizedState.cachePool!==null&&(e=t.memoizedState.cachePool.pool),e!==n&&(e!=null&&e.refCount++,n!=null&&sa(n))}function wl(e,t){e=null,t.alternate!==null&&(e=t.alternate.memoizedState.cache),t=t.memoizedState.cache,t!==e&&(t.refCount++,e!=null&&sa(e))}function Tl(e,t,n,r){if(t.subtreeFlags&10256)for(t=t.child;t!==null;)El(e,t,n,r),t=t.sibling}function El(e,t,n,r){var i=t.flags;switch(t.tag){case 0:case 11:case 15:Tl(e,t,n,r),i&2048&&Bc(9,t);break;case 1:Tl(e,t,n,r);break;case 3:Tl(e,t,n,r),i&2048&&(e=null,t.alternate!==null&&(e=t.alternate.memoizedState.cache),t=t.memoizedState.cache,t!==e&&(t.refCount++,e!=null&&sa(e)));break;case 12:if(i&2048){Tl(e,t,n,r),e=t.stateNode;try{var a=t.memoizedProps,o=a.id,s=a.onPostCommit;typeof s==`function`&&s(o,t.alternate===null?`mount`:`update`,e.passiveEffectDuration,-0)}catch(e){Z(t,t.return,e)}}else Tl(e,t,n,r);break;case 31:Tl(e,t,n,r);break;case 13:Tl(e,t,n,r);break;case 23:break;case 22:a=t.stateNode,o=t.alternate,t.memoizedState===null?a._visibility&2?Tl(e,t,n,r):(a._visibility|=2,Dl(e,t,n,r,(t.subtreeFlags&10256)!=0||!1)):a._visibility&2?Tl(e,t,n,r):Ol(e,t),i&2048&&Cl(o,t);break;case 24:Tl(e,t,n,r),i&2048&&wl(t.alternate,t);break;default:Tl(e,t,n,r)}}function Dl(e,t,n,r,i){for(i&&=(t.subtreeFlags&10256)!=0||!1,t=t.child;t!==null;){var a=e,o=t,s=n,c=r,l=o.flags;switch(o.tag){case 0:case 11:case 15:Dl(a,o,s,c,i),Bc(8,o);break;case 23:break;case 22:var u=o.stateNode;o.memoizedState===null?(u._visibility|=2,Dl(a,o,s,c,i)):u._visibility&2?Dl(a,o,s,c,i):Ol(a,o),i&&l&2048&&Cl(o.alternate,o);break;case 24:Dl(a,o,s,c,i),i&&l&2048&&wl(o.alternate,o);break;default:Dl(a,o,s,c,i)}t=t.sibling}}function Ol(e,t){if(t.subtreeFlags&10256)for(t=t.child;t!==null;){var n=e,r=t,i=r.flags;switch(r.tag){case 22:Ol(n,r),i&2048&&Cl(r.alternate,r);break;case 24:Ol(n,r),i&2048&&wl(r.alternate,r);break;default:Ol(n,r)}t=t.sibling}}var kl=8192;function Al(e,t,n){if(e.subtreeFlags&kl)for(e=e.child;e!==null;)jl(e,t,n),e=e.sibling}function jl(e,t,n){switch(e.tag){case 26:Al(e,t,n),e.flags&kl&&e.memoizedState!==null&&Gf(n,gl,e.memoizedState,e.memoizedProps);break;case 5:Al(e,t,n);break;case 3:case 4:var r=gl;gl=gf(e.stateNode.containerInfo),Al(e,t,n),gl=r;break;case 22:e.memoizedState===null&&(r=e.alternate,r!==null&&r.memoizedState!==null?(r=kl,kl=16777216,Al(e,t,n),kl=r):Al(e,t,n));break;default:Al(e,t,n)}}function Ml(e){var t=e.alternate;if(t!==null&&(e=t.child,e!==null)){t.child=null;do t=e.sibling,e.sibling=null,e=t;while(e!==null)}}function Nl(e){var t=e.deletions;if(e.flags&16){if(t!==null)for(var n=0;n<t.length;n++){var r=t[n];rl=r,Il(r,e)}Ml(e)}if(e.subtreeFlags&10256)for(e=e.child;e!==null;)Pl(e),e=e.sibling}function Pl(e){switch(e.tag){case 0:case 11:case 15:Nl(e),e.flags&2048&&Vc(9,e,e.return);break;case 3:Nl(e);break;case 12:Nl(e);break;case 22:var t=e.stateNode;e.memoizedState!==null&&t._visibility&2&&(e.return===null||e.return.tag!==13)?(t._visibility&=-3,Fl(e)):Nl(e);break;default:Nl(e)}}function Fl(e){var t=e.deletions;if(e.flags&16){if(t!==null)for(var n=0;n<t.length;n++){var r=t[n];rl=r,Il(r,e)}Ml(e)}for(e=e.child;e!==null;){switch(t=e,t.tag){case 0:case 11:case 15:Vc(8,t,t.return),Fl(t);break;case 22:n=t.stateNode,n._visibility&2&&(n._visibility&=-3,Fl(t));break;default:Fl(t)}e=e.sibling}}function Il(e,t){for(;rl!==null;){var n=rl;switch(n.tag){case 0:case 11:case 15:Vc(8,n,t);break;case 23:case 22:if(n.memoizedState!==null&&n.memoizedState.cachePool!==null){var r=n.memoizedState.cachePool.pool;r!=null&&r.refCount++}break;case 24:sa(n.memoizedState.cache)}if(r=n.child,r!==null)r.return=n,rl=r;else a:for(n=e;rl!==null;){r=rl;var i=r.sibling,a=r.return;if(ol(r),r===n){rl=null;break a}if(i!==null){i.return=a,rl=i;break a}rl=a}}}var Ll={getCacheForType:function(e){var t=$i(aa),n=t.data.get(e);return n===void 0&&(n=e(),t.data.set(e,n)),n},cacheSignal:function(){return $i(aa).controller.signal}},Rl=typeof WeakMap==`function`?WeakMap:Map,K=0,q=null,J=null,Y=0,X=0,zl=null,Bl=!1,Vl=!1,Hl=!1,Ul=0,Wl=0,Gl=0,Kl=0,ql=0,Jl=0,Yl=0,Xl=null,Zl=null,Ql=!1,$l=0,eu=0,tu=1/0,nu=null,ru=null,iu=0,au=null,ou=null,su=0,cu=0,lu=null,uu=null,du=0,fu=null;function pu(){return K&2&&Y!==0?Y&-Y:F.T===null?tt():dd()}function mu(){if(Jl===0)if(!(Y&536870912)||V){var e=Be;Be<<=1,!(Be&3932160)&&(Be=262144),Jl=e}else Jl=536870912;return e=eo.current,e!==null&&(e.flags|=32),Jl}function hu(e,t,n){(e===q&&(X===2||X===9)||e.cancelPendingCommit!==null)&&(Su(e,0),yu(e,Y,Jl,!1)),Je(e,n),(!(K&2)||e!==q)&&(e===q&&(!(K&2)&&(Kl|=n),Wl===4&&yu(e,Y,Jl,!1)),rd(e))}function gu(e,t,n){if(K&6)throw Error(i(327));var r=!n&&(t&127)==0&&(t&e.expiredLanes)===0||We(e,t),a=r?Au(e,t):Ou(e,t,!0),o=r;do{if(a===0){Vl&&!r&&yu(e,t,0,!1);break}else{if(n=e.current.alternate,o&&!vu(n)){a=Ou(e,t,!1),o=!1;continue}if(a===2){if(o=t,e.errorRecoveryDisabledLanes&o)var s=0;else s=e.pendingLanes&-536870913,s=s===0?s&536870912?536870912:0:s;if(s!==0){t=s;a:{var c=e;a=Xl;var l=c.current.memoizedState.isDehydrated;if(l&&(Su(c,s).flags|=256),s=Ou(c,s,!1),s!==2){if(Hl&&!l){c.errorRecoveryDisabledLanes|=o,Kl|=o,a=4;break a}o=Zl,Zl=a,o!==null&&(Zl===null?Zl=o:Zl.push.apply(Zl,o))}a=s}if(o=!1,a!==2)continue}}if(a===1){Su(e,0),yu(e,t,0,!0);break}a:{switch(r=e,o=a,o){case 0:case 1:throw Error(i(345));case 4:if((t&4194048)!==t)break;case 6:yu(r,t,Jl,!Bl);break a;case 2:Zl=null;break;case 3:case 5:break;default:throw Error(i(329))}if((t&62914560)===t&&(a=$l+300-Ce(),10<a)){if(yu(r,t,Jl,!Bl),Ue(r,0,!0)!==0)break a;su=t,r.timeoutHandle=Kd(_u.bind(null,r,n,Zl,nu,Ql,t,Jl,Kl,Yl,Bl,o,`Throttled`,-0,0),a);break a}_u(r,n,Zl,nu,Ql,t,Jl,Kl,Yl,Bl,o,null,-0,0)}}break}while(1);rd(e)}function _u(e,t,n,r,i,a,o,s,c,l,u,d,f,p){if(e.timeoutHandle=-1,d=t.subtreeFlags,d&8192||(d&16785408)==16785408){d={stylesheets:null,count:0,imgCount:0,imgBytes:0,suspenseyImages:[],waitingForImages:!0,waitingForViewTransition:!1,unsuspend:Zt},jl(t,a,d);var m=(a&62914560)===a?$l-Ce():(a&4194048)===a?eu-Ce():0;if(m=qf(d,m),m!==null){su=a,e.cancelPendingCommit=m(Lu.bind(null,e,t,a,n,r,i,o,s,c,u,d,null,f,p)),yu(e,a,o,!l);return}}Lu(e,t,a,n,r,i,o,s,c)}function vu(e){for(var t=e;;){var n=t.tag;if((n===0||n===11||n===15)&&t.flags&16384&&(n=t.updateQueue,n!==null&&(n=n.stores,n!==null)))for(var r=0;r<n.length;r++){var i=n[r],a=i.getSnapshot;i=i.value;try{if(!br(a(),i))return!1}catch{return!1}}if(n=t.child,t.subtreeFlags&16384&&n!==null)n.return=t,t=n;else{if(t===e)break;for(;t.sibling===null;){if(t.return===null||t.return===e)return!0;t=t.return}t.sibling.return=t.return,t=t.sibling}}return!0}function yu(e,t,n,r){t&=~ql,t&=~Kl,e.suspendedLanes|=t,e.pingedLanes&=~t,r&&(e.warmLanes|=t),r=e.expirationTimes;for(var i=t;0<i;){var a=31-Fe(i),o=1<<a;r[a]=-1,i&=~o}n!==0&&Xe(e,n,t)}function bu(){return K&6?!0:(id(0,!1),!1)}function xu(){if(J!==null){if(X===0)var e=J.return;else e=J,Gi=Wi=null,Do(e),ka=null,Aa=0,e=J;for(;e!==null;)zc(e.alternate,e),e=e.return;J=null}}function Su(e,t){var n=e.timeoutHandle;n!==-1&&(e.timeoutHandle=-1,qd(n)),n=e.cancelPendingCommit,n!==null&&(e.cancelPendingCommit=null,n()),su=0,xu(),q=e,J=n=ci(e.current,null),Y=t,X=0,zl=null,Bl=!1,Vl=We(e,t),Hl=!1,Yl=Jl=ql=Kl=Gl=Wl=0,Zl=Xl=null,Ql=!1,t&8&&(t|=t&32);var r=e.entangledLanes;if(r!==0)for(e=e.entanglements,r&=t;0<r;){var i=31-Fe(r),a=1<<i;t|=e[i],r&=~a}return Ul=t,Qr(),n}function Cu(e,t){U=null,F.H=Ls,t===ba||t===Sa?(t=Oa(),X=3):t===xa?(t=Oa(),X=4):X=t===tc?8:typeof t==`object`&&t&&typeof t.then==`function`?6:1,zl=t,J===null&&(Wl=1,Ys(e,gi(t,e.current)))}function wu(){var e=eo.current;return e===null?!0:(Y&4194048)===Y?to===null:(Y&62914560)===Y||Y&536870912?e===to:!1}function Tu(){var e=F.H;return F.H=Ls,e===null?Ls:e}function Eu(){var e=F.A;return F.A=Ll,e}function Du(){Wl=4,Bl||(Y&4194048)!==Y&&eo.current!==null||(Vl=!0),!(Gl&134217727)&&!(Kl&134217727)||q===null||yu(q,Y,Jl,!1)}function Ou(e,t,n){var r=K;K|=2;var i=Tu(),a=Eu();(q!==e||Y!==t)&&(nu=null,Su(e,t)),t=!1;var o=Wl;a:do try{if(X!==0&&J!==null){var s=J,c=zl;switch(X){case 8:xu(),o=6;break a;case 3:case 2:case 9:case 6:eo.current===null&&(t=!0);var l=X;if(X=0,zl=null,Pu(e,s,c,l),n&&Vl){o=0;break a}break;default:l=X,X=0,zl=null,Pu(e,s,c,l)}}ku(),o=Wl;break}catch(t){Cu(e,t)}while(1);return t&&e.shellSuspendCounter++,Gi=Wi=null,K=r,F.H=i,F.A=a,J===null&&(q=null,Y=0,Qr()),o}function ku(){for(;J!==null;)Mu(J)}function Au(e,t){var n=K;K|=2;var r=Tu(),a=Eu();q!==e||Y!==t?(nu=null,tu=Ce()+500,Su(e,t)):Vl=We(e,t);a:do try{if(X!==0&&J!==null){t=J;var o=zl;b:switch(X){case 1:X=0,zl=null,Pu(e,t,o,1);break;case 2:case 9:if(wa(o)){X=0,zl=null,Nu(t);break}t=function(){X!==2&&X!==9||q!==e||(X=7),rd(e)},o.then(t,t);break a;case 3:X=7;break a;case 4:X=5;break a;case 7:wa(o)?(X=0,zl=null,Nu(t)):(X=0,zl=null,Pu(e,t,o,7));break;case 5:var s=null;switch(J.tag){case 26:s=J.memoizedState;case 5:case 27:var c=J;if(s?Wf(s):c.stateNode.complete){X=0,zl=null;var l=c.sibling;if(l!==null)J=l;else{var u=c.return;u===null?J=null:(J=u,Fu(u))}break b}}X=0,zl=null,Pu(e,t,o,5);break;case 6:X=0,zl=null,Pu(e,t,o,6);break;case 8:xu(),Wl=6;break a;default:throw Error(i(462))}}ju();break}catch(t){Cu(e,t)}while(1);return Gi=Wi=null,F.H=r,F.A=a,K=n,J===null?(q=null,Y=0,Qr(),Wl):0}function ju(){for(;J!==null&&!xe();)Mu(J)}function Mu(e){var t=Ac(e.alternate,e,Ul);e.memoizedProps=e.pendingProps,t===null?Fu(e):J=t}function Nu(e){var t=e,n=t.alternate;switch(t.tag){case 15:case 0:t=hc(n,t,t.pendingProps,t.type,void 0,Y);break;case 11:t=hc(n,t,t.pendingProps,t.type.render,t.ref,Y);break;case 5:Do(t);default:zc(n,t),t=J=li(t,Ul),t=Ac(n,t,Ul)}e.memoizedProps=e.pendingProps,t===null?Fu(e):J=t}function Pu(e,t,n,r){Gi=Wi=null,Do(t),ka=null,Aa=0;var i=t.return;try{if(ec(e,i,t,n,Y)){Wl=1,Ys(e,gi(n,e.current)),J=null;return}}catch(t){if(i!==null)throw J=i,t;Wl=1,Ys(e,gi(n,e.current)),J=null;return}t.flags&32768?(V||r===1?e=!0:Vl||Y&536870912?e=!1:(Bl=e=!0,(r===2||r===9||r===3||r===6)&&(r=eo.current,r!==null&&r.tag===13&&(r.flags|=16384))),Iu(t,e)):Fu(t)}function Fu(e){var t=e;do{if(t.flags&32768){Iu(t,Bl);return}e=t.return;var n=Lc(t.alternate,t,Ul);if(n!==null){J=n;return}if(t=t.sibling,t!==null){J=t;return}J=t=e}while(t!==null);Wl===0&&(Wl=5)}function Iu(e,t){do{var n=Rc(e.alternate,e);if(n!==null){n.flags&=32767,J=n;return}if(n=e.return,n!==null&&(n.flags|=32768,n.subtreeFlags=0,n.deletions=null),!t&&(e=e.sibling,e!==null)){J=e;return}J=e=n}while(e!==null);Wl=6,J=null}function Lu(e,t,n,r,a,o,s,c,l){e.cancelPendingCommit=null;do Hu();while(iu!==0);if(K&6)throw Error(i(327));if(t!==null){if(t===e.current)throw Error(i(177));if(o=t.lanes|t.childLanes,o|=Zr,Ye(e,n,o,s,c,l),e===q&&(J=q=null,Y=0),ou=t,au=e,su=n,cu=o,lu=a,uu=r,t.subtreeFlags&10256||t.flags&10256?(e.callbackNode=null,e.callbackPriority=0,Xu(De,function(){return Uu(),null})):(e.callbackNode=null,e.callbackPriority=0),r=(t.flags&13878)!=0,t.subtreeFlags&13878||r){r=F.T,F.T=null,a=I.p,I.p=2,s=K,K|=4;try{il(e,t,n)}finally{K=s,I.p=a,F.T=r}}iu=1,Ru(),zu(),Bu()}}function Ru(){if(iu===1){iu=0;var e=au,t=ou,n=(t.flags&13878)!=0;if(t.subtreeFlags&13878||n){n=F.T,F.T=null;var r=I.p;I.p=2;var i=K;K|=4;try{_l(t,e);var a=zd,o=Tr(e.containerInfo),s=a.focusedElem,c=a.selectionRange;if(o!==s&&s&&s.ownerDocument&&wr(s.ownerDocument.documentElement,s)){if(c!==null&&Er(s)){var l=c.start,u=c.end;if(u===void 0&&(u=l),`selectionStart`in s)s.selectionStart=l,s.selectionEnd=Math.min(u,s.value.length);else{var d=s.ownerDocument||document,f=d&&d.defaultView||window;if(f.getSelection){var p=f.getSelection(),m=s.textContent.length,h=Math.min(c.start,m),g=c.end===void 0?h:Math.min(c.end,m);!p.extend&&h>g&&(o=g,g=h,h=o);var _=Cr(s,h),v=Cr(s,g);if(_&&v&&(p.rangeCount!==1||p.anchorNode!==_.node||p.anchorOffset!==_.offset||p.focusNode!==v.node||p.focusOffset!==v.offset)){var y=d.createRange();y.setStart(_.node,_.offset),p.removeAllRanges(),h>g?(p.addRange(y),p.extend(v.node,v.offset)):(y.setEnd(v.node,v.offset),p.addRange(y))}}}}for(d=[],p=s;p=p.parentNode;)p.nodeType===1&&d.push({element:p,left:p.scrollLeft,top:p.scrollTop});for(typeof s.focus==`function`&&s.focus(),s=0;s<d.length;s++){var b=d[s];b.element.scrollLeft=b.left,b.element.scrollTop=b.top}}sp=!!Rd,zd=Rd=null}finally{K=i,I.p=r,F.T=n}}e.current=t,iu=2}}function zu(){if(iu===2){iu=0;var e=au,t=ou,n=(t.flags&8772)!=0;if(t.subtreeFlags&8772||n){n=F.T,F.T=null;var r=I.p;I.p=2;var i=K;K|=4;try{al(e,t.alternate,t)}finally{K=i,I.p=r,F.T=n}}iu=3}}function Bu(){if(iu===4||iu===3){iu=0,Se();var e=au,t=ou,n=su,r=uu;t.subtreeFlags&10256||t.flags&10256?iu=5:(iu=0,ou=au=null,Vu(e,e.pendingLanes));var i=e.pendingLanes;if(i===0&&(ru=null),et(n),t=t.stateNode,Ne&&typeof Ne.onCommitFiberRoot==`function`)try{Ne.onCommitFiberRoot(Me,t,void 0,(t.current.flags&128)==128)}catch{}if(r!==null){t=F.T,i=I.p,I.p=2,F.T=null;try{for(var a=e.onRecoverableError,o=0;o<r.length;o++){var s=r[o];a(s.value,{componentStack:s.stack})}}finally{F.T=t,I.p=i}}su&3&&Hu(),rd(e),i=e.pendingLanes,n&261930&&i&42?e===fu?du++:(du=0,fu=e):du=0,id(0,!1)}}function Vu(e,t){(e.pooledCacheLanes&=t)===0&&(t=e.pooledCache,t!=null&&(e.pooledCache=null,sa(t)))}function Hu(){return Ru(),zu(),Bu(),Uu()}function Uu(){if(iu!==5)return!1;var e=au,t=cu;cu=0;var n=et(su),r=F.T,a=I.p;try{I.p=32>n?32:n,F.T=null,n=lu,lu=null;var o=au,s=su;if(iu=0,ou=au=null,su=0,K&6)throw Error(i(331));var c=K;if(K|=4,Pl(o.current),El(o,o.current,s,n),K=c,id(0,!1),Ne&&typeof Ne.onPostCommitFiberRoot==`function`)try{Ne.onPostCommitFiberRoot(Me,o)}catch{}return!0}finally{I.p=a,F.T=r,Vu(e,t)}}function Wu(e,t,n){t=gi(n,t),t=Zs(e.stateNode,t,2),e=Va(e,t,2),e!==null&&(Je(e,2),rd(e))}function Z(e,t,n){if(e.tag===3)Wu(e,e,n);else for(;t!==null;){if(t.tag===3){Wu(t,e,n);break}else if(t.tag===1){var r=t.stateNode;if(typeof t.type.getDerivedStateFromError==`function`||typeof r.componentDidCatch==`function`&&(ru===null||!ru.has(r))){e=gi(n,e),n=Qs(2),r=Va(t,n,2),r!==null&&($s(n,r,t,e),Je(r,2),rd(r));break}}t=t.return}}function Gu(e,t,n){var r=e.pingCache;if(r===null){r=e.pingCache=new Rl;var i=new Set;r.set(t,i)}else i=r.get(t),i===void 0&&(i=new Set,r.set(t,i));i.has(n)||(Hl=!0,i.add(n),e=Ku.bind(null,e,t,n),t.then(e,e))}function Ku(e,t,n){var r=e.pingCache;r!==null&&r.delete(t),e.pingedLanes|=e.suspendedLanes&n,e.warmLanes&=~n,q===e&&(Y&n)===n&&(Wl===4||Wl===3&&(Y&62914560)===Y&&300>Ce()-$l?!(K&2)&&Su(e,0):ql|=n,Yl===Y&&(Yl=0)),rd(e)}function qu(e,t){t===0&&(t=Ke()),e=ti(e,t),e!==null&&(Je(e,t),rd(e))}function Ju(e){var t=e.memoizedState,n=0;t!==null&&(n=t.retryLane),qu(e,n)}function Yu(e,t){var n=0;switch(e.tag){case 31:case 13:var r=e.stateNode,a=e.memoizedState;a!==null&&(n=a.retryLane);break;case 19:r=e.stateNode;break;case 22:r=e.stateNode._retryCache;break;default:throw Error(i(314))}r!==null&&r.delete(t),qu(e,n)}function Xu(e,t){return ye(e,t)}var Zu=null,Qu=null,$u=!1,ed=!1,td=!1,nd=0;function rd(e){e!==Qu&&e.next===null&&(Qu===null?Zu=Qu=e:Qu=Qu.next=e),ed=!0,$u||($u=!0,ud())}function id(e,t){if(!td&&ed){td=!0;do for(var n=!1,r=Zu;r!==null;){if(!t)if(e!==0){var i=r.pendingLanes;if(i===0)var a=0;else{var o=r.suspendedLanes,s=r.pingedLanes;a=(1<<31-Fe(42|e)+1)-1,a&=i&~(o&~s),a=a&201326741?a&201326741|1:a?a|2:0}a!==0&&(n=!0,ld(r,a))}else a=Y,a=Ue(r,r===q?a:0,r.cancelPendingCommit!==null||r.timeoutHandle!==-1),!(a&3)||We(r,a)||(n=!0,ld(r,a));r=r.next}while(n);td=!1}}function ad(){od()}function od(){ed=$u=!1;var e=0;nd!==0&&Gd()&&(e=nd);for(var t=Ce(),n=null,r=Zu;r!==null;){var i=r.next,a=sd(r,t);a===0?(r.next=null,n===null?Zu=i:n.next=i,i===null&&(Qu=n)):(n=r,(e!==0||a&3)&&(ed=!0)),r=i}iu!==0&&iu!==5||id(e,!1),nd!==0&&(nd=0)}function sd(e,t){for(var n=e.suspendedLanes,r=e.pingedLanes,i=e.expirationTimes,a=e.pendingLanes&-62914561;0<a;){var o=31-Fe(a),s=1<<o,c=i[o];c===-1?((s&n)===0||(s&r)!==0)&&(i[o]=Ge(s,t)):c<=t&&(e.expiredLanes|=s),a&=~s}if(t=q,n=Y,n=Ue(e,e===t?n:0,e.cancelPendingCommit!==null||e.timeoutHandle!==-1),r=e.callbackNode,n===0||e===t&&(X===2||X===9)||e.cancelPendingCommit!==null)return r!==null&&r!==null&&be(r),e.callbackNode=null,e.callbackPriority=0;if(!(n&3)||We(e,n)){if(t=n&-n,t===e.callbackPriority)return t;switch(r!==null&&be(r),et(n)){case 2:case 8:n=Ee;break;case 32:n=De;break;case 268435456:n=ke;break;default:n=De}return r=cd.bind(null,e),n=ye(n,r),e.callbackPriority=t,e.callbackNode=n,t}return r!==null&&r!==null&&be(r),e.callbackPriority=2,e.callbackNode=null,2}function cd(e,t){if(iu!==0&&iu!==5)return e.callbackNode=null,e.callbackPriority=0,null;var n=e.callbackNode;if(Hu()&&e.callbackNode!==n)return null;var r=Y;return r=Ue(e,e===q?r:0,e.cancelPendingCommit!==null||e.timeoutHandle!==-1),r===0?null:(gu(e,r,t),sd(e,Ce()),e.callbackNode!=null&&e.callbackNode===n?cd.bind(null,e):null)}function ld(e,t){if(Hu())return null;gu(e,t,!0)}function ud(){Yd(function(){K&6?ye(Te,ad):od()})}function dd(){if(nd===0){var e=ua;e===0&&(e=ze,ze<<=1,!(ze&261888)&&(ze=256)),nd=e}return nd}function fd(e){return e==null||typeof e==`symbol`||typeof e==`boolean`?null:typeof e==`function`?e:Xt(``+e)}function pd(e,t){var n=t.ownerDocument.createElement(`input`);return n.name=t.name,n.value=t.value,e.id&&n.setAttribute(`form`,e.id),t.parentNode.insertBefore(n,t),e=new FormData(e),n.parentNode.removeChild(n),e}function md(e,t,n,r,i){if(t===`submit`&&n&&n.stateNode===i){var a=fd((i[at]||null).action),o=r.submitter;o&&(t=(t=o[at]||null)?fd(t.formAction):o.getAttribute(`formAction`),t!==null&&(a=t,o=null));var s=new yn(`action`,`action`,null,r,i);e.push({event:s,listeners:[{instance:null,listener:function(){if(r.defaultPrevented){if(nd!==0){var e=o?pd(i,o):new FormData(i);Cs(n,{pending:!0,data:e,method:i.method,action:a},null,e)}}else typeof a==`function`&&(s.preventDefault(),e=o?pd(i,o):new FormData(i),Cs(n,{pending:!0,data:e,method:i.method,action:a},a,e))},currentTarget:i}]})}}for(var hd=0;hd<Kr.length;hd++){var gd=Kr[hd];qr(gd.toLowerCase(),`on`+(gd[0].toUpperCase()+gd.slice(1)))}qr(Rr,`onAnimationEnd`),qr(zr,`onAnimationIteration`),qr(Br,`onAnimationStart`),qr(`dblclick`,`onDoubleClick`),qr(`focusin`,`onFocus`),qr(`focusout`,`onBlur`),qr(Vr,`onTransitionRun`),qr(Hr,`onTransitionStart`),qr(Ur,`onTransitionCancel`),qr(Wr,`onTransitionEnd`),xt(`onMouseEnter`,[`mouseout`,`mouseover`]),xt(`onMouseLeave`,[`mouseout`,`mouseover`]),xt(`onPointerEnter`,[`pointerout`,`pointerover`]),xt(`onPointerLeave`,[`pointerout`,`pointerover`]),bt(`onChange`,`change click focusin focusout input keydown keyup selectionchange`.split(` `)),bt(`onSelect`,`focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange`.split(` `)),bt(`onBeforeInput`,[`compositionend`,`keypress`,`textInput`,`paste`]),bt(`onCompositionEnd`,`compositionend focusout keydown keypress keyup mousedown`.split(` `)),bt(`onCompositionStart`,`compositionstart focusout keydown keypress keyup mousedown`.split(` `)),bt(`onCompositionUpdate`,`compositionupdate focusout keydown keypress keyup mousedown`.split(` `));var _d=`abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting`.split(` `),vd=new Set(`beforetoggle cancel close invalid load scroll scrollend toggle`.split(` `).concat(_d));function yd(e,t){t=(t&4)!=0;for(var n=0;n<e.length;n++){var r=e[n],i=r.event;r=r.listeners;a:{var a=void 0;if(t)for(var o=r.length-1;0<=o;o--){var s=r[o],c=s.instance,l=s.currentTarget;if(s=s.listener,c!==a&&i.isPropagationStopped())break a;a=s,i.currentTarget=l;try{a(i)}catch(e){Jr(e)}i.currentTarget=null,a=c}else for(o=0;o<r.length;o++){if(s=r[o],c=s.instance,l=s.currentTarget,s=s.listener,c!==a&&i.isPropagationStopped())break a;a=s,i.currentTarget=l;try{a(i)}catch(e){Jr(e)}i.currentTarget=null,a=c}}}}function Q(e,t){var n=t[st];n===void 0&&(n=t[st]=new Set);var r=e+`__bubble`;n.has(r)||(Cd(t,e,2,!1),n.add(r))}function bd(e,t,n){var r=0;t&&(r|=4),Cd(n,e,r,t)}var xd=`_reactListening`+Math.random().toString(36).slice(2);function Sd(e){if(!e[xd]){e[xd]=!0,vt.forEach(function(t){t!==`selectionchange`&&(vd.has(t)||bd(t,!1,e),bd(t,!0,e))});var t=e.nodeType===9?e:e.ownerDocument;t===null||t[xd]||(t[xd]=!0,bd(`selectionchange`,!1,t))}}function Cd(e,t,n,r){switch(mp(t)){case 2:var i=cp;break;case 8:i=lp;break;default:i=up}n=i.bind(null,t,n,e),i=void 0,!cn||t!==`touchstart`&&t!==`touchmove`&&t!==`wheel`||(i=!0),r?i===void 0?e.addEventListener(t,n,!0):e.addEventListener(t,n,{capture:!0,passive:i}):i===void 0?e.addEventListener(t,n,!1):e.addEventListener(t,n,{passive:i})}function wd(e,t,n,r,i){var a=r;if(!(t&1)&&!(t&2)&&r!==null)a:for(;;){if(r===null)return;var s=r.tag;if(s===3||s===4){var c=r.stateNode.containerInfo;if(c===i)break;if(s===4)for(s=r.return;s!==null;){var l=s.tag;if((l===3||l===4)&&s.stateNode.containerInfo===i)return;s=s.return}for(;c!==null;){if(s=pt(c),s===null)return;if(l=s.tag,l===5||l===6||l===26||l===27){r=a=s;continue a}c=c.parentNode}}r=r.return}an(function(){var r=a,i=$t(n),s=[];a:{var c=Gr.get(e);if(c!==void 0){var l=yn,u=e;switch(e){case`keypress`:if(mn(n)===0)break a;case`keydown`:case`keyup`:l=Ln;break;case`focusin`:u=`focus`,l=On;break;case`focusout`:u=`blur`,l=On;break;case`beforeblur`:case`afterblur`:l=On;break;case`click`:if(n.button===2)break a;case`auxclick`:case`dblclick`:case`mousedown`:case`mousemove`:case`mouseup`:case`mouseout`:case`mouseover`:case`contextmenu`:l=En;break;case`drag`:case`dragend`:case`dragenter`:case`dragexit`:case`dragleave`:case`dragover`:case`dragstart`:case`drop`:l=Dn;break;case`touchcancel`:case`touchend`:case`touchmove`:case`touchstart`:l=zn;break;case Rr:case zr:case Br:l=kn;break;case Wr:l=Bn;break;case`scroll`:case`scrollend`:l=xn;break;case`wheel`:l=Vn;break;case`copy`:case`cut`:case`paste`:l=An;break;case`gotpointercapture`:case`lostpointercapture`:case`pointercancel`:case`pointerdown`:case`pointermove`:case`pointerout`:case`pointerover`:case`pointerup`:l=Rn;break;case`toggle`:case`beforetoggle`:l=Hn}var d=(t&4)!=0,f=!d&&(e===`scroll`||e===`scrollend`),p=d?c===null?null:c+`Capture`:c;d=[];for(var m=r,h;m!==null;){var g=m;if(h=g.stateNode,g=g.tag,g!==5&&g!==26&&g!==27||h===null||p===null||(g=on(m,p),g!=null&&d.push(Td(m,g,h))),f)break;m=m.return}0<d.length&&(c=new l(c,u,null,n,i),s.push({event:c,listeners:d}))}}if(!(t&7)){a:{if(c=e===`mouseover`||e===`pointerover`,l=e===`mouseout`||e===`pointerout`,c&&n!==Qt&&(u=n.relatedTarget||n.fromElement)&&(pt(u)||u[ot]))break a;if((l||c)&&(c=i.window===i?i:(c=i.ownerDocument)?c.defaultView||c.parentWindow:window,l?(u=n.relatedTarget||n.toElement,l=r,u=u?pt(u):null,u!==null&&(f=o(u),d=u.tag,u!==f||d!==5&&d!==27&&d!==6)&&(u=null)):(l=null,u=r),l!==u)){if(d=En,g=`onMouseLeave`,p=`onMouseEnter`,m=`mouse`,(e===`pointerout`||e===`pointerover`)&&(d=Rn,g=`onPointerLeave`,p=`onPointerEnter`,m=`pointer`),f=l==null?c:ht(l),h=u==null?c:ht(u),c=new d(g,m+`leave`,l,n,i),c.target=f,c.relatedTarget=h,g=null,pt(i)===r&&(d=new d(p,m+`enter`,u,n,i),d.target=h,d.relatedTarget=f,g=d),f=g,l&&u)b:{for(d=Dd,p=l,m=u,h=0,g=p;g;g=d(g))h++;g=0;for(var _=m;_;_=d(_))g++;for(;0<h-g;)p=d(p),h--;for(;0<g-h;)m=d(m),g--;for(;h--;){if(p===m||m!==null&&p===m.alternate){d=p;break b}p=d(p),m=d(m)}d=null}else d=null;l!==null&&Od(s,c,l,d,!1),u!==null&&f!==null&&Od(s,f,u,d,!0)}}a:{if(c=r?ht(r):window,l=c.nodeName&&c.nodeName.toLowerCase(),l===`select`||l===`input`&&c.type===`file`)var v=cr;else if(nr(c))if(lr)v=vr;else{v=gr;var y=hr}else l=c.nodeName,!l||l.toLowerCase()!==`input`||c.type!==`checkbox`&&c.type!==`radio`?r&&qt(r.elementType)&&(v=cr):v=_r;if(v&&=v(e,r)){rr(s,v,n,i);break a}y&&y(e,c,r),e===`focusout`&&r&&c.type===`number`&&r.memoizedProps.value!=null&&zt(c,`number`,c.value)}switch(y=r?ht(r):window,e){case`focusin`:(nr(y)||y.contentEditable===`true`)&&(Or=y,kr=r,Ar=null);break;case`focusout`:Ar=kr=Or=null;break;case`mousedown`:jr=!0;break;case`contextmenu`:case`mouseup`:case`dragend`:jr=!1,Mr(s,n,i);break;case`selectionchange`:if(Dr)break;case`keydown`:case`keyup`:Mr(s,n,i)}var b;if(Wn)b:{switch(e){case`compositionstart`:var x=`onCompositionStart`;break b;case`compositionend`:x=`onCompositionEnd`;break b;case`compositionupdate`:x=`onCompositionUpdate`;break b}x=void 0}else Qn?Xn(e,n)&&(x=`onCompositionEnd`):e===`keydown`&&n.keyCode===229&&(x=`onCompositionStart`);x&&(qn&&n.locale!==`ko`&&(Qn||x!==`onCompositionStart`?x===`onCompositionEnd`&&Qn&&(b=pn()):(un=i,dn=`value`in un?un.value:un.textContent,Qn=!0)),y=Ed(r,x),0<y.length&&(x=new jn(x,e,null,n,i),s.push({event:x,listeners:y}),b?x.data=b:(b=Zn(n),b!==null&&(x.data=b)))),(b=Kn?$n(e,n):er(e,n))&&(x=Ed(r,`onBeforeInput`),0<x.length&&(y=new jn(`onBeforeInput`,`beforeinput`,null,n,i),s.push({event:y,listeners:x}),y.data=b)),md(s,e,r,n,i)}yd(s,t)})}function Td(e,t,n){return{instance:e,listener:t,currentTarget:n}}function Ed(e,t){for(var n=t+`Capture`,r=[];e!==null;){var i=e,a=i.stateNode;if(i=i.tag,i!==5&&i!==26&&i!==27||a===null||(i=on(e,n),i!=null&&r.unshift(Td(e,i,a)),i=on(e,t),i!=null&&r.push(Td(e,i,a))),e.tag===3)return r;e=e.return}return[]}function Dd(e){if(e===null)return null;do e=e.return;while(e&&e.tag!==5&&e.tag!==27);return e||null}function Od(e,t,n,r,i){for(var a=t._reactName,o=[];n!==null&&n!==r;){var s=n,c=s.alternate,l=s.stateNode;if(s=s.tag,c!==null&&c===r)break;s!==5&&s!==26&&s!==27||l===null||(c=l,i?(l=on(n,a),l!=null&&o.unshift(Td(n,l,c))):i||(l=on(n,a),l!=null&&o.push(Td(n,l,c)))),n=n.return}o.length!==0&&e.push({event:t,listeners:o})}var kd=/\r\n?/g,Ad=/\u0000|\uFFFD/g;function jd(e){return(typeof e==`string`?e:``+e).replace(kd,`
+`).replace(Ad,``)}function Md(e,t){return t=jd(t),jd(e)===t}function $(e,t,n,r,a,o){switch(n){case`children`:typeof r==`string`?t===`body`||t===`textarea`&&r===``||Ut(e,r):(typeof r==`number`||typeof r==`bigint`)&&t!==`body`&&Ut(e,``+r);break;case`className`:Dt(e,`class`,r);break;case`tabIndex`:Dt(e,`tabindex`,r);break;case`dir`:case`role`:case`viewBox`:case`width`:case`height`:Dt(e,n,r);break;case`style`:Kt(e,r,o);break;case`data`:if(t!==`object`){Dt(e,`data`,r);break}case`src`:case`href`:if(r===``&&(t!==`a`||n!==`href`)){e.removeAttribute(n);break}if(r==null||typeof r==`function`||typeof r==`symbol`||typeof r==`boolean`){e.removeAttribute(n);break}r=Xt(``+r),e.setAttribute(n,r);break;case`action`:case`formAction`:if(typeof r==`function`){e.setAttribute(n,`javascript:throw new Error('A React form was unexpectedly submitted. If you called form.submit() manually, consider using form.requestSubmit() instead. If you\\'re trying to use event.stopPropagation() in a submit event handler, consider also calling event.preventDefault().')`);break}else typeof o==`function`&&(n===`formAction`?(t!==`input`&&$(e,t,`name`,a.name,a,null),$(e,t,`formEncType`,a.formEncType,a,null),$(e,t,`formMethod`,a.formMethod,a,null),$(e,t,`formTarget`,a.formTarget,a,null)):($(e,t,`encType`,a.encType,a,null),$(e,t,`method`,a.method,a,null),$(e,t,`target`,a.target,a,null)));if(r==null||typeof r==`symbol`||typeof r==`boolean`){e.removeAttribute(n);break}r=Xt(``+r),e.setAttribute(n,r);break;case`onClick`:r!=null&&(e.onclick=Zt);break;case`onScroll`:r!=null&&Q(`scroll`,e);break;case`onScrollEnd`:r!=null&&Q(`scrollend`,e);break;case`dangerouslySetInnerHTML`:if(r!=null){if(typeof r!=`object`||!(`__html`in r))throw Error(i(61));if(n=r.__html,n!=null){if(a.children!=null)throw Error(i(60));e.innerHTML=n}}break;case`multiple`:e.multiple=r&&typeof r!=`function`&&typeof r!=`symbol`;break;case`muted`:e.muted=r&&typeof r!=`function`&&typeof r!=`symbol`;break;case`suppressContentEditableWarning`:case`suppressHydrationWarning`:case`defaultValue`:case`defaultChecked`:case`innerHTML`:case`ref`:break;case`autoFocus`:break;case`xlinkHref`:if(r==null||typeof r==`function`||typeof r==`boolean`||typeof r==`symbol`){e.removeAttribute(`xlink:href`);break}n=Xt(``+r),e.setAttributeNS(`http://www.w3.org/1999/xlink`,`xlink:href`,n);break;case`contentEditable`:case`spellCheck`:case`draggable`:case`value`:case`autoReverse`:case`externalResourcesRequired`:case`focusable`:case`preserveAlpha`:r!=null&&typeof r!=`function`&&typeof r!=`symbol`?e.setAttribute(n,``+r):e.removeAttribute(n);break;case`inert`:case`allowFullScreen`:case`async`:case`autoPlay`:case`controls`:case`default`:case`defer`:case`disabled`:case`disablePictureInPicture`:case`disableRemotePlayback`:case`formNoValidate`:case`hidden`:case`loop`:case`noModule`:case`noValidate`:case`open`:case`playsInline`:case`readOnly`:case`required`:case`reversed`:case`scoped`:case`seamless`:case`itemScope`:r&&typeof r!=`function`&&typeof r!=`symbol`?e.setAttribute(n,``):e.removeAttribute(n);break;case`capture`:case`download`:!0===r?e.setAttribute(n,``):!1!==r&&r!=null&&typeof r!=`function`&&typeof r!=`symbol`?e.setAttribute(n,r):e.removeAttribute(n);break;case`cols`:case`rows`:case`size`:case`span`:r!=null&&typeof r!=`function`&&typeof r!=`symbol`&&!isNaN(r)&&1<=r?e.setAttribute(n,r):e.removeAttribute(n);break;case`rowSpan`:case`start`:r==null||typeof r==`function`||typeof r==`symbol`||isNaN(r)?e.removeAttribute(n):e.setAttribute(n,r);break;case`popover`:Q(`beforetoggle`,e),Q(`toggle`,e),Et(e,`popover`,r);break;case`xlinkActuate`:Ot(e,`http://www.w3.org/1999/xlink`,`xlink:actuate`,r);break;case`xlinkArcrole`:Ot(e,`http://www.w3.org/1999/xlink`,`xlink:arcrole`,r);break;case`xlinkRole`:Ot(e,`http://www.w3.org/1999/xlink`,`xlink:role`,r);break;case`xlinkShow`:Ot(e,`http://www.w3.org/1999/xlink`,`xlink:show`,r);break;case`xlinkTitle`:Ot(e,`http://www.w3.org/1999/xlink`,`xlink:title`,r);break;case`xlinkType`:Ot(e,`http://www.w3.org/1999/xlink`,`xlink:type`,r);break;case`xmlBase`:Ot(e,`http://www.w3.org/XML/1998/namespace`,`xml:base`,r);break;case`xmlLang`:Ot(e,`http://www.w3.org/XML/1998/namespace`,`xml:lang`,r);break;case`xmlSpace`:Ot(e,`http://www.w3.org/XML/1998/namespace`,`xml:space`,r);break;case`is`:Et(e,`is`,r);break;case`innerText`:case`textContent`:break;default:(!(2<n.length)||n[0]!==`o`&&n[0]!==`O`||n[1]!==`n`&&n[1]!==`N`)&&(n=Jt.get(n)||n,Et(e,n,r))}}function Nd(e,t,n,r,a,o){switch(n){case`style`:Kt(e,r,o);break;case`dangerouslySetInnerHTML`:if(r!=null){if(typeof r!=`object`||!(`__html`in r))throw Error(i(61));if(n=r.__html,n!=null){if(a.children!=null)throw Error(i(60));e.innerHTML=n}}break;case`children`:typeof r==`string`?Ut(e,r):(typeof r==`number`||typeof r==`bigint`)&&Ut(e,``+r);break;case`onScroll`:r!=null&&Q(`scroll`,e);break;case`onScrollEnd`:r!=null&&Q(`scrollend`,e);break;case`onClick`:r!=null&&(e.onclick=Zt);break;case`suppressContentEditableWarning`:case`suppressHydrationWarning`:case`innerHTML`:case`ref`:break;case`innerText`:case`textContent`:break;default:if(!yt.hasOwnProperty(n))a:{if(n[0]===`o`&&n[1]===`n`&&(a=n.endsWith(`Capture`),t=n.slice(2,a?n.length-7:void 0),o=e[at]||null,o=o==null?null:o[n],typeof o==`function`&&e.removeEventListener(t,o,a),typeof r==`function`)){typeof o!=`function`&&o!==null&&(n in e?e[n]=null:e.hasAttribute(n)&&e.removeAttribute(n)),e.addEventListener(t,r,a);break a}n in e?e[n]=r:!0===r?e.setAttribute(n,``):Et(e,n,r)}}}function Pd(e,t,n){switch(t){case`div`:case`span`:case`svg`:case`path`:case`a`:case`g`:case`p`:case`li`:break;case`img`:Q(`error`,e),Q(`load`,e);var r=!1,a=!1,o;for(o in n)if(n.hasOwnProperty(o)){var s=n[o];if(s!=null)switch(o){case`src`:r=!0;break;case`srcSet`:a=!0;break;case`children`:case`dangerouslySetInnerHTML`:throw Error(i(137,t));default:$(e,t,o,s,n,null)}}a&&$(e,t,`srcSet`,n.srcSet,n,null),r&&$(e,t,`src`,n.src,n,null);return;case`input`:Q(`invalid`,e);var c=o=s=a=null,l=null,u=null;for(r in n)if(n.hasOwnProperty(r)){var d=n[r];if(d!=null)switch(r){case`name`:a=d;break;case`type`:s=d;break;case`checked`:l=d;break;case`defaultChecked`:u=d;break;case`value`:o=d;break;case`defaultValue`:c=d;break;case`children`:case`dangerouslySetInnerHTML`:if(d!=null)throw Error(i(137,t));break;default:$(e,t,r,d,n,null)}}Rt(e,o,c,l,u,s,a,!1);return;case`select`:for(a in Q(`invalid`,e),r=s=o=null,n)if(n.hasOwnProperty(a)&&(c=n[a],c!=null))switch(a){case`value`:o=c;break;case`defaultValue`:s=c;break;case`multiple`:r=c;default:$(e,t,a,c,n,null)}t=o,n=s,e.multiple=!!r,t==null?n!=null&&Bt(e,!!r,n,!0):Bt(e,!!r,t,!1);return;case`textarea`:for(s in Q(`invalid`,e),o=a=r=null,n)if(n.hasOwnProperty(s)&&(c=n[s],c!=null))switch(s){case`value`:r=c;break;case`defaultValue`:a=c;break;case`children`:o=c;break;case`dangerouslySetInnerHTML`:if(c!=null)throw Error(i(91));break;default:$(e,t,s,c,n,null)}Ht(e,r,a,o);return;case`option`:for(l in n)if(n.hasOwnProperty(l)&&(r=n[l],r!=null))switch(l){case`selected`:e.selected=r&&typeof r!=`function`&&typeof r!=`symbol`;break;default:$(e,t,l,r,n,null)}return;case`dialog`:Q(`beforetoggle`,e),Q(`toggle`,e),Q(`cancel`,e),Q(`close`,e);break;case`iframe`:case`object`:Q(`load`,e);break;case`video`:case`audio`:for(r=0;r<_d.length;r++)Q(_d[r],e);break;case`image`:Q(`error`,e),Q(`load`,e);break;case`details`:Q(`toggle`,e);break;case`embed`:case`source`:case`link`:Q(`error`,e),Q(`load`,e);case`area`:case`base`:case`br`:case`col`:case`hr`:case`keygen`:case`meta`:case`param`:case`track`:case`wbr`:case`menuitem`:for(u in n)if(n.hasOwnProperty(u)&&(r=n[u],r!=null))switch(u){case`children`:case`dangerouslySetInnerHTML`:throw Error(i(137,t));default:$(e,t,u,r,n,null)}return;default:if(qt(t)){for(d in n)n.hasOwnProperty(d)&&(r=n[d],r!==void 0&&Nd(e,t,d,r,n,void 0));return}}for(c in n)n.hasOwnProperty(c)&&(r=n[c],r!=null&&$(e,t,c,r,n,null))}function Fd(e,t,n,r){switch(t){case`div`:case`span`:case`svg`:case`path`:case`a`:case`g`:case`p`:case`li`:break;case`input`:var a=null,o=null,s=null,c=null,l=null,u=null,d=null;for(m in n){var f=n[m];if(n.hasOwnProperty(m)&&f!=null)switch(m){case`checked`:break;case`value`:break;case`defaultValue`:l=f;default:r.hasOwnProperty(m)||$(e,t,m,null,r,f)}}for(var p in r){var m=r[p];if(f=n[p],r.hasOwnProperty(p)&&(m!=null||f!=null))switch(p){case`type`:o=m;break;case`name`:a=m;break;case`checked`:u=m;break;case`defaultChecked`:d=m;break;case`value`:s=m;break;case`defaultValue`:c=m;break;case`children`:case`dangerouslySetInnerHTML`:if(m!=null)throw Error(i(137,t));break;default:m!==f&&$(e,t,p,m,r,f)}}Lt(e,s,c,l,u,d,o,a);return;case`select`:for(o in m=s=c=p=null,n)if(l=n[o],n.hasOwnProperty(o)&&l!=null)switch(o){case`value`:break;case`multiple`:m=l;default:r.hasOwnProperty(o)||$(e,t,o,null,r,l)}for(a in r)if(o=r[a],l=n[a],r.hasOwnProperty(a)&&(o!=null||l!=null))switch(a){case`value`:p=o;break;case`defaultValue`:c=o;break;case`multiple`:s=o;default:o!==l&&$(e,t,a,o,r,l)}t=c,n=s,r=m,p==null?!!r!=!!n&&(t==null?Bt(e,!!n,n?[]:``,!1):Bt(e,!!n,t,!0)):Bt(e,!!n,p,!1);return;case`textarea`:for(c in m=p=null,n)if(a=n[c],n.hasOwnProperty(c)&&a!=null&&!r.hasOwnProperty(c))switch(c){case`value`:break;case`children`:break;default:$(e,t,c,null,r,a)}for(s in r)if(a=r[s],o=n[s],r.hasOwnProperty(s)&&(a!=null||o!=null))switch(s){case`value`:p=a;break;case`defaultValue`:m=a;break;case`children`:break;case`dangerouslySetInnerHTML`:if(a!=null)throw Error(i(91));break;default:a!==o&&$(e,t,s,a,r,o)}Vt(e,p,m);return;case`option`:for(var h in n)if(p=n[h],n.hasOwnProperty(h)&&p!=null&&!r.hasOwnProperty(h))switch(h){case`selected`:e.selected=!1;break;default:$(e,t,h,null,r,p)}for(l in r)if(p=r[l],m=n[l],r.hasOwnProperty(l)&&p!==m&&(p!=null||m!=null))switch(l){case`selected`:e.selected=p&&typeof p!=`function`&&typeof p!=`symbol`;break;default:$(e,t,l,p,r,m)}return;case`img`:case`link`:case`area`:case`base`:case`br`:case`col`:case`embed`:case`hr`:case`keygen`:case`meta`:case`param`:case`source`:case`track`:case`wbr`:case`menuitem`:for(var g in n)p=n[g],n.hasOwnProperty(g)&&p!=null&&!r.hasOwnProperty(g)&&$(e,t,g,null,r,p);for(u in r)if(p=r[u],m=n[u],r.hasOwnProperty(u)&&p!==m&&(p!=null||m!=null))switch(u){case`children`:case`dangerouslySetInnerHTML`:if(p!=null)throw Error(i(137,t));break;default:$(e,t,u,p,r,m)}return;default:if(qt(t)){for(var _ in n)p=n[_],n.hasOwnProperty(_)&&p!==void 0&&!r.hasOwnProperty(_)&&Nd(e,t,_,void 0,r,p);for(d in r)p=r[d],m=n[d],!r.hasOwnProperty(d)||p===m||p===void 0&&m===void 0||Nd(e,t,d,p,r,m);return}}for(var v in n)p=n[v],n.hasOwnProperty(v)&&p!=null&&!r.hasOwnProperty(v)&&$(e,t,v,null,r,p);for(f in r)p=r[f],m=n[f],!r.hasOwnProperty(f)||p===m||p==null&&m==null||$(e,t,f,p,r,m)}function Id(e){switch(e){case`css`:case`script`:case`font`:case`img`:case`image`:case`input`:case`link`:return!0;default:return!1}}function Ld(){if(typeof performance.getEntriesByType==`function`){for(var e=0,t=0,n=performance.getEntriesByType(`resource`),r=0;r<n.length;r++){var i=n[r],a=i.transferSize,o=i.initiatorType,s=i.duration;if(a&&s&&Id(o)){for(o=0,s=i.responseEnd,r+=1;r<n.length;r++){var c=n[r],l=c.startTime;if(l>s)break;var u=c.transferSize,d=c.initiatorType;u&&Id(d)&&(c=c.responseEnd,o+=u*(c<s?1:(s-l)/(c-l)))}if(--r,t+=8*(a+o)/(i.duration/1e3),e++,10<e)break}}if(0<e)return t/e/1e6}return navigator.connection&&(e=navigator.connection.downlink,typeof e==`number`)?e:5}var Rd=null,zd=null;function Bd(e){return e.nodeType===9?e:e.ownerDocument}function Vd(e){switch(e){case`http://www.w3.org/2000/svg`:return 1;case`http://www.w3.org/1998/Math/MathML`:return 2;default:return 0}}function Hd(e,t){if(e===0)switch(t){case`svg`:return 1;case`math`:return 2;default:return 0}return e===1&&t===`foreignObject`?0:e}function Ud(e,t){return e===`textarea`||e===`noscript`||typeof t.children==`string`||typeof t.children==`number`||typeof t.children==`bigint`||typeof t.dangerouslySetInnerHTML==`object`&&t.dangerouslySetInnerHTML!==null&&t.dangerouslySetInnerHTML.__html!=null}var Wd=null;function Gd(){var e=window.event;return e&&e.type===`popstate`?e===Wd?!1:(Wd=e,!0):(Wd=null,!1)}var Kd=typeof setTimeout==`function`?setTimeout:void 0,qd=typeof clearTimeout==`function`?clearTimeout:void 0,Jd=typeof Promise==`function`?Promise:void 0,Yd=typeof queueMicrotask==`function`?queueMicrotask:Jd===void 0?Kd:function(e){return Jd.resolve(null).then(e).catch(Xd)};function Xd(e){setTimeout(function(){throw e})}function Zd(e){return e===`head`}function Qd(e,t){var n=t,r=0;do{var i=n.nextSibling;if(e.removeChild(n),i&&i.nodeType===8)if(n=i.data,n===`/$`||n===`/&`){if(r===0){e.removeChild(i),Np(t);return}r--}else if(n===`$`||n===`$?`||n===`$~`||n===`$!`||n===`&`)r++;else if(n===`html`)pf(e.ownerDocument.documentElement);else if(n===`head`){n=e.ownerDocument.head,pf(n);for(var a=n.firstChild;a;){var o=a.nextSibling,s=a.nodeName;a[dt]||s===`SCRIPT`||s===`STYLE`||s===`LINK`&&a.rel.toLowerCase()===`stylesheet`||n.removeChild(a),a=o}}else n===`body`&&pf(e.ownerDocument.body);n=i}while(n);Np(t)}function $d(e,t){var n=e;e=0;do{var r=n.nextSibling;if(n.nodeType===1?t?(n._stashedDisplay=n.style.display,n.style.display=`none`):(n.style.display=n._stashedDisplay||``,n.getAttribute(`style`)===``&&n.removeAttribute(`style`)):n.nodeType===3&&(t?(n._stashedText=n.nodeValue,n.nodeValue=``):n.nodeValue=n._stashedText||``),r&&r.nodeType===8)if(n=r.data,n===`/$`){if(e===0)break;e--}else n!==`$`&&n!==`$?`&&n!==`$~`&&n!==`$!`||e++;n=r}while(n)}function ef(e){var t=e.firstChild;for(t&&t.nodeType===10&&(t=t.nextSibling);t;){var n=t;switch(t=t.nextSibling,n.nodeName){case`HTML`:case`HEAD`:case`BODY`:ef(n),ft(n);continue;case`SCRIPT`:case`STYLE`:continue;case`LINK`:if(n.rel.toLowerCase()===`stylesheet`)continue}e.removeChild(n)}}function tf(e,t,n,r){for(;e.nodeType===1;){var i=n;if(e.nodeName.toLowerCase()!==t.toLowerCase()){if(!r&&(e.nodeName!==`INPUT`||e.type!==`hidden`))break}else if(!r)if(t===`input`&&e.type===`hidden`){var a=i.name==null?null:``+i.name;if(i.type===`hidden`&&e.getAttribute(`name`)===a)return e}else return e;else if(!e[dt])switch(t){case`meta`:if(!e.hasAttribute(`itemprop`))break;return e;case`link`:if(a=e.getAttribute(`rel`),a===`stylesheet`&&e.hasAttribute(`data-precedence`)||a!==i.rel||e.getAttribute(`href`)!==(i.href==null||i.href===``?null:i.href)||e.getAttribute(`crossorigin`)!==(i.crossOrigin==null?null:i.crossOrigin)||e.getAttribute(`title`)!==(i.title==null?null:i.title))break;return e;case`style`:if(e.hasAttribute(`data-precedence`))break;return e;case`script`:if(a=e.getAttribute(`src`),(a!==(i.src==null?null:i.src)||e.getAttribute(`type`)!==(i.type==null?null:i.type)||e.getAttribute(`crossorigin`)!==(i.crossOrigin==null?null:i.crossOrigin))&&a&&e.hasAttribute(`async`)&&!e.hasAttribute(`itemprop`))break;return e;default:return e}if(e=cf(e.nextSibling),e===null)break}return null}function nf(e,t,n){if(t===``)return null;for(;e.nodeType!==3;)if((e.nodeType!==1||e.nodeName!==`INPUT`||e.type!==`hidden`)&&!n||(e=cf(e.nextSibling),e===null))return null;return e}function rf(e,t){for(;e.nodeType!==8;)if((e.nodeType!==1||e.nodeName!==`INPUT`||e.type!==`hidden`)&&!t||(e=cf(e.nextSibling),e===null))return null;return e}function af(e){return e.data===`$?`||e.data===`$~`}function of(e){return e.data===`$!`||e.data===`$?`&&e.ownerDocument.readyState!==`loading`}function sf(e,t){var n=e.ownerDocument;if(e.data===`$~`)e._reactRetry=t;else if(e.data!==`$?`||n.readyState!==`loading`)t();else{var r=function(){t(),n.removeEventListener(`DOMContentLoaded`,r)};n.addEventListener(`DOMContentLoaded`,r),e._reactRetry=r}}function cf(e){for(;e!=null;e=e.nextSibling){var t=e.nodeType;if(t===1||t===3)break;if(t===8){if(t=e.data,t===`$`||t===`$!`||t===`$?`||t===`$~`||t===`&`||t===`F!`||t===`F`)break;if(t===`/$`||t===`/&`)return null}}return e}var lf=null;function uf(e){e=e.nextSibling;for(var t=0;e;){if(e.nodeType===8){var n=e.data;if(n===`/$`||n===`/&`){if(t===0)return cf(e.nextSibling);t--}else n!==`$`&&n!==`$!`&&n!==`$?`&&n!==`$~`&&n!==`&`||t++}e=e.nextSibling}return null}function df(e){e=e.previousSibling;for(var t=0;e;){if(e.nodeType===8){var n=e.data;if(n===`$`||n===`$!`||n===`$?`||n===`$~`||n===`&`){if(t===0)return e;t--}else n!==`/$`&&n!==`/&`||t++}e=e.previousSibling}return null}function ff(e,t,n){switch(t=Bd(n),e){case`html`:if(e=t.documentElement,!e)throw Error(i(452));return e;case`head`:if(e=t.head,!e)throw Error(i(453));return e;case`body`:if(e=t.body,!e)throw Error(i(454));return e;default:throw Error(i(451))}}function pf(e){for(var t=e.attributes;t.length;)e.removeAttributeNode(t[0]);ft(e)}var mf=new Map,hf=new Set;function gf(e){return typeof e.getRootNode==`function`?e.getRootNode():e.nodeType===9?e:e.ownerDocument}var _f=I.d;I.d={f:vf,r:yf,D:Sf,C:Cf,L:wf,m:Tf,X:Df,S:Ef,M:Of};function vf(){var e=_f.f(),t=bu();return e||t}function yf(e){var t=mt(e);t!==null&&t.tag===5&&t.type===`form`?Ts(t):_f.r(e)}var bf=typeof document>`u`?null:document;function xf(e,t,n){var r=bf;if(r&&typeof t==`string`&&t){var i=It(t);i=`link[rel="`+e+`"][href="`+i+`"]`,typeof n==`string`&&(i+=`[crossorigin="`+n+`"]`),hf.has(i)||(hf.add(i),e={rel:e,crossOrigin:n,href:t},r.querySelector(i)===null&&(t=r.createElement(`link`),Pd(t,`link`,e),_t(t),r.head.appendChild(t)))}}function Sf(e){_f.D(e),xf(`dns-prefetch`,e,null)}function Cf(e,t){_f.C(e,t),xf(`preconnect`,e,t)}function wf(e,t,n){_f.L(e,t,n);var r=bf;if(r&&e&&t){var i=`link[rel="preload"][as="`+It(t)+`"]`;t===`image`&&n&&n.imageSrcSet?(i+=`[imagesrcset="`+It(n.imageSrcSet)+`"]`,typeof n.imageSizes==`string`&&(i+=`[imagesizes="`+It(n.imageSizes)+`"]`)):i+=`[href="`+It(e)+`"]`;var a=i;switch(t){case`style`:a=Af(e);break;case`script`:a=Pf(e)}mf.has(a)||(e=h({rel:`preload`,href:t===`image`&&n&&n.imageSrcSet?void 0:e,as:t},n),mf.set(a,e),r.querySelector(i)!==null||t===`style`&&r.querySelector(jf(a))||t===`script`&&r.querySelector(Ff(a))||(t=r.createElement(`link`),Pd(t,`link`,e),_t(t),r.head.appendChild(t)))}}function Tf(e,t){_f.m(e,t);var n=bf;if(n&&e){var r=t&&typeof t.as==`string`?t.as:`script`,i=`link[rel="modulepreload"][as="`+It(r)+`"][href="`+It(e)+`"]`,a=i;switch(r){case`audioworklet`:case`paintworklet`:case`serviceworker`:case`sharedworker`:case`worker`:case`script`:a=Pf(e)}if(!mf.has(a)&&(e=h({rel:`modulepreload`,href:e},t),mf.set(a,e),n.querySelector(i)===null)){switch(r){case`audioworklet`:case`paintworklet`:case`serviceworker`:case`sharedworker`:case`worker`:case`script`:if(n.querySelector(Ff(a)))return}r=n.createElement(`link`),Pd(r,`link`,e),_t(r),n.head.appendChild(r)}}}function Ef(e,t,n){_f.S(e,t,n);var r=bf;if(r&&e){var i=gt(r).hoistableStyles,a=Af(e);t||=`default`;var o=i.get(a);if(!o){var s={loading:0,preload:null};if(o=r.querySelector(jf(a)))s.loading=5;else{e=h({rel:`stylesheet`,href:e,"data-precedence":t},n),(n=mf.get(a))&&Rf(e,n);var c=o=r.createElement(`link`);_t(c),Pd(c,`link`,e),c._p=new Promise(function(e,t){c.onload=e,c.onerror=t}),c.addEventListener(`load`,function(){s.loading|=1}),c.addEventListener(`error`,function(){s.loading|=2}),s.loading|=4,Lf(o,t,r)}o={type:`stylesheet`,instance:o,count:1,state:s},i.set(a,o)}}}function Df(e,t){_f.X(e,t);var n=bf;if(n&&e){var r=gt(n).hoistableScripts,i=Pf(e),a=r.get(i);a||(a=n.querySelector(Ff(i)),a||(e=h({src:e,async:!0},t),(t=mf.get(i))&&zf(e,t),a=n.createElement(`script`),_t(a),Pd(a,`link`,e),n.head.appendChild(a)),a={type:`script`,instance:a,count:1,state:null},r.set(i,a))}}function Of(e,t){_f.M(e,t);var n=bf;if(n&&e){var r=gt(n).hoistableScripts,i=Pf(e),a=r.get(i);a||(a=n.querySelector(Ff(i)),a||(e=h({src:e,async:!0,type:`module`},t),(t=mf.get(i))&&zf(e,t),a=n.createElement(`script`),_t(a),Pd(a,`link`,e),n.head.appendChild(a)),a={type:`script`,instance:a,count:1,state:null},r.set(i,a))}}function kf(e,t,n,r){var a=(a=ae.current)?gf(a):null;if(!a)throw Error(i(446));switch(e){case`meta`:case`title`:return null;case`style`:return typeof n.precedence==`string`&&typeof n.href==`string`?(t=Af(n.href),n=gt(a).hoistableStyles,r=n.get(t),r||(r={type:`style`,instance:null,count:0,state:null},n.set(t,r)),r):{type:`void`,instance:null,count:0,state:null};case`link`:if(n.rel===`stylesheet`&&typeof n.href==`string`&&typeof n.precedence==`string`){e=Af(n.href);var o=gt(a).hoistableStyles,s=o.get(e);if(s||(a=a.ownerDocument||a,s={type:`stylesheet`,instance:null,count:0,state:{loading:0,preload:null}},o.set(e,s),(o=a.querySelector(jf(e)))&&!o._p&&(s.instance=o,s.state.loading=5),mf.has(e)||(n={rel:`preload`,as:`style`,href:n.href,crossOrigin:n.crossOrigin,integrity:n.integrity,media:n.media,hrefLang:n.hrefLang,referrerPolicy:n.referrerPolicy},mf.set(e,n),o||Nf(a,e,n,s.state))),t&&r===null)throw Error(i(528,``));return s}if(t&&r!==null)throw Error(i(529,``));return null;case`script`:return t=n.async,n=n.src,typeof n==`string`&&t&&typeof t!=`function`&&typeof t!=`symbol`?(t=Pf(n),n=gt(a).hoistableScripts,r=n.get(t),r||(r={type:`script`,instance:null,count:0,state:null},n.set(t,r)),r):{type:`void`,instance:null,count:0,state:null};default:throw Error(i(444,e))}}function Af(e){return`href="`+It(e)+`"`}function jf(e){return`link[rel="stylesheet"][`+e+`]`}function Mf(e){return h({},e,{"data-precedence":e.precedence,precedence:null})}function Nf(e,t,n,r){e.querySelector(`link[rel="preload"][as="style"][`+t+`]`)?r.loading=1:(t=e.createElement(`link`),r.preload=t,t.addEventListener(`load`,function(){return r.loading|=1}),t.addEventListener(`error`,function(){return r.loading|=2}),Pd(t,`link`,n),_t(t),e.head.appendChild(t))}function Pf(e){return`[src="`+It(e)+`"]`}function Ff(e){return`script[async]`+e}function If(e,t,n){if(t.count++,t.instance===null)switch(t.type){case`style`:var r=e.querySelector(`style[data-href~="`+It(n.href)+`"]`);if(r)return t.instance=r,_t(r),r;var a=h({},n,{"data-href":n.href,"data-precedence":n.precedence,href:null,precedence:null});return r=(e.ownerDocument||e).createElement(`style`),_t(r),Pd(r,`style`,a),Lf(r,n.precedence,e),t.instance=r;case`stylesheet`:a=Af(n.href);var o=e.querySelector(jf(a));if(o)return t.state.loading|=4,t.instance=o,_t(o),o;r=Mf(n),(a=mf.get(a))&&Rf(r,a),o=(e.ownerDocument||e).createElement(`link`),_t(o);var s=o;return s._p=new Promise(function(e,t){s.onload=e,s.onerror=t}),Pd(o,`link`,r),t.state.loading|=4,Lf(o,n.precedence,e),t.instance=o;case`script`:return o=Pf(n.src),(a=e.querySelector(Ff(o)))?(t.instance=a,_t(a),a):(r=n,(a=mf.get(o))&&(r=h({},n),zf(r,a)),e=e.ownerDocument||e,a=e.createElement(`script`),_t(a),Pd(a,`link`,r),e.head.appendChild(a),t.instance=a);case`void`:return null;default:throw Error(i(443,t.type))}else t.type===`stylesheet`&&!(t.state.loading&4)&&(r=t.instance,t.state.loading|=4,Lf(r,n.precedence,e));return t.instance}function Lf(e,t,n){for(var r=n.querySelectorAll(`link[rel="stylesheet"][data-precedence],style[data-precedence]`),i=r.length?r[r.length-1]:null,a=i,o=0;o<r.length;o++){var s=r[o];if(s.dataset.precedence===t)a=s;else if(a!==i)break}a?a.parentNode.insertBefore(e,a.nextSibling):(t=n.nodeType===9?n.head:n,t.insertBefore(e,t.firstChild))}function Rf(e,t){e.crossOrigin??=t.crossOrigin,e.referrerPolicy??=t.referrerPolicy,e.title??=t.title}function zf(e,t){e.crossOrigin??=t.crossOrigin,e.referrerPolicy??=t.referrerPolicy,e.integrity??=t.integrity}var Bf=null;function Vf(e,t,n){if(Bf===null){var r=new Map,i=Bf=new Map;i.set(n,r)}else i=Bf,r=i.get(n),r||(r=new Map,i.set(n,r));if(r.has(e))return r;for(r.set(e,null),n=n.getElementsByTagName(e),i=0;i<n.length;i++){var a=n[i];if(!(a[dt]||a[it]||e===`link`&&a.getAttribute(`rel`)===`stylesheet`)&&a.namespaceURI!==`http://www.w3.org/2000/svg`){var o=a.getAttribute(t)||``;o=e+o;var s=r.get(o);s?s.push(a):r.set(o,[a])}}return r}function Hf(e,t,n){e=e.ownerDocument||e,e.head.insertBefore(n,t===`title`?e.querySelector(`head > title`):null)}function Uf(e,t,n){if(n===1||t.itemProp!=null)return!1;switch(e){case`meta`:case`title`:return!0;case`style`:if(typeof t.precedence!=`string`||typeof t.href!=`string`||t.href===``)break;return!0;case`link`:if(typeof t.rel!=`string`||typeof t.href!=`string`||t.href===``||t.onLoad||t.onError)break;switch(t.rel){case`stylesheet`:return e=t.disabled,typeof t.precedence==`string`&&e==null;default:return!0}case`script`:if(t.async&&typeof t.async!=`function`&&typeof t.async!=`symbol`&&!t.onLoad&&!t.onError&&t.src&&typeof t.src==`string`)return!0}return!1}function Wf(e){return!(e.type===`stylesheet`&&!(e.state.loading&3))}function Gf(e,t,n,r){if(n.type===`stylesheet`&&(typeof r.media!=`string`||!1!==matchMedia(r.media).matches)&&!(n.state.loading&4)){if(n.instance===null){var i=Af(r.href),a=t.querySelector(jf(i));if(a){t=a._p,typeof t==`object`&&t&&typeof t.then==`function`&&(e.count++,e=Jf.bind(e),t.then(e,e)),n.state.loading|=4,n.instance=a,_t(a);return}a=t.ownerDocument||t,r=Mf(r),(i=mf.get(i))&&Rf(r,i),a=a.createElement(`link`),_t(a);var o=a;o._p=new Promise(function(e,t){o.onload=e,o.onerror=t}),Pd(a,`link`,r),n.instance=a}e.stylesheets===null&&(e.stylesheets=new Map),e.stylesheets.set(n,t),(t=n.state.preload)&&!(n.state.loading&3)&&(e.count++,n=Jf.bind(e),t.addEventListener(`load`,n),t.addEventListener(`error`,n))}}var Kf=0;function qf(e,t){return e.stylesheets&&e.count===0&&Xf(e,e.stylesheets),0<e.count||0<e.imgCount?function(n){var r=setTimeout(function(){if(e.stylesheets&&Xf(e,e.stylesheets),e.unsuspend){var t=e.unsuspend;e.unsuspend=null,t()}},6e4+t);0<e.imgBytes&&Kf===0&&(Kf=62500*Ld());var i=setTimeout(function(){if(e.waitingForImages=!1,e.count===0&&(e.stylesheets&&Xf(e,e.stylesheets),e.unsuspend)){var t=e.unsuspend;e.unsuspend=null,t()}},(e.imgBytes>Kf?50:800)+t);return e.unsuspend=n,function(){e.unsuspend=null,clearTimeout(r),clearTimeout(i)}}:null}function Jf(){if(this.count--,this.count===0&&(this.imgCount===0||!this.waitingForImages)){if(this.stylesheets)Xf(this,this.stylesheets);else if(this.unsuspend){var e=this.unsuspend;this.unsuspend=null,e()}}}var Yf=null;function Xf(e,t){e.stylesheets=null,e.unsuspend!==null&&(e.count++,Yf=new Map,t.forEach(Zf,e),Yf=null,Jf.call(e))}function Zf(e,t){if(!(t.state.loading&4)){var n=Yf.get(e);if(n)var r=n.get(null);else{n=new Map,Yf.set(e,n);for(var i=e.querySelectorAll(`link[data-precedence],style[data-precedence]`),a=0;a<i.length;a++){var o=i[a];(o.nodeName===`LINK`||o.getAttribute(`media`)!==`not all`)&&(n.set(o.dataset.precedence,o),r=o)}r&&n.set(null,r)}i=t.instance,o=i.getAttribute(`data-precedence`),a=n.get(o)||r,a===r&&n.set(null,i),n.set(o,i),this.count++,r=Jf.bind(this),i.addEventListener(`load`,r),i.addEventListener(`error`,r),a?a.parentNode.insertBefore(i,a.nextSibling):(e=e.nodeType===9?e.head:e,e.insertBefore(i,e.firstChild)),t.state.loading|=4}}var Qf={$$typeof:C,Provider:null,Consumer:null,_currentValue:te,_currentValue2:te,_threadCount:0};function $f(e,t,n,r,i,a,o,s,c){this.tag=1,this.containerInfo=e,this.pingCache=this.current=this.pendingChildren=null,this.timeoutHandle=-1,this.callbackNode=this.next=this.pendingContext=this.context=this.cancelPendingCommit=null,this.callbackPriority=0,this.expirationTimes=qe(-1),this.entangledLanes=this.shellSuspendCounter=this.errorRecoveryDisabledLanes=this.expiredLanes=this.warmLanes=this.pingedLanes=this.suspendedLanes=this.pendingLanes=0,this.entanglements=qe(0),this.hiddenUpdates=qe(null),this.identifierPrefix=r,this.onUncaughtError=i,this.onCaughtError=a,this.onRecoverableError=o,this.pooledCache=null,this.pooledCacheLanes=0,this.formState=c,this.incompleteTransitions=new Map}function ep(e,t,n,r,i,a,o,s,c,l,u,d){return e=new $f(e,t,n,o,c,l,u,d,s),t=1,!0===a&&(t|=24),a=oi(3,null,null,t),e.current=a,a.stateNode=e,t=oa(),t.refCount++,e.pooledCache=t,t.refCount++,a.memoizedState={element:r,isDehydrated:n,cache:t},Ra(a),e}function tp(e){return e?(e=ii,e):ii}function np(e,t,n,r,i,a){i=tp(i),r.context===null?r.context=i:r.pendingContext=i,r=Ba(t),r.payload={element:n},a=a===void 0?null:a,a!==null&&(r.callback=a),n=Va(e,r,t),n!==null&&(hu(n,e,t),Ha(n,e,t))}function rp(e,t){if(e=e.memoizedState,e!==null&&e.dehydrated!==null){var n=e.retryLane;e.retryLane=n!==0&&n<t?n:t}}function ip(e,t){rp(e,t),(e=e.alternate)&&rp(e,t)}function ap(e){if(e.tag===13||e.tag===31){var t=ti(e,67108864);t!==null&&hu(t,e,67108864),ip(e,67108864)}}function op(e){if(e.tag===13||e.tag===31){var t=pu();t=$e(t);var n=ti(e,t);n!==null&&hu(n,e,t),ip(e,t)}}var sp=!0;function cp(e,t,n,r){var i=F.T;F.T=null;var a=I.p;try{I.p=2,up(e,t,n,r)}finally{I.p=a,F.T=i}}function lp(e,t,n,r){var i=F.T;F.T=null;var a=I.p;try{I.p=8,up(e,t,n,r)}finally{I.p=a,F.T=i}}function up(e,t,n,r){if(sp){var i=dp(r);if(i===null)wd(e,t,r,fp,n),Cp(e,r);else if(Tp(i,e,t,n,r))r.stopPropagation();else if(Cp(e,r),t&4&&-1<Sp.indexOf(e)){for(;i!==null;){var a=mt(i);if(a!==null)switch(a.tag){case 3:if(a=a.stateNode,a.current.memoizedState.isDehydrated){var o=He(a.pendingLanes);if(o!==0){var s=a;for(s.pendingLanes|=2,s.entangledLanes|=2;o;){var c=1<<31-Fe(o);s.entanglements[1]|=c,o&=~c}rd(a),!(K&6)&&(tu=Ce()+500,id(0,!1))}}break;case 31:case 13:s=ti(a,2),s!==null&&hu(s,a,2),bu(),ip(a,2)}if(a=dp(r),a===null&&wd(e,t,r,fp,n),a===i)break;i=a}i!==null&&r.stopPropagation()}else wd(e,t,r,null,n)}}function dp(e){return e=$t(e),pp(e)}var fp=null;function pp(e){if(fp=null,e=pt(e),e!==null){var t=o(e);if(t===null)e=null;else{var n=t.tag;if(n===13){if(e=s(t),e!==null)return e;e=null}else if(n===31){if(e=c(t),e!==null)return e;e=null}else if(n===3){if(t.stateNode.current.memoizedState.isDehydrated)return t.tag===3?t.stateNode.containerInfo:null;e=null}else t!==e&&(e=null)}}return fp=e,null}function mp(e){switch(e){case`beforetoggle`:case`cancel`:case`click`:case`close`:case`contextmenu`:case`copy`:case`cut`:case`auxclick`:case`dblclick`:case`dragend`:case`dragstart`:case`drop`:case`focusin`:case`focusout`:case`input`:case`invalid`:case`keydown`:case`keypress`:case`keyup`:case`mousedown`:case`mouseup`:case`paste`:case`pause`:case`play`:case`pointercancel`:case`pointerdown`:case`pointerup`:case`ratechange`:case`reset`:case`resize`:case`seeked`:case`submit`:case`toggle`:case`touchcancel`:case`touchend`:case`touchstart`:case`volumechange`:case`change`:case`selectionchange`:case`textInput`:case`compositionstart`:case`compositionend`:case`compositionupdate`:case`beforeblur`:case`afterblur`:case`beforeinput`:case`blur`:case`fullscreenchange`:case`focus`:case`hashchange`:case`popstate`:case`select`:case`selectstart`:return 2;case`drag`:case`dragenter`:case`dragexit`:case`dragleave`:case`dragover`:case`mousemove`:case`mouseout`:case`mouseover`:case`pointermove`:case`pointerout`:case`pointerover`:case`scroll`:case`touchmove`:case`wheel`:case`mouseenter`:case`mouseleave`:case`pointerenter`:case`pointerleave`:return 8;case`message`:switch(we()){case Te:return 2;case Ee:return 8;case De:case Oe:return 32;case ke:return 268435456;default:return 32}default:return 32}}var hp=!1,gp=null,_p=null,vp=null,yp=new Map,bp=new Map,xp=[],Sp=`mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset`.split(` `);function Cp(e,t){switch(e){case`focusin`:case`focusout`:gp=null;break;case`dragenter`:case`dragleave`:_p=null;break;case`mouseover`:case`mouseout`:vp=null;break;case`pointerover`:case`pointerout`:yp.delete(t.pointerId);break;case`gotpointercapture`:case`lostpointercapture`:bp.delete(t.pointerId)}}function wp(e,t,n,r,i,a){return e===null||e.nativeEvent!==a?(e={blockedOn:t,domEventName:n,eventSystemFlags:r,nativeEvent:a,targetContainers:[i]},t!==null&&(t=mt(t),t!==null&&ap(t)),e):(e.eventSystemFlags|=r,t=e.targetContainers,i!==null&&t.indexOf(i)===-1&&t.push(i),e)}function Tp(e,t,n,r,i){switch(t){case`focusin`:return gp=wp(gp,e,t,n,r,i),!0;case`dragenter`:return _p=wp(_p,e,t,n,r,i),!0;case`mouseover`:return vp=wp(vp,e,t,n,r,i),!0;case`pointerover`:var a=i.pointerId;return yp.set(a,wp(yp.get(a)||null,e,t,n,r,i)),!0;case`gotpointercapture`:return a=i.pointerId,bp.set(a,wp(bp.get(a)||null,e,t,n,r,i)),!0}return!1}function Ep(e){var t=pt(e.target);if(t!==null){var n=o(t);if(n!==null){if(t=n.tag,t===13){if(t=s(n),t!==null){e.blockedOn=t,nt(e.priority,function(){op(n)});return}}else if(t===31){if(t=c(n),t!==null){e.blockedOn=t,nt(e.priority,function(){op(n)});return}}else if(t===3&&n.stateNode.current.memoizedState.isDehydrated){e.blockedOn=n.tag===3?n.stateNode.containerInfo:null;return}}}e.blockedOn=null}function Dp(e){if(e.blockedOn!==null)return!1;for(var t=e.targetContainers;0<t.length;){var n=dp(e.nativeEvent);if(n===null){n=e.nativeEvent;var r=new n.constructor(n.type,n);Qt=r,n.target.dispatchEvent(r),Qt=null}else return t=mt(n),t!==null&&ap(t),e.blockedOn=n,!1;t.shift()}return!0}function Op(e,t,n){Dp(e)&&n.delete(t)}function kp(){hp=!1,gp!==null&&Dp(gp)&&(gp=null),_p!==null&&Dp(_p)&&(_p=null),vp!==null&&Dp(vp)&&(vp=null),yp.forEach(Op),bp.forEach(Op)}function Ap(e,n){e.blockedOn===n&&(e.blockedOn=null,hp||(hp=!0,t.unstable_scheduleCallback(t.unstable_NormalPriority,kp)))}var jp=null;function Mp(e){jp!==e&&(jp=e,t.unstable_scheduleCallback(t.unstable_NormalPriority,function(){jp===e&&(jp=null);for(var t=0;t<e.length;t+=3){var n=e[t],r=e[t+1],i=e[t+2];if(typeof r!=`function`){if(pp(r||n)===null)continue;break}var a=mt(n);a!==null&&(e.splice(t,3),t-=3,Cs(a,{pending:!0,data:i,method:n.method,action:r},r,i))}}))}function Np(e){function t(t){return Ap(t,e)}gp!==null&&Ap(gp,e),_p!==null&&Ap(_p,e),vp!==null&&Ap(vp,e),yp.forEach(t),bp.forEach(t);for(var n=0;n<xp.length;n++){var r=xp[n];r.blockedOn===e&&(r.blockedOn=null)}for(;0<xp.length&&(n=xp[0],n.blockedOn===null);)Ep(n),n.blockedOn===null&&xp.shift();if(n=(e.ownerDocument||e).$$reactFormReplay,n!=null)for(r=0;r<n.length;r+=3){var i=n[r],a=n[r+1],o=i[at]||null;if(typeof a==`function`)o||Mp(n);else if(o){var s=null;if(a&&a.hasAttribute(`formAction`)){if(i=a,o=a[at]||null)s=o.formAction;else if(pp(i)!==null)continue}else s=o.action;typeof s==`function`?n[r+1]=s:(n.splice(r,3),r-=3),Mp(n)}}}function Pp(){function e(e){e.canIntercept&&e.info===`react-transition`&&e.intercept({handler:function(){return new Promise(function(e){return i=e})},focusReset:`manual`,scroll:`manual`})}function t(){i!==null&&(i(),i=null),r||setTimeout(n,20)}function n(){if(!r&&!navigation.transition){var e=navigation.currentEntry;e&&e.url!=null&&navigation.navigate(e.url,{state:e.getState(),info:`react-transition`,history:`replace`})}}if(typeof navigation==`object`){var r=!1,i=null;return navigation.addEventListener(`navigate`,e),navigation.addEventListener(`navigatesuccess`,t),navigation.addEventListener(`navigateerror`,t),setTimeout(n,100),function(){r=!0,navigation.removeEventListener(`navigate`,e),navigation.removeEventListener(`navigatesuccess`,t),navigation.removeEventListener(`navigateerror`,t),i!==null&&(i(),i=null)}}}function Fp(e){this._internalRoot=e}Ip.prototype.render=Fp.prototype.render=function(e){var t=this._internalRoot;if(t===null)throw Error(i(409));var n=t.current;np(n,pu(),e,t,null,null)},Ip.prototype.unmount=Fp.prototype.unmount=function(){var e=this._internalRoot;if(e!==null){this._internalRoot=null;var t=e.containerInfo;np(e.current,2,null,e,null,null),bu(),t[ot]=null}};function Ip(e){this._internalRoot=e}Ip.prototype.unstable_scheduleHydration=function(e){if(e){var t=tt();e={blockedOn:null,target:e,priority:t};for(var n=0;n<xp.length&&t!==0&&t<xp[n].priority;n++);xp.splice(n,0,e),n===0&&Ep(e)}};var Lp=n.version;if(Lp!==`19.2.7`)throw Error(i(527,Lp,`19.2.7`));I.findDOMNode=function(e){var t=e._reactInternals;if(t===void 0)throw typeof e.render==`function`?Error(i(188)):(e=Object.keys(e).join(`,`),Error(i(268,e)));return e=d(t),e=e===null?null:p(e),e=e===null?null:e.stateNode,e};var Rp={bundleType:0,version:`19.2.7`,rendererPackageName:`react-dom`,currentDispatcherRef:F,reconcilerVersion:`19.2.7`};if(typeof __REACT_DEVTOOLS_GLOBAL_HOOK__<`u`){var zp=__REACT_DEVTOOLS_GLOBAL_HOOK__;if(!zp.isDisabled&&zp.supportsFiber)try{Me=zp.inject(Rp),Ne=zp}catch{}}e.createRoot=function(e,t){if(!a(e))throw Error(i(299));var n=!1,r=``,o=Ks,s=qs,c=Js;return t!=null&&(!0===t.unstable_strictMode&&(n=!0),t.identifierPrefix!==void 0&&(r=t.identifierPrefix),t.onUncaughtError!==void 0&&(o=t.onUncaughtError),t.onCaughtError!==void 0&&(s=t.onCaughtError),t.onRecoverableError!==void 0&&(c=t.onRecoverableError)),t=ep(e,1,!1,null,null,n,r,null,o,s,c,Pp),e[ot]=t.current,Sd(e),new Fp(t)}})),g=o(((e,t)=>{function n(){if(!(typeof __REACT_DEVTOOLS_GLOBAL_HOOK__>`u`||typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE!=`function`))try{__REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(n)}catch(e){console.error(e)}}n(),t.exports=h()})),_=o((e=>{var t=Symbol.for(`react.transitional.element`),n=Symbol.for(`react.fragment`);function r(e,n,r){var i=null;if(r!==void 0&&(i=``+r),n.key!==void 0&&(i=``+n.key),`key`in n)for(var a in r={},n)a!==`key`&&(r[a]=n[a]);else r=n;return n=r.ref,{$$typeof:t,type:e,key:i,ref:n===void 0?null:n,props:r}}e.Fragment=n,e.jsx=r,e.jsxs=r})),v=o(((e,t)=>{t.exports=_()})),y=c(u(),1),b=g(),x=v();function S(e){if(typeof e==`string`||typeof e==`number`)return``+e;let t=``;if(Array.isArray(e))for(let n=0,r;n<e.length;n++)(r=S(e[n]))!==``&&(t+=(t&&` `)+r);else for(let n in e)e[n]&&(t+=(t&&` `)+n);return t}var C={value:()=>{}};function w(){for(var e=0,t=arguments.length,n={},r;e<t;++e){if(!(r=arguments[e]+``)||r in n||/[\s.]/.test(r))throw Error(`illegal type: `+r);n[r]=[]}return new T(n)}function T(e){this._=e}function E(e,t){return e.trim().split(/^|\s+/).map(function(e){var n=``,r=e.indexOf(`.`);if(r>=0&&(n=e.slice(r+1),e=e.slice(0,r)),e&&!t.hasOwnProperty(e))throw Error(`unknown type: `+e);return{type:e,name:n}})}T.prototype=w.prototype={constructor:T,on:function(e,t){var n=this._,r=E(e+``,n),i,a=-1,o=r.length;if(arguments.length<2){for(;++a<o;)if((i=(e=r[a]).type)&&(i=D(n[i],e.name)))return i;return}if(t!=null&&typeof t!=`function`)throw Error(`invalid callback: `+t);for(;++a<o;)if(i=(e=r[a]).type)n[i]=O(n[i],e.name,t);else if(t==null)for(i in n)n[i]=O(n[i],e.name,null);return this},copy:function(){var e={},t=this._;for(var n in t)e[n]=t[n].slice();return new T(e)},call:function(e,t){if((i=arguments.length-2)>0)for(var n=Array(i),r=0,i,a;r<i;++r)n[r]=arguments[r+2];if(!this._.hasOwnProperty(e))throw Error(`unknown type: `+e);for(a=this._[e],r=0,i=a.length;r<i;++r)a[r].value.apply(t,n)},apply:function(e,t,n){if(!this._.hasOwnProperty(e))throw Error(`unknown type: `+e);for(var r=this._[e],i=0,a=r.length;i<a;++i)r[i].value.apply(t,n)}};function D(e,t){for(var n=0,r=e.length,i;n<r;++n)if((i=e[n]).name===t)return i.value}function O(e,t,n){for(var r=0,i=e.length;r<i;++r)if(e[r].name===t){e[r]=C,e=e.slice(0,r).concat(e.slice(r+1));break}return n!=null&&e.push({name:t,value:n}),e}function k(e){return function(){return this.matches(e)}}function A(e){return function(t){return t.matches(e)}}var j={svg:`http://www.w3.org/2000/svg`,xhtml:`http://www.w3.org/1999/xhtml`,xlink:`http://www.w3.org/1999/xlink`,xml:`http://www.w3.org/XML/1998/namespace`,xmlns:`http://www.w3.org/2000/xmlns/`};function M(e){var t=e+=``,n=t.indexOf(`:`);return n>=0&&(t=e.slice(0,n))!==`xmlns`&&(e=e.slice(n+1)),j.hasOwnProperty(t)?{space:j[t],local:e}:e}function N(e){let t;for(;t=e.sourceEvent;)e=t;return e}function P(e,t){if(e=N(e),t===void 0&&(t=e.currentTarget),t){var n=t.ownerSVGElement||t;if(n.createSVGPoint){var r=n.createSVGPoint();return r.x=e.clientX,r.y=e.clientY,r=r.matrixTransform(t.getScreenCTM().inverse()),[r.x,r.y]}if(t.getBoundingClientRect){var i=t.getBoundingClientRect();return[e.clientX-i.left-t.clientLeft,e.clientY-i.top-t.clientTop]}}return[e.pageX,e.pageY]}function ee(){}function F(e){return e==null?ee:function(){return this.querySelector(e)}}function I(e){typeof e!=`function`&&(e=F(e));for(var t=this._groups,n=t.length,r=Array(n),i=0;i<n;++i)for(var a=t[i],o=a.length,s=r[i]=Array(o),c,l,u=0;u<o;++u)(c=a[u])&&(l=e.call(c,c.__data__,u,a))&&(`__data__`in c&&(l.__data__=c.__data__),s[u]=l);return new zt(r,this._parents)}function te(e){return e==null?[]:Array.isArray(e)?e:Array.from(e)}function ne(){return[]}function L(e){return e==null?ne:function(){return this.querySelectorAll(e)}}function R(e){return function(){return te(e.apply(this,arguments))}}function z(e){e=typeof e==`function`?R(e):L(e);for(var t=this._groups,n=t.length,r=[],i=[],a=0;a<n;++a)for(var o=t[a],s=o.length,c,l=0;l<s;++l)(c=o[l])&&(r.push(e.call(c,c.__data__,l,o)),i.push(c));return new zt(r,i)}var B=Array.prototype.find;function re(e){return function(){return B.call(this.children,e)}}function ie(){return this.firstElementChild}function ae(e){return this.select(e==null?ie:re(typeof e==`function`?e:A(e)))}var oe=Array.prototype.filter;function se(){return Array.from(this.children)}function ce(e){return function(){return oe.call(this.children,e)}}function le(e){return this.selectAll(e==null?se:ce(typeof e==`function`?e:A(e)))}function ue(e){typeof e!=`function`&&(e=k(e));for(var t=this._groups,n=t.length,r=Array(n),i=0;i<n;++i)for(var a=t[i],o=a.length,s=r[i]=[],c,l=0;l<o;++l)(c=a[l])&&e.call(c,c.__data__,l,a)&&s.push(c);return new zt(r,this._parents)}function de(e){return Array(e.length)}function fe(){return new zt(this._enter||this._groups.map(de),this._parents)}function pe(e,t){this.ownerDocument=e.ownerDocument,this.namespaceURI=e.namespaceURI,this._next=null,this._parent=e,this.__data__=t}pe.prototype={constructor:pe,appendChild:function(e){return this._parent.insertBefore(e,this._next)},insertBefore:function(e,t){return this._parent.insertBefore(e,t)},querySelector:function(e){return this._parent.querySelector(e)},querySelectorAll:function(e){return this._parent.querySelectorAll(e)}};function me(e){return function(){return e}}function he(e,t,n,r,i,a){for(var o=0,s,c=t.length,l=a.length;o<l;++o)(s=t[o])?(s.__data__=a[o],r[o]=s):n[o]=new pe(e,a[o]);for(;o<c;++o)(s=t[o])&&(i[o]=s)}function ge(e,t,n,r,i,a,o){var s,c,l=new Map,u=t.length,d=a.length,f=Array(u),p;for(s=0;s<u;++s)(c=t[s])&&(f[s]=p=o.call(c,c.__data__,s,t)+``,l.has(p)?i[s]=c:l.set(p,c));for(s=0;s<d;++s)p=o.call(e,a[s],s,a)+``,(c=l.get(p))?(r[s]=c,c.__data__=a[s],l.delete(p)):n[s]=new pe(e,a[s]);for(s=0;s<u;++s)(c=t[s])&&l.get(f[s])===c&&(i[s]=c)}function _e(e){return e.__data__}function ve(e,t){if(!arguments.length)return Array.from(this,_e);var n=t?ge:he,r=this._parents,i=this._groups;typeof e!=`function`&&(e=me(e));for(var a=i.length,o=Array(a),s=Array(a),c=Array(a),l=0;l<a;++l){var u=r[l],d=i[l],f=d.length,p=ye(e.call(u,u&&u.__data__,l,r)),m=p.length,h=s[l]=Array(m),g=o[l]=Array(m);n(u,d,h,g,c[l]=Array(f),p,t);for(var _=0,v=0,y,b;_<m;++_)if(y=h[_]){for(_>=v&&(v=_+1);!(b=g[v])&&++v<m;);y._next=b||null}}return o=new zt(o,r),o._enter=s,o._exit=c,o}function ye(e){return typeof e==`object`&&`length`in e?e:Array.from(e)}function be(){return new zt(this._exit||this._groups.map(de),this._parents)}function xe(e,t,n){var r=this.enter(),i=this,a=this.exit();return typeof e==`function`?(r=e(r),r&&=r.selection()):r=r.append(e+``),t!=null&&(i=t(i),i&&=i.selection()),n==null?a.remove():n(a),r&&i?r.merge(i).order():i}function Se(e){for(var t=e.selection?e.selection():e,n=this._groups,r=t._groups,i=n.length,a=r.length,o=Math.min(i,a),s=Array(i),c=0;c<o;++c)for(var l=n[c],u=r[c],d=l.length,f=s[c]=Array(d),p,m=0;m<d;++m)(p=l[m]||u[m])&&(f[m]=p);for(;c<i;++c)s[c]=n[c];return new zt(s,this._parents)}function Ce(){for(var e=this._groups,t=-1,n=e.length;++t<n;)for(var r=e[t],i=r.length-1,a=r[i],o;--i>=0;)(o=r[i])&&(a&&o.compareDocumentPosition(a)^4&&a.parentNode.insertBefore(o,a),a=o);return this}function we(e){e||=Te;function t(t,n){return t&&n?e(t.__data__,n.__data__):!t-!n}for(var n=this._groups,r=n.length,i=Array(r),a=0;a<r;++a){for(var o=n[a],s=o.length,c=i[a]=Array(s),l,u=0;u<s;++u)(l=o[u])&&(c[u]=l);c.sort(t)}return new zt(i,this._parents).order()}function Te(e,t){return e<t?-1:e>t?1:e>=t?0:NaN}function Ee(){var e=arguments[0];return arguments[0]=this,e.apply(null,arguments),this}function De(){return Array.from(this)}function Oe(){for(var e=this._groups,t=0,n=e.length;t<n;++t)for(var r=e[t],i=0,a=r.length;i<a;++i){var o=r[i];if(o)return o}return null}function ke(){let e=0;for(let t of this)++e;return e}function Ae(){return!this.node()}function je(e){for(var t=this._groups,n=0,r=t.length;n<r;++n)for(var i=t[n],a=0,o=i.length,s;a<o;++a)(s=i[a])&&e.call(s,s.__data__,a,i);return this}function Me(e){return function(){this.removeAttribute(e)}}function Ne(e){return function(){this.removeAttributeNS(e.space,e.local)}}function Pe(e,t){return function(){this.setAttribute(e,t)}}function Fe(e,t){return function(){this.setAttributeNS(e.space,e.local,t)}}function Ie(e,t){return function(){var n=t.apply(this,arguments);n==null?this.removeAttribute(e):this.setAttribute(e,n)}}function Le(e,t){return function(){var n=t.apply(this,arguments);n==null?this.removeAttributeNS(e.space,e.local):this.setAttributeNS(e.space,e.local,n)}}function Re(e,t){var n=M(e);if(arguments.length<2){var r=this.node();return n.local?r.getAttributeNS(n.space,n.local):r.getAttribute(n)}return this.each((t==null?n.local?Ne:Me:typeof t==`function`?n.local?Le:Ie:n.local?Fe:Pe)(n,t))}function ze(e){return e.ownerDocument&&e.ownerDocument.defaultView||e.document&&e||e.defaultView}function Be(e){return function(){this.style.removeProperty(e)}}function Ve(e,t,n){return function(){this.style.setProperty(e,t,n)}}function He(e,t,n){return function(){var r=t.apply(this,arguments);r==null?this.style.removeProperty(e):this.style.setProperty(e,r,n)}}function Ue(e,t,n){return arguments.length>1?this.each((t==null?Be:typeof t==`function`?He:Ve)(e,t,n??``)):We(this.node(),e)}function We(e,t){return e.style.getPropertyValue(t)||ze(e).getComputedStyle(e,null).getPropertyValue(t)}function Ge(e){return function(){delete this[e]}}function Ke(e,t){return function(){this[e]=t}}function qe(e,t){return function(){var n=t.apply(this,arguments);n==null?delete this[e]:this[e]=n}}function Je(e,t){return arguments.length>1?this.each((t==null?Ge:typeof t==`function`?qe:Ke)(e,t)):this.node()[e]}function Ye(e){return e.trim().split(/^|\s+/)}function Xe(e){return e.classList||new Ze(e)}function Ze(e){this._node=e,this._names=Ye(e.getAttribute(`class`)||``)}Ze.prototype={add:function(e){this._names.indexOf(e)<0&&(this._names.push(e),this._node.setAttribute(`class`,this._names.join(` `)))},remove:function(e){var t=this._names.indexOf(e);t>=0&&(this._names.splice(t,1),this._node.setAttribute(`class`,this._names.join(` `)))},contains:function(e){return this._names.indexOf(e)>=0}};function Qe(e,t){for(var n=Xe(e),r=-1,i=t.length;++r<i;)n.add(t[r])}function $e(e,t){for(var n=Xe(e),r=-1,i=t.length;++r<i;)n.remove(t[r])}function et(e){return function(){Qe(this,e)}}function tt(e){return function(){$e(this,e)}}function nt(e,t){return function(){(t.apply(this,arguments)?Qe:$e)(this,e)}}function rt(e,t){var n=Ye(e+``);if(arguments.length<2){for(var r=Xe(this.node()),i=-1,a=n.length;++i<a;)if(!r.contains(n[i]))return!1;return!0}return this.each((typeof t==`function`?nt:t?et:tt)(n,t))}function it(){this.textContent=``}function at(e){return function(){this.textContent=e}}function ot(e){return function(){var t=e.apply(this,arguments);this.textContent=t??``}}function st(e){return arguments.length?this.each(e==null?it:(typeof e==`function`?ot:at)(e)):this.node().textContent}function ct(){this.innerHTML=``}function lt(e){return function(){this.innerHTML=e}}function ut(e){return function(){var t=e.apply(this,arguments);this.innerHTML=t??``}}function dt(e){return arguments.length?this.each(e==null?ct:(typeof e==`function`?ut:lt)(e)):this.node().innerHTML}function ft(){this.nextSibling&&this.parentNode.appendChild(this)}function pt(){return this.each(ft)}function mt(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function ht(){return this.each(mt)}function gt(e){return function(){var t=this.ownerDocument,n=this.namespaceURI;return n===`http://www.w3.org/1999/xhtml`&&t.documentElement.namespaceURI===`http://www.w3.org/1999/xhtml`?t.createElement(e):t.createElementNS(n,e)}}function _t(e){return function(){return this.ownerDocument.createElementNS(e.space,e.local)}}function vt(e){var t=M(e);return(t.local?_t:gt)(t)}function yt(e){var t=typeof e==`function`?e:vt(e);return this.select(function(){return this.appendChild(t.apply(this,arguments))})}function bt(){return null}function xt(e,t){var n=typeof e==`function`?e:vt(e),r=t==null?bt:typeof t==`function`?t:F(t);return this.select(function(){return this.insertBefore(n.apply(this,arguments),r.apply(this,arguments)||null)})}function St(){var e=this.parentNode;e&&e.removeChild(this)}function Ct(){return this.each(St)}function wt(){var e=this.cloneNode(!1),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function Tt(){var e=this.cloneNode(!0),t=this.parentNode;return t?t.insertBefore(e,this.nextSibling):e}function Et(e){return this.select(e?Tt:wt)}function Dt(e){return arguments.length?this.property(`__data__`,e):this.node().__data__}function Ot(e){return function(t){e.call(this,t,this.__data__)}}function kt(e){return e.trim().split(/^|\s+/).map(function(e){var t=``,n=e.indexOf(`.`);return n>=0&&(t=e.slice(n+1),e=e.slice(0,n)),{type:e,name:t}})}function At(e){return function(){var t=this.__on;if(t){for(var n=0,r=-1,i=t.length,a;n<i;++n)a=t[n],(!e.type||a.type===e.type)&&a.name===e.name?this.removeEventListener(a.type,a.listener,a.options):t[++r]=a;++r?t.length=r:delete this.__on}}}function jt(e,t,n){return function(){var r=this.__on,i,a=Ot(t);if(r){for(var o=0,s=r.length;o<s;++o)if((i=r[o]).type===e.type&&i.name===e.name){this.removeEventListener(i.type,i.listener,i.options),this.addEventListener(i.type,i.listener=a,i.options=n),i.value=t;return}}this.addEventListener(e.type,a,n),i={type:e.type,name:e.name,value:t,listener:a,options:n},r?r.push(i):this.__on=[i]}}function Mt(e,t,n){var r=kt(e+``),i,a=r.length,o;if(arguments.length<2){var s=this.node().__on;if(s){for(var c=0,l=s.length,u;c<l;++c)for(i=0,u=s[c];i<a;++i)if((o=r[i]).type===u.type&&o.name===u.name)return u.value}return}for(s=t?jt:At,i=0;i<a;++i)this.each(s(r[i],t,n));return this}function Nt(e,t,n){var r=ze(e),i=r.CustomEvent;typeof i==`function`?i=new i(t,n):(i=r.document.createEvent(`Event`),n?(i.initEvent(t,n.bubbles,n.cancelable),i.detail=n.detail):i.initEvent(t,!1,!1)),e.dispatchEvent(i)}function Pt(e,t){return function(){return Nt(this,e,t)}}function Ft(e,t){return function(){return Nt(this,e,t.apply(this,arguments))}}function It(e,t){return this.each((typeof t==`function`?Ft:Pt)(e,t))}function*Lt(){for(var e=this._groups,t=0,n=e.length;t<n;++t)for(var r=e[t],i=0,a=r.length,o;i<a;++i)(o=r[i])&&(yield o)}var Rt=[null];function zt(e,t){this._groups=e,this._parents=t}function Bt(){return new zt([[document.documentElement]],Rt)}function Vt(){return this}zt.prototype=Bt.prototype={constructor:zt,select:I,selectAll:z,selectChild:ae,selectChildren:le,filter:ue,data:ve,enter:fe,exit:be,join:xe,merge:Se,selection:Vt,order:Ce,sort:we,call:Ee,nodes:De,node:Oe,size:ke,empty:Ae,each:je,attr:Re,style:Ue,property:Je,classed:rt,text:st,html:dt,raise:pt,lower:ht,append:yt,insert:xt,remove:Ct,clone:Et,datum:Dt,on:Mt,dispatch:It,[Symbol.iterator]:Lt};function Ht(e){return typeof e==`string`?new zt([[document.querySelector(e)]],[document.documentElement]):new zt([[e]],Rt)}var Ut={passive:!1},Wt={capture:!0,passive:!1};function Gt(e){e.stopImmediatePropagation()}function Kt(e){e.preventDefault(),e.stopImmediatePropagation()}function qt(e){var t=e.document.documentElement,n=Ht(e).on(`dragstart.drag`,Kt,Wt);`onselectstart`in t?n.on(`selectstart.drag`,Kt,Wt):(t.__noselect=t.style.MozUserSelect,t.style.MozUserSelect=`none`)}function Jt(e,t){var n=e.document.documentElement,r=Ht(e).on(`dragstart.drag`,null);t&&(r.on(`click.drag`,Kt,Wt),setTimeout(function(){r.on(`click.drag`,null)},0)),`onselectstart`in n?r.on(`selectstart.drag`,null):(n.style.MozUserSelect=n.__noselect,delete n.__noselect)}var Yt=e=>()=>e;function Xt(e,{sourceEvent:t,subject:n,target:r,identifier:i,active:a,x:o,y:s,dx:c,dy:l,dispatch:u}){Object.defineProperties(this,{type:{value:e,enumerable:!0,configurable:!0},sourceEvent:{value:t,enumerable:!0,configurable:!0},subject:{value:n,enumerable:!0,configurable:!0},target:{value:r,enumerable:!0,configurable:!0},identifier:{value:i,enumerable:!0,configurable:!0},active:{value:a,enumerable:!0,configurable:!0},x:{value:o,enumerable:!0,configurable:!0},y:{value:s,enumerable:!0,configurable:!0},dx:{value:c,enumerable:!0,configurable:!0},dy:{value:l,enumerable:!0,configurable:!0},_:{value:u}})}Xt.prototype.on=function(){var e=this._.on.apply(this._,arguments);return e===this._?this:e};function Zt(e){return!e.ctrlKey&&!e.button}function Qt(){return this.parentNode}function $t(e,t){return t??{x:e.x,y:e.y}}function en(){return navigator.maxTouchPoints||`ontouchstart`in this}function tn(){var e=Zt,t=Qt,n=$t,r=en,i={},a=w(`start`,`drag`,`end`),o=0,s,c,l,u,d=0;function f(e){e.on(`mousedown.drag`,p).filter(r).on(`touchstart.drag`,g).on(`touchmove.drag`,_,Ut).on(`touchend.drag touchcancel.drag`,v).style(`touch-action`,`none`).style(`-webkit-tap-highlight-color`,`rgba(0,0,0,0)`)}function p(n,r){if(!(u||!e.call(this,n,r))){var i=y(this,t.call(this,n,r),n,r,`mouse`);i&&(Ht(n.view).on(`mousemove.drag`,m,Wt).on(`mouseup.drag`,h,Wt),qt(n.view),Gt(n),l=!1,s=n.clientX,c=n.clientY,i(`start`,n))}}function m(e){if(Kt(e),!l){var t=e.clientX-s,n=e.clientY-c;l=t*t+n*n>d}i.mouse(`drag`,e)}function h(e){Ht(e.view).on(`mousemove.drag mouseup.drag`,null),Jt(e.view,l),Kt(e),i.mouse(`end`,e)}function g(n,r){if(e.call(this,n,r)){var i=n.changedTouches,a=t.call(this,n,r),o=i.length,s,c;for(s=0;s<o;++s)(c=y(this,a,n,r,i[s].identifier,i[s]))&&(Gt(n),c(`start`,n,i[s]))}}function _(e){var t=e.changedTouches,n=t.length,r,a;for(r=0;r<n;++r)(a=i[t[r].identifier])&&(Kt(e),a(`drag`,e,t[r]))}function v(e){var t=e.changedTouches,n=t.length,r,a;for(u&&clearTimeout(u),u=setTimeout(function(){u=null},500),r=0;r<n;++r)(a=i[t[r].identifier])&&(Gt(e),a(`end`,e,t[r]))}function y(e,t,r,s,c,l){var u=a.copy(),d=P(l||r,t),p,m,h;if((h=n.call(e,new Xt(`beforestart`,{sourceEvent:r,target:f,identifier:c,active:o,x:d[0],y:d[1],dx:0,dy:0,dispatch:u}),s))!=null)return p=h.x-d[0]||0,m=h.y-d[1]||0,function n(r,a,l){var g=d,_;switch(r){case`start`:i[c]=n,_=o++;break;case`end`:delete i[c],--o;case`drag`:d=P(l||a,t),_=o;break}u.call(r,e,new Xt(r,{sourceEvent:a,subject:h,target:f,identifier:c,active:_,x:d[0]+p,y:d[1]+m,dx:d[0]-g[0],dy:d[1]-g[1],dispatch:u}),s)}}return f.filter=function(t){return arguments.length?(e=typeof t==`function`?t:Yt(!!t),f):e},f.container=function(e){return arguments.length?(t=typeof e==`function`?e:Yt(e),f):t},f.subject=function(e){return arguments.length?(n=typeof e==`function`?e:Yt(e),f):n},f.touchable=function(e){return arguments.length?(r=typeof e==`function`?e:Yt(!!e),f):r},f.on=function(){var e=a.on.apply(a,arguments);return e===a?f:e},f.clickDistance=function(e){return arguments.length?(d=(e=+e)*e,f):Math.sqrt(d)},f}function nn(e,t,n){e.prototype=t.prototype=n,n.constructor=e}function rn(e,t){var n=Object.create(e.prototype);for(var r in t)n[r]=t[r];return n}function an(){}var on=.7,sn=1/on,cn=`\\s*([+-]?\\d+)\\s*`,ln=`\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)\\s*`,un=`\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)%\\s*`,dn=/^#([0-9a-f]{3,8})$/,fn=RegExp(`^rgb\\(${cn},${cn},${cn}\\)$`),pn=RegExp(`^rgb\\(${un},${un},${un}\\)$`),mn=RegExp(`^rgba\\(${cn},${cn},${cn},${ln}\\)$`),hn=RegExp(`^rgba\\(${un},${un},${un},${ln}\\)$`),gn=RegExp(`^hsl\\(${ln},${un},${un}\\)$`),_n=RegExp(`^hsla\\(${ln},${un},${un},${ln}\\)$`),vn={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};nn(an,Cn,{copy(e){return Object.assign(new this.constructor,this,e)},displayable(){return this.rgb().displayable()},hex:yn,formatHex:yn,formatHex8:bn,formatHsl:xn,formatRgb:Sn,toString:Sn});function yn(){return this.rgb().formatHex()}function bn(){return this.rgb().formatHex8()}function xn(){return In(this).formatHsl()}function Sn(){return this.rgb().formatRgb()}function Cn(e){var t,n;return e=(e+``).trim().toLowerCase(),(t=dn.exec(e))?(n=t[1].length,t=parseInt(t[1],16),n===6?wn(t):n===3?new On(t>>8&15|t>>4&240,t>>4&15|t&240,(t&15)<<4|t&15,1):n===8?Tn(t>>24&255,t>>16&255,t>>8&255,(t&255)/255):n===4?Tn(t>>12&15|t>>8&240,t>>8&15|t>>4&240,t>>4&15|t&240,((t&15)<<4|t&15)/255):null):(t=fn.exec(e))?new On(t[1],t[2],t[3],1):(t=pn.exec(e))?new On(t[1]*255/100,t[2]*255/100,t[3]*255/100,1):(t=mn.exec(e))?Tn(t[1],t[2],t[3],t[4]):(t=hn.exec(e))?Tn(t[1]*255/100,t[2]*255/100,t[3]*255/100,t[4]):(t=gn.exec(e))?Fn(t[1],t[2]/100,t[3]/100,1):(t=_n.exec(e))?Fn(t[1],t[2]/100,t[3]/100,t[4]):vn.hasOwnProperty(e)?wn(vn[e]):e===`transparent`?new On(NaN,NaN,NaN,0):null}function wn(e){return new On(e>>16&255,e>>8&255,e&255,1)}function Tn(e,t,n,r){return r<=0&&(e=t=n=NaN),new On(e,t,n,r)}function En(e){return e instanceof an||(e=Cn(e)),e?(e=e.rgb(),new On(e.r,e.g,e.b,e.opacity)):new On}function Dn(e,t,n,r){return arguments.length===1?En(e):new On(e,t,n,r??1)}function On(e,t,n,r){this.r=+e,this.g=+t,this.b=+n,this.opacity=+r}nn(On,Dn,rn(an,{brighter(e){return e=e==null?sn:sn**+e,new On(this.r*e,this.g*e,this.b*e,this.opacity)},darker(e){return e=e==null?on:on**+e,new On(this.r*e,this.g*e,this.b*e,this.opacity)},rgb(){return this},clamp(){return new On(Nn(this.r),Nn(this.g),Nn(this.b),Mn(this.opacity))},displayable(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:kn,formatHex:kn,formatHex8:An,formatRgb:jn,toString:jn}));function kn(){return`#${Pn(this.r)}${Pn(this.g)}${Pn(this.b)}`}function An(){return`#${Pn(this.r)}${Pn(this.g)}${Pn(this.b)}${Pn((isNaN(this.opacity)?1:this.opacity)*255)}`}function jn(){let e=Mn(this.opacity);return`${e===1?`rgb(`:`rgba(`}${Nn(this.r)}, ${Nn(this.g)}, ${Nn(this.b)}${e===1?`)`:`, ${e})`}`}function Mn(e){return isNaN(e)?1:Math.max(0,Math.min(1,e))}function Nn(e){return Math.max(0,Math.min(255,Math.round(e)||0))}function Pn(e){return e=Nn(e),(e<16?`0`:``)+e.toString(16)}function Fn(e,t,n,r){return r<=0?e=t=n=NaN:n<=0||n>=1?e=t=NaN:t<=0&&(e=NaN),new Rn(e,t,n,r)}function In(e){if(e instanceof Rn)return new Rn(e.h,e.s,e.l,e.opacity);if(e instanceof an||(e=Cn(e)),!e)return new Rn;if(e instanceof Rn)return e;e=e.rgb();var t=e.r/255,n=e.g/255,r=e.b/255,i=Math.min(t,n,r),a=Math.max(t,n,r),o=NaN,s=a-i,c=(a+i)/2;return s?(o=t===a?(n-r)/s+(n<r)*6:n===a?(r-t)/s+2:(t-n)/s+4,s/=c<.5?a+i:2-a-i,o*=60):s=c>0&&c<1?0:o,new Rn(o,s,c,e.opacity)}function Ln(e,t,n,r){return arguments.length===1?In(e):new Rn(e,t,n,r??1)}function Rn(e,t,n,r){this.h=+e,this.s=+t,this.l=+n,this.opacity=+r}nn(Rn,Ln,rn(an,{brighter(e){return e=e==null?sn:sn**+e,new Rn(this.h,this.s,this.l*e,this.opacity)},darker(e){return e=e==null?on:on**+e,new Rn(this.h,this.s,this.l*e,this.opacity)},rgb(){var e=this.h%360+(this.h<0)*360,t=isNaN(e)||isNaN(this.s)?0:this.s,n=this.l,r=n+(n<.5?n:1-n)*t,i=2*n-r;return new On(Vn(e>=240?e-240:e+120,i,r),Vn(e,i,r),Vn(e<120?e+240:e-120,i,r),this.opacity)},clamp(){return new Rn(zn(this.h),Bn(this.s),Bn(this.l),Mn(this.opacity))},displayable(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl(){let e=Mn(this.opacity);return`${e===1?`hsl(`:`hsla(`}${zn(this.h)}, ${Bn(this.s)*100}%, ${Bn(this.l)*100}%${e===1?`)`:`, ${e})`}`}}));function zn(e){return e=(e||0)%360,e<0?e+360:e}function Bn(e){return Math.max(0,Math.min(1,e||0))}function Vn(e,t,n){return(e<60?t+(n-t)*e/60:e<180?n:e<240?t+(n-t)*(240-e)/60:t)*255}var Hn=e=>()=>e;function Un(e,t){return function(n){return e+n*t}}function Wn(e,t,n){return e**=+n,t=t**+n-e,n=1/n,function(r){return(e+r*t)**+n}}function Gn(e){return(e=+e)==1?Kn:function(t,n){return n-t?Wn(t,n,e):Hn(isNaN(t)?n:t)}}function Kn(e,t){var n=t-e;return n?Un(e,n):Hn(isNaN(e)?t:e)}var qn=(function e(t){var n=Gn(t);function r(e,t){var r=n((e=Dn(e)).r,(t=Dn(t)).r),i=n(e.g,t.g),a=n(e.b,t.b),o=Kn(e.opacity,t.opacity);return function(t){return e.r=r(t),e.g=i(t),e.b=a(t),e.opacity=o(t),e+``}}return r.gamma=e,r})(1);function Jn(e,t){t||=[];var n=e?Math.min(t.length,e.length):0,r=t.slice(),i;return function(a){for(i=0;i<n;++i)r[i]=e[i]*(1-a)+t[i]*a;return r}}function Yn(e){return ArrayBuffer.isView(e)&&!(e instanceof DataView)}function Xn(e,t){var n=t?t.length:0,r=e?Math.min(n,e.length):0,i=Array(r),a=Array(n),o;for(o=0;o<r;++o)i[o]=ar(e[o],t[o]);for(;o<n;++o)a[o]=t[o];return function(e){for(o=0;o<r;++o)a[o]=i[o](e);return a}}function Zn(e,t){var n=new Date;return e=+e,t=+t,function(r){return n.setTime(e*(1-r)+t*r),n}}function Qn(e,t){return e=+e,t=+t,function(n){return e*(1-n)+t*n}}function $n(e,t){var n={},r={},i;for(i in(typeof e!=`object`||!e)&&(e={}),(typeof t!=`object`||!t)&&(t={}),t)i in e?n[i]=ar(e[i],t[i]):r[i]=t[i];return function(e){for(i in n)r[i]=n[i](e);return r}}var er=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,tr=new RegExp(er.source,`g`);function nr(e){return function(){return e}}function rr(e){return function(t){return e(t)+``}}function ir(e,t){var n=er.lastIndex=tr.lastIndex=0,r,i,a,o=-1,s=[],c=[];for(e+=``,t+=``;(r=er.exec(e))&&(i=tr.exec(t));)(a=i.index)>n&&(a=t.slice(n,a),s[o]?s[o]+=a:s[++o]=a),(r=r[0])===(i=i[0])?s[o]?s[o]+=i:s[++o]=i:(s[++o]=null,c.push({i:o,x:Qn(r,i)})),n=tr.lastIndex;return n<t.length&&(a=t.slice(n),s[o]?s[o]+=a:s[++o]=a),s.length<2?c[0]?rr(c[0].x):nr(t):(t=c.length,function(e){for(var n=0,r;n<t;++n)s[(r=c[n]).i]=r.x(e);return s.join(``)})}function ar(e,t){var n=typeof t,r;return t==null||n===`boolean`?Hn(t):(n===`number`?Qn:n===`string`?(r=Cn(t))?(t=r,qn):ir:t instanceof Cn?qn:t instanceof Date?Zn:Yn(t)?Jn:Array.isArray(t)?Xn:typeof t.valueOf!=`function`&&typeof t.toString!=`function`||isNaN(t)?$n:Qn)(e,t)}var or=180/Math.PI,sr={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1};function cr(e,t,n,r,i,a){var o,s,c;return(o=Math.sqrt(e*e+t*t))&&(e/=o,t/=o),(c=e*n+t*r)&&(n-=e*c,r-=t*c),(s=Math.sqrt(n*n+r*r))&&(n/=s,r/=s,c/=s),e*r<t*n&&(e=-e,t=-t,c=-c,o=-o),{translateX:i,translateY:a,rotate:Math.atan2(t,e)*or,skewX:Math.atan(c)*or,scaleX:o,scaleY:s}}var lr;function ur(e){let t=new(typeof DOMMatrix==`function`?DOMMatrix:WebKitCSSMatrix)(e+``);return t.isIdentity?sr:cr(t.a,t.b,t.c,t.d,t.e,t.f)}function dr(e){return e==null||(lr||=document.createElementNS(`http://www.w3.org/2000/svg`,`g`),lr.setAttribute(`transform`,e),!(e=lr.transform.baseVal.consolidate()))?sr:(e=e.matrix,cr(e.a,e.b,e.c,e.d,e.e,e.f))}function fr(e,t,n,r){function i(e){return e.length?e.pop()+` `:``}function a(e,r,i,a,o,s){if(e!==i||r!==a){var c=o.push(`translate(`,null,t,null,n);s.push({i:c-4,x:Qn(e,i)},{i:c-2,x:Qn(r,a)})}else(i||a)&&o.push(`translate(`+i+t+a+n)}function o(e,t,n,a){e===t?t&&n.push(i(n)+`rotate(`+t+r):(e-t>180?t+=360:t-e>180&&(e+=360),a.push({i:n.push(i(n)+`rotate(`,null,r)-2,x:Qn(e,t)}))}function s(e,t,n,a){e===t?t&&n.push(i(n)+`skewX(`+t+r):a.push({i:n.push(i(n)+`skewX(`,null,r)-2,x:Qn(e,t)})}function c(e,t,n,r,a,o){if(e!==n||t!==r){var s=a.push(i(a)+`scale(`,null,`,`,null,`)`);o.push({i:s-4,x:Qn(e,n)},{i:s-2,x:Qn(t,r)})}else(n!==1||r!==1)&&a.push(i(a)+`scale(`+n+`,`+r+`)`)}return function(t,n){var r=[],i=[];return t=e(t),n=e(n),a(t.translateX,t.translateY,n.translateX,n.translateY,r,i),o(t.rotate,n.rotate,r,i),s(t.skewX,n.skewX,r,i),c(t.scaleX,t.scaleY,n.scaleX,n.scaleY,r,i),t=n=null,function(e){for(var t=-1,n=i.length,a;++t<n;)r[(a=i[t]).i]=a.x(e);return r.join(``)}}}var pr=fr(ur,`px, `,`px)`,`deg)`),mr=fr(dr,`, `,`)`,`)`),hr=1e-12;function gr(e){return((e=Math.exp(e))+1/e)/2}function _r(e){return((e=Math.exp(e))-1/e)/2}function vr(e){return((e=Math.exp(2*e))-1)/(e+1)}var yr=(function e(t,n,r){function i(e,i){var a=e[0],o=e[1],s=e[2],c=i[0],l=i[1],u=i[2],d=c-a,f=l-o,p=d*d+f*f,m,h;if(p<hr)h=Math.log(u/s)/t,m=function(e){return[a+e*d,o+e*f,s*Math.exp(t*e*h)]};else{var g=Math.sqrt(p),_=(u*u-s*s+r*p)/(2*s*n*g),v=(u*u-s*s-r*p)/(2*u*n*g),y=Math.log(Math.sqrt(_*_+1)-_);h=(Math.log(Math.sqrt(v*v+1)-v)-y)/t,m=function(e){var r=e*h,i=gr(y),c=s/(n*g)*(i*vr(t*r+y)-_r(y));return[a+c*d,o+c*f,s*i/gr(t*r+y)]}}return m.duration=h*1e3*t/Math.SQRT2,m}return i.rho=function(t){var n=Math.max(.001,+t),r=n*n;return e(n,r,r*r)},i})(Math.SQRT2,2,4),br=0,xr=0,Sr=0,Cr=1e3,wr,Tr,Er=0,Dr=0,Or=0,kr=typeof performance==`object`&&performance.now?performance:Date,Ar=typeof window==`object`&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(e){setTimeout(e,17)};function jr(){return Dr||=(Ar(Mr),kr.now()+Or)}function Mr(){Dr=0}function Nr(){this._call=this._time=this._next=null}Nr.prototype=Pr.prototype={constructor:Nr,restart:function(e,t,n){if(typeof e!=`function`)throw TypeError(`callback is not a function`);n=(n==null?jr():+n)+(t==null?0:+t),!this._next&&Tr!==this&&(Tr?Tr._next=this:wr=this,Tr=this),this._call=e,this._time=n,zr()},stop:function(){this._call&&(this._call=null,this._time=1/0,zr())}};function Pr(e,t,n){var r=new Nr;return r.restart(e,t,n),r}function Fr(){jr(),++br;for(var e=wr,t;e;)(t=Dr-e._time)>=0&&e._call.call(void 0,t),e=e._next;--br}function Ir(){Dr=(Er=kr.now())+Or,br=xr=0;try{Fr()}finally{br=0,Rr(),Dr=0}}function Lr(){var e=kr.now(),t=e-Er;t>Cr&&(Or-=t,Er=e)}function Rr(){for(var e,t=wr,n,r=1/0;t;)t._call?(r>t._time&&(r=t._time),e=t,t=t._next):(n=t._next,t._next=null,t=e?e._next=n:wr=n);Tr=e,zr(r)}function zr(e){br||(xr&&=clearTimeout(xr),e-Dr>24?(e<1/0&&(xr=setTimeout(Ir,e-kr.now()-Or)),Sr&&=clearInterval(Sr)):(Sr||=(Er=kr.now(),setInterval(Lr,Cr)),br=1,Ar(Ir)))}function Br(e,t,n){var r=new Nr;return t=t==null?0:+t,r.restart(n=>{r.stop(),e(n+t)},t,n),r}var Vr=w(`start`,`end`,`cancel`,`interrupt`),Hr=[];function Ur(e,t,n,r,i,a){var o=e.__transition;if(!o)e.__transition={};else if(n in o)return;qr(e,n,{name:t,index:r,group:i,on:Vr,tween:Hr,time:a.time,delay:a.delay,duration:a.duration,ease:a.ease,timer:null,state:0})}function Wr(e,t){var n=Kr(e,t);if(n.state>0)throw Error(`too late; already scheduled`);return n}function Gr(e,t){var n=Kr(e,t);if(n.state>3)throw Error(`too late; already running`);return n}function Kr(e,t){var n=e.__transition;if(!n||!(n=n[t]))throw Error(`transition not found`);return n}function qr(e,t,n){var r=e.__transition,i;r[t]=n,n.timer=Pr(a,0,n.time);function a(e){n.state=1,n.timer.restart(o,n.delay,n.time),n.delay<=e&&o(e-n.delay)}function o(a){var l,u,d,f;if(n.state!==1)return c();for(l in r)if(f=r[l],f.name===n.name){if(f.state===3)return Br(o);f.state===4?(f.state=6,f.timer.stop(),f.on.call(`interrupt`,e,e.__data__,f.index,f.group),delete r[l]):+l<t&&(f.state=6,f.timer.stop(),f.on.call(`cancel`,e,e.__data__,f.index,f.group),delete r[l])}if(Br(function(){n.state===3&&(n.state=4,n.timer.restart(s,n.delay,n.time),s(a))}),n.state=2,n.on.call(`start`,e,e.__data__,n.index,n.group),n.state===2){for(n.state=3,i=Array(d=n.tween.length),l=0,u=-1;l<d;++l)(f=n.tween[l].value.call(e,e.__data__,n.index,n.group))&&(i[++u]=f);i.length=u+1}}function s(t){for(var r=t<n.duration?n.ease.call(null,t/n.duration):(n.timer.restart(c),n.state=5,1),a=-1,o=i.length;++a<o;)i[a].call(e,r);n.state===5&&(n.on.call(`end`,e,e.__data__,n.index,n.group),c())}function c(){for(var i in n.state=6,n.timer.stop(),delete r[t],r)return;delete e.__transition}}function Jr(e,t){var n=e.__transition,r,i,a=!0,o;if(n){for(o in t=t==null?null:t+``,n){if((r=n[o]).name!==t){a=!1;continue}i=r.state>2&&r.state<5,r.state=6,r.timer.stop(),r.on.call(i?`interrupt`:`cancel`,e,e.__data__,r.index,r.group),delete n[o]}a&&delete e.__transition}}function Yr(e){return this.each(function(){Jr(this,e)})}function Xr(e,t){var n,r;return function(){var i=Gr(this,e),a=i.tween;if(a!==n){r=n=a;for(var o=0,s=r.length;o<s;++o)if(r[o].name===t){r=r.slice(),r.splice(o,1);break}}i.tween=r}}function Zr(e,t,n){var r,i;if(typeof n!=`function`)throw Error();return function(){var a=Gr(this,e),o=a.tween;if(o!==r){i=(r=o).slice();for(var s={name:t,value:n},c=0,l=i.length;c<l;++c)if(i[c].name===t){i[c]=s;break}c===l&&i.push(s)}a.tween=i}}function Qr(e,t){var n=this._id;if(e+=``,arguments.length<2){for(var r=Kr(this.node(),n).tween,i=0,a=r.length,o;i<a;++i)if((o=r[i]).name===e)return o.value;return null}return this.each((t==null?Xr:Zr)(n,e,t))}function $r(e,t,n){var r=e._id;return e.each(function(){var e=Gr(this,r);(e.value||={})[t]=n.apply(this,arguments)}),function(e){return Kr(e,r).value[t]}}function ei(e,t){var n;return(typeof t==`number`?Qn:t instanceof Cn?qn:(n=Cn(t))?(t=n,qn):ir)(e,t)}function ti(e){return function(){this.removeAttribute(e)}}function ni(e){return function(){this.removeAttributeNS(e.space,e.local)}}function ri(e,t,n){var r,i=n+``,a;return function(){var o=this.getAttribute(e);return o===i?null:o===r?a:a=t(r=o,n)}}function ii(e,t,n){var r,i=n+``,a;return function(){var o=this.getAttributeNS(e.space,e.local);return o===i?null:o===r?a:a=t(r=o,n)}}function ai(e,t,n){var r,i,a;return function(){var o,s=n(this),c;return s==null?void this.removeAttribute(e):(o=this.getAttribute(e),c=s+``,o===c?null:o===r&&c===i?a:(i=c,a=t(r=o,s)))}}function oi(e,t,n){var r,i,a;return function(){var o,s=n(this),c;return s==null?void this.removeAttributeNS(e.space,e.local):(o=this.getAttributeNS(e.space,e.local),c=s+``,o===c?null:o===r&&c===i?a:(i=c,a=t(r=o,s)))}}function si(e,t){var n=M(e),r=n===`transform`?mr:ei;return this.attrTween(e,typeof t==`function`?(n.local?oi:ai)(n,r,$r(this,`attr.`+e,t)):t==null?(n.local?ni:ti)(n):(n.local?ii:ri)(n,r,t))}function ci(e,t){return function(n){this.setAttribute(e,t.call(this,n))}}function li(e,t){return function(n){this.setAttributeNS(e.space,e.local,t.call(this,n))}}function ui(e,t){var n,r;function i(){var i=t.apply(this,arguments);return i!==r&&(n=(r=i)&&li(e,i)),n}return i._value=t,i}function di(e,t){var n,r;function i(){var i=t.apply(this,arguments);return i!==r&&(n=(r=i)&&ci(e,i)),n}return i._value=t,i}function fi(e,t){var n=`attr.`+e;if(arguments.length<2)return(n=this.tween(n))&&n._value;if(t==null)return this.tween(n,null);if(typeof t!=`function`)throw Error();var r=M(e);return this.tween(n,(r.local?ui:di)(r,t))}function pi(e,t){return function(){Wr(this,e).delay=+t.apply(this,arguments)}}function mi(e,t){return t=+t,function(){Wr(this,e).delay=t}}function hi(e){var t=this._id;return arguments.length?this.each((typeof e==`function`?pi:mi)(t,e)):Kr(this.node(),t).delay}function gi(e,t){return function(){Gr(this,e).duration=+t.apply(this,arguments)}}function _i(e,t){return t=+t,function(){Gr(this,e).duration=t}}function vi(e){var t=this._id;return arguments.length?this.each((typeof e==`function`?gi:_i)(t,e)):Kr(this.node(),t).duration}function yi(e,t){if(typeof t!=`function`)throw Error();return function(){Gr(this,e).ease=t}}function bi(e){var t=this._id;return arguments.length?this.each(yi(t,e)):Kr(this.node(),t).ease}function xi(e,t){return function(){var n=t.apply(this,arguments);if(typeof n!=`function`)throw Error();Gr(this,e).ease=n}}function Si(e){if(typeof e!=`function`)throw Error();return this.each(xi(this._id,e))}function Ci(e){typeof e!=`function`&&(e=k(e));for(var t=this._groups,n=t.length,r=Array(n),i=0;i<n;++i)for(var a=t[i],o=a.length,s=r[i]=[],c,l=0;l<o;++l)(c=a[l])&&e.call(c,c.__data__,l,a)&&s.push(c);return new Zi(r,this._parents,this._name,this._id)}function wi(e){if(e._id!==this._id)throw Error();for(var t=this._groups,n=e._groups,r=t.length,i=n.length,a=Math.min(r,i),o=Array(r),s=0;s<a;++s)for(var c=t[s],l=n[s],u=c.length,d=o[s]=Array(u),f,p=0;p<u;++p)(f=c[p]||l[p])&&(d[p]=f);for(;s<r;++s)o[s]=t[s];return new Zi(o,this._parents,this._name,this._id)}function Ti(e){return(e+``).trim().split(/^|\s+/).every(function(e){var t=e.indexOf(`.`);return t>=0&&(e=e.slice(0,t)),!e||e===`start`})}function Ei(e,t,n){var r,i,a=Ti(t)?Wr:Gr;return function(){var o=a(this,e),s=o.on;s!==r&&(i=(r=s).copy()).on(t,n),o.on=i}}function Di(e,t){var n=this._id;return arguments.length<2?Kr(this.node(),n).on.on(e):this.each(Ei(n,e,t))}function Oi(e){return function(){var t=this.parentNode;for(var n in this.__transition)if(+n!==e)return;t&&t.removeChild(this)}}function ki(){return this.on(`end.remove`,Oi(this._id))}function Ai(e){var t=this._name,n=this._id;typeof e!=`function`&&(e=F(e));for(var r=this._groups,i=r.length,a=Array(i),o=0;o<i;++o)for(var s=r[o],c=s.length,l=a[o]=Array(c),u,d,f=0;f<c;++f)(u=s[f])&&(d=e.call(u,u.__data__,f,s))&&(`__data__`in u&&(d.__data__=u.__data__),l[f]=d,Ur(l[f],t,n,f,l,Kr(u,n)));return new Zi(a,this._parents,t,n)}function ji(e){var t=this._name,n=this._id;typeof e!=`function`&&(e=L(e));for(var r=this._groups,i=r.length,a=[],o=[],s=0;s<i;++s)for(var c=r[s],l=c.length,u,d=0;d<l;++d)if(u=c[d]){for(var f=e.call(u,u.__data__,d,c),p,m=Kr(u,n),h=0,g=f.length;h<g;++h)(p=f[h])&&Ur(p,t,n,h,f,m);a.push(f),o.push(u)}return new Zi(a,o,t,n)}var Mi=Bt.prototype.constructor;function V(){return new Mi(this._groups,this._parents)}function Ni(e,t){var n,r,i;return function(){var a=We(this,e),o=(this.style.removeProperty(e),We(this,e));return a===o?null:a===n&&o===r?i:i=t(n=a,r=o)}}function Pi(e){return function(){this.style.removeProperty(e)}}function Fi(e,t,n){var r,i=n+``,a;return function(){var o=We(this,e);return o===i?null:o===r?a:a=t(r=o,n)}}function Ii(e,t,n){var r,i,a;return function(){var o=We(this,e),s=n(this),c=s+``;return s??(c=s=(this.style.removeProperty(e),We(this,e))),o===c?null:o===r&&c===i?a:(i=c,a=t(r=o,s))}}function Li(e,t){var n,r,i,a=`style.`+t,o=`end.`+a,s;return function(){var c=Gr(this,e),l=c.on,u=c.value[a]==null?s||=Pi(t):void 0;(l!==n||i!==u)&&(r=(n=l).copy()).on(o,i=u),c.on=r}}function Ri(e,t,n){var r=(e+=``)==`transform`?pr:ei;return t==null?this.styleTween(e,Ni(e,r)).on(`end.style.`+e,Pi(e)):typeof t==`function`?this.styleTween(e,Ii(e,r,$r(this,`style.`+e,t))).each(Li(this._id,e)):this.styleTween(e,Fi(e,r,t),n).on(`end.style.`+e,null)}function zi(e,t,n){return function(r){this.style.setProperty(e,t.call(this,r),n)}}function Bi(e,t,n){var r,i;function a(){var a=t.apply(this,arguments);return a!==i&&(r=(i=a)&&zi(e,a,n)),r}return a._value=t,a}function Vi(e,t,n){var r=`style.`+(e+=``);if(arguments.length<2)return(r=this.tween(r))&&r._value;if(t==null)return this.tween(r,null);if(typeof t!=`function`)throw Error();return this.tween(r,Bi(e,t,n??``))}function Hi(e){return function(){this.textContent=e}}function Ui(e){return function(){var t=e(this);this.textContent=t??``}}function Wi(e){return this.tween(`text`,typeof e==`function`?Ui($r(this,`text`,e)):Hi(e==null?``:e+``))}function Gi(e){return function(t){this.textContent=e.call(this,t)}}function Ki(e){var t,n;function r(){var r=e.apply(this,arguments);return r!==n&&(t=(n=r)&&Gi(r)),t}return r._value=e,r}function qi(e){var t=`text`;if(arguments.length<1)return(t=this.tween(t))&&t._value;if(e==null)return this.tween(t,null);if(typeof e!=`function`)throw Error();return this.tween(t,Ki(e))}function Ji(){for(var e=this._name,t=this._id,n=$i(),r=this._groups,i=r.length,a=0;a<i;++a)for(var o=r[a],s=o.length,c,l=0;l<s;++l)if(c=o[l]){var u=Kr(c,t);Ur(c,e,n,l,o,{time:u.time+u.delay+u.duration,delay:0,duration:u.duration,ease:u.ease})}return new Zi(r,this._parents,e,n)}function Yi(){var e,t,n=this,r=n._id,i=n.size();return new Promise(function(a,o){var s={value:o},c={value:function(){--i===0&&a()}};n.each(function(){var n=Gr(this,r),i=n.on;i!==e&&(t=(e=i).copy(),t._.cancel.push(s),t._.interrupt.push(s),t._.end.push(c)),n.on=t}),i===0&&a()})}var Xi=0;function Zi(e,t,n,r){this._groups=e,this._parents=t,this._name=n,this._id=r}function Qi(e){return Bt().transition(e)}function $i(){return++Xi}var ea=Bt.prototype;Zi.prototype=Qi.prototype={constructor:Zi,select:Ai,selectAll:ji,selectChild:ea.selectChild,selectChildren:ea.selectChildren,filter:Ci,merge:wi,selection:V,transition:Ji,call:ea.call,nodes:ea.nodes,node:ea.node,size:ea.size,empty:ea.empty,each:ea.each,on:Di,attr:si,attrTween:fi,style:Ri,styleTween:Vi,text:Wi,textTween:qi,remove:ki,tween:Qr,delay:hi,duration:vi,ease:bi,easeVarying:Si,end:Yi,[Symbol.iterator]:ea[Symbol.iterator]};function ta(e){return((e*=2)<=1?e*e*e:(e-=2)*e*e+2)/2}var na={time:null,delay:0,duration:250,ease:ta};function ra(e,t){for(var n;!(n=e.__transition)||!(n=n[t]);)if(!(e=e.parentNode))throw Error(`transition ${t} not found`);return n}function ia(e){var t,n;e instanceof Zi?(t=e._id,e=e._name):(t=$i(),(n=na).time=jr(),e=e==null?null:e+``);for(var r=this._groups,i=r.length,a=0;a<i;++a)for(var o=r[a],s=o.length,c,l=0;l<s;++l)(c=o[l])&&Ur(c,e,t,l,o,n||ra(c,t));return new Zi(r,this._parents,e,t)}Bt.prototype.interrupt=Yr,Bt.prototype.transition=ia;var aa=e=>()=>e;function oa(e,{sourceEvent:t,target:n,transform:r,dispatch:i}){Object.defineProperties(this,{type:{value:e,enumerable:!0,configurable:!0},sourceEvent:{value:t,enumerable:!0,configurable:!0},target:{value:n,enumerable:!0,configurable:!0},transform:{value:r,enumerable:!0,configurable:!0},_:{value:i}})}function sa(e,t,n){this.k=e,this.x=t,this.y=n}sa.prototype={constructor:sa,scale:function(e){return e===1?this:new sa(this.k*e,this.x,this.y)},translate:function(e,t){return e===0&t===0?this:new sa(this.k,this.x+this.k*e,this.y+this.k*t)},apply:function(e){return[e[0]*this.k+this.x,e[1]*this.k+this.y]},applyX:function(e){return e*this.k+this.x},applyY:function(e){return e*this.k+this.y},invert:function(e){return[(e[0]-this.x)/this.k,(e[1]-this.y)/this.k]},invertX:function(e){return(e-this.x)/this.k},invertY:function(e){return(e-this.y)/this.k},rescaleX:function(e){return e.copy().domain(e.range().map(this.invertX,this).map(e.invert,e))},rescaleY:function(e){return e.copy().domain(e.range().map(this.invertY,this).map(e.invert,e))},toString:function(){return`translate(`+this.x+`,`+this.y+`) scale(`+this.k+`)`}};var ca=new sa(1,0,0);la.prototype=sa.prototype;function la(e){for(;!e.__zoom;)if(!(e=e.parentNode))return ca;return e.__zoom}function ua(e){e.stopImmediatePropagation()}function da(e){e.preventDefault(),e.stopImmediatePropagation()}function fa(e){return(!e.ctrlKey||e.type===`wheel`)&&!e.button}function pa(){var e=this;return e instanceof SVGElement?(e=e.ownerSVGElement||e,e.hasAttribute(`viewBox`)?(e=e.viewBox.baseVal,[[e.x,e.y],[e.x+e.width,e.y+e.height]]):[[0,0],[e.width.baseVal.value,e.height.baseVal.value]]):[[0,0],[e.clientWidth,e.clientHeight]]}function ma(){return this.__zoom||ca}function ha(e){return-e.deltaY*(e.deltaMode===1?.05:e.deltaMode?1:.002)*(e.ctrlKey?10:1)}function ga(){return navigator.maxTouchPoints||`ontouchstart`in this}function _a(e,t,n){var r=e.invertX(t[0][0])-n[0][0],i=e.invertX(t[1][0])-n[1][0],a=e.invertY(t[0][1])-n[0][1],o=e.invertY(t[1][1])-n[1][1];return e.translate(i>r?(r+i)/2:Math.min(0,r)||Math.max(0,i),o>a?(a+o)/2:Math.min(0,a)||Math.max(0,o))}function va(){var e=fa,t=pa,n=_a,r=ha,i=ga,a=[0,1/0],o=[[-1/0,-1/0],[1/0,1/0]],s=250,c=yr,l=w(`start`,`zoom`,`end`),u,d,f,p=500,m=150,h=0,g=10;function _(e){e.property(`__zoom`,ma).on(`wheel.zoom`,T,{passive:!1}).on(`mousedown.zoom`,E).on(`dblclick.zoom`,D).filter(i).on(`touchstart.zoom`,O).on(`touchmove.zoom`,k).on(`touchend.zoom touchcancel.zoom`,A).style(`-webkit-tap-highlight-color`,`rgba(0,0,0,0)`)}_.transform=function(e,t,n,r){var i=e.selection?e.selection():e;i.property(`__zoom`,ma),e===i?i.interrupt().each(function(){S(this,arguments).event(r).start().zoom(null,typeof t==`function`?t.apply(this,arguments):t).end()}):x(e,t,n,r)},_.scaleBy=function(e,t,n,r){_.scaleTo(e,function(){return this.__zoom.k*(typeof t==`function`?t.apply(this,arguments):t)},n,r)},_.scaleTo=function(e,r,i,a){_.transform(e,function(){var e=t.apply(this,arguments),a=this.__zoom,s=i==null?b(e):typeof i==`function`?i.apply(this,arguments):i,c=a.invert(s),l=typeof r==`function`?r.apply(this,arguments):r;return n(y(v(a,l),s,c),e,o)},i,a)},_.translateBy=function(e,r,i,a){_.transform(e,function(){return n(this.__zoom.translate(typeof r==`function`?r.apply(this,arguments):r,typeof i==`function`?i.apply(this,arguments):i),t.apply(this,arguments),o)},null,a)},_.translateTo=function(e,r,i,a,s){_.transform(e,function(){var e=t.apply(this,arguments),s=this.__zoom,c=a==null?b(e):typeof a==`function`?a.apply(this,arguments):a;return n(ca.translate(c[0],c[1]).scale(s.k).translate(typeof r==`function`?-r.apply(this,arguments):-r,typeof i==`function`?-i.apply(this,arguments):-i),e,o)},a,s)};function v(e,t){return t=Math.max(a[0],Math.min(a[1],t)),t===e.k?e:new sa(t,e.x,e.y)}function y(e,t,n){var r=t[0]-n[0]*e.k,i=t[1]-n[1]*e.k;return r===e.x&&i===e.y?e:new sa(e.k,r,i)}function b(e){return[(+e[0][0]+ +e[1][0])/2,(+e[0][1]+ +e[1][1])/2]}function x(e,n,r,i){e.on(`start.zoom`,function(){S(this,arguments).event(i).start()}).on(`interrupt.zoom end.zoom`,function(){S(this,arguments).event(i).end()}).tween(`zoom`,function(){var e=this,a=arguments,o=S(e,a).event(i),s=t.apply(e,a),l=r==null?b(s):typeof r==`function`?r.apply(e,a):r,u=Math.max(s[1][0]-s[0][0],s[1][1]-s[0][1]),d=e.__zoom,f=typeof n==`function`?n.apply(e,a):n,p=c(d.invert(l).concat(u/d.k),f.invert(l).concat(u/f.k));return function(e){if(e===1)e=f;else{var t=p(e),n=u/t[2];e=new sa(n,l[0]-t[0]*n,l[1]-t[1]*n)}o.zoom(null,e)}})}function S(e,t,n){return!n&&e.__zooming||new C(e,t)}function C(e,n){this.that=e,this.args=n,this.active=0,this.sourceEvent=null,this.extent=t.apply(e,n),this.taps=0}C.prototype={event:function(e){return e&&(this.sourceEvent=e),this},start:function(){return++this.active===1&&(this.that.__zooming=this,this.emit(`start`)),this},zoom:function(e,t){return this.mouse&&e!==`mouse`&&(this.mouse[1]=t.invert(this.mouse[0])),this.touch0&&e!==`touch`&&(this.touch0[1]=t.invert(this.touch0[0])),this.touch1&&e!==`touch`&&(this.touch1[1]=t.invert(this.touch1[0])),this.that.__zoom=t,this.emit(`zoom`),this},end:function(){return--this.active===0&&(delete this.that.__zooming,this.emit(`end`)),this},emit:function(e){var t=Ht(this.that).datum();l.call(e,this.that,new oa(e,{sourceEvent:this.sourceEvent,target:_,type:e,transform:this.that.__zoom,dispatch:l}),t)}};function T(t,...i){if(!e.apply(this,arguments))return;var s=S(this,i).event(t),c=this.__zoom,l=Math.max(a[0],Math.min(a[1],c.k*2**r.apply(this,arguments))),u=P(t);if(s.wheel)(s.mouse[0][0]!==u[0]||s.mouse[0][1]!==u[1])&&(s.mouse[1]=c.invert(s.mouse[0]=u)),clearTimeout(s.wheel);else if(c.k===l)return;else s.mouse=[u,c.invert(u)],Jr(this),s.start();da(t),s.wheel=setTimeout(d,m),s.zoom(`mouse`,n(y(v(c,l),s.mouse[0],s.mouse[1]),s.extent,o));function d(){s.wheel=null,s.end()}}function E(t,...r){if(f||!e.apply(this,arguments))return;var i=t.currentTarget,a=S(this,r,!0).event(t),s=Ht(t.view).on(`mousemove.zoom`,d,!0).on(`mouseup.zoom`,p,!0),c=P(t,i),l=t.clientX,u=t.clientY;qt(t.view),ua(t),a.mouse=[c,this.__zoom.invert(c)],Jr(this),a.start();function d(e){if(da(e),!a.moved){var t=e.clientX-l,r=e.clientY-u;a.moved=t*t+r*r>h}a.event(e).zoom(`mouse`,n(y(a.that.__zoom,a.mouse[0]=P(e,i),a.mouse[1]),a.extent,o))}function p(e){s.on(`mousemove.zoom mouseup.zoom`,null),Jt(e.view,a.moved),da(e),a.event(e).end()}}function D(r,...i){if(e.apply(this,arguments)){var a=this.__zoom,c=P(r.changedTouches?r.changedTouches[0]:r,this),l=a.invert(c),u=a.k*(r.shiftKey?.5:2),d=n(y(v(a,u),c,l),t.apply(this,i),o);da(r),s>0?Ht(this).transition().duration(s).call(x,d,c,r):Ht(this).call(_.transform,d,c,r)}}function O(t,...n){if(e.apply(this,arguments)){var r=t.touches,i=r.length,a=S(this,n,t.changedTouches.length===i).event(t),o,s,c,l;for(ua(t),s=0;s<i;++s)c=r[s],l=P(c,this),l=[l,this.__zoom.invert(l),c.identifier],a.touch0?!a.touch1&&a.touch0[2]!==l[2]&&(a.touch1=l,a.taps=0):(a.touch0=l,o=!0,a.taps=1+!!u);u&&=clearTimeout(u),o&&(a.taps<2&&(d=l[0],u=setTimeout(function(){u=null},p)),Jr(this),a.start())}}function k(e,...t){if(this.__zooming){var r=S(this,t).event(e),i=e.changedTouches,a=i.length,s,c,l,u;for(da(e),s=0;s<a;++s)c=i[s],l=P(c,this),r.touch0&&r.touch0[2]===c.identifier?r.touch0[0]=l:r.touch1&&r.touch1[2]===c.identifier&&(r.touch1[0]=l);if(c=r.that.__zoom,r.touch1){var d=r.touch0[0],f=r.touch0[1],p=r.touch1[0],m=r.touch1[1],h=(h=p[0]-d[0])*h+(h=p[1]-d[1])*h,g=(g=m[0]-f[0])*g+(g=m[1]-f[1])*g;c=v(c,Math.sqrt(h/g)),l=[(d[0]+p[0])/2,(d[1]+p[1])/2],u=[(f[0]+m[0])/2,(f[1]+m[1])/2]}else if(r.touch0)l=r.touch0[0],u=r.touch0[1];else return;r.zoom(`touch`,n(y(c,l,u),r.extent,o))}}function A(e,...t){if(this.__zooming){var n=S(this,t).event(e),r=e.changedTouches,i=r.length,a,o;for(ua(e),f&&clearTimeout(f),f=setTimeout(function(){f=null},p),a=0;a<i;++a)o=r[a],n.touch0&&n.touch0[2]===o.identifier?delete n.touch0:n.touch1&&n.touch1[2]===o.identifier&&delete n.touch1;if(n.touch1&&!n.touch0&&(n.touch0=n.touch1,delete n.touch1),n.touch0)n.touch0[1]=this.__zoom.invert(n.touch0[0]);else if(n.end(),n.taps===2&&(o=P(o,this),Math.hypot(d[0]-o[0],d[1]-o[1])<g)){var s=Ht(this).on(`dblclick.zoom`);s&&s.apply(this,arguments)}}}return _.wheelDelta=function(e){return arguments.length?(r=typeof e==`function`?e:aa(+e),_):r},_.filter=function(t){return arguments.length?(e=typeof t==`function`?t:aa(!!t),_):e},_.touchable=function(e){return arguments.length?(i=typeof e==`function`?e:aa(!!e),_):i},_.extent=function(e){return arguments.length?(t=typeof e==`function`?e:aa([[+e[0][0],+e[0][1]],[+e[1][0],+e[1][1]]]),_):t},_.scaleExtent=function(e){return arguments.length?(a[0]=+e[0],a[1]=+e[1],_):[a[0],a[1]]},_.translateExtent=function(e){return arguments.length?(o[0][0]=+e[0][0],o[1][0]=+e[1][0],o[0][1]=+e[0][1],o[1][1]=+e[1][1],_):[[o[0][0],o[0][1]],[o[1][0],o[1][1]]]},_.constrain=function(e){return arguments.length?(n=e,_):n},_.duration=function(e){return arguments.length?(s=+e,_):s},_.interpolate=function(e){return arguments.length?(c=e,_):c},_.on=function(){var e=l.on.apply(l,arguments);return e===l?_:e},_.clickDistance=function(e){return arguments.length?(h=(e=+e)*e,_):Math.sqrt(h)},_.tapDistance=function(e){return arguments.length?(g=+e,_):g},_}var ya={error001:(e=`react`)=>`Seems like you have not used ${e===`svelte`?`SvelteFlowProvider`:`ReactFlowProvider`} as an ancestor. Help: https://${e}flow.dev/error#001`,error002:()=>`It looks like you've created a new nodeTypes or edgeTypes object. If this wasn't on purpose please define the nodeTypes/edgeTypes outside of the component or memoize them.`,error003:e=>`Node type "${e}" not found. Using fallback type "default".`,error004:()=>`The parent container needs a width and a height to render the graph.`,error005:()=>`Only child nodes can use a parent extent.`,error006:()=>`Can't create edge. An edge needs a source and a target.`,error007:e=>`The old edge with id=${e} does not exist.`,error009:e=>`Marker type "${e}" doesn't exist.`,error008:(e,{id:t,sourceHandle:n,targetHandle:r})=>`Couldn't create edge for ${e} handle id: "${e===`source`?n:r}", edge id: ${t}.`,error010:()=>`Handle: No node id found. Make sure to only use a Handle inside a custom Node.`,error011:e=>`Edge type "${e}" not found. Using fallback type "default".`,error012:e=>`Node with id "${e}" does not exist, it may have been removed. This can happen when a node is deleted before the "onNodeClick" handler is called.`,error013:(e=`react`)=>`It seems that you haven't loaded the styles. Please import '@xyflow/${e}/dist/style.css' or base.css to make sure everything is working properly.`,error014:()=>`useNodeConnections: No node ID found. Call useNodeConnections inside a custom Node or provide a node ID.`,error015:()=>`It seems that you are trying to drag a node that is not initialized. Please use onNodesChange as explained in the docs.`,error016:e=>`Edge with id "${e}" does not exist, it may have been removed. This can happen when an edge is deleted before the "onEdgeClick" handler is called.`},ba=[[-1/0,-1/0],[1/0,1/0]],xa=[`Enter`,` `,`Escape`],Sa={"node.a11yDescription.default":`Press enter or space to select a node. Press delete to remove it and escape to cancel.`,"node.a11yDescription.keyboardDisabled":`Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.`,"node.a11yDescription.ariaLiveMessage":({direction:e,x:t,y:n})=>`Moved selected node ${e}. New position, x: ${t}, y: ${n}`,"edge.a11yDescription.default":`Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.`,"controls.ariaLabel":`Control Panel`,"controls.zoomIn.ariaLabel":`Zoom In`,"controls.zoomOut.ariaLabel":`Zoom Out`,"controls.fitView.ariaLabel":`Fit View`,"controls.interactive.ariaLabel":`Toggle Interactivity`,"minimap.ariaLabel":`Mini Map`,"handle.ariaLabel":`Handle`},Ca;(function(e){e.Strict=`strict`,e.Loose=`loose`})(Ca||={});var wa;(function(e){e.Free=`free`,e.Vertical=`vertical`,e.Horizontal=`horizontal`})(wa||={});var Ta;(function(e){e.Partial=`partial`,e.Full=`full`})(Ta||={});var Ea={inProgress:!1,isValid:null,from:null,fromHandle:null,fromPosition:null,fromNode:null,to:null,toHandle:null,toPosition:null,toNode:null,pointer:null},Da;(function(e){e.Bezier=`default`,e.Straight=`straight`,e.Step=`step`,e.SmoothStep=`smoothstep`,e.SimpleBezier=`simplebezier`})(Da||={});var Oa;(function(e){e.Arrow=`arrow`,e.ArrowClosed=`arrowclosed`})(Oa||={});var H;(function(e){e.Left=`left`,e.Top=`top`,e.Right=`right`,e.Bottom=`bottom`})(H||={});var ka={[H.Left]:H.Right,[H.Right]:H.Left,[H.Top]:H.Bottom,[H.Bottom]:H.Top};function Aa(e){return e===null?null:e?`valid`:`invalid`}var ja=e=>`id`in e&&`source`in e&&`target`in e,Ma=e=>`id`in e&&`position`in e&&!(`source`in e)&&!(`target`in e),Na=e=>`id`in e&&`internals`in e&&!(`source`in e)&&!(`target`in e),Pa=(e,t=[0,0])=>{let{width:n,height:r}=po(e),i=e.origin??t,a=n*i[0],o=r*i[1];return{x:e.position.x-a,y:e.position.y-o}},Fa=(e,t={nodeOrigin:[0,0]})=>e.length===0?{x:0,y:0,width:0,height:0}:Xa(e.reduce((e,n)=>{let r=typeof n==`string`,i=!t.nodeLookup&&!r?n:void 0;return t.nodeLookup&&(i=r?t.nodeLookup.get(n):Na(n)?n:t.nodeLookup.get(n.id)),Ja(e,i?Qa(i,t.nodeOrigin):{x:0,y:0,x2:0,y2:0})},{x:1/0,y:1/0,x2:-1/0,y2:-1/0})),Ia=(e,t={})=>{let n={x:1/0,y:1/0,x2:-1/0,y2:-1/0},r=!1;return e.forEach(e=>{(t.filter===void 0||t.filter(e))&&(n=Ja(n,Qa(e)),r=!0)}),r?Xa(n):{x:0,y:0,width:0,height:0}},La=(e,t,[n,r,i]=[0,0,1],a=!1,o=!1)=>{let s=(t.x-n)/i,c=(t.y-r)/i,l=t.width/i,u=t.height/i,d=[];for(let t of e.values()){let{measured:e,selectable:n=!0,hidden:r=!1}=t;if(o&&!n||r)continue;let i=e.width??t.width??t.initialWidth??0,f=e.height??t.height??t.initialHeight??0,{x:p,y:m}=t.internals.positionAbsolute,h=eo(s,c,l,u,p,m,i,f),g=i*f,_=a&&h>0;(!t.internals.handleBounds||_||h>=g||t.dragging)&&d.push(t)}return d},Ra=(e,t)=>{let n=new Set;return e.forEach(e=>{n.add(e.id)}),t.filter(e=>n.has(e.source)||n.has(e.target))};function za(e,t){let n=new Map,r=t?.nodes?new Set(t.nodes.map(e=>e.id)):null;return e.forEach(e=>{e.measured.width&&e.measured.height&&(t?.includeHiddenNodes||!e.hidden)&&(!r||r.has(e.id))&&n.set(e.id,e)}),n}async function Ba({nodes:e,width:t,height:n,panZoom:r,minZoom:i,maxZoom:a},o){if(e.size===0)return!0;let s=W(Ia(za(e,o)),t,n,o?.minZoom??i,o?.maxZoom??a,o?.padding??.1);return await r.setViewport(s,{duration:o?.duration,ease:o?.ease,interpolate:o?.interpolate}),!0}function Va({nodeId:e,nextPosition:t,nodeLookup:n,nodeOrigin:r=[0,0],nodeExtent:i,onError:a}){let o=n.get(e),s=o.parentId?n.get(o.parentId):void 0,{x:c,y:l}=s?s.internals.positionAbsolute:{x:0,y:0},u=o.origin??r,d=o.extent||i;if(o.extent===`parent`&&!o.expandParent)if(!s)a?.(`005`,ya.error005());else{let e=s.measured.width,t=s.measured.height;e&&t&&(d=[[c,l],[c+e,l+t]])}else s&&fo(o.extent)&&(d=[[o.extent[0][0]+c,o.extent[0][1]+l],[o.extent[1][0]+c,o.extent[1][1]+l]]);let f=fo(d)?Wa(t,d,o.measured):t;return(o.measured.width===void 0||o.measured.height===void 0)&&a?.(`015`,ya.error015()),{position:{x:f.x-c+(o.measured.width??0)*u[0],y:f.y-l+(o.measured.height??0)*u[1]},positionAbsolute:f}}async function Ha({nodesToRemove:e=[],edgesToRemove:t=[],nodes:n,edges:r,onBeforeDelete:i}){let a=new Set(e.map(e=>e.id)),o=[];for(let e of n){if(e.deletable===!1)continue;let t=a.has(e.id),n=!t&&e.parentId&&o.find(t=>t.id===e.parentId);(t||n)&&o.push(e)}let s=new Set(t.map(e=>e.id)),c=r.filter(e=>e.deletable!==!1),l=Ra(o,c);for(let e of c)s.has(e.id)&&!l.find(t=>t.id===e.id)&&l.push(e);if(!i)return{edges:l,nodes:o};let u=await i({nodes:o,edges:l});return typeof u==`boolean`?u?{edges:l,nodes:o}:{edges:[],nodes:[]}:u}var Ua=(e,t=0,n=1)=>Math.min(Math.max(e,t),n),Wa=(e={x:0,y:0},t,n)=>({x:Ua(e.x,t[0][0],t[1][0]-(n?.width??0)),y:Ua(e.y,t[0][1],t[1][1]-(n?.height??0))});function Ga(e,t,n){let{width:r,height:i}=po(n),{x:a,y:o}=n.internals.positionAbsolute;return Wa(e,[[a,o],[a+r,o+i]],t)}var Ka=(e,t,n)=>e<t?Ua(Math.abs(e-t),1,t)/t:e>n?-Ua(Math.abs(e-n),1,t)/t:0,qa=(e,t,n=15,r=40)=>[Ka(e.x,r,t.width-r)*n,Ka(e.y,r,t.height-r)*n],Ja=(e,t)=>({x:Math.min(e.x,t.x),y:Math.min(e.y,t.y),x2:Math.max(e.x2,t.x2),y2:Math.max(e.y2,t.y2)}),Ya=({x:e,y:t,width:n,height:r})=>({x:e,y:t,x2:e+n,y2:t+r}),Xa=({x:e,y:t,x2:n,y2:r})=>({x:e,y:t,width:n-e,height:r-t}),Za=(e,t=[0,0])=>{let{x:n,y:r}=Na(e)?e.internals.positionAbsolute:Pa(e,t);return{x:n,y:r,width:e.measured?.width??e.width??e.initialWidth??0,height:e.measured?.height??e.height??e.initialHeight??0}},Qa=(e,t=[0,0])=>{let{x:n,y:r}=Na(e)?e.internals.positionAbsolute:Pa(e,t);return{x:n,y:r,x2:n+(e.measured?.width??e.width??e.initialWidth??0),y2:r+(e.measured?.height??e.height??e.initialHeight??0)}},$a=(e,t)=>Xa(Ja(Ya(e),Ya(t))),eo=(e,t,n,r,i,a,o,s)=>{let c=Math.max(0,Math.min(e+n,i+o)-Math.max(e,i)),l=Math.max(0,Math.min(t+r,a+s)-Math.max(t,a));return Math.ceil(c*l)},to=(e,t)=>eo(e.x,e.y,e.width,e.height,t.x,t.y,t.width,t.height),no=e=>ro(e.width)&&ro(e.height)&&ro(e.x)&&ro(e.y),ro=e=>!isNaN(e)&&isFinite(e),io=(e,t)=>(e,t)=>{},ao=(e,t=[1,1])=>({x:t[0]*Math.round(e.x/t[0]),y:t[1]*Math.round(e.y/t[1])}),oo=({x:e,y:t},[n,r,i],a=!1,o=[1,1])=>{let s={x:(e-n)/i,y:(t-r)/i};return a?ao(s,o):s},so=({x:e,y:t},[n,r,i])=>({x:e*i+n,y:t*i+r});function co(e,t){if(typeof e==`number`)return Math.floor((t-t/(1+e))*.5);if(typeof e==`string`&&e.endsWith(`px`)){let t=parseFloat(e);if(!Number.isNaN(t))return Math.floor(t)}if(typeof e==`string`&&e.endsWith(`%`)){let n=parseFloat(e);if(!Number.isNaN(n))return Math.floor(t*n*.01)}return console.error(`The padding value "${e}" is invalid. Please provide a number or a string with a valid unit (px or %).`),0}function lo(e,t,n){if(typeof e==`string`||typeof e==`number`){let r=co(e,n),i=co(e,t);return{top:r,right:i,bottom:r,left:i,x:i*2,y:r*2}}if(typeof e==`object`){let r=co(e.top??e.y??0,n),i=co(e.bottom??e.y??0,n),a=co(e.left??e.x??0,t),o=co(e.right??e.x??0,t);return{top:r,right:o,bottom:i,left:a,x:a+o,y:r+i}}return{top:0,right:0,bottom:0,left:0,x:0,y:0}}function U(e,t,n,r,i,a){let{x:o,y:s}=so(e,[t,n,r]),{x:c,y:l}=so({x:e.x+e.width,y:e.y+e.height},[t,n,r]),u=i-c,d=a-l;return{left:Math.floor(o),top:Math.floor(s),right:Math.floor(u),bottom:Math.floor(d)}}var W=(e,t,n,r,i,a)=>{let o=lo(a,t,n),s=(t-o.x)/e.width,c=(n-o.y)/e.height,l=Ua(Math.min(s,c),r,i),u=e.x+e.width/2,d=e.y+e.height/2,f=t/2-u*l,p=n/2-d*l,m=U(e,f,p,l,t,n),h={left:Math.min(m.left-o.left,0),top:Math.min(m.top-o.top,0),right:Math.min(m.right-o.right,0),bottom:Math.min(m.bottom-o.bottom,0)};return{x:f-h.left+h.right,y:p-h.top+h.bottom,zoom:l}},uo=()=>typeof navigator<`u`&&navigator?.userAgent?.indexOf(`Mac`)>=0;function fo(e){return e!=null&&e!==`parent`}function po(e){return{width:e.measured?.width??e.width??e.initialWidth??0,height:e.measured?.height??e.height??e.initialHeight??0}}function mo(e){return(e.measured?.width??e.width??e.initialWidth)!==void 0&&(e.measured?.height??e.height??e.initialHeight)!==void 0}function ho(e,t={width:0,height:0},n,r,i){let a={...e},o=r.get(n);if(o){let e=o.origin||i;a.x+=o.internals.positionAbsolute.x-(t.width??0)*e[0],a.y+=o.internals.positionAbsolute.y-(t.height??0)*e[1]}return a}function go(e,t){if(e.size!==t.size)return!1;for(let n of e)if(!t.has(n))return!1;return!0}function _o(){let e,t;return{promise:new Promise((n,r)=>{e=n,t=r}),resolve:e,reject:t}}function vo(e){return{...Sa,...e||{}}}function yo(e,{snapGrid:t=[0,0],snapToGrid:n=!1,transform:r,containerBounds:i}){let{x:a,y:o}=To(e),s=oo({x:a-(i?.left??0),y:o-(i?.top??0)},r),{x:c,y:l}=n?ao(s,t):s;return{xSnapped:c,ySnapped:l,...s}}var bo=e=>({width:e.offsetWidth,height:e.offsetHeight}),xo=e=>e?.getRootNode?.()||window?.document,So=[`INPUT`,`SELECT`,`TEXTAREA`];function Co(e){let t=e.composedPath?.()?.[0]||e.target;return t?.nodeType===1?So.includes(t.nodeName)||t.hasAttribute(`contenteditable`)||!!t.closest(`.nokey`):!1}var wo=e=>`clientX`in e,To=(e,t)=>{let n=wo(e),r=n?e.clientX:e.touches?.[0].clientX,i=n?e.clientY:e.touches?.[0].clientY;return{x:r-(t?.left??0),y:i-(t?.top??0)}},Eo=(e,t,n,r,i)=>{let a=t.querySelectorAll(`.${e}`);return!a||!a.length?null:Array.from(a).map(t=>{let a=t.getBoundingClientRect();return{id:t.getAttribute(`data-handleid`),type:e,nodeId:i,position:t.getAttribute(`data-handlepos`),x:(a.left-n.left)/r,y:(a.top-n.top)/r,...bo(t)}})};function Do({sourceX:e,sourceY:t,targetX:n,targetY:r,sourceControlX:i,sourceControlY:a,targetControlX:o,targetControlY:s}){let c=e*.125+i*.375+o*.375+n*.125,l=t*.125+a*.375+s*.375+r*.125;return[c,l,Math.abs(c-e),Math.abs(l-t)]}function Oo(e,t){return e>=0?.5*e:t*25*Math.sqrt(-e)}function ko({pos:e,x1:t,y1:n,x2:r,y2:i,c:a}){switch(e){case H.Left:return[t-Oo(t-r,a),n];case H.Right:return[t+Oo(r-t,a),n];case H.Top:return[t,n-Oo(n-i,a)];case H.Bottom:return[t,n+Oo(i-n,a)]}}function Ao({sourceX:e,sourceY:t,sourcePosition:n=H.Bottom,targetX:r,targetY:i,targetPosition:a=H.Top,curvature:o=.25}){let[s,c]=ko({pos:n,x1:e,y1:t,x2:r,y2:i,c:o}),[l,u]=ko({pos:a,x1:r,y1:i,x2:e,y2:t,c:o}),[d,f,p,m]=Do({sourceX:e,sourceY:t,targetX:r,targetY:i,sourceControlX:s,sourceControlY:c,targetControlX:l,targetControlY:u});return[`M${e},${t} C${s},${c} ${l},${u} ${r},${i}`,d,f,p,m]}function jo({sourceX:e,sourceY:t,targetX:n,targetY:r}){let i=Math.abs(n-e)/2,a=n<e?n+i:n-i,o=Math.abs(r-t)/2;return[a,r<t?r+o:r-o,i,o]}function Mo({sourceNode:e,targetNode:t,selected:n=!1,zIndex:r=0,elevateOnSelect:i=!1,zIndexMode:a=`basic`}){return a===`manual`?r:(i&&n?r+1e3:r)+Math.max(e.parentId||i&&e.selected?e.internals.z:0,t.parentId||i&&t.selected?t.internals.z:0)}function No({sourceNode:e,targetNode:t,width:n,height:r,transform:i}){let a=Ja(Qa(e),Qa(t));return a.x===a.x2&&(a.x2+=1),a.y===a.y2&&(a.y2+=1),to({x:-i[0]/i[2],y:-i[1]/i[2],width:n/i[2],height:r/i[2]},Xa(a))>0}var Po=({source:e,sourceHandle:t,target:n,targetHandle:r})=>`xy-edge__${e}${t||``}-${n}${r||``}`,Fo=(e,t)=>t.some(t=>t.source===e.source&&t.target===e.target&&(t.sourceHandle===e.sourceHandle||!t.sourceHandle&&!e.sourceHandle)&&(t.targetHandle===e.targetHandle||!t.targetHandle&&!e.targetHandle)),Io=(e,t,n={})=>{if(!e.source||!e.target)return n.onError?.(`006`,ya.error006()),t;let r=n.getEdgeId||Po,i;return i=ja(e)?{...e}:{...e,id:r(e)},Fo(i,t)?t:(i.sourceHandle===null&&delete i.sourceHandle,i.targetHandle===null&&delete i.targetHandle,t.concat(i))};function Lo({sourceX:e,sourceY:t,targetX:n,targetY:r}){let[i,a,o,s]=jo({sourceX:e,sourceY:t,targetX:n,targetY:r});return[`M ${e},${t}L ${n},${r}`,i,a,o,s]}var Ro={[H.Left]:{x:-1,y:0},[H.Right]:{x:1,y:0},[H.Top]:{x:0,y:-1},[H.Bottom]:{x:0,y:1}},zo=({source:e,sourcePosition:t=H.Bottom,target:n})=>t===H.Left||t===H.Right?e.x<n.x?{x:1,y:0}:{x:-1,y:0}:e.y<n.y?{x:0,y:1}:{x:0,y:-1},Bo=(e,t)=>Math.sqrt((t.x-e.x)**2+(t.y-e.y)**2);function Vo({source:e,sourcePosition:t=H.Bottom,target:n,targetPosition:r=H.Top,center:i,offset:a,stepPosition:o}){let s=Ro[t],c=Ro[r],l={x:e.x+s.x*a,y:e.y+s.y*a},u={x:n.x+c.x*a,y:n.y+c.y*a},d=zo({source:l,sourcePosition:t,target:u}),f=d.x===0?`y`:`x`,p=d[f],m=[],h,g,_={x:0,y:0},v={x:0,y:0},[,,y,b]=jo({sourceX:e.x,sourceY:e.y,targetX:n.x,targetY:n.y});if(s[f]*c[f]===-1){f===`x`?(h=i.x??l.x+(u.x-l.x)*o,g=i.y??(l.y+u.y)/2):(h=i.x??(l.x+u.x)/2,g=i.y??l.y+(u.y-l.y)*o);let e=[{x:h,y:l.y},{x:h,y:u.y}],t=[{x:l.x,y:g},{x:u.x,y:g}];m=s[f]===p?f===`x`?e:t:f===`x`?t:e}else{let i=[{x:l.x,y:u.y}],o=[{x:u.x,y:l.y}];if(m=f===`x`?s.x===p?o:i:s.y===p?i:o,t===r){let t=Math.abs(e[f]-n[f]);if(t<=a){let r=Math.min(a-1,a-t);s[f]===p?_[f]=(l[f]>e[f]?-1:1)*r:v[f]=(u[f]>n[f]?-1:1)*r}}if(t!==r){let e=f===`x`?`y`:`x`,t=s[f]===c[e],n=l[e]>u[e],r=l[e]<u[e];(s[f]===1&&(!t&&n||t&&r)||s[f]!==1&&(!t&&r||t&&n))&&(m=f===`x`?i:o)}let d={x:l.x+_.x,y:l.y+_.y},y={x:u.x+v.x,y:u.y+v.y};Math.max(Math.abs(d.x-m[0].x),Math.abs(y.x-m[0].x))>=Math.max(Math.abs(d.y-m[0].y),Math.abs(y.y-m[0].y))?(h=(d.x+y.x)/2,g=m[0].y):(h=m[0].x,g=(d.y+y.y)/2)}let x={x:l.x+_.x,y:l.y+_.y},S={x:u.x+v.x,y:u.y+v.y};return[[e,...x.x!==m[0].x||x.y!==m[0].y?[x]:[],...m,...S.x!==m[m.length-1].x||S.y!==m[m.length-1].y?[S]:[],n],h,g,y,b]}function Ho(e,t,n,r){let i=Math.min(Bo(e,t)/2,Bo(t,n)/2,r),{x:a,y:o}=t;if(e.x===a&&a===n.x||e.y===o&&o===n.y)return`L${a} ${o}`;if(e.y===o){let t=e.x<n.x?-1:1,r=e.y<n.y?1:-1;return`L ${a+i*t},${o}Q ${a},${o} ${a},${o+i*r}`}let s=e.x<n.x?1:-1;return`L ${a},${o+i*(e.y<n.y?-1:1)}Q ${a},${o} ${a+i*s},${o}`}function Uo({sourceX:e,sourceY:t,sourcePosition:n=H.Bottom,targetX:r,targetY:i,targetPosition:a=H.Top,borderRadius:o=5,centerX:s,centerY:c,offset:l=20,stepPosition:u=.5}){let[d,f,p,m,h]=Vo({source:{x:e,y:t},sourcePosition:n,target:{x:r,y:i},targetPosition:a,center:{x:s,y:c},offset:l,stepPosition:u}),g=`M${d[0].x} ${d[0].y}`;for(let e=1;e<d.length-1;e++)g+=Ho(d[e-1],d[e],d[e+1],o);return g+=`L${d[d.length-1].x} ${d[d.length-1].y}`,[g,f,p,m,h]}function Wo(e){return e&&!!(e.internals.handleBounds||e.handles?.length)&&!!(e.measured.width||e.width||e.initialWidth)}function Go(e){let{sourceNode:t,targetNode:n}=e;if(!Wo(t)||!Wo(n))return null;let r=t.internals.handleBounds||Ko(t.handles),i=n.internals.handleBounds||Ko(n.handles),a=Jo(r?.source??[],e.sourceHandle),o=Jo(e.connectionMode===Ca.Strict?i?.target??[]:(i?.target??[]).concat(i?.source??[]),e.targetHandle);if(!a||!o)return e.onError?.(`008`,ya.error008(a?`target`:`source`,{id:e.id,sourceHandle:e.sourceHandle,targetHandle:e.targetHandle})),null;let s=a?.position||H.Bottom,c=o?.position||H.Top,l=qo(t,a,s),u=qo(n,o,c);return{sourceX:l.x,sourceY:l.y,targetX:u.x,targetY:u.y,sourcePosition:s,targetPosition:c}}function Ko(e){if(!e)return null;let t=[],n=[];for(let r of e)r.width=r.width??1,r.height=r.height??1,r.type===`source`?t.push(r):r.type===`target`&&n.push(r);return{source:t,target:n}}function qo(e,t,n=H.Left,r=!1){let i=(t?.x??0)+e.internals.positionAbsolute.x,a=(t?.y??0)+e.internals.positionAbsolute.y,{width:o,height:s}=t??po(e);if(r)return{x:i+o/2,y:a+s/2};switch(t?.position??n){case H.Top:return{x:i+o/2,y:a};case H.Right:return{x:i+o,y:a+s/2};case H.Bottom:return{x:i+o/2,y:a+s};case H.Left:return{x:i,y:a+s/2}}}function Jo(e,t){return e&&(t?e.find(e=>e.id===t):e[0])||null}function Yo(e,t){return e?typeof e==`string`?e:`${t?`${t}__`:``}${Object.keys(e).sort().map(t=>`${t}=${e[t]}`).join(`&`)}`:``}function Xo(e,{id:t,defaultColor:n,defaultMarkerStart:r,defaultMarkerEnd:i}){let a=new Set;return e.reduce((e,o)=>([o.markerStart||r,o.markerEnd||i].forEach(r=>{if(r&&typeof r==`object`){let i=Yo(r,t);a.has(i)||(e.push({id:i,color:r.color||n,...r}),a.add(i))}}),e),[]).sort((e,t)=>e.id.localeCompare(t.id))}var Zo=1e3,Qo=10,$o={nodeOrigin:[0,0],nodeExtent:ba,elevateNodesOnSelect:!0,zIndexMode:`basic`,defaults:{}},es={...$o,checkEquality:!0};function ts(e,t){let n={...e};for(let e in t)t[e]!==void 0&&(n[e]=t[e]);return n}function ns(e,t,n){let r=ts($o,n);for(let n of e.values())if(n.parentId)ss(n,e,t,r);else{let e=Wa(Pa(n,r.nodeOrigin),fo(n.extent)?n.extent:r.nodeExtent,po(n));n.internals.positionAbsolute=e}}function rs(e,t){if(!e.handles)return e.measured?t?.internals.handleBounds:void 0;let n=[],r=[];for(let t of e.handles){let i={id:t.id,width:t.width??1,height:t.height??1,nodeId:e.id,x:t.x,y:t.y,position:t.position,type:t.type};t.type===`source`?n.push(i):t.type===`target`&&r.push(i)}return{source:n,target:r}}function is(e){return e===`manual`}function as(e,t,n,r={}){let i=ts(es,r),a={i:0},o=new Map(t),s=i?.elevateNodesOnSelect&&!is(i.zIndexMode)?Zo:0,c=e.length>0,l=!1;t.clear(),n.clear();for(let u of e){let e=o.get(u.id);if(i.checkEquality&&u===e?.internals.userNode)t.set(u.id,e);else{let n=Wa(Pa(u,i.nodeOrigin),fo(u.extent)?u.extent:i.nodeExtent,po(u));e={...i.defaults,...u,measured:{width:u.measured?.width,height:u.measured?.height},internals:{positionAbsolute:n,handleBounds:rs(u,e),z:cs(u,s,i.zIndexMode),userNode:u}},t.set(u.id,e)}(e.measured===void 0||e.measured.width===void 0||e.measured.height===void 0)&&!e.hidden&&(c=!1),u.parentId&&ss(e,t,n,r,a),l||=u.selected??!1}return{nodesInitialized:c,hasSelectedNodes:l}}function os(e,t){if(!e.parentId)return;let n=t.get(e.parentId);n?n.set(e.id,e):t.set(e.parentId,new Map([[e.id,e]]))}function ss(e,t,n,r,i){let{elevateNodesOnSelect:a,nodeOrigin:o,nodeExtent:s,zIndexMode:c}=ts($o,r),l=e.parentId,u=t.get(l);if(!u){console.warn(`Parent node ${l} not found. Please make sure that parent nodes are in front of their child nodes in the nodes array.`);return}os(e,n),i&&!u.parentId&&u.internals.rootParentIndex===void 0&&c===`auto`&&(u.internals.rootParentIndex=++i.i,u.internals.z=u.internals.z+i.i*Qo),i&&u.internals.rootParentIndex!==void 0&&(i.i=u.internals.rootParentIndex);let{x:d,y:f,z:p}=ls(e,u,o,s,a&&!is(c)?Zo:0,c),{positionAbsolute:m}=e.internals,h=d!==m.x||f!==m.y;(h||p!==e.internals.z)&&t.set(e.id,{...e,internals:{...e.internals,positionAbsolute:h?{x:d,y:f}:m,z:p}})}function cs(e,t,n){let r=ro(e.zIndex)?e.zIndex:0;return is(n)?r:r+(e.selected?t:0)}function ls(e,t,n,r,i,a){let{x:o,y:s}=t.internals.positionAbsolute,c=po(e),l=Pa(e,n),u=fo(e.extent)?Wa(l,e.extent,c):l,d=Wa({x:o+u.x,y:s+u.y},r,c);e.extent===`parent`&&(d=Ga(d,c,t));let f=cs(e,i,a),p=t.internals.z??0;return{x:d.x,y:d.y,z:p>=f?p+1:f}}function us(e,t,n,r=[0,0]){let i=[],a=new Map;for(let n of e){let e=t.get(n.parentId);if(!e)continue;let r=$a(a.get(n.parentId)?.expandedRect??Za(e),n.rect);a.set(n.parentId,{expandedRect:r,parent:e})}return a.size>0&&a.forEach(({expandedRect:t,parent:a},o)=>{let s=a.internals.positionAbsolute,c=po(a),l=a.origin??r,u=t.x<s.x?Math.round(Math.abs(s.x-t.x)):0,d=t.y<s.y?Math.round(Math.abs(s.y-t.y)):0,f=Math.max(c.width,Math.round(t.width)),p=Math.max(c.height,Math.round(t.height)),m=(f-c.width)*l[0],h=(p-c.height)*l[1];(u>0||d>0||m||h)&&(i.push({id:o,type:`position`,position:{x:a.position.x-u+m,y:a.position.y-d+h}}),n.get(o)?.forEach(t=>{e.some(e=>e.id===t.id)||i.push({id:t.id,type:`position`,position:{x:t.position.x+u,y:t.position.y+d}})})),(c.width<t.width||c.height<t.height||u||d)&&i.push({id:o,type:`dimensions`,setAttributes:!0,dimensions:{width:f+(u?l[0]*u-m:0),height:p+(d?l[1]*d-h:0)}})}),i}function ds(e,t,n,r,i,a,o){let s=r?.querySelector(`.xyflow__viewport`),c=!1;if(!s)return{changes:[],updatedInternals:c};let l=[],u=window.getComputedStyle(s),{m22:d}=new window.DOMMatrixReadOnly(u.transform),f=[];for(let r of e.values()){let e=t.get(r.id);if(!e)continue;if(e.hidden){t.set(e.id,{...e,internals:{...e.internals,handleBounds:void 0}}),c=!0;continue}let s=bo(r.nodeElement),u=e.measured.width!==s.width||e.measured.height!==s.height;if(s.width&&s.height&&(u||!e.internals.handleBounds||r.force)){let p=r.nodeElement.getBoundingClientRect(),m=fo(e.extent)?e.extent:a,{positionAbsolute:h}=e.internals;e.parentId&&e.extent===`parent`?h=Ga(h,s,t.get(e.parentId)):m&&(h=Wa(h,m,s));let g={...e,measured:s,internals:{...e.internals,positionAbsolute:h,handleBounds:{source:Eo(`source`,r.nodeElement,p,d,e.id),target:Eo(`target`,r.nodeElement,p,d,e.id)}}};t.set(e.id,g),e.parentId&&ss(g,t,n,{nodeOrigin:i,zIndexMode:o}),c=!0,u&&(l.push({id:e.id,type:`dimensions`,dimensions:s}),e.expandParent&&e.parentId&&f.push({id:e.id,parentId:e.parentId,rect:Za(g,i)}))}}if(f.length>0){let e=us(f,t,n,i);l.push(...e)}return{changes:l,updatedInternals:c}}async function fs({delta:e,panZoom:t,transform:n,translateExtent:r,width:i,height:a}){if(!t||!e.x&&!e.y)return!1;let o=await t.setViewportConstrained({x:n[0]+e.x,y:n[1]+e.y,zoom:n[2]},[[0,0],[i,a]],r);return!!o&&(o.x!==n[0]||o.y!==n[1]||o.k!==n[2])}function ps(e,t,n,r,i,a){let o=i,s=r.get(o)||new Map;r.set(o,s.set(n,t)),o=`${i}-${e}`;let c=r.get(o)||new Map;if(r.set(o,c.set(n,t)),a){o=`${i}-${e}-${a}`;let s=r.get(o)||new Map;r.set(o,s.set(n,t))}}function ms(e,t,n){e.clear(),t.clear();for(let r of n){let{source:n,target:i,sourceHandle:a=null,targetHandle:o=null}=r,s={edgeId:r.id,source:n,target:i,sourceHandle:a,targetHandle:o},c=`${n}-${a}--${i}-${o}`;ps(`source`,s,`${i}-${o}--${n}-${a}`,e,n,a),ps(`target`,s,c,e,i,o),t.set(r.id,r)}}function hs(e,t){if(!e.parentId)return!1;let n=t.get(e.parentId);return n?n.selected?!0:hs(n,t):!1}function gs(e,t,n){let r=e;do{if(r?.matches?.(t))return!0;if(r===n)return!1;r=r?.parentElement}while(r);return!1}function _s(e,t,n,r){let i=new Map;for(let[a,o]of e)if((o.selected||o.id===r)&&(!o.parentId||!hs(o,e))&&(o.draggable||t&&o.draggable===void 0)){let t=e.get(a);t&&i.set(a,{id:a,position:t.position||{x:0,y:0},distance:{x:n.x-t.internals.positionAbsolute.x,y:n.y-t.internals.positionAbsolute.y},extent:t.extent,parentId:t.parentId,origin:t.origin,expandParent:t.expandParent,internals:{positionAbsolute:t.internals.positionAbsolute||{x:0,y:0}},measured:{width:t.measured.width??0,height:t.measured.height??0}})}return i}function vs({nodeId:e,dragItems:t,nodeLookup:n,dragging:r=!0}){let i=[];for(let[e,a]of t){let t=n.get(e)?.internals.userNode;t&&i.push({...t,position:a.position,dragging:r})}if(!e)return[i[0],i];let a=n.get(e)?.internals.userNode;return[a?{...a,position:t.get(e)?.position||a.position,dragging:r}:i[0],i]}function ys({dragItems:e,snapGrid:t,x:n,y:r}){let i=e.values().next().value;if(!i)return null;let a={x:n-i.distance.x,y:r-i.distance.y},o=ao(a,t);return{x:o.x-a.x,y:o.y-a.y}}function bs({onNodeMouseDown:e,getStoreItems:t,onDragStart:n,onDrag:r,onDragStop:i}){let a={x:null,y:null},o=0,s=new Map,c=!1,l={x:0,y:0},u=null,d=!1,f=null,p=!1,m=!1,h=null;function g({noDragClassName:g,handleSelector:_,domNode:v,isSelectable:y,nodeId:b,nodeClickDistance:x=0}){f=Ht(v);function S({x:e,y:n}){let{nodeLookup:i,nodeExtent:o,snapGrid:c,snapToGrid:l,nodeOrigin:u,onNodeDrag:d,onSelectionDrag:f,onError:p,updateNodePositions:g}=t();a={x:e,y:n};let _=!1,v=s.size>1,y=v&&o?Ya(Ia(s)):null,x=v&&l?ys({dragItems:s,snapGrid:c,x:e,y:n}):null;for(let[t,r]of s){if(!i.has(t))continue;let a={x:e-r.distance.x,y:n-r.distance.y};l&&(a=x?{x:Math.round(a.x+x.x),y:Math.round(a.y+x.y)}:ao(a,c));let s=null;if(v&&o&&!r.extent&&y){let{positionAbsolute:e}=r.internals,t=e.x-y.x+o[0][0],n=e.x+r.measured.width-y.x2+o[1][0],i=e.y-y.y+o[0][1],a=e.y+r.measured.height-y.y2+o[1][1];s=[[t,i],[n,a]]}let{position:d,positionAbsolute:f}=Va({nodeId:t,nextPosition:a,nodeLookup:i,nodeExtent:s||o,nodeOrigin:u,onError:p});_=_||r.position.x!==d.x||r.position.y!==d.y,r.position=d,r.internals.positionAbsolute=f}if(m||=_,_&&(g(s,!0),h&&(r||d||!b&&f))){let[e,t]=vs({nodeId:b,dragItems:s,nodeLookup:i});r?.(h,s,e,t),d?.(h,e,t),b||f?.(h,t)}}async function C(){if(!u)return;let{transform:e,panBy:n,autoPanSpeed:r,autoPanOnNodeDrag:i}=t();if(!i){c=!1,cancelAnimationFrame(o);return}let[s,d]=qa(l,u,r);(s!==0||d!==0)&&(a.x=(a.x??0)-s/e[2],a.y=(a.y??0)-d/e[2],await n({x:s,y:d})&&S(a)),o=requestAnimationFrame(C)}function w(r){let{nodeLookup:i,multiSelectionActive:o,nodesDraggable:c,transform:l,snapGrid:f,snapToGrid:p,selectNodesOnDrag:m,onNodeDragStart:h,onSelectionDragStart:g,unselectNodesAndEdges:_}=t();d=!0,(!m||!y)&&!o&&b&&(i.get(b)?.selected||_()),y&&m&&b&&e?.(b);let v=yo(r.sourceEvent,{transform:l,snapGrid:f,snapToGrid:p,containerBounds:u});if(a=v,s=_s(i,c,v,b),s.size>0&&(n||h||!b&&g)){let[e,t]=vs({nodeId:b,dragItems:s,nodeLookup:i});n?.(r.sourceEvent,s,e,t),h?.(r.sourceEvent,e,t),b||g?.(r.sourceEvent,t)}}let T=tn().clickDistance(x).on(`start`,e=>{let{domNode:n,nodeDragThreshold:r,transform:i,snapGrid:o,snapToGrid:s}=t();u=n?.getBoundingClientRect()||null,p=!1,m=!1,h=e.sourceEvent,r===0&&w(e),a=yo(e.sourceEvent,{transform:i,snapGrid:o,snapToGrid:s,containerBounds:u}),l=To(e.sourceEvent,u)}).on(`drag`,e=>{let{autoPanOnNodeDrag:n,transform:r,snapGrid:i,snapToGrid:o,nodeDragThreshold:f,nodeLookup:m}=t(),g=yo(e.sourceEvent,{transform:r,snapGrid:i,snapToGrid:o,containerBounds:u});if(h=e.sourceEvent,(e.sourceEvent.type===`touchmove`&&e.sourceEvent.touches.length>1||b&&!m.has(b))&&(p=!0),!p){if(!c&&n&&d&&(c=!0,C()),!d){let t=To(e.sourceEvent,u),n=t.x-l.x,r=t.y-l.y;Math.sqrt(n*n+r*r)>f&&w(e)}(a.x!==g.xSnapped||a.y!==g.ySnapped)&&s&&d&&(l=To(e.sourceEvent,u),S(g))}}).on(`end`,e=>{if(!d||p){p&&s.size>0&&t().updateNodePositions(s,!1);return}if(c=!1,d=!1,cancelAnimationFrame(o),s.size>0){let{nodeLookup:n,updateNodePositions:r,onNodeDragStop:a,onSelectionDragStop:o}=t();if(m&&=(r(s,!1),!1),i||a||!b&&o){let[t,r]=vs({nodeId:b,dragItems:s,nodeLookup:n,dragging:!1});i?.(e.sourceEvent,s,t,r),a?.(e.sourceEvent,t,r),b||o?.(e.sourceEvent,r)}}}).filter(e=>{let t=e.target;return!e.button&&(!g||!gs(t,`.${g}`,v))&&(!_||gs(t,_,v))});f.call(T)}function _(){f?.on(`.drag`,null)}return{update:g,destroy:_}}function xs(e,t,n){let r=[],i={x:e.x-n,y:e.y-n,width:n*2,height:n*2};for(let e of t.values())to(i,Za(e))>0&&r.push(e);return r}var Ss=250;function Cs(e,t,n,r){let i=[],a=1/0,o=xs(e,n,t+Ss);for(let n of o){let o=[...n.internals.handleBounds?.source??[],...n.internals.handleBounds?.target??[]];for(let s of o){if(r.nodeId===s.nodeId&&r.type===s.type&&r.id===s.id)continue;let{x:o,y:c}=qo(n,s,s.position,!0),l=Math.sqrt((o-e.x)**2+(c-e.y)**2);l>t||(l<a?(i=[{...s,x:o,y:c}],a=l):l===a&&i.push({...s,x:o,y:c}))}}if(!i.length)return null;if(i.length>1){let e=r.type===`source`?`target`:`source`;return i.find(t=>t.type===e)??i[0]}return i[0]}function ws(e,t,n,r,i,a=!1){let o=r.get(e);if(!o)return null;let s=i===`strict`?o.internals.handleBounds?.[t]:[...o.internals.handleBounds?.source??[],...o.internals.handleBounds?.target??[]],c=(n?s?.find(e=>e.id===n):s?.[0])??null;return c&&a?{...c,...qo(o,c,c.position,!0)}:c}function Ts(e,t){return e||(t?.classList.contains(`target`)?`target`:t?.classList.contains(`source`)?`source`:null)}function Es(e,t){let n=null;return t?n=!0:e&&!t&&(n=!1),n}var Ds=()=>!0;function Os(e,{connectionMode:t,connectionRadius:n,handleId:r,nodeId:i,edgeUpdaterType:a,isTarget:o,domNode:s,nodeLookup:c,lib:l,autoPanOnConnect:u,flowId:d,panBy:f,cancelConnection:p,onConnectStart:m,onConnect:h,onConnectEnd:g,isValidConnection:_=Ds,onReconnectEnd:v,updateConnection:y,getTransform:b,getFromHandle:x,autoPanSpeed:S,dragThreshold:C=1,handleDomNode:w}){let T=xo(e.target),E=0,D,{x:O,y:k}=To(e),A=Ts(a,w),j=s?.getBoundingClientRect(),M=!1;if(!j||!A)return;let N=ws(i,A,r,c,t);if(!N)return;let P=To(e,j),ee=!1,F=null,I=!1,te=null;function ne(){if(!u||!j)return;let[e,t]=qa(P,j,S);f({x:e,y:t}),E=requestAnimationFrame(ne)}let L={...N,nodeId:i,type:A,position:N.position},R=c.get(i),z={inProgress:!0,isValid:null,from:qo(R,L,H.Left,!0),fromHandle:L,fromPosition:L.position,fromNode:R,to:P,toHandle:null,toPosition:ka[L.position],toNode:null,pointer:P};function B(){M=!0,y(z),m?.(e,{nodeId:i,handleId:r,handleType:A})}C===0&&B();function re(e){if(!M){let{x:t,y:n}=To(e),r=t-O,i=n-k;if(!(r*r+i*i>C*C))return;B()}if(!x()||!L){ie(e);return}let a=b();P=To(e,j),D=Cs(oo(P,a,!1,[1,1]),n,c,L),ee||=(ne(),!0);let s=ks(e,{handle:D,connectionMode:t,fromNodeId:i,fromHandleId:r,fromType:o?`target`:`source`,isValidConnection:_,doc:T,lib:l,flowId:d,nodeLookup:c});te=s.handleDomNode,F=s.connection,I=Es(!!D,s.isValid);let u=c.get(i),f=u?qo(u,L,H.Left,!0):z.from,p={...z,from:f,isValid:I,to:s.toHandle&&I?so({x:s.toHandle.x,y:s.toHandle.y},a):P,toHandle:s.toHandle,toPosition:I&&s.toHandle?s.toHandle.position:ka[L.position],toNode:s.toHandle?c.get(s.toHandle.nodeId):null,pointer:P};y(p),z=p}function ie(e){if(!(`touches`in e&&e.touches.length>0)){if(M){(D||te)&&F&&I&&h?.(F);let{inProgress:t,...n}=z,r={...n,toPosition:z.toHandle?z.toPosition:null};g?.(e,r),a&&v?.(e,r)}p(),cancelAnimationFrame(E),ee=!1,I=!1,F=null,te=null,T.removeEventListener(`mousemove`,re),T.removeEventListener(`mouseup`,ie),T.removeEventListener(`touchmove`,re),T.removeEventListener(`touchend`,ie)}}T.addEventListener(`mousemove`,re),T.addEventListener(`mouseup`,ie),T.addEventListener(`touchmove`,re),T.addEventListener(`touchend`,ie)}function ks(e,{handle:t,connectionMode:n,fromNodeId:r,fromHandleId:i,fromType:a,doc:o,lib:s,flowId:c,isValidConnection:l=Ds,nodeLookup:u}){let d=a===`target`,f=t?o.querySelector(`.${s}-flow__handle[data-id="${c}-${t?.nodeId}-${t?.id}-${t?.type}"]`):null,{x:p,y:m}=To(e),h=o.elementFromPoint(p,m),g=h?.classList.contains(`${s}-flow__handle`)?h:f,_={handleDomNode:g,isValid:!1,connection:null,toHandle:null};if(g){let e=Ts(void 0,g),t=g.getAttribute(`data-nodeid`),a=g.getAttribute(`data-handleid`),o=g.classList.contains(`connectable`),s=g.classList.contains(`connectableend`);if(!t||!e)return _;let c={source:d?t:r,sourceHandle:d?a:i,target:d?r:t,targetHandle:d?i:a};_.connection=c,_.isValid=o&&s&&(n===Ca.Strict?d&&e===`source`||!d&&e===`target`:t!==r||a!==i)&&l(c),_.toHandle=ws(t,e,a,u,n,!0)}return _}var As={onPointerDown:Os,isValid:ks};function js({domNode:e,panZoom:t,getTransform:n,getViewScale:r}){let i=Ht(e);function a({translateExtent:e,width:a,height:o,zoomStep:s=1,pannable:c=!0,zoomable:l=!0,inversePan:u=!1}){let d=e=>{if(e.sourceEvent.type!==`wheel`||!t)return;let r=n(),i=e.sourceEvent.ctrlKey&&uo()?10:1,a=-e.sourceEvent.deltaY*(e.sourceEvent.deltaMode===1?.05:e.sourceEvent.deltaMode?1:.002)*s,o=r[2]*2**(a*i);t.scaleTo(o)},f=[0,0],p=va().on(`start`,e=>{(e.sourceEvent.type===`mousedown`||e.sourceEvent.type===`touchstart`)&&(f=[e.sourceEvent.clientX??e.sourceEvent.touches[0].clientX,e.sourceEvent.clientY??e.sourceEvent.touches[0].clientY])}).on(`zoom`,c?i=>{let s=n();if(i.sourceEvent.type!==`mousemove`&&i.sourceEvent.type!==`touchmove`||!t)return;let c=[i.sourceEvent.clientX??i.sourceEvent.touches[0].clientX,i.sourceEvent.clientY??i.sourceEvent.touches[0].clientY],l=[c[0]-f[0],c[1]-f[1]];f=c;let d=r()*Math.max(s[2],Math.log(s[2]))*(u?-1:1),p={x:s[0]-l[0]*d,y:s[1]-l[1]*d},m=[[0,0],[a,o]];t.setViewportConstrained({x:p.x,y:p.y,zoom:s[2]},m,e)}:null).on(`zoom.wheel`,l?d:null);i.call(p,{})}function o(){i.on(`zoom`,null)}return{update:a,destroy:o,pointer:P}}var Ms=e=>({x:e.x,y:e.y,zoom:e.k}),Ns=({x:e,y:t,zoom:n})=>ca.translate(e,t).scale(n),Ps=(e,t)=>e.target.closest(`.${t}`),Fs=(e,t)=>t===2&&Array.isArray(e)&&e.includes(2),Is=e=>((e*=2)<=1?e*e*e:(e-=2)*e*e+2)/2,Ls=(e,t=0,n=Is,r=()=>{})=>{let i=typeof t==`number`&&t>0;return i||r(),i?e.transition().duration(t).ease(n).on(`end`,r):e},Rs=e=>{let t=e.ctrlKey&&uo()?10:1;return-e.deltaY*(e.deltaMode===1?.05:e.deltaMode?1:.002)*t};function zs({zoomPanValues:e,noWheelClassName:t,d3Selection:n,d3Zoom:r,panOnScrollMode:i,panOnScrollSpeed:a,zoomOnPinch:o,onPanZoomStart:s,onPanZoom:c,onPanZoomEnd:l}){return u=>{if(Ps(u,t))return u.ctrlKey&&u.preventDefault(),!1;u.preventDefault(),u.stopImmediatePropagation();let d=n.property(`__zoom`).k||1;if(u.ctrlKey&&o){let e=P(u),t=d*2**Rs(u);r.scaleTo(n,t,e,u);return}let f=u.deltaMode===1?20:1,p=i===wa.Vertical?0:u.deltaX*f,m=i===wa.Horizontal?0:u.deltaY*f;!uo()&&u.shiftKey&&i!==wa.Vertical&&(p=u.deltaY*f,m=0),r.translateBy(n,-(p/d)*a,-(m/d)*a,{internal:!0});let h=Ms(n.property(`__zoom`));clearTimeout(e.panScrollTimeout),e.isPanScrolling?(c?.(u,h),e.panScrollTimeout=setTimeout(()=>{l?.(u,h),e.isPanScrolling=!1},150)):(e.isPanScrolling=!0,s?.(u,h))}}function Bs({noWheelClassName:e,preventScrolling:t,d3ZoomHandler:n}){return function(r,i){let a=r.type===`wheel`,o=!t&&a&&!r.ctrlKey,s=Ps(r,e);if(r.ctrlKey&&a&&s&&r.preventDefault(),o||s)return null;r.preventDefault(),n.call(this,r,i)}}function Vs({zoomPanValues:e,onDraggingChange:t,onPanZoomStart:n}){return r=>{if(r.sourceEvent?.internal)return;let i=Ms(r.transform);e.mouseButton=r.sourceEvent?.button||0,e.isZoomingOrPanning=!0,e.prevViewport=i,r.sourceEvent?.type===`mousedown`&&t(!0),n&&n?.(r.sourceEvent,i)}}function Hs({zoomPanValues:e,panOnDrag:t,onPaneContextMenu:n,onTransformChange:r,onPanZoom:i}){return a=>{e.usedRightMouseButton=!!(n&&Fs(t,e.mouseButton??0)),a.sourceEvent?.sync||r([a.transform.x,a.transform.y,a.transform.k]),i&&!a.sourceEvent?.internal&&i?.(a.sourceEvent,Ms(a.transform))}}function Us({zoomPanValues:e,panOnDrag:t,panOnScroll:n,onDraggingChange:r,onPanZoomEnd:i,onPaneContextMenu:a}){return o=>{if(!o.sourceEvent?.internal&&(e.isZoomingOrPanning=!1,a&&Fs(t,e.mouseButton??0)&&!e.usedRightMouseButton&&o.sourceEvent&&a(o.sourceEvent),e.usedRightMouseButton=!1,r(!1),i)){let t=Ms(o.transform);e.prevViewport=t,clearTimeout(e.timerId),e.timerId=setTimeout(()=>{i?.(o.sourceEvent,t)},n?150:0)}}}function Ws({zoomActivationKeyPressed:e,zoomOnScroll:t,zoomOnPinch:n,panOnDrag:r,panOnScroll:i,zoomOnDoubleClick:a,userSelectionActive:o,noWheelClassName:s,noPanClassName:c,lib:l,connectionInProgress:u}){return d=>{let f=e||t,p=n&&d.ctrlKey,m=d.type===`wheel`;if(d.button===1&&d.type===`mousedown`&&(Ps(d,`${l}-flow__node`)||Ps(d,`${l}-flow__edge`)))return!0;if(!r&&!f&&!i&&!a&&!n||o||u&&!m||Ps(d,s)&&m||Ps(d,c)&&(!m||i&&m&&!e)||!n&&d.ctrlKey&&m)return!1;if(!n&&d.type===`touchstart`&&d.touches?.length>1)return d.preventDefault(),!1;if(!f&&!i&&!p&&m||!r&&(d.type===`mousedown`||d.type===`touchstart`)||Array.isArray(r)&&!r.includes(d.button)&&d.type===`mousedown`)return!1;let h=Array.isArray(r)&&r.includes(d.button)||!d.button||d.button<=1;return(!d.ctrlKey||m)&&h}}function Gs({domNode:e,minZoom:t,maxZoom:n,translateExtent:r,viewport:i,onPanZoom:a,onPanZoomStart:o,onPanZoomEnd:s,onDraggingChange:c}){let l={isZoomingOrPanning:!1,usedRightMouseButton:!1,prevViewport:{},mouseButton:0,timerId:void 0,panScrollTimeout:void 0,isPanScrolling:!1},u=e.getBoundingClientRect(),d=va().scaleExtent([t,n]).translateExtent(r),f=Ht(e).call(d);v({x:i.x,y:i.y,zoom:Ua(i.zoom,t,n)},[[0,0],[u.width,u.height]],r);let p=f.on(`wheel.zoom`),m=f.on(`dblclick.zoom`);d.wheelDelta(Rs);async function h(e,t){return f?new Promise(n=>{d?.interpolate(t?.interpolate===`linear`?ar:yr).transform(Ls(f,t?.duration,t?.ease,()=>n(!0)),e)}):!1}function g({noWheelClassName:e,noPanClassName:t,onPaneContextMenu:n,userSelectionActive:r,panOnScroll:i,panOnDrag:u,panOnScrollMode:h,panOnScrollSpeed:g,preventScrolling:v,zoomOnPinch:y,zoomOnScroll:b,zoomOnDoubleClick:x,zoomActivationKeyPressed:S,lib:C,onTransformChange:w,connectionInProgress:T,paneClickDistance:E,selectionOnDrag:D}){r&&!l.isZoomingOrPanning&&_();let O=i&&!S&&!r;d.clickDistance(D?1/0:!ro(E)||E<0?0:E);let k=O?zs({zoomPanValues:l,noWheelClassName:e,d3Selection:f,d3Zoom:d,panOnScrollMode:h,panOnScrollSpeed:g,zoomOnPinch:y,onPanZoomStart:o,onPanZoom:a,onPanZoomEnd:s}):Bs({noWheelClassName:e,preventScrolling:v,d3ZoomHandler:p});f.on(`wheel.zoom`,k,{passive:!1});let A=Vs({zoomPanValues:l,onDraggingChange:c,onPanZoomStart:o});d.on(`start`,A);let j=Hs({zoomPanValues:l,panOnDrag:u,onPaneContextMenu:!!n,onPanZoom:a,onTransformChange:w});d.on(`zoom`,j);let M=Us({zoomPanValues:l,panOnDrag:u,panOnScroll:i,onPaneContextMenu:n,onPanZoomEnd:s,onDraggingChange:c});d.on(`end`,M);let N=Ws({zoomActivationKeyPressed:S,panOnDrag:u,zoomOnScroll:b,panOnScroll:i,zoomOnDoubleClick:x,zoomOnPinch:y,userSelectionActive:r,noPanClassName:t,noWheelClassName:e,lib:C,connectionInProgress:T});d.filter(N),x?f.on(`dblclick.zoom`,m):f.on(`dblclick.zoom`,null)}function _(){d.on(`zoom`,null)}async function v(e,t,n){let r=Ns(e),i=d?.constrain()(r,t,n);return i&&await h(i),i}async function y(e,t){let n=Ns(e);return await h(n,t),n}function b(e){if(f){let t=Ns(e),n=f.property(`__zoom`);(n.k!==e.zoom||n.x!==e.x||n.y!==e.y)&&d?.transform(f,t,null,{sync:!0})}}function x(){let e=f?la(f.node()):{x:0,y:0,k:1};return{x:e.x,y:e.y,zoom:e.k}}async function S(e,t){return f?new Promise(n=>{d?.interpolate(t?.interpolate===`linear`?ar:yr).scaleTo(Ls(f,t?.duration,t?.ease,()=>n(!0)),e)}):!1}async function C(e,t){return f?new Promise(n=>{d?.interpolate(t?.interpolate===`linear`?ar:yr).scaleBy(Ls(f,t?.duration,t?.ease,()=>n(!0)),e)}):!1}function w(e){d?.scaleExtent(e)}function T(e){d?.translateExtent(e)}function E(e){let t=!ro(e)||e<0?0:e;d?.clickDistance(t)}return{update:g,destroy:_,setViewport:y,setViewportConstrained:v,getViewport:x,scaleTo:S,scaleBy:C,setScaleExtent:w,setTranslateExtent:T,syncViewport:b,setClickDistance:E}}var Ks;(function(e){e.Line=`line`,e.Handle=`handle`})(Ks||={});function qs({width:e,prevWidth:t,height:n,prevHeight:r,affectsX:i,affectsY:a}){let o=e-t,s=n-r,c=[o>0?1:o<0?-1:0,s>0?1:s<0?-1:0];return o&&i&&(c[0]*=-1),s&&a&&(c[1]*=-1),c}function Js(e){return{isHorizontal:e.includes(`right`)||e.includes(`left`),isVertical:e.includes(`bottom`)||e.includes(`top`),affectsX:e.includes(`left`),affectsY:e.includes(`top`)}}function Ys(e,t){return Math.max(0,t-e)}function Xs(e,t){return Math.max(0,e-t)}function Zs(e,t,n){return Math.max(0,t-e,e-n)}function Qs(e,t){return e?!t:t}function $s(e,t,n,r,i,a,o,s){let{affectsX:c,affectsY:l}=t,{isHorizontal:u,isVertical:d}=t,f=u&&d,{xSnapped:p,ySnapped:m}=n,{minWidth:h,maxWidth:g,minHeight:_,maxHeight:v}=r,{x:y,y:b,width:x,height:S,aspectRatio:C}=e,w=Math.floor(u?p-e.pointerX:0),T=Math.floor(d?m-e.pointerY:0),E=x+(c?-w:w),D=S+(l?-T:T),O=-a[0]*x,k=-a[1]*S,A=Zs(E,h,g),j=Zs(D,_,v);if(o){let e=0,t=0;c&&w<0?e=Ys(y+w+O,o[0][0]):!c&&w>0&&(e=Xs(y+E+O,o[1][0])),l&&T<0?t=Ys(b+T+k,o[0][1]):!l&&T>0&&(t=Xs(b+D+k,o[1][1])),A=Math.max(A,e),j=Math.max(j,t)}if(s){let e=0,t=0;c&&w>0?e=Xs(y+w,s[0][0]):!c&&w<0&&(e=Ys(y+E,s[1][0])),l&&T>0?t=Xs(b+T,s[0][1]):!l&&T<0&&(t=Ys(b+D,s[1][1])),A=Math.max(A,e),j=Math.max(j,t)}if(i){if(u){let e=Zs(E/C,_,v)*C;if(A=Math.max(A,e),o){let e=0;e=!c&&!l||c&&!l&&f?Xs(b+k+E/C,o[1][1])*C:Ys(b+k+(c?w:-w)/C,o[0][1])*C,A=Math.max(A,e)}if(s){let e=0;e=!c&&!l||c&&!l&&f?Ys(b+E/C,s[1][1])*C:Xs(b+(c?w:-w)/C,s[0][1])*C,A=Math.max(A,e)}}if(d){let e=Zs(D*C,h,g)/C;if(j=Math.max(j,e),o){let e=0;e=!c&&!l||l&&!c&&f?Xs(y+D*C+O,o[1][0])/C:Ys(y+(l?T:-T)*C+O,o[0][0])/C,j=Math.max(j,e)}if(s){let e=0;e=!c&&!l||l&&!c&&f?Ys(y+D*C,s[1][0])/C:Xs(y+(l?T:-T)*C,s[0][0])/C,j=Math.max(j,e)}}}T+=T<0?j:-j,w+=w<0?A:-A,i&&(f?E>D*C?T=(Qs(c,l)?-w:w)/C:w=(Qs(c,l)?-T:T)*C:u?(T=w/C,l=c):(w=T*C,c=l));let M=c?y+w:y,N=l?b+T:b;return{width:x+(c?-w:w),height:S+(l?-T:T),x:a[0]*w*(c?-1:1)+M,y:a[1]*T*(l?-1:1)+N}}var ec={width:0,height:0,x:0,y:0},tc={...ec,pointerX:0,pointerY:0,aspectRatio:1};function nc(e,t,n){let r=t.position.x+e.position.x,i=t.position.y+e.position.y,a=e.measured.width??0,o=e.measured.height??0,s=n[0]*a,c=n[1]*o;return[[r-s,i-c],[r+a-s,i+o-c]]}function rc({domNode:e,nodeId:t,getStoreItems:n,onChange:r,onEnd:i}){let a=Ht(e),o={controlDirection:Js(`bottom-right`),boundaries:{minWidth:0,minHeight:0,maxWidth:Number.MAX_VALUE,maxHeight:Number.MAX_VALUE},resizeDirection:void 0,keepAspectRatio:!1};function s({controlPosition:e,boundaries:s,keepAspectRatio:c,resizeDirection:l,onResizeStart:u,onResize:d,onResizeEnd:f,shouldResize:p}){let m={...ec},h={...tc};o={boundaries:s,resizeDirection:l,keepAspectRatio:c,controlDirection:Js(e)};let g,_=null,v=[],y,b,x,S=!1,C=tn().on(`start`,e=>{let{nodeLookup:r,transform:i,snapGrid:a,snapToGrid:o,nodeOrigin:s,paneDomNode:c}=n();if(g=r.get(t),!g)return;_=c?.getBoundingClientRect()??null;let{xSnapped:l,ySnapped:d}=yo(e.sourceEvent,{transform:i,snapGrid:a,snapToGrid:o,containerBounds:_});m={width:g.measured.width??0,height:g.measured.height??0,x:g.position.x??0,y:g.position.y??0},h={...m,pointerX:l,pointerY:d,aspectRatio:m.width/m.height},y=void 0,b=fo(g.extent)?g.extent:void 0,g.parentId&&(g.extent===`parent`||g.expandParent)&&(y=r.get(g.parentId)),y&&g.extent===`parent`&&(b=[[0,0],[y.measured.width,y.measured.height]]),v=[],x=void 0;for(let[e,n]of r)if(n.parentId===t&&(v.push({id:e,position:{...n.position},extent:n.extent}),n.extent===`parent`||n.expandParent)){let e=nc(n,g,n.origin??s);x=x?[[Math.min(e[0][0],x[0][0]),Math.min(e[0][1],x[0][1])],[Math.max(e[1][0],x[1][0]),Math.max(e[1][1],x[1][1])]]:e}u?.(e,{...m})}).on(`drag`,e=>{let{transform:t,snapGrid:i,snapToGrid:a,nodeOrigin:s}=n(),c=yo(e.sourceEvent,{transform:t,snapGrid:i,snapToGrid:a,containerBounds:_}),l=[];if(!g)return;let{x:u,y:f,width:C,height:w}=m,T={},E=g.origin??s,{width:D,height:O,x:k,y:A}=$s(h,o.controlDirection,c,o.boundaries,o.keepAspectRatio,E,b,x),j=D!==C,M=O!==w,N=k!==u&&j,P=A!==f&&M;if(!N&&!P&&!j&&!M)return;if((N||P||E[0]===1||E[1]===1)&&(T.x=N?k:m.x,T.y=P?A:m.y,m.x=T.x,m.y=T.y,v.length>0)){let e=k-u,t=A-f;for(let n of v)n.position={x:n.position.x-e+E[0]*(D-C),y:n.position.y-t+E[1]*(O-w)},l.push(n)}if((j||M)&&(T.width=j&&(!o.resizeDirection||o.resizeDirection===`horizontal`)?D:m.width,T.height=M&&(!o.resizeDirection||o.resizeDirection===`vertical`)?O:m.height,m.width=T.width,m.height=T.height),y&&g.expandParent){let e=E[0]*(T.width??0);T.x&&T.x<e&&(m.x=e,h.x-=T.x-e);let t=E[1]*(T.height??0);T.y&&T.y<t&&(m.y=t,h.y-=T.y-t)}let ee=qs({width:m.width,prevWidth:C,height:m.height,prevHeight:w,affectsX:o.controlDirection.affectsX,affectsY:o.controlDirection.affectsY}),F={...m,direction:ee};p?.(e,F)!==!1&&(S=!0,d?.(e,F),r(T,l))}).on(`end`,e=>{S&&=(f?.(e,{...m}),i?.({...m}),!1)});a.call(C)}function c(){a.on(`.drag`,null)}return{update:s,destroy:c}}var ic=o((e=>{var t=u();function n(e,t){return e===t&&(e!==0||1/e==1/t)||e!==e&&t!==t}var r=typeof Object.is==`function`?Object.is:n,i=t.useState,a=t.useEffect,o=t.useLayoutEffect,s=t.useDebugValue;function c(e,t){var n=t(),r=i({inst:{value:n,getSnapshot:t}}),c=r[0].inst,u=r[1];return o(function(){c.value=n,c.getSnapshot=t,l(c)&&u({inst:c})},[e,n,t]),a(function(){return l(c)&&u({inst:c}),e(function(){l(c)&&u({inst:c})})},[e]),s(n),n}function l(e){var t=e.getSnapshot;e=e.value;try{var n=t();return!r(e,n)}catch{return!0}}function d(e,t){return t()}var f=typeof window>`u`||window.document===void 0||window.document.createElement===void 0?d:c;e.useSyncExternalStore=t.useSyncExternalStore===void 0?f:t.useSyncExternalStore})),ac=o(((e,t)=>{t.exports=ic()})),oc=o((e=>{var t=u(),n=ac();function r(e,t){return e===t&&(e!==0||1/e==1/t)||e!==e&&t!==t}var i=typeof Object.is==`function`?Object.is:r,a=n.useSyncExternalStore,o=t.useRef,s=t.useEffect,c=t.useMemo,l=t.useDebugValue;e.useSyncExternalStoreWithSelector=function(e,t,n,r,u){var d=o(null);if(d.current===null){var f={hasValue:!1,value:null};d.current=f}else f=d.current;d=c(function(){function e(e){if(!a){if(a=!0,o=e,e=r(e),u!==void 0&&f.hasValue){var t=f.value;if(u(t,e))return s=t}return s=e}if(t=s,i(o,e))return t;var n=r(e);return u!==void 0&&u(t,n)?(o=e,t):(o=e,s=n)}var a=!1,o,s,c=n===void 0?null:n;return[function(){return e(t())},c===null?void 0:function(){return e(c())}]},[t,n,r,u]);var p=a(e,d[0],d[1]);return s(function(){f.hasValue=!0,f.value=p},[p]),l(p),p}})),sc=c(o(((e,t)=>{t.exports=oc()}))(),1),cc=e=>{let t,n=new Set,r=(e,r)=>{let i=typeof e==`function`?e(t):e;if(!Object.is(i,t)){let e=t;t=r??(typeof i!=`object`||!i)?i:Object.assign({},t,i),n.forEach(n=>n(t,e))}},i=()=>t,a={setState:r,getState:i,getInitialState:()=>o,subscribe:e=>(n.add(e),()=>n.delete(e)),destroy:()=>{n.clear()}},o=t=e(r,i,a);return a},lc=e=>e?cc(e):cc,{useDebugValue:uc}=y.default,{useSyncExternalStoreWithSelector:dc}=sc.default,fc=e=>e;function pc(e,t=fc,n){let r=dc(e.subscribe,e.getState,e.getServerState||e.getInitialState,t,n);return uc(r),r}var mc=(e,t)=>{let n=lc(e),r=(e,r=t)=>pc(n,e,r);return Object.assign(r,n),r},hc=(e,t)=>e?mc(e,t):mc;function gc(e,t){if(Object.is(e,t))return!0;if(typeof e!=`object`||!e||typeof t!=`object`||!t)return!1;if(e instanceof Map&&t instanceof Map){if(e.size!==t.size)return!1;for(let[n,r]of e)if(!Object.is(r,t.get(n)))return!1;return!0}if(e instanceof Set&&t instanceof Set){if(e.size!==t.size)return!1;for(let n of e)if(!t.has(n))return!1;return!0}let n=Object.keys(e);if(n.length!==Object.keys(t).length)return!1;for(let r of n)if(!Object.prototype.hasOwnProperty.call(t,r)||!Object.is(e[r],t[r]))return!1;return!0}var _c=m(),vc=(0,y.createContext)(null),yc=vc.Provider,bc=ya.error001(`react`);function G(e,t){let n=(0,y.useContext)(vc);if(n===null)throw Error(bc);return pc(n,e,t)}function xc(){let e=(0,y.useContext)(vc);if(e===null)throw Error(bc);return(0,y.useMemo)(()=>({getState:e.getState,setState:e.setState,subscribe:e.subscribe}),[e])}var Sc={display:`none`},Cc={position:`absolute`,width:1,height:1,margin:-1,border:0,padding:0,overflow:`hidden`,clip:`rect(0px, 0px, 0px, 0px)`,clipPath:`inset(100%)`},wc=`react-flow__node-desc`,Tc=`react-flow__edge-desc`,Ec=`react-flow__aria-live`,Dc=e=>e.ariaLiveMessage,Oc=e=>e.ariaLabelConfig;function kc({rfId:e}){let t=G(Dc);return(0,x.jsx)(`div`,{id:`${Ec}-${e}`,"aria-live":`assertive`,"aria-atomic":`true`,style:Cc,children:t})}function Ac({rfId:e,disableKeyboardA11y:t}){let n=G(Oc);return(0,x.jsxs)(x.Fragment,{children:[(0,x.jsx)(`div`,{id:`${wc}-${e}`,style:Sc,children:t?n[`node.a11yDescription.default`]:n[`node.a11yDescription.keyboardDisabled`]}),(0,x.jsx)(`div`,{id:`${Tc}-${e}`,style:Sc,children:n[`edge.a11yDescription.default`]}),!t&&(0,x.jsx)(kc,{rfId:e})]})}var jc=(0,y.forwardRef)(({position:e=`top-left`,children:t,className:n,style:r,...i},a)=>(0,x.jsx)(`div`,{className:S([`react-flow__panel`,n,...`${e}`.split(`-`)]),style:r,ref:a,...i,children:t}));jc.displayName=`Panel`;var Mc=`https://reactflow.dev?utm_source=attribution`;function Nc({proOptions:e,position:t=`bottom-right`}){return e?.hideAttribution?null:(0,x.jsx)(jc,{position:t,className:`react-flow__attribution`,"data-message":`Please only hide this attribution when you are subscribed to React Flow Pro: ${Mc}`,children:(0,x.jsx)(`a`,{href:Mc,target:`_blank`,rel:`noopener noreferrer`,"aria-label":`React Flow attribution`,children:`React Flow`})})}var Pc=e=>{let t=[],n=[];for(let[,n]of e.nodeLookup)n.selected&&t.push(n.internals.userNode);for(let[,t]of e.edgeLookup)t.selected&&n.push(t);return{selectedNodes:t,selectedEdges:n}},Fc=e=>e.id;function Ic(e,t){return gc(e.selectedNodes.map(Fc),t.selectedNodes.map(Fc))&&gc(e.selectedEdges.map(Fc),t.selectedEdges.map(Fc))}function Lc({onSelectionChange:e}){let t=xc(),{selectedNodes:n,selectedEdges:r}=G(Pc,Ic);return(0,y.useEffect)(()=>{let i={nodes:n,edges:r};e?.(i),t.getState().onSelectionChangeHandlers.forEach(e=>e(i))},[n,r,e]),null}var Rc=e=>!!e.onSelectionChangeHandlers;function zc({onSelectionChange:e}){let t=G(Rc);return e||t?(0,x.jsx)(Lc,{onSelectionChange:e}):null}var Bc=[0,0],Vc={x:0,y:0,zoom:1},Hc=[...`nodes.edges.defaultNodes.defaultEdges.onConnect.onConnectStart.onConnectEnd.onClickConnectStart.onClickConnectEnd.nodesDraggable.autoPanOnNodeFocus.nodesConnectable.nodesFocusable.edgesFocusable.edgesReconnectable.elevateNodesOnSelect.elevateEdgesOnSelect.minZoom.maxZoom.nodeExtent.onNodesChange.onEdgesChange.elementsSelectable.connectionMode.snapGrid.snapToGrid.translateExtent.connectOnClick.defaultEdgeOptions.fitView.fitViewOptions.onNodesDelete.onEdgesDelete.onDelete.onNodeDrag.onNodeDragStart.onNodeDragStop.onSelectionDrag.onSelectionDragStart.onSelectionDragStop.onMoveStart.onMove.onMoveEnd.noPanClassName.nodeOrigin.autoPanOnConnect.autoPanOnNodeDrag.onError.connectionRadius.isValidConnection.selectNodesOnDrag.nodeDragThreshold.connectionDragThreshold.onBeforeDelete.debug.autoPanSpeed.ariaLabelConfig.zIndexMode`.split(`.`),`rfId`],Uc=e=>({setNodes:e.setNodes,setEdges:e.setEdges,setMinZoom:e.setMinZoom,setMaxZoom:e.setMaxZoom,setTranslateExtent:e.setTranslateExtent,setNodeExtent:e.setNodeExtent,reset:e.reset,setDefaultNodesAndEdges:e.setDefaultNodesAndEdges}),Wc={translateExtent:ba,nodeOrigin:Bc,minZoom:.5,maxZoom:2,elementsSelectable:!0,noPanClassName:`nopan`,rfId:`1`};function Gc(e){let{setNodes:t,setEdges:n,setMinZoom:r,setMaxZoom:i,setTranslateExtent:a,setNodeExtent:o,reset:s,setDefaultNodesAndEdges:c}=G(Uc,gc),l=xc();(0,y.useEffect)(()=>(c(e.defaultNodes,e.defaultEdges),()=>{u.current=Wc,s()}),[]);let u=(0,y.useRef)(Wc);return(0,y.useEffect)(()=>{for(let s of Hc){let c=e[s];c!==u.current[s]&&e[s]!==void 0&&(s===`nodes`?t(c):s===`edges`?n(c):s===`minZoom`?r(c):s===`maxZoom`?i(c):s===`translateExtent`?a(c):s===`nodeExtent`?o(c):s===`ariaLabelConfig`?l.setState({ariaLabelConfig:vo(c)}):s===`fitView`?l.setState({fitViewQueued:c}):s===`fitViewOptions`?l.setState({fitViewOptions:c}):l.setState({[s]:c}))}u.current=e},Hc.map(t=>e[t])),null}function Kc(){return typeof window>`u`||!window.matchMedia?null:window.matchMedia(`(prefers-color-scheme: dark)`)}function qc(e){let[t,n]=(0,y.useState)(e===`system`?null:e);return(0,y.useEffect)(()=>{if(e!==`system`){n(e);return}let t=Kc(),r=()=>n(t?.matches?`dark`:`light`);return r(),t?.addEventListener(`change`,r),()=>{t?.removeEventListener(`change`,r)}},[e]),t===null?Kc()?.matches?`dark`:`light`:t}var Jc=typeof document<`u`?document:null;function Yc(e=null,t={target:Jc,actInsideInputWithModifier:!0}){let[n,r]=(0,y.useState)(!1),i=(0,y.useRef)(!1),a=(0,y.useRef)(new Set([])),[o,s]=(0,y.useMemo)(()=>{if(e!==null){let t=(Array.isArray(e)?e:[e]).filter(e=>typeof e==`string`).map(e=>e.replace(`+`,`
+`).replace(`
+
+`,`
++`).split(`
+`));return[t,t.reduce((e,t)=>e.concat(...t),[])]}return[[],[]]},[e]);return(0,y.useEffect)(()=>{let n=t?.target??Jc,c=t?.actInsideInputWithModifier??!0;if(e!==null){let e=e=>{if(i.current=e.ctrlKey||e.metaKey||e.shiftKey||e.altKey,(!i.current||i.current&&!c)&&Co(e))return!1;let n=Zc(e.code,s);if(a.current.add(e[n]),Xc(o,a.current,!1)){let n=e.composedPath?.()?.[0]||e.target,a=n?.nodeName===`BUTTON`||n?.nodeName===`A`;t.preventDefault!==!1&&(i.current||!a)&&e.preventDefault(),r(!0)}},l=e=>{let t=Zc(e.code,s);Xc(o,a.current,!0)?(r(!1),a.current.clear()):a.current.delete(e[t]),e.key===`Meta`&&a.current.clear(),i.current=!1},u=()=>{a.current.clear(),r(!1)};return n?.addEventListener(`keydown`,e),n?.addEventListener(`keyup`,l),window.addEventListener(`blur`,u),window.addEventListener(`contextmenu`,u),()=>{n?.removeEventListener(`keydown`,e),n?.removeEventListener(`keyup`,l),window.removeEventListener(`blur`,u),window.removeEventListener(`contextmenu`,u)}}},[e,r]),n}function Xc(e,t,n){return e.filter(e=>n||e.length===t.size).some(e=>e.every(e=>t.has(e)))}function Zc(e,t){return t.includes(e)?`code`:`key`}var Qc=()=>{let e=xc();return(0,y.useMemo)(()=>({zoomIn:async t=>{let{panZoom:n}=e.getState();return n?n.scaleBy(1.2,t):!1},zoomOut:async t=>{let{panZoom:n}=e.getState();return n?n.scaleBy(1/1.2,t):!1},zoomTo:async(t,n)=>{let{panZoom:r}=e.getState();return r?r.scaleTo(t,n):!1},getZoom:()=>e.getState().transform[2],setViewport:async(t,n)=>{let{transform:[r,i,a],panZoom:o}=e.getState();return o?(await o.setViewport({x:t.x??r,y:t.y??i,zoom:t.zoom??a},n),!0):!1},getViewport:()=>{let[t,n,r]=e.getState().transform;return{x:t,y:n,zoom:r}},setCenter:async(t,n,r)=>e.getState().setCenter(t,n,r),fitBounds:async(t,n)=>{let{width:r,height:i,minZoom:a,maxZoom:o,panZoom:s}=e.getState(),c=W(t,r,i,a,o,n?.padding??.1);return s?(await s.setViewport(c,{duration:n?.duration,ease:n?.ease,interpolate:n?.interpolate}),!0):!1},screenToFlowPosition:(t,n={})=>{let{transform:r,snapGrid:i,snapToGrid:a,domNode:o}=e.getState();if(!o)return t;let{x:s,y:c}=o.getBoundingClientRect(),l={x:t.x-s,y:t.y-c},u=n.snapGrid??i;return oo(l,r,n.snapToGrid??a,u)},flowToScreenPosition:t=>{let{transform:n,domNode:r}=e.getState();if(!r)return t;let{x:i,y:a}=r.getBoundingClientRect(),o=so(t,n);return{x:o.x+i,y:o.y+a}}}),[])};function $c(e,t){let n=[],r=new Map,i=[];for(let t of e)if(t.type===`add`){i.push(t);continue}else if(t.type===`remove`||t.type===`replace`)r.set(t.id,[t]);else{let e=r.get(t.id);e?e.push(t):r.set(t.id,[t])}for(let e of t){let t=r.get(e.id);if(!t){n.push(e);continue}if(t[0].type===`remove`)continue;if(t[0].type===`replace`){n.push({...t[0].item});continue}let i={...e};for(let e of t)el(e,i);n.push(i)}return i.length&&i.forEach(e=>{e.index===void 0?n.push({...e.item}):n.splice(e.index,0,{...e.item})}),n}function el(e,t){switch(e.type){case`select`:t.selected=e.selected;break;case`position`:e.position!==void 0&&(t.position=e.position),e.dragging!==void 0&&(t.dragging=e.dragging);break;case`dimensions`:e.dimensions!==void 0&&(t.measured={...e.dimensions},e.setAttributes&&((e.setAttributes===!0||e.setAttributes===`width`)&&(t.width=e.dimensions.width),(e.setAttributes===!0||e.setAttributes===`height`)&&(t.height=e.dimensions.height))),typeof e.resizing==`boolean`&&(t.resizing=e.resizing);break}}function tl(e,t){return $c(e,t)}function nl(e,t){return $c(e,t)}function rl(e,t){return{id:e,type:`select`,selected:t}}function il(e,t=new Set,n=!1){let r=[];for(let[i,a]of e){let e=t.has(i);!(a.selected===void 0&&!e)&&a.selected!==e&&(n&&(a.selected=e),r.push(rl(a.id,e)))}return r}function al({items:e=[],lookup:t}){let n=[],r=new Map(e.map(e=>[e.id,e]));for(let[r,i]of e.entries()){let e=t.get(i.id),a=e?.internals?.userNode??e;a!==void 0&&a!==i&&n.push({id:i.id,item:i,type:`replace`}),a===void 0&&n.push({item:i,type:`add`,index:r})}for(let[e]of t)r.get(e)===void 0&&n.push({id:e,type:`remove`});return n}function ol(e){return{id:e.id,type:`remove`}}var sl=io(`React Flow`,`https://reactflow.dev/`);function cl(e,t,n={}){return Io(e,t,{...n,onError:n.onError??sl})}var ll=e=>Ma(e),ul=e=>ja(e);function dl(e){return(0,y.forwardRef)(e)}var fl=typeof window<`u`?y.useLayoutEffect:y.useEffect;function pl(e){let[t,n]=(0,y.useState)(BigInt(0)),[r]=(0,y.useState)(()=>ml(()=>n(e=>e+BigInt(1))));return fl(()=>{let t=r.get();t.length&&(e(t),r.reset())},[t]),r}function ml(e){let t=[];return{get:()=>t,reset:()=>{t=[]},push:n=>{t.push(n),e()}}}var hl=(0,y.createContext)(null);function gl({children:e}){let t=xc(),n=pl((0,y.useCallback)(e=>{let{nodes:n=[],setNodes:r,hasDefaultNodes:i,onNodesChange:a,nodeLookup:o,fitViewQueued:s,onNodesChangeMiddlewareMap:c}=t.getState(),l=n;for(let t of e)l=typeof t==`function`?t(l):t;let u=al({items:l,lookup:o});for(let e of c.values())u=e(u);i&&r(l),u.length>0?a?.(u):s&&window.requestAnimationFrame(()=>{let{fitViewQueued:e,nodes:n,setNodes:r}=t.getState();e&&r(n)})},[])),r=pl((0,y.useCallback)(e=>{let{edges:n=[],setEdges:r,hasDefaultEdges:i,onEdgesChange:a,edgeLookup:o}=t.getState(),s=n;for(let t of e)s=typeof t==`function`?t(s):t;i?r(s):a&&a(al({items:s,lookup:o}))},[])),i=(0,y.useMemo)(()=>({nodeQueue:n,edgeQueue:r}),[]);return(0,x.jsx)(hl.Provider,{value:i,children:e})}function _l(){let e=(0,y.useContext)(hl);if(!e)throw Error(`useBatchContext must be used within a BatchProvider`);return e}var vl=e=>!!e.panZoom;function yl(){let e=Qc(),t=xc(),n=_l(),r=G(vl),i=(0,y.useMemo)(()=>{let e=e=>t.getState().nodeLookup.get(e),r=e=>{n.nodeQueue.push(e)},i=e=>{n.edgeQueue.push(e)},a=e=>{let{nodeLookup:n,nodeOrigin:r}=t.getState(),i=ll(e)?e:n.get(e.id),a=i.parentId?ho(i.position,i.measured,i.parentId,n,r):i.position;return Za({...i,position:a,width:i.measured?.width??i.width,height:i.measured?.height??i.height})},o=(e,t,n={replace:!1})=>{r(r=>r.map(r=>{if(r.id===e){let e=typeof t==`function`?t(r):t;return n.replace&&ll(e)?e:{...r,...e}}return r}))},s=(e,t,n={replace:!1})=>{i(r=>r.map(r=>{if(r.id===e){let e=typeof t==`function`?t(r):t;return n.replace&&ul(e)?e:{...r,...e}}return r}))};return{getNodes:()=>t.getState().nodes.map(e=>({...e})),getNode:t=>e(t)?.internals.userNode,getInternalNode:e,getEdges:()=>{let{edges:e=[]}=t.getState();return e.map(e=>({...e}))},getEdge:e=>t.getState().edgeLookup.get(e),setNodes:r,setEdges:i,addNodes:e=>{let t=Array.isArray(e)?e:[e];n.nodeQueue.push(e=>[...e,...t])},addEdges:e=>{let t=Array.isArray(e)?e:[e];n.edgeQueue.push(e=>[...e,...t])},toObject:()=>{let{nodes:e=[],edges:n=[],transform:r}=t.getState(),[i,a,o]=r;return{nodes:e.map(e=>({...e})),edges:n.map(e=>({...e})),viewport:{x:i,y:a,zoom:o}}},deleteElements:async({nodes:e=[],edges:n=[]})=>{let{nodes:r,edges:i,onNodesDelete:a,onEdgesDelete:o,triggerNodeChanges:s,triggerEdgeChanges:c,onDelete:l,onBeforeDelete:u}=t.getState(),{nodes:d,edges:f}=await Ha({nodesToRemove:e,edgesToRemove:n,nodes:r,edges:i,onBeforeDelete:u}),p=f.length>0,m=d.length>0;if(p){let e=f.map(ol);o?.(f),c(e)}if(m){let e=d.map(ol);a?.(d),s(e)}return(m||p)&&l?.({nodes:d,edges:f}),{deletedNodes:d,deletedEdges:f}},getIntersectingNodes:(e,n=!0,r)=>{let i=no(e),o=i?e:a(e),s=r!==void 0;return o?(r||t.getState().nodes).filter(r=>{let a=t.getState().nodeLookup.get(r.id);if(a&&!i&&(r.id===e.id||!a.internals.positionAbsolute))return!1;let c=Za(s?r:a),l=to(c,o);return n&&l>0||l>=c.width*c.height||l>=o.width*o.height}):[]},isNodeIntersecting:(e,t,n=!0)=>{let r=no(e)?e:a(e);if(!r)return!1;let i=to(r,t);return n&&i>0||i>=t.width*t.height||i>=r.width*r.height},updateNode:o,updateNodeData:(e,t,n={replace:!1})=>{o(e,e=>{let r=typeof t==`function`?t(e):t;return n.replace?{...e,data:r}:{...e,data:{...e.data,...r}}},n)},updateEdge:s,updateEdgeData:(e,t,n={replace:!1})=>{s(e,e=>{let r=typeof t==`function`?t(e):t;return n.replace?{...e,data:r}:{...e,data:{...e.data,...r}}},n)},getNodesBounds:e=>{let{nodeLookup:n,nodeOrigin:r}=t.getState();return Fa(e,{nodeLookup:n,nodeOrigin:r})},getHandleConnections:({type:e,id:n,nodeId:r})=>Array.from(t.getState().connectionLookup.get(`${r}-${e}${n?`-${n}`:``}`)?.values()??[]),getNodeConnections:({type:e,handleId:n,nodeId:r})=>Array.from(t.getState().connectionLookup.get(`${r}${e?n?`-${e}-${n}`:`-${e}`:``}`)?.values()??[]),fitView:async e=>{let r=t.getState().fitViewResolver??_o();return t.setState({fitViewQueued:!0,fitViewOptions:e,fitViewResolver:r}),n.nodeQueue.push(e=>[...e]),r.promise}}},[]);return(0,y.useMemo)(()=>({...i,...e,viewportInitialized:r}),[r])}var bl=e=>e.selected,xl=typeof window<`u`?window:void 0;function Sl({deleteKeyCode:e,multiSelectionKeyCode:t}){let n=xc(),{deleteElements:r}=yl(),i=Yc(e,{actInsideInputWithModifier:!1}),a=Yc(t,{target:xl});(0,y.useEffect)(()=>{if(i){let{edges:e,nodes:t}=n.getState();r({nodes:t.filter(bl),edges:e.filter(bl)}),n.setState({nodesSelectionActive:!1})}},[i]),(0,y.useEffect)(()=>{n.setState({multiSelectionActive:a})},[a])}function Cl(e){let t=xc();(0,y.useEffect)(()=>{let n=()=>{if(!e.current||!(e.current.checkVisibility?.()??!0))return!1;let n=bo(e.current);(n.height===0||n.width===0)&&t.getState().onError?.(`004`,ya.error004()),t.setState({width:n.width||500,height:n.height||500})};if(e.current){n(),window.addEventListener(`resize`,n);let t=new ResizeObserver(()=>n());return t.observe(e.current),()=>{window.removeEventListener(`resize`,n),t&&e.current&&t.unobserve(e.current)}}},[])}var wl={position:`absolute`,width:`100%`,height:`100%`,top:0,left:0},Tl=e=>({userSelectionActive:e.userSelectionActive,lib:e.lib,connectionInProgress:e.connection.inProgress});function El({onPaneContextMenu:e,zoomOnScroll:t=!0,zoomOnPinch:n=!0,panOnScroll:r=!1,panOnScrollSpeed:i=.5,panOnScrollMode:a=wa.Free,zoomOnDoubleClick:o=!0,panOnDrag:s=!0,defaultViewport:c,translateExtent:l,minZoom:u,maxZoom:d,zoomActivationKeyCode:f,preventScrolling:p=!0,children:m,noWheelClassName:h,noPanClassName:g,onViewportChange:_,isControlledViewport:v,paneClickDistance:b,selectionOnDrag:S}){let C=xc(),w=(0,y.useRef)(null),{userSelectionActive:T,lib:E,connectionInProgress:D}=G(Tl,gc),O=Yc(f),k=(0,y.useRef)();Cl(w);let A=(0,y.useCallback)(e=>{_?.({x:e[0],y:e[1],zoom:e[2]}),v||C.setState({transform:e})},[_,v]);return(0,y.useEffect)(()=>{if(w.current){k.current=Gs({domNode:w.current,minZoom:u,maxZoom:d,translateExtent:l,viewport:c,onDraggingChange:e=>C.setState(t=>t.paneDragging===e?t:{paneDragging:e}),onPanZoomStart:(e,t)=>{let{onViewportChangeStart:n,onMoveStart:r}=C.getState();r?.(e,t),n?.(t)},onPanZoom:(e,t)=>{let{onViewportChange:n,onMove:r}=C.getState();r?.(e,t),n?.(t)},onPanZoomEnd:(e,t)=>{let{onViewportChangeEnd:n,onMoveEnd:r}=C.getState();r?.(e,t),n?.(t)}});let{x:e,y:t,zoom:n}=k.current.getViewport();return C.setState({panZoom:k.current,transform:[e,t,n],domNode:w.current.closest(`.react-flow`)}),()=>{k.current?.destroy()}}},[]),(0,y.useEffect)(()=>{k.current?.update({onPaneContextMenu:e,zoomOnScroll:t,zoomOnPinch:n,panOnScroll:r,panOnScrollSpeed:i,panOnScrollMode:a,zoomOnDoubleClick:o,panOnDrag:s,zoomActivationKeyPressed:O,preventScrolling:p,noPanClassName:g,userSelectionActive:T,noWheelClassName:h,lib:E,onTransformChange:A,connectionInProgress:D,selectionOnDrag:S,paneClickDistance:b})},[e,t,n,r,i,a,o,s,O,p,g,T,h,E,A,D,S,b]),(0,x.jsx)(`div`,{className:`react-flow__renderer`,ref:w,style:wl,children:m})}var Dl=e=>({userSelectionActive:e.userSelectionActive,userSelectionRect:e.userSelectionRect});function Ol(){let{userSelectionActive:e,userSelectionRect:t}=G(Dl,gc);return e&&t?(0,x.jsx)(`div`,{className:`react-flow__selection react-flow__container`,style:{width:t.width,height:t.height,transform:`translate(${t.x}px, ${t.y}px)`}}):null}var kl=(e,t)=>n=>{n.target===t.current&&e?.(n)},Al=e=>({userSelectionActive:e.userSelectionActive,elementsSelectable:e.elementsSelectable,dragging:e.paneDragging,panBy:e.panBy,autoPanSpeed:e.autoPanSpeed});function jl({isSelecting:e,selectionKeyPressed:t,selectionMode:n=Ta.Full,panOnDrag:r,autoPanOnSelection:i,paneClickDistance:a,selectionOnDrag:o,onSelectionStart:s,onSelectionEnd:c,onPaneClick:l,onPaneContextMenu:u,onPaneScroll:d,onPaneMouseEnter:f,onPaneMouseMove:p,onPaneMouseLeave:m,children:h}){let g=(0,y.useRef)(0),_=xc(),{userSelectionActive:v,elementsSelectable:b,dragging:C,panBy:w,autoPanSpeed:T}=G(Al,gc),E=b&&(e||v),D=(0,y.useRef)(null),O=(0,y.useRef)(),k=(0,y.useRef)(new Set),A=(0,y.useRef)(new Set),j=(0,y.useRef)(!1),M=(0,y.useRef)(!1),N=(0,y.useRef)({x:0,y:0}),P=(0,y.useRef)(!1),ee=e=>{if(M.current||j.current||_.getState().connection.inProgress){M.current=!1,j.current=!1;return}l?.(e),_.getState().resetSelectedElements(),_.setState({nodesSelectionActive:!1})},F=e=>{if(Array.isArray(r)&&r?.includes(2)){e.preventDefault();return}u?.(e)},I=d?e=>d(e):void 0,te=e=>{M.current&&=(e.stopPropagation(),!1)},ne=n=>{let{domNode:r,transform:i}=_.getState();if(O.current=r?.getBoundingClientRect(),!O.current)return;let a=n.target===D.current;if(!a&&n.target.closest(`.nokey`)||!e||!(o&&a||t)||n.button!==0||!n.isPrimary)return;n.target?.setPointerCapture?.(n.pointerId),M.current=!1;let{x:s,y:c}=To(n.nativeEvent,O.current),l=oo({x:s,y:c},i);_.setState({userSelectionRect:{width:0,height:0,startX:l.x,startY:l.y,x:s,y:c}}),a||(n.stopPropagation(),n.preventDefault())};function L(e,t){let{userSelectionRect:r}=_.getState();if(!r)return;let{transform:i,nodeLookup:a,edgeLookup:o,connectionLookup:s,triggerNodeChanges:c,triggerEdgeChanges:l,defaultEdgeOptions:u}=_.getState(),d={x:r.startX,y:r.startY},{x:f,y:p}=so(d,i),m={startX:d.x,startY:d.y,x:e<f?e:f,y:t<p?t:p,width:Math.abs(e-f),height:Math.abs(t-p)},h=k.current,g=A.current;k.current=new Set(La(a,m,i,n===Ta.Partial,!0).map(e=>e.id)),A.current=new Set;let v=u?.selectable??!0;for(let e of k.current){let t=s.get(e);if(t)for(let{edgeId:e}of t.values()){let t=o.get(e);t&&(t.selectable??v)&&A.current.add(e)}}go(h,k.current)||c(il(a,k.current,!0)),go(g,A.current)||l(il(o,A.current)),_.setState({userSelectionRect:m,userSelectionActive:!0,nodesSelectionActive:!1})}function R(){if(!i||!O.current)return;let[e,t]=qa(N.current,O.current,T);w({x:e,y:t}).then(e=>{if(!M.current||!e){g.current=requestAnimationFrame(R);return}let{x:t,y:n}=N.current;L(t,n),g.current=requestAnimationFrame(R)})}let z=()=>{cancelAnimationFrame(g.current),g.current=0,P.current=!1};return(0,y.useEffect)(()=>()=>z(),[]),(0,x.jsxs)(`div`,{className:S([`react-flow__pane`,{draggable:r===!0||Array.isArray(r)&&r.includes(0),dragging:C,selection:e}]),onClick:E?void 0:kl(ee,D),onContextMenu:kl(F,D),onWheel:kl(I,D),onPointerEnter:E?void 0:f,onPointerMove:E?e=>{let{userSelectionRect:n,transform:r,resetSelectedElements:i}=_.getState();if(!O.current||!n)return;let{x:o,y:c}=To(e.nativeEvent,O.current);N.current={x:o,y:c};let l=so({x:n.startX,y:n.startY},r);if(!M.current){let n=t?0:a;if(Math.hypot(o-l.x,c-l.y)<=n)return;i(),s?.(e)}M.current=!0,P.current||=(R(),!0),L(o,c)}:p,onPointerUp:e=>{if(!E){e.target===D.current&&_.getState().connection.inProgress&&(j.current=!0);return}e.button===0&&(e.target?.releasePointerCapture?.(e.pointerId),!v&&e.target===D.current&&_.getState().userSelectionRect&&ee?.(e),_.setState({userSelectionActive:!1,userSelectionRect:null}),M.current&&(c?.(e),_.setState({nodesSelectionActive:k.current.size>0})),z())},onPointerCancel:E?e=>{e.target?.releasePointerCapture?.(e.pointerId),z()}:void 0,onPointerDownCapture:E?ne:void 0,onClickCapture:E?te:void 0,onPointerLeave:m,ref:D,style:wl,children:[h,(0,x.jsx)(Ol,{})]})}function Ml({id:e,store:t,unselect:n=!1,nodeRef:r}){let{addSelectedNodes:i,unselectNodesAndEdges:a,multiSelectionActive:o,nodeLookup:s,onError:c}=t.getState(),l=s.get(e);if(!l){c?.(`012`,ya.error012(e));return}t.setState({nodesSelectionActive:!1}),l.selected?(n||l.selected&&o)&&(a({nodes:[l],edges:[]}),requestAnimationFrame(()=>r?.current?.blur())):i([e])}function Nl({nodeRef:e,disabled:t=!1,noDragClassName:n,handleSelector:r,nodeId:i,isSelectable:a,nodeClickDistance:o}){let s=xc(),[c,l]=(0,y.useState)(!1),u=(0,y.useRef)();return(0,y.useEffect)(()=>{u.current=bs({getStoreItems:()=>s.getState(),onNodeMouseDown:t=>{Ml({id:t,store:s,nodeRef:e})},onDragStart:()=>{l(!0)},onDragStop:()=>{l(!1)}})},[]),(0,y.useEffect)(()=>{if(!(t||!e.current||!u.current))return u.current.update({noDragClassName:n,handleSelector:r,domNode:e.current,isSelectable:a,nodeId:i,nodeClickDistance:o}),()=>{u.current?.destroy()}},[n,r,t,a,e,i,o]),c}var Pl=e=>t=>t.selected&&(t.draggable||e&&t.draggable===void 0);function Fl(){let e=xc();return(0,y.useCallback)(t=>{let{nodeExtent:n,snapToGrid:r,snapGrid:i,nodesDraggable:a,onError:o,updateNodePositions:s,nodeLookup:c,nodeOrigin:l}=e.getState(),u=new Map,d=Pl(a),f=r?i[0]:5,p=r?i[1]:5,m=t.direction.x*f*t.factor,h=t.direction.y*p*t.factor;for(let[,e]of c){if(!d(e))continue;let t={x:e.internals.positionAbsolute.x+m,y:e.internals.positionAbsolute.y+h};r&&(t=ao(t,i));let{position:a,positionAbsolute:s}=Va({nodeId:e.id,nextPosition:t,nodeLookup:c,nodeExtent:n,nodeOrigin:l,onError:o});e.position=a,e.internals.positionAbsolute=s,u.set(e.id,e)}s(u)},[])}var Il=(0,y.createContext)(null),Ll=Il.Provider;Il.Consumer;var Rl=()=>(0,y.useContext)(Il),K=e=>({connectOnClick:e.connectOnClick,noPanClassName:e.noPanClassName,rfId:e.rfId}),q=(0,y.createContext)(null);function J({children:e}){let t=G(K,gc);return(0,x.jsx)(q.Provider,{value:t,children:e})}function Y(){let e=(0,y.useContext)(q);if(!e)throw Error(`useHandleConfig must be used within a HandleConfigProvider`);return e}var X={connectingFrom:!1,connectingTo:!1,clickConnecting:!1,isPossibleEndHandle:!0,connectionInProcess:!1,clickConnectionInProcess:!1,valid:!1},zl=(e,t,n)=>r=>{let{connectionClickStartHandle:i,connectionMode:a,connection:o}=r,{fromHandle:s,toHandle:c,isValid:l}=o;if(!s&&!i)return X;let u=c?.nodeId===e&&c?.id===t&&c?.type===n;return{connectingFrom:s?.nodeId===e&&s?.id===t&&s?.type===n,connectingTo:u,clickConnecting:i?.nodeId===e&&i?.id===t&&i?.type===n,isPossibleEndHandle:a===Ca.Strict?s?.type!==n:e!==s?.nodeId||t!==s?.id,connectionInProcess:!!s,clickConnectionInProcess:!!i,valid:u&&l}};function Bl({type:e=`source`,position:t=H.Top,isValidConnection:n,isConnectable:r=!0,isConnectableStart:i=!0,isConnectableEnd:a=!0,id:o,onConnect:s,children:c,className:l,onMouseDown:u,onTouchStart:d,...f},p){let m=o||null,h=e===`target`,g=xc(),_=Rl(),{connectOnClick:v,noPanClassName:y,rfId:b}=Y(),{connectingFrom:C,connectingTo:w,clickConnecting:T,isPossibleEndHandle:E,connectionInProcess:D,clickConnectionInProcess:O,valid:k}=G(zl(_,m,e),gc);_||g.getState().onError?.(`010`,ya.error010());let A=e=>{let{defaultEdgeOptions:t,onConnect:n,hasDefaultEdges:r}=g.getState(),i={...t,...e};if(r){let{edges:e,setEdges:t,onError:n}=g.getState();t(cl(i,e,{onError:n}))}n?.(i),s?.(i)},j=e=>{if(!_)return;let t=wo(e.nativeEvent);if(i&&(t&&e.button===0||!t)){let t=g.getState();As.onPointerDown(e.nativeEvent,{handleDomNode:e.currentTarget,autoPanOnConnect:t.autoPanOnConnect,connectionMode:t.connectionMode,connectionRadius:t.connectionRadius,domNode:t.domNode,nodeLookup:t.nodeLookup,lib:t.lib,isTarget:h,handleId:m,nodeId:_,flowId:t.rfId,panBy:t.panBy,cancelConnection:t.cancelConnection,onConnectStart:t.onConnectStart,onConnectEnd:(...e)=>g.getState().onConnectEnd?.(...e),updateConnection:t.updateConnection,onConnect:A,isValidConnection:n||((...e)=>g.getState().isValidConnection?.(...e)??!0),getTransform:()=>g.getState().transform,getFromHandle:()=>g.getState().connection.fromHandle,autoPanSpeed:t.autoPanSpeed,dragThreshold:t.connectionDragThreshold})}t?u?.(e):d?.(e)};return(0,x.jsx)(`div`,{"data-handleid":m,"data-nodeid":_,"data-handlepos":t,"data-id":`${b}-${_}-${m}-${e}`,className:S([`react-flow__handle`,`react-flow__handle-${t}`,`nodrag`,y,l,{source:!h,target:h,connectable:r,connectablestart:i,connectableend:a,clickconnecting:T,connectingfrom:C,connectingto:w,valid:k,connectionindicator:r&&(!D||E)&&(D||O?a:i)}]),onMouseDown:j,onTouchStart:j,onClick:v?t=>{let{onClickConnectStart:r,onClickConnectEnd:a,connectionClickStartHandle:o,connectionMode:s,isValidConnection:c,lib:l,rfId:u,nodeLookup:d,connection:f}=g.getState();if(!_||!o&&!i)return;if(!o){r?.(t.nativeEvent,{nodeId:_,handleId:m,handleType:e}),g.setState({connectionClickStartHandle:{nodeId:_,type:e,id:m}});return}let p=xo(t.target),h=n||c,{connection:v,isValid:y}=As.isValid(t.nativeEvent,{handle:{nodeId:_,id:m,type:e},connectionMode:s,fromNodeId:o.nodeId,fromHandleId:o.id||null,fromType:o.type,isValidConnection:h,flowId:u,doc:p,lib:l,nodeLookup:d});y&&v&&A(v);let b=structuredClone(f);delete b.inProgress,b.toPosition=b.toHandle?b.toHandle.position:null,a?.(t,b),g.setState({connectionClickStartHandle:null})}:void 0,ref:p,...f,children:c})}var Vl=(0,y.memo)(dl(Bl));function Hl({data:e,isConnectable:t,sourcePosition:n=H.Bottom}){return(0,x.jsxs)(x.Fragment,{children:[e?.label,(0,x.jsx)(Vl,{type:`source`,position:n,isConnectable:t})]})}function Ul({data:e,isConnectable:t,targetPosition:n=H.Top,sourcePosition:r=H.Bottom}){return(0,x.jsxs)(x.Fragment,{children:[(0,x.jsx)(Vl,{type:`target`,position:n,isConnectable:t}),e?.label,(0,x.jsx)(Vl,{type:`source`,position:r,isConnectable:t})]})}function Wl(){return null}function Gl({data:e,isConnectable:t,targetPosition:n=H.Top}){return(0,x.jsxs)(x.Fragment,{children:[(0,x.jsx)(Vl,{type:`target`,position:n,isConnectable:t}),e?.label]})}var Kl={ArrowUp:{x:0,y:-1},ArrowDown:{x:0,y:1},ArrowLeft:{x:-1,y:0},ArrowRight:{x:1,y:0}},ql={input:Hl,default:Ul,output:Gl,group:Wl};function Jl(e){return e.internals.handleBounds===void 0?{width:e.width??e.initialWidth??e.style?.width,height:e.height??e.initialHeight??e.style?.height}:{width:e.width??e.style?.width,height:e.height??e.style?.height}}var Yl=e=>{let{width:t,height:n,x:r,y:i}=Ia(e.nodeLookup,{filter:e=>!!e.selected});return{width:ro(t)?t:null,height:ro(n)?n:null,userSelectionActive:e.userSelectionActive,transformString:`translate(${e.transform[0]}px,${e.transform[1]}px) scale(${e.transform[2]}) translate(${r}px,${i}px)`}};function Xl({onSelectionContextMenu:e,noPanClassName:t,disableKeyboardA11y:n}){let r=xc(),{width:i,height:a,transformString:o,userSelectionActive:s}=G(Yl,gc),c=Fl(),l=(0,y.useRef)(null);(0,y.useEffect)(()=>{n||l.current?.focus({preventScroll:!0})},[n]);let u=!s&&i!==null&&a!==null;if(Nl({nodeRef:l,disabled:!u}),!u)return null;let d=e?t=>{e(t,r.getState().nodes.filter(e=>e.selected))}:void 0;return(0,x.jsx)(`div`,{className:S([`react-flow__nodesselection`,`react-flow__container`,t]),style:{transform:o},children:(0,x.jsx)(`div`,{ref:l,className:`react-flow__nodesselection-rect`,onContextMenu:d,tabIndex:n?void 0:-1,onKeyDown:n?void 0:e=>{Object.prototype.hasOwnProperty.call(Kl,e.key)&&(e.preventDefault(),c({direction:Kl[e.key],factor:e.shiftKey?4:1}))},style:{width:i,height:a}})})}var Zl=typeof window<`u`?window:void 0,Ql=e=>({nodesSelectionActive:e.nodesSelectionActive,userSelectionActive:e.userSelectionActive});function $l({children:e,onPaneClick:t,onPaneMouseEnter:n,onPaneMouseMove:r,onPaneMouseLeave:i,onPaneContextMenu:a,onPaneScroll:o,paneClickDistance:s,deleteKeyCode:c,selectionKeyCode:l,selectionOnDrag:u,selectionMode:d,onSelectionStart:f,onSelectionEnd:p,multiSelectionKeyCode:m,panActivationKeyCode:h,zoomActivationKeyCode:g,elementsSelectable:_,zoomOnScroll:v,zoomOnPinch:y,panOnScroll:b,panOnScrollSpeed:S,panOnScrollMode:C,zoomOnDoubleClick:w,panOnDrag:T,autoPanOnSelection:E,defaultViewport:D,translateExtent:O,minZoom:k,maxZoom:A,preventScrolling:j,onSelectionContextMenu:M,noWheelClassName:N,noPanClassName:P,disableKeyboardA11y:ee,onViewportChange:F,isControlledViewport:I}){let{nodesSelectionActive:te,userSelectionActive:ne}=G(Ql,gc),L=Yc(l,{target:Zl}),R=Yc(h,{target:Zl}),z=R||T,B=R||b,re=u&&z!==!0,ie=L||ne||re;return Sl({deleteKeyCode:c,multiSelectionKeyCode:m}),(0,x.jsx)(El,{onPaneContextMenu:a,elementsSelectable:_,zoomOnScroll:v,zoomOnPinch:y,panOnScroll:B,panOnScrollSpeed:S,panOnScrollMode:C,zoomOnDoubleClick:w,panOnDrag:!L&&z,defaultViewport:D,translateExtent:O,minZoom:k,maxZoom:A,zoomActivationKeyCode:g,preventScrolling:j,noWheelClassName:N,noPanClassName:P,onViewportChange:F,isControlledViewport:I,paneClickDistance:s,selectionOnDrag:re,children:(0,x.jsxs)(jl,{onSelectionStart:f,onSelectionEnd:p,onPaneClick:t,onPaneMouseEnter:n,onPaneMouseMove:r,onPaneMouseLeave:i,onPaneContextMenu:a,onPaneScroll:o,panOnDrag:z,autoPanOnSelection:E,isSelecting:!!ie,selectionMode:d,selectionKeyPressed:L,paneClickDistance:s,selectionOnDrag:re,children:[e,te&&(0,x.jsx)(Xl,{onSelectionContextMenu:M,noPanClassName:P,disableKeyboardA11y:ee})]})})}$l.displayName=`FlowRenderer`;var eu=(0,y.memo)($l),tu=e=>t=>e?La(t.nodeLookup,{x:0,y:0,width:t.width,height:t.height},t.transform,!0).map(e=>e.id):Array.from(t.nodeLookup.keys());function nu(e){return G((0,y.useCallback)(tu(e),[e]),gc)}var ru=e=>e.updateNodeInternals;function iu(){let e=G(ru),[t]=(0,y.useState)(()=>typeof ResizeObserver>`u`?null:new ResizeObserver(t=>{let n=new Map;t.forEach(e=>{let t=e.target.getAttribute(`data-id`);n.set(t,{id:t,nodeElement:e.target,force:!0})}),e(n)}));return(0,y.useEffect)(()=>()=>{t?.disconnect()},[t]),t}function au({node:e,nodeType:t,hasDimensions:n,resizeObserver:r}){let i=xc(),a=(0,y.useRef)(null),o=(0,y.useRef)(null),s=(0,y.useRef)(e.sourcePosition),c=(0,y.useRef)(e.targetPosition),l=(0,y.useRef)(t),u=n&&!!e.internals.handleBounds;return(0,y.useEffect)(()=>{a.current&&!e.hidden&&(!u||o.current!==a.current)&&(o.current&&r?.unobserve(o.current),r?.observe(a.current),o.current=a.current)},[u,e.hidden]),(0,y.useEffect)(()=>()=>{o.current&&=(r?.unobserve(o.current),null)},[]),(0,y.useEffect)(()=>{if(a.current){let n=l.current!==t,r=s.current!==e.sourcePosition,o=c.current!==e.targetPosition;(n||r||o)&&(l.current=t,s.current=e.sourcePosition,c.current=e.targetPosition,i.getState().updateNodeInternals(new Map([[e.id,{id:e.id,nodeElement:a.current,force:!0}]])))}},[e.id,t,e.sourcePosition,e.targetPosition]),a}function ou({id:e,onClick:t,onMouseEnter:n,onMouseMove:r,onMouseLeave:i,onContextMenu:a,onDoubleClick:o,nodesDraggable:s,elementsSelectable:c,nodesConnectable:l,nodesFocusable:u,resizeObserver:d,noDragClassName:f,noPanClassName:p,disableKeyboardA11y:m,rfId:h,nodeTypes:g,nodeClickDistance:_,onError:v}){let{node:y,internals:b,isParent:C}=G(t=>{let n=t.nodeLookup.get(e),r=t.parentLookup.has(e);return{node:n,internals:n.internals,isParent:r}},gc),w=y.type||`default`,T=g?.[w]||ql[w];T===void 0&&(v?.(`003`,ya.error003(w)),w=`default`,T=g?.default||ql.default);let E=!!(y.draggable||s&&y.draggable===void 0),D=!!(y.selectable||c&&y.selectable===void 0),O=!!(y.connectable||l&&y.connectable===void 0),k=!!(y.focusable||u&&y.focusable===void 0),A=xc(),j=mo(y),M=au({node:y,nodeType:w,hasDimensions:j,resizeObserver:d}),N=Nl({nodeRef:M,disabled:y.hidden||!E,noDragClassName:f,handleSelector:y.dragHandle,nodeId:e,isSelectable:D,nodeClickDistance:_}),P=Fl();if(y.hidden)return null;let ee=po(y),F=Jl(y),I=D||E||t||n||r||i,te=n?e=>n(e,{...b.userNode}):void 0,ne=r?e=>r(e,{...b.userNode}):void 0,L=i?e=>i(e,{...b.userNode}):void 0,R=a?e=>a(e,{...b.userNode}):void 0,z=o?e=>o(e,{...b.userNode}):void 0,B=n=>{let{selectNodesOnDrag:r,nodeDragThreshold:i}=A.getState();D&&(!r||!E||i>0)&&Ml({id:e,store:A,nodeRef:M}),t&&t(n,{...b.userNode})},re=t=>{if(!(Co(t.nativeEvent)||m)){if(xa.includes(t.key)&&D)Ml({id:e,store:A,unselect:t.key===`Escape`,nodeRef:M});else if(E&&y.selected&&Object.prototype.hasOwnProperty.call(Kl,t.key)){t.preventDefault();let{ariaLabelConfig:e}=A.getState();A.setState({ariaLiveMessage:e[`node.a11yDescription.ariaLiveMessage`]({direction:t.key.replace(`Arrow`,``).toLowerCase(),x:~~b.positionAbsolute.x,y:~~b.positionAbsolute.y})}),P({direction:Kl[t.key],factor:t.shiftKey?4:1})}}},ie=()=>{if(m||!M.current?.matches(`:focus-visible`))return;let{transform:t,width:n,height:r,autoPanOnNodeFocus:i,setCenter:a}=A.getState();i&&(La(new Map([[e,y]]),{x:0,y:0,width:n,height:r},t,!0).length>0||a(y.position.x+ee.width/2,y.position.y+ee.height/2,{zoom:t[2]}))};return(0,x.jsx)(`div`,{className:S([`react-flow__node`,`react-flow__node-${w}`,{[p]:E},y.className,{selected:y.selected,selectable:D,parent:C,draggable:E,dragging:N}]),ref:M,style:{zIndex:b.z,transform:`translate(${b.positionAbsolute.x}px,${b.positionAbsolute.y}px)`,pointerEvents:I?`all`:`none`,visibility:j?`visible`:`hidden`,...y.style,...F},"data-id":e,"data-testid":`rf__node-${e}`,onMouseEnter:te,onMouseMove:ne,onMouseLeave:L,onContextMenu:R,onClick:B,onDoubleClick:z,onKeyDown:k?re:void 0,tabIndex:k?0:void 0,onFocus:k?ie:void 0,role:y.ariaRole??(k?`group`:void 0),"aria-roledescription":`node`,"aria-describedby":m?void 0:`${wc}-${h}`,"aria-label":y.ariaLabel,...y.domAttributes,children:(0,x.jsx)(Ll,{value:e,children:(0,x.jsx)(T,{id:e,data:y.data,type:w,positionAbsoluteX:b.positionAbsolute.x,positionAbsoluteY:b.positionAbsolute.y,selected:y.selected??!1,selectable:D,draggable:E,deletable:y.deletable??!0,isConnectable:O,sourcePosition:y.sourcePosition,targetPosition:y.targetPosition,dragging:N,dragHandle:y.dragHandle,zIndex:b.z,parentId:y.parentId,...ee})})})}var su=(0,y.memo)(ou),cu=e=>({nodesDraggable:e.nodesDraggable,nodesConnectable:e.nodesConnectable,nodesFocusable:e.nodesFocusable,elementsSelectable:e.elementsSelectable,onError:e.onError});function lu(e){let{nodesDraggable:t,nodesConnectable:n,nodesFocusable:r,elementsSelectable:i,onError:a}=G(cu,gc),o=nu(e.onlyRenderVisibleElements),s=iu();return(0,x.jsx)(`div`,{className:`react-flow__nodes`,style:wl,children:o.map(o=>(0,x.jsx)(su,{id:o,nodeTypes:e.nodeTypes,nodeExtent:e.nodeExtent,onClick:e.onNodeClick,onMouseEnter:e.onNodeMouseEnter,onMouseMove:e.onNodeMouseMove,onMouseLeave:e.onNodeMouseLeave,onContextMenu:e.onNodeContextMenu,onDoubleClick:e.onNodeDoubleClick,noDragClassName:e.noDragClassName,noPanClassName:e.noPanClassName,rfId:e.rfId,disableKeyboardA11y:e.disableKeyboardA11y,resizeObserver:s,nodesDraggable:t,nodesConnectable:n,nodesFocusable:r,elementsSelectable:i,nodeClickDistance:e.nodeClickDistance,onError:a},o))})}lu.displayName=`NodeRenderer`;var uu=(0,y.memo)(lu);function du(e){return G((0,y.useCallback)(t=>{if(!e)return t.edges.map(e=>e.id);let n=[];if(t.width&&t.height)for(let e of t.edges){let r=t.nodeLookup.get(e.source),i=t.nodeLookup.get(e.target);r&&i&&No({sourceNode:r,targetNode:i,width:t.width,height:t.height,transform:t.transform})&&n.push(e.id)}return n},[e]),gc)}var fu=({color:e=`none`,strokeWidth:t=1})=>(0,x.jsx)(`polyline`,{className:`arrow`,style:{strokeWidth:t,...e&&{stroke:e}},strokeLinecap:`round`,fill:`none`,strokeLinejoin:`round`,points:`-5,-4 0,0 -5,4`}),pu=({color:e=`none`,strokeWidth:t=1})=>(0,x.jsx)(`polyline`,{className:`arrowclosed`,style:{strokeWidth:t,...e&&{stroke:e,fill:e}},strokeLinecap:`round`,strokeLinejoin:`round`,points:`-5,-4 0,0 -5,4 -5,-4`}),mu={[Oa.Arrow]:fu,[Oa.ArrowClosed]:pu};function hu(e){let t=xc();return(0,y.useMemo)(()=>Object.prototype.hasOwnProperty.call(mu,e)?mu[e]:(t.getState().onError?.(`009`,ya.error009(e)),null),[e])}var gu=({id:e,type:t,color:n,width:r=12.5,height:i=12.5,markerUnits:a=`strokeWidth`,strokeWidth:o,orient:s=`auto-start-reverse`})=>{let c=hu(t);return c?(0,x.jsx)(`marker`,{className:`react-flow__arrowhead`,id:e,markerWidth:`${r}`,markerHeight:`${i}`,viewBox:`-10 -10 20 20`,markerUnits:a,orient:s,refX:`0`,refY:`0`,children:(0,x.jsx)(c,{color:n,strokeWidth:o})}):null},_u=({defaultColor:e,rfId:t})=>{let n=G(e=>e.edges),r=G(e=>e.defaultEdgeOptions),i=(0,y.useMemo)(()=>Xo(n,{id:t,defaultColor:e,defaultMarkerStart:r?.markerStart,defaultMarkerEnd:r?.markerEnd}),[n,r,t,e]);return i.length?(0,x.jsx)(`svg`,{className:`react-flow__marker`,"aria-hidden":`true`,children:(0,x.jsx)(`defs`,{children:i.map(e=>(0,x.jsx)(gu,{id:e.id,type:e.type,color:e.color,width:e.width,height:e.height,markerUnits:e.markerUnits,strokeWidth:e.strokeWidth,orient:e.orient},e.id))})}):null};_u.displayName=`MarkerDefinitions`;var vu=(0,y.memo)(_u);function yu({x:e,y:t,label:n,labelStyle:r,labelShowBg:i=!0,labelBgStyle:a,labelBgPadding:o=[2,4],labelBgBorderRadius:s=2,children:c,className:l,...u}){let[d,f]=(0,y.useState)({x:1,y:0,width:0,height:0}),p=S([`react-flow__edge-textwrapper`,l]),m=(0,y.useRef)(null);return(0,y.useEffect)(()=>{if(m.current){let e=m.current.getBBox();f({x:e.x,y:e.y,width:e.width,height:e.height})}},[n]),n?(0,x.jsxs)(`g`,{transform:`translate(${e-d.width/2} ${t-d.height/2})`,className:p,visibility:d.width?`visible`:`hidden`,...u,children:[i&&(0,x.jsx)(`rect`,{width:d.width+2*o[0],x:-o[0],y:-o[1],height:d.height+2*o[1],className:`react-flow__edge-textbg`,style:a,rx:s,ry:s}),(0,x.jsx)(`text`,{className:`react-flow__edge-text`,y:d.height/2,dy:`0.3em`,ref:m,style:r,children:n}),c]}):null}yu.displayName=`EdgeText`;var bu=(0,y.memo)(yu);function xu({path:e,labelX:t,labelY:n,label:r,labelStyle:i,labelShowBg:a,labelBgStyle:o,labelBgPadding:s,labelBgBorderRadius:c,interactionWidth:l=20,...u}){return(0,x.jsxs)(x.Fragment,{children:[(0,x.jsx)(`path`,{...u,d:e,fill:`none`,className:S([`react-flow__edge-path`,u.className])}),l?(0,x.jsx)(`path`,{d:e,fill:`none`,strokeOpacity:0,strokeWidth:l,className:`react-flow__edge-interaction`}):null,r&&ro(t)&&ro(n)?(0,x.jsx)(bu,{x:t,y:n,label:r,labelStyle:i,labelShowBg:a,labelBgStyle:o,labelBgPadding:s,labelBgBorderRadius:c}):null]})}function Su({pos:e,x1:t,y1:n,x2:r,y2:i}){return e===H.Left||e===H.Right?[.5*(t+r),n]:[t,.5*(n+i)]}function Cu({sourceX:e,sourceY:t,sourcePosition:n=H.Bottom,targetX:r,targetY:i,targetPosition:a=H.Top}){let[o,s]=Su({pos:n,x1:e,y1:t,x2:r,y2:i}),[c,l]=Su({pos:a,x1:r,y1:i,x2:e,y2:t}),[u,d,f,p]=Do({sourceX:e,sourceY:t,targetX:r,targetY:i,sourceControlX:o,sourceControlY:s,targetControlX:c,targetControlY:l});return[`M${e},${t} C${o},${s} ${c},${l} ${r},${i}`,u,d,f,p]}function wu(e){return(0,y.memo)(({id:t,sourceX:n,sourceY:r,targetX:i,targetY:a,sourcePosition:o,targetPosition:s,label:c,labelStyle:l,labelShowBg:u,labelBgStyle:d,labelBgPadding:f,labelBgBorderRadius:p,style:m,markerEnd:h,markerStart:g,interactionWidth:_})=>{let[v,y,b]=Cu({sourceX:n,sourceY:r,sourcePosition:o,targetX:i,targetY:a,targetPosition:s});return(0,x.jsx)(xu,{id:e.isInternal?void 0:t,path:v,labelX:y,labelY:b,label:c,labelStyle:l,labelShowBg:u,labelBgStyle:d,labelBgPadding:f,labelBgBorderRadius:p,style:m,markerEnd:h,markerStart:g,interactionWidth:_})})}var Tu=wu({isInternal:!1}),Eu=wu({isInternal:!0});Tu.displayName=`SimpleBezierEdge`,Eu.displayName=`SimpleBezierEdgeInternal`;function Du(e){return(0,y.memo)(({id:t,sourceX:n,sourceY:r,targetX:i,targetY:a,label:o,labelStyle:s,labelShowBg:c,labelBgStyle:l,labelBgPadding:u,labelBgBorderRadius:d,style:f,sourcePosition:p=H.Bottom,targetPosition:m=H.Top,markerEnd:h,markerStart:g,pathOptions:_,interactionWidth:v})=>{let[y,b,S]=Uo({sourceX:n,sourceY:r,sourcePosition:p,targetX:i,targetY:a,targetPosition:m,borderRadius:_?.borderRadius,offset:_?.offset,stepPosition:_?.stepPosition});return(0,x.jsx)(xu,{id:e.isInternal?void 0:t,path:y,labelX:b,labelY:S,label:o,labelStyle:s,labelShowBg:c,labelBgStyle:l,labelBgPadding:u,labelBgBorderRadius:d,style:f,markerEnd:h,markerStart:g,interactionWidth:v})})}var Ou=Du({isInternal:!1}),ku=Du({isInternal:!0});Ou.displayName=`SmoothStepEdge`,ku.displayName=`SmoothStepEdgeInternal`;function Au(e){return(0,y.memo)(({id:t,...n})=>{let r=e.isInternal?void 0:t;return(0,x.jsx)(Ou,{...n,id:r,pathOptions:(0,y.useMemo)(()=>({borderRadius:0,offset:n.pathOptions?.offset}),[n.pathOptions?.offset])})})}var ju=Au({isInternal:!1}),Mu=Au({isInternal:!0});ju.displayName=`StepEdge`,Mu.displayName=`StepEdgeInternal`;function Nu(e){return(0,y.memo)(({id:t,sourceX:n,sourceY:r,targetX:i,targetY:a,label:o,labelStyle:s,labelShowBg:c,labelBgStyle:l,labelBgPadding:u,labelBgBorderRadius:d,style:f,markerEnd:p,markerStart:m,interactionWidth:h})=>{let[g,_,v]=Lo({sourceX:n,sourceY:r,targetX:i,targetY:a});return(0,x.jsx)(xu,{id:e.isInternal?void 0:t,path:g,labelX:_,labelY:v,label:o,labelStyle:s,labelShowBg:c,labelBgStyle:l,labelBgPadding:u,labelBgBorderRadius:d,style:f,markerEnd:p,markerStart:m,interactionWidth:h})})}var Pu=Nu({isInternal:!1}),Fu=Nu({isInternal:!0});Pu.displayName=`StraightEdge`,Fu.displayName=`StraightEdgeInternal`;function Iu(e){return(0,y.memo)(({id:t,sourceX:n,sourceY:r,targetX:i,targetY:a,sourcePosition:o=H.Bottom,targetPosition:s=H.Top,label:c,labelStyle:l,labelShowBg:u,labelBgStyle:d,labelBgPadding:f,labelBgBorderRadius:p,style:m,markerEnd:h,markerStart:g,pathOptions:_,interactionWidth:v})=>{let[y,b,S]=Ao({sourceX:n,sourceY:r,sourcePosition:o,targetX:i,targetY:a,targetPosition:s,curvature:_?.curvature});return(0,x.jsx)(xu,{id:e.isInternal?void 0:t,path:y,labelX:b,labelY:S,label:c,labelStyle:l,labelShowBg:u,labelBgStyle:d,labelBgPadding:f,labelBgBorderRadius:p,style:m,markerEnd:h,markerStart:g,interactionWidth:v})})}var Lu=Iu({isInternal:!1}),Ru=Iu({isInternal:!0});Lu.displayName=`BezierEdge`,Ru.displayName=`BezierEdgeInternal`;var zu={default:Ru,straight:Fu,step:Mu,smoothstep:ku,simplebezier:Eu},Bu={sourceX:null,sourceY:null,targetX:null,targetY:null,sourcePosition:null,targetPosition:null,zIndex:void 0},Vu=(e,t,n)=>n===H.Left?e-t:n===H.Right?e+t:e,Hu=(e,t,n)=>n===H.Top?e-t:n===H.Bottom?e+t:e,Uu=`react-flow__edgeupdater`;function Wu({position:e,centerX:t,centerY:n,radius:r=10,onMouseDown:i,onMouseEnter:a,onMouseOut:o,type:s}){return(0,x.jsx)(`circle`,{onMouseDown:i,onMouseEnter:a,onMouseOut:o,className:S([Uu,`${Uu}-${s}`]),cx:Vu(t,r,e),cy:Hu(n,r,e),r,stroke:`transparent`,fill:`transparent`})}function Z({isReconnectable:e,reconnectRadius:t,edge:n,sourceX:r,sourceY:i,targetX:a,targetY:o,sourcePosition:s,targetPosition:c,onReconnect:l,onReconnectStart:u,onReconnectEnd:d,setReconnecting:f,setUpdateHover:p}){let m=xc(),h=(e,t)=>{if(e.button!==0)return;let{autoPanOnConnect:r,domNode:i,connectionMode:a,connectionRadius:o,lib:s,onConnectStart:c,cancelConnection:p,nodeLookup:h,rfId:g,panBy:_,updateConnection:v}=m.getState(),y=t.type===`target`;As.onPointerDown(e.nativeEvent,{autoPanOnConnect:r,connectionMode:a,connectionRadius:o,domNode:i,handleId:t.id,nodeId:t.nodeId,nodeLookup:h,isTarget:y,edgeUpdaterType:t.type,lib:s,flowId:g,cancelConnection:p,panBy:_,isValidConnection:(...e)=>m.getState().isValidConnection?.(...e)??!0,onConnect:e=>l?.(n,e),onConnectStart:(r,i)=>{f(!0),u?.(e,n,t.type),c?.(r,i)},onConnectEnd:(...e)=>m.getState().onConnectEnd?.(...e),onReconnectEnd:(e,r)=>{f(!1),d?.(e,n,t.type,r)},updateConnection:v,getTransform:()=>m.getState().transform,getFromHandle:()=>m.getState().connection.fromHandle,dragThreshold:m.getState().connectionDragThreshold,handleDomNode:e.currentTarget})},g=e=>h(e,{nodeId:n.target,id:n.targetHandle??null,type:`target`}),_=e=>h(e,{nodeId:n.source,id:n.sourceHandle??null,type:`source`}),v=()=>p(!0),y=()=>p(!1);return(0,x.jsxs)(x.Fragment,{children:[(e===!0||e===`source`)&&(0,x.jsx)(Wu,{position:s,centerX:r,centerY:i,radius:t,onMouseDown:g,onMouseEnter:v,onMouseOut:y,type:`source`}),(e===!0||e===`target`)&&(0,x.jsx)(Wu,{position:c,centerX:a,centerY:o,radius:t,onMouseDown:_,onMouseEnter:v,onMouseOut:y,type:`target`})]})}function Gu({id:e,edgesFocusable:t,edgesReconnectable:n,elementsSelectable:r,onClick:i,onDoubleClick:a,onContextMenu:o,onMouseEnter:s,onMouseMove:c,onMouseLeave:l,reconnectRadius:u,onReconnect:d,onReconnectStart:f,onReconnectEnd:p,rfId:m,edgeTypes:h,noPanClassName:g,onError:_,disableKeyboardA11y:v}){let b=G(t=>t.edgeLookup.get(e)),C=G(e=>e.defaultEdgeOptions);b=C?{...C,...b}:b;let w=b.type||`default`,T=h?.[w]||zu[w];T===void 0&&(_?.(`011`,ya.error011(w)),w=`default`,T=h?.default||zu.default);let E=!!(b.focusable||t&&b.focusable===void 0),D=d!==void 0&&(b.reconnectable||n&&b.reconnectable===void 0),O=!!(b.selectable||r&&b.selectable===void 0),k=(0,y.useRef)(null),[A,j]=(0,y.useState)(!1),[M,N]=(0,y.useState)(!1),P=xc(),{zIndex:ee=b.zIndex,sourceX:F,sourceY:I,targetX:te,targetY:ne,sourcePosition:L,targetPosition:R}=G((0,y.useCallback)(t=>{let n=t.nodeLookup.get(b.source),r=t.nodeLookup.get(b.target);if(!n||!r)return Bu;let i=Go({id:e,sourceNode:n,targetNode:r,sourceHandle:b.sourceHandle||null,targetHandle:b.targetHandle||null,connectionMode:t.connectionMode,onError:_}),a=Mo({selected:b.selected,zIndex:b.zIndex,sourceNode:n,targetNode:r,elevateOnSelect:t.elevateEdgesOnSelect,zIndexMode:t.zIndexMode});return{...i||Bu,zIndex:a}},[b.source,b.target,b.sourceHandle,b.targetHandle,b.selected,b.zIndex]),gc),z=(0,y.useMemo)(()=>b.markerStart?`url('#${Yo(b.markerStart,m)}')`:void 0,[b.markerStart,m]),B=(0,y.useMemo)(()=>b.markerEnd?`url('#${Yo(b.markerEnd,m)}')`:void 0,[b.markerEnd,m]);if(b.hidden||F===null||I===null||te===null||ne===null)return null;let re=t=>{let{addSelectedEdges:n,unselectNodesAndEdges:r,multiSelectionActive:a}=P.getState();O&&(P.setState({nodesSelectionActive:!1}),b.selected&&a?(r({nodes:[],edges:[b]}),k.current?.blur()):n([e])),i&&i(t,b)},ie=a?e=>{a(e,{...b})}:void 0,ae=o?e=>{o(e,{...b})}:void 0,oe=s?e=>{s(e,{...b})}:void 0,se=c?e=>{c(e,{...b})}:void 0,ce=l?e=>{l(e,{...b})}:void 0;return(0,x.jsx)(`svg`,{style:{zIndex:ee},children:(0,x.jsxs)(`g`,{className:S([`react-flow__edge`,`react-flow__edge-${w}`,b.className,g,{selected:b.selected,animated:b.animated,inactive:!O&&!i,updating:A,selectable:O}]),onClick:re,onDoubleClick:ie,onContextMenu:ae,onMouseEnter:oe,onMouseMove:se,onMouseLeave:ce,onKeyDown:E?t=>{if(!v&&xa.includes(t.key)&&O){let{unselectNodesAndEdges:n,addSelectedEdges:r}=P.getState();t.key===`Escape`?(k.current?.blur(),n({edges:[b]})):r([e])}}:void 0,tabIndex:E?0:void 0,role:b.ariaRole??(E?`group`:`img`),"aria-roledescription":`edge`,"data-id":e,"data-testid":`rf__edge-${e}`,"aria-label":b.ariaLabel===null?void 0:b.ariaLabel||`Edge from ${b.source} to ${b.target}`,"aria-describedby":E?`${Tc}-${m}`:void 0,ref:k,...b.domAttributes,children:[!M&&(0,x.jsx)(T,{id:e,source:b.source,target:b.target,type:b.type,selected:b.selected,animated:b.animated,selectable:O,deletable:b.deletable??!0,label:b.label,labelStyle:b.labelStyle,labelShowBg:b.labelShowBg,labelBgStyle:b.labelBgStyle,labelBgPadding:b.labelBgPadding,labelBgBorderRadius:b.labelBgBorderRadius,sourceX:F,sourceY:I,targetX:te,targetY:ne,sourcePosition:L,targetPosition:R,data:b.data,style:b.style,sourceHandleId:b.sourceHandle,targetHandleId:b.targetHandle,markerStart:z,markerEnd:B,pathOptions:`pathOptions`in b?b.pathOptions:void 0,interactionWidth:b.interactionWidth}),D&&(0,x.jsx)(Z,{edge:b,isReconnectable:D,reconnectRadius:u,onReconnect:d,onReconnectStart:f,onReconnectEnd:p,sourceX:F,sourceY:I,targetX:te,targetY:ne,sourcePosition:L,targetPosition:R,setUpdateHover:j,setReconnecting:N})]})})}var Ku=(0,y.memo)(Gu),qu=e=>({edgesFocusable:e.edgesFocusable,edgesReconnectable:e.edgesReconnectable,elementsSelectable:e.elementsSelectable,connectionMode:e.connectionMode,onError:e.onError});function Ju({defaultMarkerColor:e,onlyRenderVisibleElements:t,rfId:n,edgeTypes:r,noPanClassName:i,onReconnect:a,onEdgeContextMenu:o,onEdgeMouseEnter:s,onEdgeMouseMove:c,onEdgeMouseLeave:l,onEdgeClick:u,reconnectRadius:d,onEdgeDoubleClick:f,onReconnectStart:p,onReconnectEnd:m,disableKeyboardA11y:h}){let{edgesFocusable:g,edgesReconnectable:_,elementsSelectable:v,onError:y}=G(qu,gc),b=du(t);return(0,x.jsxs)(`div`,{className:`react-flow__edges`,children:[(0,x.jsx)(vu,{defaultColor:e,rfId:n}),b.map(e=>(0,x.jsx)(Ku,{id:e,edgesFocusable:g,edgesReconnectable:_,elementsSelectable:v,noPanClassName:i,onReconnect:a,onContextMenu:o,onMouseEnter:s,onMouseMove:c,onMouseLeave:l,onClick:u,reconnectRadius:d,onDoubleClick:f,onReconnectStart:p,onReconnectEnd:m,rfId:n,onError:y,edgeTypes:r,disableKeyboardA11y:h},e))]})}Ju.displayName=`EdgeRenderer`;var Yu=(0,y.memo)(Ju),Xu=e=>`translate(${e.transform[0]}px,${e.transform[1]}px) scale(${e.transform[2]})`;function Zu({children:e}){return(0,x.jsx)(`div`,{className:`react-flow__viewport xyflow__viewport react-flow__container`,style:{transform:G(Xu)},children:e})}function Qu(e){let t=yl(),n=(0,y.useRef)(!1);(0,y.useEffect)(()=>{!n.current&&t.viewportInitialized&&e&&(setTimeout(()=>e(t),1),n.current=!0)},[e,t.viewportInitialized])}var $u=e=>e.panZoom?.syncViewport;function ed(e){let t=G($u),n=xc();return(0,y.useEffect)(()=>{e&&(t?.(e),n.setState({transform:[e.x,e.y,e.zoom]}))},[e,t]),null}function td(e){return e.connection.inProgress?{...e.connection,to:oo(e.connection.to,e.transform)}:{...e.connection}}function nd(e){return e?t=>e(td(t)):td}function rd(e){return G(nd(e),gc)}var id=e=>({nodesConnectable:e.nodesConnectable,isValid:e.connection.isValid,inProgress:e.connection.inProgress,width:e.width,height:e.height});function ad({containerStyle:e,style:t,type:n,component:r}){let{nodesConnectable:i,width:a,height:o,isValid:s,inProgress:c}=G(id,gc);return a&&i&&c?(0,x.jsx)(`svg`,{style:e,width:a,height:o,className:`react-flow__connectionline react-flow__container`,children:(0,x.jsx)(`g`,{className:S([`react-flow__connection`,Aa(s)]),children:(0,x.jsx)(od,{style:t,type:n,CustomComponent:r,isValid:s})})}):null}var od=({style:e,type:t=Da.Bezier,CustomComponent:n,isValid:r})=>{let{inProgress:i,from:a,fromNode:o,fromHandle:s,fromPosition:c,to:l,toNode:u,toHandle:d,toPosition:f,pointer:p}=rd();if(!i)return;if(n)return(0,x.jsx)(n,{connectionLineType:t,connectionLineStyle:e,fromNode:o,fromHandle:s,fromX:a.x,fromY:a.y,toX:l.x,toY:l.y,fromPosition:c,toPosition:f,connectionStatus:Aa(r),toNode:u,toHandle:d,pointer:p});let m=``,h={sourceX:a.x,sourceY:a.y,sourcePosition:c,targetX:l.x,targetY:l.y,targetPosition:f};switch(t){case Da.Bezier:[m]=Ao(h);break;case Da.SimpleBezier:[m]=Cu(h);break;case Da.Step:[m]=Uo({...h,borderRadius:0});break;case Da.SmoothStep:[m]=Uo(h);break;default:[m]=Lo(h)}return(0,x.jsx)(`path`,{d:m,fill:`none`,className:`react-flow__connection-path`,style:e})};od.displayName=`ConnectionLine`;var sd={};function cd(e=sd){(0,y.useRef)(e),xc(),(0,y.useEffect)(()=>{},[e])}function ld(){xc(),(0,y.useRef)(!1),(0,y.useEffect)(()=>{},[])}function ud({nodeTypes:e,edgeTypes:t,onInit:n,onNodeClick:r,onEdgeClick:i,onNodeDoubleClick:a,onEdgeDoubleClick:o,onNodeMouseEnter:s,onNodeMouseMove:c,onNodeMouseLeave:l,onNodeContextMenu:u,onSelectionContextMenu:d,onSelectionStart:f,onSelectionEnd:p,connectionLineType:m,connectionLineStyle:h,connectionLineComponent:g,connectionLineContainerStyle:_,selectionKeyCode:v,selectionOnDrag:y,selectionMode:b,multiSelectionKeyCode:S,panActivationKeyCode:C,zoomActivationKeyCode:w,deleteKeyCode:T,onlyRenderVisibleElements:E,elementsSelectable:D,defaultViewport:O,translateExtent:k,minZoom:A,maxZoom:j,preventScrolling:M,defaultMarkerColor:N,zoomOnScroll:P,zoomOnPinch:ee,panOnScroll:F,panOnScrollSpeed:I,panOnScrollMode:te,zoomOnDoubleClick:ne,panOnDrag:L,autoPanOnSelection:R,onPaneClick:z,onPaneMouseEnter:B,onPaneMouseMove:re,onPaneMouseLeave:ie,onPaneScroll:ae,onPaneContextMenu:oe,paneClickDistance:se,nodeClickDistance:ce,onEdgeContextMenu:le,onEdgeMouseEnter:ue,onEdgeMouseMove:de,onEdgeMouseLeave:fe,reconnectRadius:pe,onReconnect:me,onReconnectStart:he,onReconnectEnd:ge,noDragClassName:_e,noWheelClassName:ve,noPanClassName:ye,disableKeyboardA11y:be,nodeExtent:xe,rfId:Se,viewport:Ce,onViewportChange:we}){return cd(e),cd(t),ld(),Qu(n),ed(Ce),(0,x.jsx)(eu,{onPaneClick:z,onPaneMouseEnter:B,onPaneMouseMove:re,onPaneMouseLeave:ie,onPaneContextMenu:oe,onPaneScroll:ae,paneClickDistance:se,deleteKeyCode:T,selectionKeyCode:v,selectionOnDrag:y,selectionMode:b,onSelectionStart:f,onSelectionEnd:p,multiSelectionKeyCode:S,panActivationKeyCode:C,zoomActivationKeyCode:w,elementsSelectable:D,zoomOnScroll:P,zoomOnPinch:ee,zoomOnDoubleClick:ne,panOnScroll:F,panOnScrollSpeed:I,panOnScrollMode:te,panOnDrag:L,autoPanOnSelection:R,defaultViewport:O,translateExtent:k,minZoom:A,maxZoom:j,onSelectionContextMenu:d,preventScrolling:M,noDragClassName:_e,noWheelClassName:ve,noPanClassName:ye,disableKeyboardA11y:be,onViewportChange:we,isControlledViewport:!!Ce,children:(0,x.jsxs)(Zu,{children:[(0,x.jsx)(Yu,{edgeTypes:t,onEdgeClick:i,onEdgeDoubleClick:o,onReconnect:me,onReconnectStart:he,onReconnectEnd:ge,onlyRenderVisibleElements:E,onEdgeContextMenu:le,onEdgeMouseEnter:ue,onEdgeMouseMove:de,onEdgeMouseLeave:fe,reconnectRadius:pe,defaultMarkerColor:N,noPanClassName:ye,disableKeyboardA11y:be,rfId:Se}),(0,x.jsx)(ad,{style:h,type:m,component:g,containerStyle:_}),(0,x.jsx)(`div`,{className:`react-flow__edgelabel-renderer`}),(0,x.jsx)(uu,{nodeTypes:e,onNodeClick:r,onNodeDoubleClick:a,onNodeMouseEnter:s,onNodeMouseMove:c,onNodeMouseLeave:l,onNodeContextMenu:u,nodeClickDistance:ce,onlyRenderVisibleElements:E,noPanClassName:ye,noDragClassName:_e,disableKeyboardA11y:be,nodeExtent:xe,rfId:Se}),(0,x.jsx)(`div`,{className:`react-flow__viewport-portal`})]})})}ud.displayName=`GraphView`;var dd=(0,y.memo)(ud),fd=io(`React Flow`,`https://reactflow.dev/`),pd=({nodes:e,edges:t,defaultNodes:n,defaultEdges:r,width:i,height:a,fitView:o,fitViewOptions:s,minZoom:c=.5,maxZoom:l=2,nodeOrigin:u,nodeExtent:d,zIndexMode:f=`basic`}={})=>{let p=new Map,m=new Map,h=new Map,g=new Map,_=r??t??[],v=n??e??[],y=u??[0,0],b=d??ba;ms(h,g,_);let{nodesInitialized:x}=as(v,p,m,{nodeOrigin:y,nodeExtent:b,zIndexMode:f}),S=[0,0,1];if(o&&i&&a){let{x:e,y:t,zoom:n}=W(Ia(p,{filter:e=>!!((e.width||e.initialWidth)&&(e.height||e.initialHeight))}),i,a,c,l,s?.padding??.1);S=[e,t,n]}return{rfId:`1`,width:i??0,height:a??0,transform:S,nodes:v,nodesInitialized:x,nodeLookup:p,parentLookup:m,edges:_,edgeLookup:g,connectionLookup:h,onNodesChange:null,onEdgesChange:null,hasDefaultNodes:n!==void 0,hasDefaultEdges:r!==void 0,panZoom:null,minZoom:c,maxZoom:l,translateExtent:ba,nodeExtent:b,nodesSelectionActive:!1,userSelectionActive:!1,userSelectionRect:null,connectionMode:Ca.Strict,domNode:null,paneDragging:!1,noPanClassName:`nopan`,nodeOrigin:y,nodeDragThreshold:1,connectionDragThreshold:1,snapGrid:[15,15],snapToGrid:!1,nodesDraggable:!0,nodesConnectable:!0,nodesFocusable:!0,edgesFocusable:!0,edgesReconnectable:!0,elementsSelectable:!0,elevateNodesOnSelect:!0,elevateEdgesOnSelect:!0,selectNodesOnDrag:!0,multiSelectionActive:!1,fitViewQueued:o??!1,fitViewOptions:s,fitViewResolver:null,connection:{...Ea},connectionClickStartHandle:null,connectOnClick:!0,ariaLiveMessage:``,autoPanOnConnect:!0,autoPanOnNodeDrag:!0,autoPanOnNodeFocus:!0,autoPanSpeed:15,connectionRadius:20,onError:fd,isValidConnection:void 0,onSelectionChangeHandlers:[],lib:`react`,debug:!1,ariaLabelConfig:Sa,zIndexMode:f,onNodesChangeMiddlewareMap:new Map,onEdgesChangeMiddlewareMap:new Map}},md=({nodes:e,edges:t,defaultNodes:n,defaultEdges:r,width:i,height:a,fitView:o,fitViewOptions:s,minZoom:c,maxZoom:l,nodeOrigin:u,nodeExtent:d,zIndexMode:f})=>hc((p,m)=>{async function h(){let{nodeLookup:e,panZoom:t,fitViewOptions:n,fitViewResolver:r,width:i,height:a,minZoom:o,maxZoom:s}=m();t&&(await Ba({nodes:e,width:i,height:a,panZoom:t,minZoom:o,maxZoom:s},n),r?.resolve(!0),p({fitViewResolver:null}))}return{...pd({nodes:e,edges:t,width:i,height:a,fitView:o,fitViewOptions:s,minZoom:c,maxZoom:l,nodeOrigin:u,nodeExtent:d,defaultNodes:n,defaultEdges:r,zIndexMode:f}),setNodes:e=>{let{nodeLookup:t,parentLookup:n,nodeOrigin:r,elevateNodesOnSelect:i,fitViewQueued:a,zIndexMode:o,nodesSelectionActive:s}=m(),{nodesInitialized:c,hasSelectedNodes:l}=as(e,t,n,{nodeOrigin:r,nodeExtent:d,elevateNodesOnSelect:i,checkEquality:!0,zIndexMode:o}),u=s&&l;a&&c?(h(),p({nodes:e,nodesInitialized:c,fitViewQueued:!1,fitViewOptions:void 0,nodesSelectionActive:u})):p({nodes:e,nodesInitialized:c,nodesSelectionActive:u})},setEdges:e=>{let{connectionLookup:t,edgeLookup:n}=m();ms(t,n,e),p({edges:e})},setDefaultNodesAndEdges:(e,t)=>{if(e){let{setNodes:t}=m();t(e),p({hasDefaultNodes:!0})}if(t){let{setEdges:e}=m();e(t),p({hasDefaultEdges:!0})}},updateNodeInternals:e=>{let{triggerNodeChanges:t,nodeLookup:n,parentLookup:r,domNode:i,nodeOrigin:a,nodeExtent:o,debug:s,fitViewQueued:c,zIndexMode:l}=m(),{changes:u,updatedInternals:d}=ds(e,n,r,i,a,o,l);d&&(ns(n,r,{nodeOrigin:a,nodeExtent:o,zIndexMode:l}),c?(h(),p({fitViewQueued:!1,fitViewOptions:void 0})):p({}),u?.length>0&&(s&&console.log(`React Flow: trigger node changes`,u),t?.(u)))},updateNodePositions:(e,t=!1)=>{let n=[],r=[],{nodeLookup:i,triggerNodeChanges:a,connection:o,updateConnection:s,onNodesChangeMiddlewareMap:c}=m();for(let[a,c]of e){let e=i.get(a),l=!!(e?.expandParent&&e?.parentId&&c?.position),u={id:a,type:`position`,position:l?{x:Math.max(0,c.position.x),y:Math.max(0,c.position.y)}:c.position,dragging:t};if(e&&o.inProgress&&o.fromNode.id===e.id){let t=qo(e,o.fromHandle,H.Left,!0);s({...o,from:t})}l&&e.parentId&&n.push({id:a,parentId:e.parentId,rect:{...c.internals.positionAbsolute,width:c.measured.width??0,height:c.measured.height??0}}),r.push(u)}if(n.length>0){let{parentLookup:e,nodeOrigin:t}=m(),a=us(n,i,e,t);r.push(...a)}for(let e of c.values())r=e(r);a(r)},triggerNodeChanges:e=>{let{onNodesChange:t,setNodes:n,nodes:r,hasDefaultNodes:i,debug:a}=m();e?.length&&(i&&n(tl(e,r)),a&&console.log(`React Flow: trigger node changes`,e),t?.(e))},triggerEdgeChanges:e=>{let{onEdgesChange:t,setEdges:n,edges:r,hasDefaultEdges:i,debug:a}=m();e?.length&&(i&&n(nl(e,r)),a&&console.log(`React Flow: trigger edge changes`,e),t?.(e))},addSelectedNodes:e=>{let{multiSelectionActive:t,edgeLookup:n,nodeLookup:r,triggerNodeChanges:i,triggerEdgeChanges:a}=m();if(t){i(e.map(e=>rl(e,!0)));return}i(il(r,new Set([...e]),!0)),a(il(n))},addSelectedEdges:e=>{let{multiSelectionActive:t,edgeLookup:n,nodeLookup:r,triggerNodeChanges:i,triggerEdgeChanges:a}=m();if(t){a(e.map(e=>rl(e,!0)));return}a(il(n,new Set([...e]))),i(il(r,new Set,!0))},unselectNodesAndEdges:({nodes:e,edges:t}={})=>{let{edges:n,nodes:r,nodeLookup:i,triggerNodeChanges:a,triggerEdgeChanges:o}=m(),s=e||r,c=t||n,l=[];for(let e of s){if(!e.selected)continue;let t=i.get(e.id);t&&(t.selected=!1),l.push(rl(e.id,!1))}let u=[];for(let e of c)e.selected&&u.push(rl(e.id,!1));a(l),o(u)},setMinZoom:e=>{let{panZoom:t,maxZoom:n}=m();t?.setScaleExtent([e,n]),p({minZoom:e})},setMaxZoom:e=>{let{panZoom:t,minZoom:n}=m();t?.setScaleExtent([n,e]),p({maxZoom:e})},setTranslateExtent:e=>{m().panZoom?.setTranslateExtent(e),p({translateExtent:e})},resetSelectedElements:()=>{let{edges:e,nodes:t,triggerNodeChanges:n,triggerEdgeChanges:r,elementsSelectable:i}=m();if(!i)return;let a=t.reduce((e,t)=>t.selected?[...e,rl(t.id,!1)]:e,[]),o=e.reduce((e,t)=>t.selected?[...e,rl(t.id,!1)]:e,[]);n(a),r(o)},setNodeExtent:e=>{let{nodes:t,nodeLookup:n,parentLookup:r,nodeOrigin:i,elevateNodesOnSelect:a,nodeExtent:o,zIndexMode:s}=m();e[0][0]===o[0][0]&&e[0][1]===o[0][1]&&e[1][0]===o[1][0]&&e[1][1]===o[1][1]||(as(t,n,r,{nodeOrigin:i,nodeExtent:e,elevateNodesOnSelect:a,checkEquality:!1,zIndexMode:s}),p({nodeExtent:e}))},panBy:e=>{let{transform:t,width:n,height:r,panZoom:i,translateExtent:a}=m();return fs({delta:e,panZoom:i,transform:t,translateExtent:a,width:n,height:r})},setCenter:async(e,t,n)=>{let{width:r,height:i,maxZoom:a,panZoom:o}=m();if(!o)return!1;let s=n?.zoom===void 0?a:n.zoom;return await o.setViewport({x:r/2-e*s,y:i/2-t*s,zoom:s},{duration:n?.duration,ease:n?.ease,interpolate:n?.interpolate}),!0},cancelConnection:()=>{p({connection:{...Ea}})},updateConnection:e=>{p({connection:e})},reset:()=>p({...pd()})}},Object.is);function hd({initialNodes:e,initialEdges:t,defaultNodes:n,defaultEdges:r,initialWidth:i,initialHeight:a,initialMinZoom:o,initialMaxZoom:s,initialFitViewOptions:c,fitView:l,nodeOrigin:u,nodeExtent:d,zIndexMode:f,children:p}){let[m]=(0,y.useState)(()=>md({nodes:e,edges:t,defaultNodes:n,defaultEdges:r,width:i,height:a,fitView:l,minZoom:o,maxZoom:s,fitViewOptions:c,nodeOrigin:u,nodeExtent:d,zIndexMode:f}));return(0,x.jsx)(yc,{value:m,children:(0,x.jsx)(gl,{children:(0,x.jsx)(J,{children:p})})})}function gd({children:e,nodes:t,edges:n,defaultNodes:r,defaultEdges:i,width:a,height:o,fitView:s,fitViewOptions:c,minZoom:l,maxZoom:u,nodeOrigin:d,nodeExtent:f,zIndexMode:p}){return(0,y.useContext)(vc)?(0,x.jsx)(x.Fragment,{children:e}):(0,x.jsx)(hd,{initialNodes:t,initialEdges:n,defaultNodes:r,defaultEdges:i,initialWidth:a,initialHeight:o,fitView:s,initialFitViewOptions:c,initialMinZoom:l,initialMaxZoom:u,nodeOrigin:d,nodeExtent:f,zIndexMode:p,children:e})}var _d={width:`100%`,height:`100%`,overflow:`hidden`,position:`relative`,zIndex:0};function vd({nodes:e,edges:t,defaultNodes:n,defaultEdges:r,className:i,nodeTypes:a,edgeTypes:o,onNodeClick:s,onEdgeClick:c,onInit:l,onMove:u,onMoveStart:d,onMoveEnd:f,onConnect:p,onConnectStart:m,onConnectEnd:h,onClickConnectStart:g,onClickConnectEnd:_,onNodeMouseEnter:v,onNodeMouseMove:b,onNodeMouseLeave:C,onNodeContextMenu:w,onNodeDoubleClick:T,onNodeDragStart:E,onNodeDrag:D,onNodeDragStop:O,onNodesDelete:k,onEdgesDelete:A,onDelete:j,onSelectionChange:M,onSelectionDragStart:N,onSelectionDrag:P,onSelectionDragStop:ee,onSelectionContextMenu:F,onSelectionStart:I,onSelectionEnd:te,onBeforeDelete:ne,connectionMode:L,connectionLineType:R=Da.Bezier,connectionLineStyle:z,connectionLineComponent:B,connectionLineContainerStyle:re,deleteKeyCode:ie=`Backspace`,selectionKeyCode:ae=`Shift`,selectionOnDrag:oe=!1,selectionMode:se=Ta.Full,panActivationKeyCode:ce=`Space`,multiSelectionKeyCode:le=uo()?`Meta`:`Control`,zoomActivationKeyCode:ue=uo()?`Meta`:`Control`,snapToGrid:de,snapGrid:fe,onlyRenderVisibleElements:pe=!1,selectNodesOnDrag:me,nodesDraggable:he,autoPanOnNodeFocus:ge,nodesConnectable:_e,nodesFocusable:ve,nodeOrigin:ye=Bc,edgesFocusable:be,edgesReconnectable:xe,elementsSelectable:Se=!0,defaultViewport:Ce=Vc,minZoom:we=.5,maxZoom:Te=2,translateExtent:Ee=ba,preventScrolling:De=!0,nodeExtent:Oe,defaultMarkerColor:ke=`#b1b1b7`,zoomOnScroll:Ae=!0,zoomOnPinch:je=!0,panOnScroll:Me=!1,panOnScrollSpeed:Ne=.5,panOnScrollMode:Pe=wa.Free,zoomOnDoubleClick:Fe=!0,panOnDrag:Ie=!0,onPaneClick:Le,onPaneMouseEnter:Re,onPaneMouseMove:ze,onPaneMouseLeave:Be,onPaneScroll:Ve,onPaneContextMenu:He,paneClickDistance:Ue=1,nodeClickDistance:We=0,children:Ge,onReconnect:Ke,onReconnectStart:qe,onReconnectEnd:Je,onEdgeContextMenu:Ye,onEdgeDoubleClick:Xe,onEdgeMouseEnter:Ze,onEdgeMouseMove:Qe,onEdgeMouseLeave:$e,reconnectRadius:et=10,onNodesChange:tt,onEdgesChange:nt,noDragClassName:rt=`nodrag`,noWheelClassName:it=`nowheel`,noPanClassName:at=`nopan`,fitView:ot,fitViewOptions:st,connectOnClick:ct,attributionPosition:lt,proOptions:ut,defaultEdgeOptions:dt,elevateNodesOnSelect:ft=!0,elevateEdgesOnSelect:pt=!1,disableKeyboardA11y:mt=!1,autoPanOnConnect:ht,autoPanOnNodeDrag:gt,autoPanOnSelection:_t=!0,autoPanSpeed:vt,connectionRadius:yt,isValidConnection:bt,onError:xt,style:St,id:Ct,nodeDragThreshold:wt,connectionDragThreshold:Tt,viewport:Et,onViewportChange:Dt,width:Ot,height:kt,colorMode:At=`light`,debug:jt,onScroll:Mt,ariaLabelConfig:Nt,zIndexMode:Pt=`basic`,...Ft},It){let Lt=Ct||`1`,Rt=qc(At),zt=(0,y.useCallback)(e=>{e.currentTarget.scrollTo({top:0,left:0,behavior:`instant`}),Mt?.(e)},[Mt]);return(0,x.jsx)(`div`,{"data-testid":`rf__wrapper`,...Ft,onScroll:zt,style:{...St,..._d},ref:It,className:S([`react-flow`,i,Rt]),id:Ct,role:`application`,children:(0,x.jsxs)(gd,{nodes:e,edges:t,width:Ot,height:kt,fitView:ot,fitViewOptions:st,minZoom:we,maxZoom:Te,nodeOrigin:ye,nodeExtent:Oe,zIndexMode:Pt,children:[(0,x.jsx)(Gc,{nodes:e,edges:t,defaultNodes:n,defaultEdges:r,onConnect:p,onConnectStart:m,onConnectEnd:h,onClickConnectStart:g,onClickConnectEnd:_,nodesDraggable:he,autoPanOnNodeFocus:ge,nodesConnectable:_e,nodesFocusable:ve,edgesFocusable:be,edgesReconnectable:xe,elementsSelectable:Se,elevateNodesOnSelect:ft,elevateEdgesOnSelect:pt,minZoom:we,maxZoom:Te,nodeExtent:Oe,onNodesChange:tt,onEdgesChange:nt,snapToGrid:de,snapGrid:fe,connectionMode:L,translateExtent:Ee,connectOnClick:ct,defaultEdgeOptions:dt,fitView:ot,fitViewOptions:st,onNodesDelete:k,onEdgesDelete:A,onDelete:j,onNodeDragStart:E,onNodeDrag:D,onNodeDragStop:O,onSelectionDrag:P,onSelectionDragStart:N,onSelectionDragStop:ee,onMove:u,onMoveStart:d,onMoveEnd:f,noPanClassName:at,nodeOrigin:ye,rfId:Lt,autoPanOnConnect:ht,autoPanOnNodeDrag:gt,autoPanSpeed:vt,onError:xt,connectionRadius:yt,isValidConnection:bt,selectNodesOnDrag:me,nodeDragThreshold:wt,connectionDragThreshold:Tt,onBeforeDelete:ne,debug:jt,ariaLabelConfig:Nt,zIndexMode:Pt}),(0,x.jsx)(dd,{onInit:l,onNodeClick:s,onEdgeClick:c,onNodeMouseEnter:v,onNodeMouseMove:b,onNodeMouseLeave:C,onNodeContextMenu:w,onNodeDoubleClick:T,nodeTypes:a,edgeTypes:o,connectionLineType:R,connectionLineStyle:z,connectionLineComponent:B,connectionLineContainerStyle:re,selectionKeyCode:ae,selectionOnDrag:oe,selectionMode:se,deleteKeyCode:ie,multiSelectionKeyCode:le,panActivationKeyCode:ce,zoomActivationKeyCode:ue,onlyRenderVisibleElements:pe,defaultViewport:Ce,translateExtent:Ee,minZoom:we,maxZoom:Te,preventScrolling:De,zoomOnScroll:Ae,zoomOnPinch:je,zoomOnDoubleClick:Fe,panOnScroll:Me,panOnScrollSpeed:Ne,panOnScrollMode:Pe,panOnDrag:Ie,autoPanOnSelection:_t,onPaneClick:Le,onPaneMouseEnter:Re,onPaneMouseMove:ze,onPaneMouseLeave:Be,onPaneScroll:Ve,onPaneContextMenu:He,paneClickDistance:Ue,nodeClickDistance:We,onSelectionContextMenu:F,onSelectionStart:I,onSelectionEnd:te,onReconnect:Ke,onReconnectStart:qe,onReconnectEnd:Je,onEdgeContextMenu:Ye,onEdgeDoubleClick:Xe,onEdgeMouseEnter:Ze,onEdgeMouseMove:Qe,onEdgeMouseLeave:$e,reconnectRadius:et,defaultMarkerColor:ke,noDragClassName:rt,noWheelClassName:it,noPanClassName:at,rfId:Lt,disableKeyboardA11y:mt,nodeExtent:Oe,viewport:Et,onViewportChange:Dt}),(0,x.jsx)(zc,{onSelectionChange:M}),Ge,(0,x.jsx)(Nc,{proOptions:ut,position:lt}),(0,x.jsx)(Ac,{rfId:Lt,disableKeyboardA11y:mt})]})})}var yd=dl(vd),Q=e=>e.domNode?.querySelector(`.react-flow__edgelabel-renderer`);function bd({children:e}){let t=G(Q);return t?(0,_c.createPortal)(e,t):null}ya.error014();function xd({dimensions:e,lineWidth:t,variant:n,className:r}){return(0,x.jsx)(`path`,{strokeWidth:t,d:`M${e[0]/2} 0 V${e[1]} M0 ${e[1]/2} H${e[0]}`,className:S([`react-flow__background-pattern`,n,r])})}function Sd({radius:e,className:t}){return(0,x.jsx)(`circle`,{cx:e,cy:e,r:e,className:S([`react-flow__background-pattern`,`dots`,t])})}var Cd;(function(e){e.Lines=`lines`,e.Dots=`dots`,e.Cross=`cross`})(Cd||={});var wd={[Cd.Dots]:1,[Cd.Lines]:1,[Cd.Cross]:6},Td=e=>({transform:e.transform,patternId:`pattern-${e.rfId}`});function Ed({id:e,variant:t=Cd.Dots,gap:n=20,size:r,lineWidth:i=1,offset:a=0,color:o,bgColor:s,style:c,className:l,patternClassName:u}){let d=(0,y.useRef)(null),{transform:f,patternId:p}=G(Td,gc),m=r||wd[t],h=t===Cd.Dots,g=t===Cd.Cross,_=Array.isArray(n)?n:[n,n],v=[_[0]*f[2]||1,_[1]*f[2]||1],b=m*f[2],C=Array.isArray(a)?a:[a,a],w=g?[b,b]:v,T=[C[0]*f[2]||1+w[0]/2,C[1]*f[2]||1+w[1]/2],E=`${p}${e||``}`;return(0,x.jsxs)(`svg`,{className:S([`react-flow__background`,l]),style:{...c,...wl,"--xy-background-color-props":s,"--xy-background-pattern-color-props":o},ref:d,"data-testid":`rf__background`,children:[(0,x.jsx)(`pattern`,{id:E,x:f[0]%v[0],y:f[1]%v[1],width:v[0],height:v[1],patternUnits:`userSpaceOnUse`,patternTransform:`translate(-${T[0]},-${T[1]})`,children:h?(0,x.jsx)(Sd,{radius:b/2,className:u}):(0,x.jsx)(xd,{dimensions:w,lineWidth:i,variant:t,className:u})}),(0,x.jsx)(`rect`,{x:`0`,y:`0`,width:`100%`,height:`100%`,fill:`url(#${E})`})]})}Ed.displayName=`Background`;var Dd=(0,y.memo)(Ed);function Od(){return(0,x.jsx)(`svg`,{xmlns:`http://www.w3.org/2000/svg`,viewBox:`0 0 32 32`,children:(0,x.jsx)(`path`,{d:`M32 18.133H18.133V32h-4.266V18.133H0v-4.266h13.867V0h4.266v13.867H32z`})})}function kd(){return(0,x.jsx)(`svg`,{xmlns:`http://www.w3.org/2000/svg`,viewBox:`0 0 32 5`,children:(0,x.jsx)(`path`,{d:`M0 0h32v4.2H0z`})})}function Ad(){return(0,x.jsx)(`svg`,{xmlns:`http://www.w3.org/2000/svg`,viewBox:`0 0 32 30`,children:(0,x.jsx)(`path`,{d:`M3.692 4.63c0-.53.4-.938.939-.938h5.215V0H4.708C2.13 0 0 2.054 0 4.63v5.216h3.692V4.631zM27.354 0h-5.2v3.692h5.17c.53 0 .984.4.984.939v5.215H32V4.631A4.624 4.624 0 0027.354 0zm.954 24.83c0 .532-.4.94-.939.94h-5.215v3.768h5.215c2.577 0 4.631-2.13 4.631-4.707v-5.139h-3.692v5.139zm-23.677.94c-.531 0-.939-.4-.939-.94v-5.138H0v5.139c0 2.577 2.13 4.707 4.708 4.707h5.138V25.77H4.631z`})})}function jd(){return(0,x.jsx)(`svg`,{xmlns:`http://www.w3.org/2000/svg`,viewBox:`0 0 25 32`,children:(0,x.jsx)(`path`,{d:`M21.333 10.667H19.81V7.619C19.81 3.429 16.38 0 12.19 0 8 0 4.571 3.429 4.571 7.619v3.048H3.048A3.056 3.056 0 000 13.714v15.238A3.056 3.056 0 003.048 32h18.285a3.056 3.056 0 003.048-3.048V13.714a3.056 3.056 0 00-3.048-3.047zM12.19 24.533a3.056 3.056 0 01-3.047-3.047 3.056 3.056 0 013.047-3.048 3.056 3.056 0 013.048 3.048 3.056 3.056 0 01-3.048 3.047zm4.724-13.866H7.467V7.619c0-2.59 2.133-4.724 4.723-4.724 2.591 0 4.724 2.133 4.724 4.724v3.048z`})})}function Md(){return(0,x.jsx)(`svg`,{xmlns:`http://www.w3.org/2000/svg`,viewBox:`0 0 25 32`,children:(0,x.jsx)(`path`,{d:`M21.333 10.667H19.81V7.619C19.81 3.429 16.38 0 12.19 0c-4.114 1.828-1.37 2.133.305 2.438 1.676.305 4.42 2.59 4.42 5.181v3.048H3.047A3.056 3.056 0 000 13.714v15.238A3.056 3.056 0 003.048 32h18.285a3.056 3.056 0 003.048-3.048V13.714a3.056 3.056 0 00-3.048-3.047zM12.19 24.533a3.056 3.056 0 01-3.047-3.047 3.056 3.056 0 013.047-3.048 3.056 3.056 0 013.048 3.048 3.056 3.056 0 01-3.048 3.047z`})})}function $({children:e,className:t,...n}){return(0,x.jsx)(`button`,{type:`button`,className:S([`react-flow__controls-button`,t]),...n,children:e})}var Nd=e=>({isInteractive:e.nodesDraggable||e.nodesConnectable||e.elementsSelectable,minZoomReached:e.transform[2]<=e.minZoom,maxZoomReached:e.transform[2]>=e.maxZoom,ariaLabelConfig:e.ariaLabelConfig});function Pd({style:e,showZoom:t=!0,showFitView:n=!0,showInteractive:r=!0,fitViewOptions:i,onZoomIn:a,onZoomOut:o,onFitView:s,onInteractiveChange:c,className:l,children:u,position:d=`bottom-left`,orientation:f=`vertical`,"aria-label":p}){let m=xc(),{isInteractive:h,minZoomReached:g,maxZoomReached:_,ariaLabelConfig:v}=G(Nd,gc),{zoomIn:y,zoomOut:b,fitView:C}=yl();return(0,x.jsxs)(jc,{className:S([`react-flow__controls`,f===`horizontal`?`horizontal`:`vertical`,l]),position:d,style:e,"data-testid":`rf__controls`,"aria-label":p??v[`controls.ariaLabel`],children:[t&&(0,x.jsxs)(x.Fragment,{children:[(0,x.jsx)($,{onClick:()=>{y(),a?.()},className:`react-flow__controls-zoomin`,title:v[`controls.zoomIn.ariaLabel`],"aria-label":v[`controls.zoomIn.ariaLabel`],disabled:_,children:(0,x.jsx)(Od,{})}),(0,x.jsx)($,{onClick:()=>{b(),o?.()},className:`react-flow__controls-zoomout`,title:v[`controls.zoomOut.ariaLabel`],"aria-label":v[`controls.zoomOut.ariaLabel`],disabled:g,children:(0,x.jsx)(kd,{})})]}),n&&(0,x.jsx)($,{className:`react-flow__controls-fitview`,onClick:()=>{C(i),s?.()},title:v[`controls.fitView.ariaLabel`],"aria-label":v[`controls.fitView.ariaLabel`],children:(0,x.jsx)(Ad,{})}),r&&(0,x.jsx)($,{className:`react-flow__controls-interactive`,onClick:()=>{m.setState({nodesDraggable:!h,nodesConnectable:!h,elementsSelectable:!h}),c?.(!h)},title:v[`controls.interactive.ariaLabel`],"aria-label":v[`controls.interactive.ariaLabel`],children:h?(0,x.jsx)(Md,{}):(0,x.jsx)(jd,{})}),u]})}Pd.displayName=`Controls`;var Fd=(0,y.memo)(Pd);function Id({id:e,x:t,y:n,width:r,height:i,style:a,color:o,strokeColor:s,strokeWidth:c,className:l,borderRadius:u,shapeRendering:d,selected:f,onClick:p}){let{background:m,backgroundColor:h}=a||{},g=o||m||h;return(0,x.jsx)(`rect`,{className:S([`react-flow__minimap-node`,{selected:f},l]),x:t,y:n,rx:u,ry:u,width:r,height:i,style:{fill:g,stroke:s,strokeWidth:c},shapeRendering:d,onClick:p?t=>p(t,e):void 0})}var Ld=(0,y.memo)(Id),Rd=e=>e.nodes.map(e=>e.id),zd=e=>e instanceof Function?e:()=>e;function Bd({nodeStrokeColor:e,nodeColor:t,nodeClassName:n=``,nodeBorderRadius:r=5,nodeStrokeWidth:i,nodeComponent:a=Ld,onClick:o}){let s=G(Rd,gc),c=zd(t),l=zd(e),u=zd(n),d=typeof window>`u`||window.chrome?`crispEdges`:`geometricPrecision`;return(0,x.jsx)(x.Fragment,{children:s.map(e=>(0,x.jsx)(Hd,{id:e,nodeColorFunc:c,nodeStrokeColorFunc:l,nodeClassNameFunc:u,nodeBorderRadius:r,nodeStrokeWidth:i,NodeComponent:a,onClick:o,shapeRendering:d},e))})}function Vd({id:e,nodeColorFunc:t,nodeStrokeColorFunc:n,nodeClassNameFunc:r,nodeBorderRadius:i,nodeStrokeWidth:a,shapeRendering:o,NodeComponent:s,onClick:c}){let{node:l,x:u,y:d,width:f,height:p}=G(t=>{let n=t.nodeLookup.get(e);if(!n)return{node:void 0,x:0,y:0,width:0,height:0};let r=n.internals.userNode,{x:i,y:a}=n.internals.positionAbsolute,{width:o,height:s}=po(r);return{node:r,x:i,y:a,width:o,height:s}},gc);return!l||l.hidden||!mo(l)?null:(0,x.jsx)(s,{x:u,y:d,width:f,height:p,style:l.style,selected:!!l.selected,className:r(l),color:t(l),borderRadius:i,strokeColor:n(l),strokeWidth:a,shapeRendering:o,onClick:c,id:l.id})}var Hd=(0,y.memo)(Vd),Ud=(0,y.memo)(Bd),Wd=200,Gd=150,Kd=e=>!e.hidden,qd=e=>{let t={x:-e.transform[0]/e.transform[2],y:-e.transform[1]/e.transform[2],width:e.width/e.transform[2],height:e.height/e.transform[2]};return{viewBB:t,boundingRect:e.nodeLookup.size>0?$a(Ia(e.nodeLookup,{filter:Kd}),t):t,rfId:e.rfId,panZoom:e.panZoom,translateExtent:e.translateExtent,flowWidth:e.width,flowHeight:e.height,ariaLabelConfig:e.ariaLabelConfig}},Jd=`react-flow__minimap-desc`;function Yd({style:e,className:t,nodeStrokeColor:n,nodeColor:r,nodeClassName:i=``,nodeBorderRadius:a=5,nodeStrokeWidth:o,nodeComponent:s,bgColor:c,maskColor:l,maskStrokeColor:u,maskStrokeWidth:d,position:f=`bottom-right`,onClick:p,onNodeClick:m,pannable:h=!1,zoomable:g=!1,ariaLabel:_,inversePan:v,zoomStep:b=1,offsetScale:C=5}){let w=xc(),T=(0,y.useRef)(null),{boundingRect:E,viewBB:D,rfId:O,panZoom:k,translateExtent:A,flowWidth:j,flowHeight:M,ariaLabelConfig:N}=G(qd,gc),P=e?.width??Wd,ee=e?.height??Gd,F=E.width/P,I=E.height/ee,te=Math.max(F,I),ne=te*P,L=te*ee,R=C*te,z=E.x-(ne-E.width)/2-R,B=E.y-(L-E.height)/2-R,re=ne+R*2,ie=L+R*2,ae=`${Jd}-${O}`,oe=(0,y.useRef)(0),se=(0,y.useRef)();oe.current=te,(0,y.useEffect)(()=>{if(T.current&&k)return se.current=js({domNode:T.current,panZoom:k,getTransform:()=>w.getState().transform,getViewScale:()=>oe.current}),()=>{se.current?.destroy()}},[k]),(0,y.useEffect)(()=>{se.current?.update({translateExtent:A,width:j,height:M,inversePan:v,pannable:h,zoomStep:b,zoomable:g})},[h,g,v,b,A,j,M]);let ce=p?e=>{let[t,n]=se.current?.pointer(e)||[0,0];p(e,{x:t,y:n})}:void 0,le=m?(0,y.useCallback)((e,t)=>{let n=w.getState().nodeLookup.get(t).internals.userNode;m(e,n)},[]):void 0,ue=_??N[`minimap.ariaLabel`];return(0,x.jsx)(jc,{position:f,style:{...e,"--xy-minimap-background-color-props":typeof c==`string`?c:void 0,"--xy-minimap-mask-background-color-props":typeof l==`string`?l:void 0,"--xy-minimap-mask-stroke-color-props":typeof u==`string`?u:void 0,"--xy-minimap-mask-stroke-width-props":typeof d==`number`?d*te:void 0,"--xy-minimap-node-background-color-props":typeof r==`string`?r:void 0,"--xy-minimap-node-stroke-color-props":typeof n==`string`?n:void 0,"--xy-minimap-node-stroke-width-props":typeof o==`number`?o:void 0},className:S([`react-flow__minimap`,t]),"data-testid":`rf__minimap`,children:(0,x.jsxs)(`svg`,{width:P,height:ee,viewBox:`${z} ${B} ${re} ${ie}`,className:`react-flow__minimap-svg`,role:`img`,"aria-labelledby":ae,ref:T,onClick:ce,children:[ue&&(0,x.jsx)(`title`,{id:ae,children:ue}),(0,x.jsx)(Ud,{onClick:le,nodeColor:r,nodeStrokeColor:n,nodeBorderRadius:a,nodeClassName:i,nodeStrokeWidth:o,nodeComponent:s}),(0,x.jsx)(`path`,{className:`react-flow__minimap-mask`,d:`M${z-R},${B-R}h${re+R*2}v${ie+R*2}h${-re-R*2}z
+        M${D.x},${D.y}h${D.width}v${D.height}h${-D.width}z`,fillRule:`evenodd`,pointerEvents:`none`})]})})}Yd.displayName=`MiniMap`;var Xd=(0,y.memo)(Yd),Zd=e=>t=>e?`${Math.max(1/t.transform[2],1)}`:void 0,Qd={[Ks.Line]:`right`,[Ks.Handle]:`bottom-right`};function $d({nodeId:e,position:t,variant:n=Ks.Handle,className:r,style:i=void 0,children:a,color:o,minWidth:s=10,minHeight:c=10,maxWidth:l=Number.MAX_VALUE,maxHeight:u=Number.MAX_VALUE,keepAspectRatio:d=!1,resizeDirection:f,autoScale:p=!0,shouldResize:m,onResizeStart:h,onResize:g,onResizeEnd:_}){let v=Rl(),b=typeof e==`string`?e:v,C=xc(),w=(0,y.useRef)(null),T=n===Ks.Handle,E=G((0,y.useCallback)(Zd(T&&p),[T,p]),gc),D=(0,y.useRef)(null),O=t??Qd[n];return(0,y.useEffect)(()=>{if(!(!w.current||!b))return D.current||=rc({domNode:w.current,nodeId:b,getStoreItems:()=>{let{nodeLookup:e,transform:t,snapGrid:n,snapToGrid:r,nodeOrigin:i,domNode:a}=C.getState();return{nodeLookup:e,transform:t,snapGrid:n,snapToGrid:r,nodeOrigin:i,paneDomNode:a}},onChange:(e,t)=>{let{triggerNodeChanges:n,nodeLookup:r,parentLookup:i,nodeOrigin:a}=C.getState(),o=[],s={x:e.x,y:e.y},c=r.get(b);if(c&&c.expandParent&&c.parentId){let t=c.origin??a,n=e.width??c.measured.width??0,l=e.height??c.measured.height??0,u=us([{id:c.id,parentId:c.parentId,rect:{width:n,height:l,...ho({x:e.x??c.position.x,y:e.y??c.position.y},{width:n,height:l},c.parentId,r,t)}}],r,i,a);o.push(...u),s.x=e.x?Math.max(t[0]*n,e.x):void 0,s.y=e.y?Math.max(t[1]*l,e.y):void 0}if(s.x!==void 0&&s.y!==void 0){let e={id:b,type:`position`,position:{...s}};o.push(e)}if(e.width!==void 0&&e.height!==void 0){let t={id:b,type:`dimensions`,resizing:!0,setAttributes:f?f===`horizontal`?`width`:`height`:!0,dimensions:{width:e.width,height:e.height}};o.push(t)}for(let e of t){let t={...e,type:`position`};o.push(t)}n(o)},onEnd:({width:e,height:t})=>{let n={id:b,type:`dimensions`,resizing:!1,dimensions:{width:e,height:t}};C.getState().triggerNodeChanges([n])}}),D.current.update({controlPosition:O,boundaries:{minWidth:s,minHeight:c,maxWidth:l,maxHeight:u},keepAspectRatio:d,resizeDirection:f,onResizeStart:h,onResize:g,onResizeEnd:_,shouldResize:m}),()=>{D.current?.destroy()}},[O,s,c,l,u,d,h,g,_,m]),(0,x.jsx)(`div`,{className:S([`react-flow__resize-control`,`nodrag`,...O.split(`-`),n,r]),ref:w,style:{...i,scale:E,...o&&{[T?`backgroundColor`:`borderColor`]:o}},children:a})}(0,y.memo)($d);var ef=[[`left-in-upper`,`target`,H.Left,`upper`],[`left-in-lower`,`target`,H.Left,`lower`],[`left-out-upper`,`source`,H.Left,`upper`],[`left-out-lower`,`source`,H.Left,`lower`],[`right-in-upper`,`target`,H.Right,`upper`],[`right-in-lower`,`target`,H.Right,`lower`],[`right-out-upper`,`source`,H.Right,`upper`],[`right-out-lower`,`source`,H.Right,`lower`],[`top-in`,`target`,H.Top,`center`],[`top-out`,`source`,H.Top,`center`],[`bottom-in`,`target`,H.Bottom,`center`],[`bottom-out`,`source`,H.Bottom,`center`]];function tf(e){return e===`root`?`◆`:e===`implementer`?`⌘`:`✓`}function nf(e){if(!e)return;let t=new Date(e);return Number.isNaN(t.getTime())?e:t.toLocaleTimeString([],{hour:`2-digit`,minute:`2-digit`})}var rf=(0,y.memo)(function({data:e,selected:t}){let{node:n,latestReport:r,pending:i}=e,a=n.runtimeLabel??(n.role===`root`?`Governor`:`Codex worker role`),o=i?`pending`:n.role===`root`?`master`:n.state;return(0,x.jsxs)(`article`,{className:`lag-node`,"data-role":n.role,"data-state":n.state,"data-selected":t?`true`:`false`,"data-testid":`graph-node-${n.role}`,"aria-label":`${n.label}, ${n.state}`,children:[ef.map(([e,t,r,i])=>(0,x.jsx)(Vl,{id:e,type:t,position:r,isConnectable:!1,className:`lag-handle lag-handle-${i} lag-handle-${t}`,"aria-label":`${t} ${e} for ${n.label}`},e)),(0,x.jsxs)(`header`,{className:`lag-node-header`,children:[(0,x.jsx)(`span`,{className:`lag-node-glyph`,"aria-hidden":`true`,children:tf(n.role)}),(0,x.jsxs)(`span`,{className:`lag-node-heading`,children:[(0,x.jsx)(`strong`,{title:n.label,children:n.label}),(0,x.jsx)(`small`,{title:n.model,children:n.model??a})]}),(0,x.jsx)(`span`,{className:`lag-state-pill`,children:o})]}),(0,x.jsx)(`div`,{className:`lag-node-body`,children:r?(0,x.jsxs)(x.Fragment,{children:[(0,x.jsxs)(`div`,{className:`lag-verdict`,"data-verdict":r.verdict??r.type,children:[(0,x.jsx)(`strong`,{children:r.verdict===`clean`?`✓ clean`:r.verdict===`issues`?`! ${r.issueCount} issue${r.issueCount===1?``:`s`}`:`done`}),(0,x.jsx)(`span`,{children:r.type})]}),r.summary?(0,x.jsx)(`p`,{className:`lag-report-summary`,title:r.summary,children:r.summary}):null]}):(0,x.jsx)(`p`,{className:`lag-node-description`,children:n.description??(n.role===`root`?`Owns the cooperative transition decision.`:n.state===`unbound`?`Waiting for a role capability.`:`Participates through typed reports.`)})}),(0,x.jsxs)(`footer`,{className:`lag-node-footer`,children:[(0,x.jsxs)(`span`,{className:`lag-node-activity`,children:[(0,x.jsx)(`b`,{children:n.activityCount??0}),` events`]}),(0,x.jsx)(`span`,{title:n.lastActivityAt,children:nf(n.lastActivityAt)??n.id})]})]})}),af={governs:`governs`,handoff:`handoff`,feedback:`feedback`,verdict:`verdict`};function of({route:e,sourceX:t,sourceY:n,targetX:r,targetY:i,sourcePosition:a,targetPosition:o}){if(e===`direct`){let[e,s,c]=Ao({sourceX:t,sourceY:n,targetX:r,targetY:i,sourcePosition:a,targetPosition:o,curvature:.32});return{path:e,labelX:s,labelY:c}}if(e===`lower`){let e=Math.max(n,i)+88;return{path:`M ${t} ${n} C ${t} ${e}, ${r} ${e}, ${r} ${i}`,labelX:(t+r)/2,labelY:e-8}}let s=e===`right`?1:-1,c=(e===`right`?Math.max(t,r):Math.min(t,r))+s*96;return{path:`M ${t} ${n} C ${c} ${n}, ${c} ${i}, ${r} ${i}`,labelX:(e===`right`?Math.max(t,r):Math.min(t,r))-s*28,labelY:(n+i)/2}}function sf({id:e,sourceX:t,sourceY:n,targetX:r,targetY:i,sourcePosition:a,targetPosition:o,markerEnd:s,selected:c,data:l}){let u=l,{edge:d,route:f,latestReport:p}=u,{path:m,labelX:h,labelY:g}=of({route:f,sourceX:t,sourceY:n,targetX:r,targetY:i,sourcePosition:a,targetPosition:o}),_=p?.verdict===`issues`?`${p.issueCount} issues`:p?.verdict===`clean`?`clean`:void 0,v=d.label??af[d.kind],y=[v,d.summary,d.gate?`gate ${d.gate}`:void 0,d.stopWhen,d.pending?`pending`:void 0].filter(Boolean).join(`
+`);return(0,x.jsxs)(x.Fragment,{children:[(0,x.jsx)(xu,{id:e,path:m,markerEnd:s,className:`lag-edge-path`,"data-kind":d.kind,"data-active":d.active?`true`:`false`,"data-recent":d.recent?`true`:`false`,"data-pending":d.pending?`true`:`false`,style:{strokeWidth:c?3:d.active?2.6:1.8}}),(0,x.jsx)(bd,{children:(0,x.jsxs)(`div`,{className:`lag-edge-label nodrag nopan`,"data-kind":d.kind,"data-active":d.active?`true`:`false`,"data-selected":c?`true`:`false`,"data-recent":d.recent?`true`:`false`,"data-pending":d.pending?`true`:`false`,"data-testid":`graph-edge-${d.kind}`,style:{transform:`translate(-50%, -50%) translate(${h}px, ${g}px)`},role:`button`,tabIndex:0,"aria-pressed":c,"aria-label":`Inspect Relationship: ${v}, ${d.reportCount} reports`,title:y,onClick:t=>{t.stopPropagation(),u.onSelect?.(e)},onKeyDown:t=>{t.key!==`Enter`&&t.key!==` `||(t.preventDefault(),t.stopPropagation(),u.onSelect?.(e))},children:[(0,x.jsx)(`strong`,{children:v}),d.pending?(0,x.jsx)(`span`,{children:`pending`}):null,_?(0,x.jsx)(`span`,{children:_}):null,d.reportCount>0?(0,x.jsx)(`span`,{children:d.reportCount}):null,d.maxFirings===void 0?null:(0,x.jsxs)(`span`,{children:[d.firings??0,`/`,d.maxFirings]})]})})]})}var cf=[`draft`,`running`,`paused`,`interrupted`,`succeeded`,`capped`,`cancelled`,`failed`],lf=[`active`,`waiting`,`bound`,`unbound`,`terminal`],uf=[`governs`,`handoff`,`feedback`,`verdict`],df=/^[a-f0-9]{64}$/;function ff(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}function pf(e,t,n={}){if(typeof e!=`string`||e.length===0||e.length>(n.max??256)||n.pattern&&!n.pattern.test(e))throw TypeError(`${t} must be a bounded string`)}function mf(e,t,n={}){if(!Number.isSafeInteger(e)||n.min!==void 0&&Number(e)<n.min||n.max!==void 0&&Number(e)>n.max)throw TypeError(`${t} must be a bounded integer`)}function hf(e){if(!ff(e))throw TypeError(`agent graph model must be an object`);if(!ff(e.identity))throw TypeError(`agent graph model identity must be an object`);if(pf(e.identity.runId,`identity.runId`,{max:128}),mf(e.identity.revision,`identity.revision`,{min:0}),pf(e.identity.projectionDigest,`identity.projectionDigest`,{max:64,pattern:df}),e.identity.integrity!==`verified`)throw TypeError(`identity.integrity must be verified`);if(!cf.includes(e.status))throw TypeError(`agent graph model status is invalid`);if(mf(e.currentLap,`currentLap`,{min:0,max:6}),mf(e.lapCap,`lapCap`,{min:1,max:6}),Number(e.currentLap)>Number(e.lapCap))throw TypeError(`currentLap cannot exceed lapCap`);if(!ff(e.lease))throw TypeError(`agent graph model lease must be an object`);if(mf(e.lease.granted,`lease.granted`,{min:0,max:6}),mf(e.lease.consumed,`lease.consumed`,{min:0,max:6}),Number(e.lease.consumed)>Number(e.lease.granted))throw TypeError(`lease.consumed cannot exceed lease.granted`);if(typeof e.cancelRequested!=`boolean`||typeof e.needsHuman!=`boolean`)throw TypeError(`agent graph model flags must be boolean`);if(!Array.isArray(e.nodes)||e.nodes.length!==3||!Array.isArray(e.edges)||e.edges.length!==4||!Array.isArray(e.timeline)||e.timeline.length>32)throw TypeError(`agent graph model cardinality is invalid`);let t=new Set;for(let[n,r]of e.nodes.entries()){if(!ff(r))throw TypeError(`nodes[${n}] must be an object`);if(pf(r.id,`nodes[${n}].id`,{max:96}),pf(r.label,`nodes[${n}].label`,{max:80}),![`root`,`worker-role`].includes(String(r.kind)))throw TypeError(`nodes[${n}].kind is invalid`);if(![`root`,`implementer`,`reviewer`].includes(String(r.role)))throw TypeError(`nodes[${n}].role is invalid`);if(!lf.includes(r.state))throw TypeError(`nodes[${n}].state is invalid`);if(t.has(String(r.id)))throw TypeError(`agent graph node ids must be unique`);t.add(String(r.id));for(let e of[`runtimeLabel`,`model`,`description`,`lastActivityAt`])r[e]!==void 0&&pf(r[e],`nodes[${n}].${e}`,{max:512});r.activityCount!==void 0&&mf(r.activityCount,`nodes[${n}].activityCount`,{min:0})}for(let[n,r]of e.edges.entries()){if(!ff(r))throw TypeError(`edges[${n}] must be an object`);if(pf(r.id,`edges[${n}].id`,{max:96}),pf(r.source,`edges[${n}].source`,{max:96}),pf(r.target,`edges[${n}].target`,{max:96}),!uf.includes(r.kind))throw TypeError(`edges[${n}].kind is invalid`);if(!t.has(String(r.source))||!t.has(String(r.target)))throw TypeError(`edges[${n}] references an unknown node`);if(typeof r.active!=`boolean`)throw TypeError(`edges[${n}].active must be boolean`);mf(r.reportCount,`edges[${n}].reportCount`,{min:0});for(let e of[`label`,`summary`,`gate`,`stopWhen`])r[e]!==void 0&&pf(r[e],`edges[${n}].${e}`,{max:512});for(let e of[`firings`,`maxFirings`])r[e]!==void 0&&mf(r[e],`edges[${n}].${e}`,{min:0});if(r.recent!==void 0&&typeof r.recent!=`boolean`||r.pending!==void 0&&typeof r.pending!=`boolean`)throw TypeError(`edges[${n}] flags must be boolean`)}if(e.latestReport!==void 0){if(!ff(e.latestReport))throw TypeError(`latestReport must be an object`);if(e.latestReport.summary!==void 0&&pf(e.latestReport.summary,`latestReport.summary`,{max:1024}),e.latestReport.issues!==void 0){if(!Array.isArray(e.latestReport.issues)||e.latestReport.issues.length>32)throw TypeError(`latestReport.issues must be bounded`);for(let[t,n]of e.latestReport.issues.entries()){if(!ff(n))throw TypeError(`latestReport.issues[${t}] must be an object`);pf(n.message,`latestReport.issues[${t}].message`,{max:1024})}}}if(e.laps!==void 0){if(!Array.isArray(e.laps)||e.laps.length>6)throw TypeError(`laps must be a bounded array`);for(let[t,n]of e.laps.entries()){if(!ff(n))throw TypeError(`laps[${t}] must be an object`);if(mf(n.index,`laps[${t}].index`,{min:0,max:6}),![`running`,`issues`,`clean`,`capped`,`interrupted`].includes(String(n.status)))throw TypeError(`laps[${t}].status is invalid`);if(!Array.isArray(n.issues)||n.issues.length>32)throw TypeError(`laps[${t}].issues must be bounded`)}}return e}var gf={root:{x:30,y:82},implementer:{x:370,y:82},reviewer:{x:710,y:82}},_f={root:{x:130,y:22},implementer:{x:130,y:232},reviewer:{x:130,y:442}},vf={governs:{sourceHandle:`right-out-upper`,targetHandle:`left-in-upper`,route:`direct`},handoff:{sourceHandle:`right-out-upper`,targetHandle:`left-in-upper`,route:`direct`},feedback:{sourceHandle:`left-out-lower`,targetHandle:`right-in-lower`,route:`lower`},verdict:{sourceHandle:`bottom-out`,targetHandle:`bottom-in`,route:`lower`}},yf={governs:{sourceHandle:`bottom-out`,targetHandle:`top-in`,route:`direct`},handoff:{sourceHandle:`bottom-out`,targetHandle:`top-in`,route:`direct`},feedback:{sourceHandle:`right-out-lower`,targetHandle:`right-in-lower`,route:`right`},verdict:{sourceHandle:`left-out-lower`,targetHandle:`left-in-lower`,route:`left`}};function bf(e,t){let n=hf(e),r=t===`horizontal`?gf:_f,i=t===`horizontal`?vf:yf;return{nodes:n.nodes.map(e=>({id:e.id,type:`agent-role`,position:r[e.role],draggable:!1,selectable:!0,data:{node:e,pending:n.pending?.role===e.role,...n.latestReport?.fromRole===e.role?{latestReport:n.latestReport}:{}}})),edges:n.edges.map(e=>({id:e.id,type:`agent-relationship`,source:e.source,target:e.target,sourceHandle:i[e.kind].sourceHandle,targetHandle:i[e.kind].targetHandle,animated:e.active,focusable:!0,markerEnd:{type:Oa.ArrowClosed,width:16,height:16},data:{edge:e,route:i[e.kind].route,...n.latestReport&&(e.kind===`feedback`&&n.latestReport.verdict===`issues`||e.kind===`verdict`&&n.latestReport.verdict===`clean`)?{latestReport:n.latestReport}:{}}}))}}function xf(e){return e<720?`vertical`:`horizontal`}function Sf(e){return e===`running`?`active`:e===`succeeded`?`success`:[`paused`,`interrupted`,`capped`].includes(e)?`warning`:[`failed`,`cancelled`].includes(e)?`danger`:`neutral`}function Cf({model:e,onOpen:t}){return(0,x.jsxs)(`button`,{type:`button`,className:`lag-loop-badge`,"data-tone":Sf(e.status),"aria-label":`Open Loop details, lap ${e.currentLap} of ${e.lapCap}`,onClick:t,children:[(0,x.jsx)(`span`,{className:`lag-loop-badge-icon`,"aria-hidden":`true`,children:`↻`}),(0,x.jsxs)(`span`,{className:`lag-loop-badge-copy`,children:[(0,x.jsx)(`strong`,{children:e.status===`running`?`Review loop active`:`Review loop ${e.status}`}),(0,x.jsx)(`small`,{children:e.stopReason??`Lap ${e.currentLap}/${e.lapCap}`})]}),(0,x.jsxs)(`span`,{className:`lag-loop-badge-lap`,children:[e.currentLap,`/`,e.lapCap]})]})}function wf({issues:e}){return(0,x.jsx)(`ul`,{className:`lag-issue-list`,children:e.map((e,t)=>(0,x.jsxs)(`li`,{children:[(0,x.jsx)(`strong`,{children:e.severity??`issue`}),(0,x.jsx)(`span`,{children:e.message}),e.file?(0,x.jsxs)(`small`,{children:[e.file,e.line?`:${e.line}`:``]}):null]},`${e.file??``}:${e.line??``}:${e.message}:${t}`))})}function Tf({model:e,onClose:t,controlAvailable:n=!1,onControl:r,confirming:i,onConfirmingChange:a}){let[o,s]=(0,y.useState)(!1),[c,l]=(0,y.useState)(!1),u=i??o,d=a??s,f=[`succeeded`,`capped`,`cancelled`,`failed`].includes(e.status),p=e.latestReport?.issues??[],m=async()=>{if(!(!r||c)){l(!0);try{await r({kind:`cancel`,runId:e.identity.runId}),d(!1)}finally{l(!1)}}};return(0,x.jsxs)(`aside`,{className:`lag-loop-panel`,"aria-label":`Loop details`,children:[(0,x.jsxs)(`header`,{children:[(0,x.jsx)(`span`,{className:`lag-panel-icon`,"data-active":e.status===`running`,"aria-hidden":`true`,children:`↻`}),(0,x.jsxs)(`div`,{children:[(0,x.jsx)(`h3`,{children:e.status===`running`?`Review loop active`:`Review loop ${e.status}`}),(0,x.jsxs)(`p`,{children:[`Lap `,e.currentLap,`/`,e.lapCap]})]}),(0,x.jsx)(`button`,{type:`button`,className:`lag-icon-button`,"aria-label":`Close loop details`,onClick:t,children:`×`})]}),(0,x.jsxs)(`div`,{className:`lag-loop-panel-body`,children:[u?(0,x.jsxs)(`section`,{className:`lag-stop-confirm`,"aria-label":`Confirm Stop loop`,children:[(0,x.jsx)(`strong`,{children:`Stop future handoffs?`}),(0,x.jsx)(`p`,{children:`Work already running may finish, but it cannot activate another lap.`}),(0,x.jsxs)(`div`,{children:[(0,x.jsx)(`button`,{type:`button`,disabled:c,onClick:()=>d(!1),children:`Keep running`}),(0,x.jsx)(`button`,{type:`button`,disabled:c,onClick:()=>void m(),children:c?`Stopping…`:`Stop handoffs`})]})]}):null,(0,x.jsxs)(`section`,{className:`lag-loop-summary`,"data-tone":Sf(e.status),children:[(0,x.jsx)(`h4`,{children:e.stopReason??(f?`Run ${e.status}`:`Review until clean`)}),(0,x.jsx)(`p`,{children:e.recovery?.reason??(e.responsibleRole?`${e.responsibleRole} is responsible for the next action.`:`The Governor owns the next transition.`)}),(0,x.jsxs)(`dl`,{children:[(0,x.jsxs)(`div`,{children:[(0,x.jsx)(`dt`,{children:`Lap`}),(0,x.jsxs)(`dd`,{children:[e.currentLap,`/`,e.lapCap]})]}),(0,x.jsxs)(`div`,{children:[(0,x.jsx)(`dt`,{children:`Now responsible`}),(0,x.jsx)(`dd`,{children:e.responsibleRole??(f?`Complete`:`Governor`)})]}),e.latestReport?.verdict?(0,x.jsxs)(`div`,{children:[(0,x.jsx)(`dt`,{children:`Last verdict`}),(0,x.jsx)(`dd`,{children:e.latestReport.verdict})]}):null,e.stopReason?(0,x.jsxs)(`div`,{children:[(0,x.jsx)(`dt`,{children:`Why it stopped`}),(0,x.jsx)(`dd`,{children:e.stopReason})]}):null]}),f?null:(0,x.jsx)(`button`,{type:`button`,disabled:!n||!r,onClick:()=>d(!0),children:n?`Stop loop`:`Control unavailable`}),e.recovery?.guidance?(0,x.jsx)(`small`,{children:e.recovery.guidance}):null]}),p.length>0?(0,x.jsxs)(`section`,{className:`lag-blocking-issues`,children:[(0,x.jsx)(`h4`,{children:`Latest blocking issues`}),(0,x.jsx)(wf,{issues:p})]}):null,(0,x.jsx)(`ol`,{className:`lag-lap-list`,children:[...e.laps??[]].reverse().map(e=>(0,x.jsxs)(`li`,{className:`lag-lap-card`,"data-status":e.status,children:[(0,x.jsxs)(`header`,{children:[(0,x.jsxs)(`strong`,{children:[`Lap `,e.index]}),(0,x.jsx)(`span`,{children:e.verdict??e.status})]}),e.implementerSummary?(0,x.jsxs)(`p`,{children:[(0,x.jsx)(`b`,{children:`Implementer`}),e.implementerSummary]}):null,e.reviewerSummary?(0,x.jsxs)(`p`,{children:[(0,x.jsx)(`b`,{children:`Reviewer`}),e.reviewerSummary]}):null,e.issues.length>0?(0,x.jsx)(wf,{issues:e.issues}):null,e.at?(0,x.jsx)(`time`,{dateTime:e.at,children:e.at}):null]},e.index))}),(0,x.jsxs)(`details`,{className:`lag-diagnostics`,children:[(0,x.jsx)(`summary`,{children:`Diagnostics & advanced details`}),(0,x.jsxs)(`div`,{children:[`runId: `,e.identity.runId]}),(0,x.jsxs)(`div`,{children:[`revision: `,e.identity.revision]}),(0,x.jsxs)(`div`,{children:[`digest: `,e.identity.projectionDigest]})]})]})]})}function Ef(e,t){return e.find(e=>e.id===t)?.label??t}function Df({edge:e,nodes:t,onClose:n,onRequestStop:r,stopAvailable:i=!1}){return(0,x.jsxs)(`aside`,{className:`lag-relationship-inspector`,"aria-label":`Relationship details`,children:[(0,x.jsxs)(`header`,{children:[(0,x.jsx)(`span`,{className:`lag-panel-icon`,"aria-hidden":`true`,children:`↗`}),(0,x.jsxs)(`div`,{children:[(0,x.jsx)(`p`,{className:`lag-eyebrow`,children:`Relationship`}),(0,x.jsx)(`h3`,{children:e.label??e.kind})]}),(0,x.jsx)(`button`,{type:`button`,className:`lag-icon-button`,"aria-label":`Close Relationship inspector`,onClick:n,children:`×`})]}),(0,x.jsxs)(`dl`,{className:`lag-relationship-grid`,children:[(0,x.jsx)(`dt`,{children:`From`}),(0,x.jsx)(`dd`,{children:Ef(t,e.source)}),(0,x.jsx)(`dt`,{children:`When`}),(0,x.jsx)(`dd`,{children:e.summary??e.kind}),(0,x.jsx)(`dt`,{children:`Then`}),(0,x.jsx)(`dd`,{children:Ef(t,e.target)}),(0,x.jsx)(`dt`,{children:`Gate`}),(0,x.jsx)(`dd`,{children:e.gate??`Governor`}),(0,x.jsx)(`dt`,{children:`State`}),(0,x.jsxs)(`dd`,{children:[e.active?`active`:`waiting`,` · `,e.firings??e.reportCount,e.maxFirings===void 0?``:`/${e.maxFirings}`,` firings`]}),(0,x.jsx)(`dt`,{children:`Stop when`}),(0,x.jsx)(`dd`,{children:e.stopWhen??`run reaches a terminal state`})]}),e.summary?(0,x.jsx)(`p`,{className:`lag-panel-note`,children:e.summary}):null,(0,x.jsx)(`button`,{type:`button`,className:`lag-danger-button`,disabled:!i||!r,onClick:r,children:i?`Stop future handoffs`:`Control unavailable`})]})}function Of({model:e,mode:t,liveState:n}){return(0,x.jsxs)(`header`,{className:`lag-header`,children:[(0,x.jsxs)(`div`,{children:[(0,x.jsx)(`p`,{className:`lag-eyebrow`,children:`looperators`}),(0,x.jsx)(`h2`,{children:`Agent Loop`})]}),(0,x.jsxs)(`div`,{className:`lag-badges`,"aria-label":`Loop status`,children:[(0,x.jsx)(`span`,{className:`lag-badge lag-verified`,children:`verified`}),(0,x.jsx)(`span`,{className:`lag-badge`,"data-tone":Sf(e.status),children:e.status}),(0,x.jsxs)(`span`,{className:`lag-badge`,children:[`lap `,e.currentLap,`/`,e.lapCap]}),(0,x.jsxs)(`span`,{className:`lag-badge`,children:[`lease `,e.lease.consumed,`/`,e.lease.granted]}),(0,x.jsx)(`span`,{className:`lag-badge`,children:t===`live`?n??`connecting`:`snapshot`})]})]})}var kf={"agent-role":rf},Af={"agent-relationship":sf};function jf(...e){return e.filter(Boolean).join(` `)}function Mf(e){return e.status===`paused`||e.status===`interrupted`?`resume`:`pause`}function Nf({model:e,mode:t=`snapshot`,liveState:n,followUpAvailable:r=!1,explainAvailable:i=r,controlAvailable:a=r,onFollowUp:o,className:s}){let c=hf(e),l=(0,y.useRef)(null),[u,d]=(0,y.useState)(960),[f,p]=(0,y.useState)(),[m,h]=(0,y.useState)(``),[g,_]=(0,y.useState)(!1),[v,b]=(0,y.useState)(!1),S=xf(u),C=(0,y.useMemo)(()=>bf(c,S),[c,S]),[w,T]=(0,y.useState)(C.nodes),E=w.map(e=>({...e,draggable:!0,selected:f?.kind===`node`&&f.id===e.id})),D=C.edges.map(e=>({...e,selected:f?.kind===`edge`&&f.id===e.id,data:{...e.data,onSelect:e=>p({kind:`edge`,id:e})}}));(0,y.useEffect)(()=>{let e=l.current;if(!e)return;let t=()=>{let t=Math.round(e.getBoundingClientRect().width);d(e=>e===t?e:t)};if(t(),!(typeof window>`u`))return window.addEventListener(`resize`,t),()=>window.removeEventListener(`resize`,t)},[]),(0,y.useEffect)(()=>{T(C.nodes)},[C.nodes]),(0,y.useEffect)(()=>{f?.kind===`node`&&!c.nodes.some(e=>e.id===f.id)&&p(void 0),f?.kind===`edge`&&!c.edges.some(e=>e.id===f.id)&&p(void 0)},[c.edges,c.nodes,f]);let O=f?.kind===`node`?c.nodes.find(e=>e.id===f.id):void 0,k=f?.kind===`edge`?c.edges.find(e=>e.id===f.id):void 0,A=(e,t)=>{p({kind:`node`,id:t.id})},j=(e,t)=>{p({kind:`edge`,id:t.id})},M=(0,y.useCallback)(({nodes:e,edges:t})=>{let n=e.at(-1);if(n){p({kind:`node`,id:n.id});return}let r=t.at(-1);if(r){p({kind:`edge`,id:r.id});return}p(void 0)},[]),N=(0,y.useCallback)(e=>{T(t=>{let n=e.filter(e=>{if(e.type!==`dimensions`||!e.dimensions)return!0;let n=t.find(t=>t.id===e.id);return n?.measured?.width!==e.dimensions.width||n?.measured?.height!==e.dimensions.height});return n.length===0?t:tl(n,t)})},[]),P=e=>{if(e.key!==`Enter`&&e.key!==` `)return;let t=e.target;if(!(t instanceof Element))return;let n=t.closest(`.react-flow__edge`),r=t.closest(`.react-flow__node`);n?.dataset.id?p({kind:`edge`,id:n.dataset.id}):r?.dataset.id&&p({kind:`node`,id:r.dataset.id})},ee=async e=>{if(!(e===`explain`?i:a)||!o){h(`Host follow-up is unavailable.`);return}try{h(`Requesting follow-up…`),await o({kind:e,runId:c.identity.runId,...f?{selection:f}:{}}),h(`Follow-up requested.`)}catch{h(`Follow-up cancelled or failed.`)}},F=[`succeeded`,`capped`,`cancelled`,`failed`].includes(c.status),I=Mf(c),te=()=>{b(!0),_(!0)};return(0,x.jsxs)(`section`,{ref:l,className:jf(`looperators-agent-graph`,s),"data-orientation":S,"data-status":c.status,"data-testid":`agent-loop-graph`,onKeyDownCapture:P,children:[(0,x.jsx)(Of,{model:c,mode:t,liveState:n}),c.needsHuman||c.cancelRequested||c.recovery?(0,x.jsx)(`div`,{className:`lag-alert`,role:`status`,children:c.recovery?`Recovery: ${c.recovery.reason}`:c.cancelRequested?`Cancellation requested.`:`Human attention is required.`}):null,(0,x.jsxs)(`div`,{className:`lag-workspace`,"data-panel-open":g||!!k,children:[(0,x.jsxs)(`div`,{className:`lag-canvas-stack`,children:[(0,x.jsx)(Cf,{model:c,onOpen:()=>_(!0)}),(0,x.jsx)(`div`,{className:`lag-flow`,"data-testid":`graph-viewport`,"data-orientation":S,children:(0,x.jsxs)(yd,{nodes:E,edges:D,nodeTypes:kf,edgeTypes:Af,nodesDraggable:!0,nodesConnectable:!1,elementsSelectable:!0,elevateEdgesOnSelect:!0,minZoom:.45,maxZoom:1.5,fitView:!0,fitViewOptions:{padding:.24,maxZoom:1.05},onNodesChange:N,onNodeClick:A,onEdgeClick:j,onSelectionChange:M,onPaneClick:()=>p(void 0),"aria-label":`Agent Loop relationship graph`,children:[(0,x.jsx)(Dd,{variant:Cd.Dots,gap:24,size:1.2}),(0,x.jsx)(Fd,{position:`bottom-right`}),(0,x.jsx)(Xd,{pannable:!0,zoomable:!0,position:`bottom-left`,bgColor:`var(--lag-card)`,maskColor:`color-mix(in srgb, var(--lag-background) 55%, transparent)`,nodeColor:`var(--lag-card-muted)`,nodeStrokeColor:`var(--lag-border)`})]},S)})]}),k&&!g?(0,x.jsx)(Df,{edge:k,nodes:c.nodes,onClose:()=>p(void 0),stopAvailable:a&&!F,onRequestStop:te}):null,g?(0,x.jsx)(Tf,{model:c,onClose:()=>{b(!1),_(!1)},controlAvailable:a,onControl:o,confirming:v,onConfirmingChange:b}):null]}),(0,x.jsxs)(`section`,{className:`lag-inspector`,"aria-live":`polite`,children:[(0,x.jsxs)(`div`,{className:`lag-inspector-copy`,children:[(0,x.jsx)(`p`,{className:`lag-eyebrow`,children:O?`Selected node`:k?`Selected relationship`:`Verified snapshot`}),(0,x.jsx)(`h3`,{children:O?.label??(k?`${k.source} → ${k.target}`:`Select a node or relationship`)}),(0,x.jsx)(`p`,{children:O?`${O.role} · ${O.state}${O.nativeAgentId?` · native worker bound`:``}`:k?`${k.kind} · ${k.reportCount} reports${k.active?` · active`:``}`:`revision ${c.identity.revision} · digest ${c.identity.projectionDigest.slice(0,12)}`})]}),(0,x.jsxs)(`div`,{className:`lag-actions`,children:[(0,x.jsx)(`button`,{type:`button`,disabled:!f||!i,onClick:()=>void ee(`explain`),children:`Explain selection`}),(0,x.jsxs)(`button`,{type:`button`,disabled:F||!a,onClick:()=>void ee(I),children:[`Request `,I]}),(0,x.jsx)(`button`,{type:`button`,disabled:F||!a,onClick:te,children:`Review stop…`})]}),m?(0,x.jsx)(`p`,{className:`lag-follow-up-status`,role:`status`,children:m}):null]}),(0,x.jsxs)(`details`,{className:`lag-timeline`,children:[(0,x.jsxs)(`summary`,{children:[`Bounded timeline `,(0,x.jsx)(`span`,{children:c.timeline.length})]}),(0,x.jsx)(`ol`,{children:c.timeline.length>0?c.timeline.map(e=>(0,x.jsxs)(`li`,{children:[(0,x.jsx)(`time`,{dateTime:e.at,children:e.at}),(0,x.jsx)(`span`,{children:e.label}),e.role?(0,x.jsx)(`small`,{children:e.role}):null]},e.id)):(0,x.jsx)(`li`,{children:`No authoritative timeline entries.`})})]})]})}var Pf=[{id:`root-governs-implementer`,source:`root`,target:`role:implementer`,kind:`governs`},{id:`implementer-handoff-reviewer`,source:`role:implementer`,target:`role:reviewer`,kind:`handoff`},{id:`reviewer-feedback-implementer`,source:`role:reviewer`,target:`role:implementer`,kind:`feedback`},{id:`reviewer-verdict-root`,source:`role:reviewer`,target:`root`,kind:`verdict`}];function Ff(e,t=!0){return[{id:`root`,kind:`root`,role:`root`,label:`Governor`,state:e[0]},{id:`role:implementer`,kind:`worker-role`,role:`implementer`,label:`Implementer`,state:e[1],...t?{nativeAgentId:`native-implementer-fixture`,nativeAgentType:`worker`}:{}},{id:`role:reviewer`,kind:`worker-role`,role:`reviewer`,label:`Reviewer`,state:e[2],...t?{nativeAgentId:`native-reviewer-fixture`,nativeAgentType:`worker`}:{}}]}function If(e,t={}){return Pf.map(n=>({...n,active:n.kind===e,reportCount:t[n.kind]??0}))}function Lf(e){return e.map(({role:e,...t})=>t.kind===`root`?t:{...t,role:e})}function Rf(e){let t=Ff(e.states,e.bound),n=If(e.activeKind,e.reports),r=e.digestCharacter.repeat(64),i=e.revision===0?[]:[{id:`transition-${e.name}`,at:`2026-07-28T18:00:00.000Z`,label:e.activeKind?`activate-${e.pendingRole??e.activeKind}`:e.status,kind:`transition`,...e.pendingRole?{role:e.pendingRole}:{}},...e.latestReport?[{id:`report-${e.name}`,at:`2026-07-28T18:00:01.000Z`,label:e.latestReport.verdict===`issues`?`reviewer verdict: issues`:e.latestReport.verdict===`clean`?`reviewer verdict: clean`:`implementer info: done`,kind:`report`,role:e.latestReport.fromRole}]:[]],a={identity:{runId:`run-${e.name}`,revision:e.revision,projectionDigest:r,integrity:`verified`},status:e.status,currentLap:e.currentLap,lapCap:e.lapCap??3,lease:e.lease??{granted:3,consumed:0},cancelRequested:e.cancelRequested??!1,needsHuman:e.needsHuman??!1,nodes:t,edges:n,...e.pendingRole?{pending:{role:e.pendingRole,kind:e.pendingRole===`implementer`?`activate-implementer`:`activate-reviewer`,lap:e.currentLap}}:{},...e.latestReport?{latestReport:e.latestReport}:{},...e.recovery?{recovery:e.recovery}:{},timeline:i};return{name:e.name,expectedModel:a,projection:{schemaVersion:1,storeVersion:1,projectionVersion:3,runId:a.identity.runId,revision:a.identity.revision,status:a.status,recipe:`review-until-clean`,currentLap:a.currentLap,lapCap:a.lapCap,continuationLease:a.lease,cancelRequested:a.cancelRequested,needsHuman:a.needsHuman,integrity:{status:`verified`,verifiedRevision:a.identity.revision},eventWatermark:{eventCount:0},nodes:Lf(t),edges:n,...a.pending?{pending:{transitionId:`transition-${e.name}`,...a.pending}}:{},...a.latestReport?{latestReport:{reportId:`report-${e.name}`,...a.latestReport}}:{},...a.recovery?{recovery:{recoveryId:`recovery_${`d`.repeat(64)}`,...a.recovery}}:{},counts:{events:0,reports:+!!a.latestReport,transitions:+(a.identity.revision>0),operations:a.identity.revision,governorDecisions:0,recoveries:+!!a.recovery,diagnostics:0,conflicts:0,corrupt:0},timeline:i,projectionDigest:r}}}var zf=[Rf({name:`draft`,digestCharacter:`a`,status:`draft`,revision:0,currentLap:0,states:[`active`,`unbound`,`unbound`],bound:!1}),Rf({name:`implementer-active`,digestCharacter:`b`,status:`running`,revision:1,currentLap:0,states:[`waiting`,`active`,`unbound`],activeKind:`governs`,pendingRole:`implementer`}),Rf({name:`reviewer-issues`,digestCharacter:`c`,status:`running`,revision:4,currentLap:1,lease:{granted:3,consumed:1},states:[`waiting`,`waiting`,`active`],activeKind:`feedback`,reports:{handoff:1,feedback:1},pendingRole:`implementer`,latestReport:{fromRole:`reviewer`,type:`verdict`,verdict:`issues`,issueCount:2}}),Rf({name:`paused-needs-human`,digestCharacter:`d`,status:`paused`,revision:5,currentLap:1,lease:{granted:3,consumed:2},states:[`active`,`bound`,`bound`],reports:{handoff:1,feedback:1},needsHuman:!0}),Rf({name:`succeeded-clean`,digestCharacter:`e`,status:`succeeded`,revision:7,currentLap:2,lease:{granted:3,consumed:2},states:[`terminal`,`terminal`,`terminal`],activeKind:`verdict`,reports:{handoff:2,feedback:1,verdict:1},latestReport:{fromRole:`reviewer`,type:`verdict`,verdict:`clean`,issueCount:0}}),Rf({name:`capped`,digestCharacter:`f`,status:`capped`,revision:6,currentLap:3,lease:{granted:3,consumed:3},states:[`terminal`,`terminal`,`terminal`],reports:{handoff:2,feedback:2},needsHuman:!0}),Rf({name:`cancelled`,digestCharacter:`1`,status:`cancelled`,revision:2,currentLap:0,lease:{granted:3,consumed:0},states:[`terminal`,`terminal`,`terminal`],cancelRequested:!0})].find(e=>e.name===`reviewer-issues`);if(!zf)throw Error(`reviewer-issues fixture is unavailable`);({...zf.expectedModel}),zf.expectedModel.nodes.map(e=>({...e,runtimeLabel:e.role===`root`?`Codex task`:`Native subagent`,model:e.role===`root`?`Governor`:`worker`,description:e.role===`root`?`Owns the bounded review policy and approves every transition.`:e.role===`implementer`?`Addresses the latest blocking findings and reports completion.`:`Reviews the implementation and returns a typed verdict.`,activityCount:e.role===`root`?4:e.role===`implementer`?7:5,lastActivityAt:`2026-08-02T18:00:04.000Z`})),zf.expectedModel.edges.map(e=>({...e,label:e.kind===`governs`?`Governed activation`:e.kind===`handoff`?`Implementation ready`:e.kind===`feedback`?`Blocking feedback`:`Clean verdict`,summary:e.kind===`feedback`?`Reviewer found blocking issues, so the Governor grants one bounded implementer continuation.`:`Typed ${e.kind} report advances the run only after Governor validation.`,recent:e.kind===`handoff`,pending:e.kind===`feedback`,gate:`Governor validates typed report and lease`,firings:e.reportCount,maxFirings:e.kind===`governs`?1:3,stopWhen:e.kind===`feedback`?`clean verdict, cancellation, or lap cap`:`terminal run state`})),{...zf.expectedModel.latestReport};var Bf=new Set([`draft`,`running`,`paused`,`interrupted`,`succeeded`,`capped`,`cancelled`,`failed`]),Vf=new Set([`active`,`waiting`,`bound`,`unbound`,`terminal`]),Hf=new Set([`event`,`report`,`transition`,`governor-decision`,`recovery`]),Uf=/^[a-f0-9]{64}$/u,Wf=[{id:`root`,kind:`root`,role:`root`},{id:`role:implementer`,kind:`worker-role`,role:`implementer`},{id:`role:reviewer`,kind:`worker-role`,role:`reviewer`}],Gf=[{id:`root-governs-implementer`,source:`root`,target:`role:implementer`,kind:`governs`},{id:`implementer-handoff-reviewer`,source:`role:implementer`,target:`role:reviewer`,kind:`handoff`},{id:`reviewer-feedback-implementer`,source:`role:reviewer`,target:`role:implementer`,kind:`feedback`},{id:`reviewer-verdict-root`,source:`role:reviewer`,target:`root`,kind:`verdict`}];function Kf(e,t){return Object.assign(TypeError(t),{code:e})}function qf(e){throw Kf(`GRAPH_VIEW_PROJECTION_INVALID`,e)}function Jf(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}function Yf(e,t,n=256){return(typeof e!=`string`||e.length===0||e.length>n)&&qf(`${t} must be a bounded string`),e}function Xf(e,t,n=256){return e===void 0?void 0:Yf(e,t,n)}function Zf(e,t,{min:n=0,max:r=2**53-1}={}){return(!Number.isSafeInteger(e)||e<n||e>r)&&qf(`${t} must be a bounded integer`),e}function Qf(e,t){return typeof e!=`boolean`&&qf(`${t} must be a boolean`),e}function $f(e,t){Jf(e)||qf(`projection must be an object`),(e.schemaVersion!==1||e.storeVersion!==1||e.projectionVersion!==3||e.recipe!==`review-until-clean`)&&qf(`projection version or recipe is unsupported`);let n=Yf(e.runId,`projection.runId`,128),r=Zf(e.revision,`projection.revision`);if(!Jf(e.integrity)||e.integrity.status!==`verified`||e.integrity.verifiedRevision!==r)throw Kf(`GRAPH_VIEW_PROJECTION_UNVERIFIED`,`projection integrity is not verified`);if((typeof e.projectionDigest!=`string`||!Uf.test(e.projectionDigest))&&qf(`projection.projectionDigest is invalid`),t.expectedProjectionDigest!==void 0&&e.projectionDigest!==t.expectedProjectionDigest)throw Kf(`PROJECTION_DIGEST_MISMATCH`,`projection digest does not match the expected snapshot`);if(t.expectedRunId!==void 0&&n!==t.expectedRunId)throw Kf(`SNAPSHOT_IDENTITY_MISMATCH`,`projection belongs to another run`);return{runId:n,revision:r,projectionDigest:e.projectionDigest}}function ep(e){(!Array.isArray(e)||e.length!==Wf.length)&&qf(`projection.nodes must contain exactly three nodes`);let t=new Map(e.map(e=>[e?.id,e]));return Wf.map(e=>{let n=t.get(e.id);(!Jf(n)||n.kind!==e.kind||e.role!==`root`&&n.role!==e.role||!Vf.has(n.state))&&qf(`projection node ${e.id} is invalid`);let r=Xf(n.nativeAgentId,`projection node ${e.id}.nativeAgentId`,256),i=Xf(n.nativeAgentType,`projection node ${e.id}.nativeAgentType`,128);return{id:e.id,kind:e.kind,role:e.role,label:Yf(n.label,`projection node ${e.id}.label`,80),state:n.state,...r?{nativeAgentId:r}:{},...i?{nativeAgentType:i}:{}}})}function tp(e){(!Array.isArray(e)||e.length!==Gf.length)&&qf(`projection.edges must contain exactly four relationships`);let t=new Map(e.map(e=>[e?.id,e]));return Gf.map(e=>{let n=t.get(e.id);return(!Jf(n)||n.source!==e.source||n.target!==e.target||n.kind!==e.kind)&&qf(`projection edge ${e.id} is invalid`),{...e,active:Qf(n.active,`projection edge ${e.id}.active`),reportCount:Zf(n.reportCount,`projection edge ${e.id}.reportCount`)}})}function np(e,t){if(e!==void 0)return(!Jf(e)||![`implementer`,`reviewer`].includes(e.role)||e.kind!==`activate-${e.role}`)&&qf(`projection.pending is invalid`),Yf(e.transitionId,`projection.pending.transitionId`,128),{role:e.role,kind:e.kind,lap:Zf(e.lap,`projection.pending.lap`,{max:t})}}function rp(e){if(e!==void 0)return(!Jf(e)||![`implementer`,`reviewer`].includes(e.fromRole)||![`info`,`verdict`].includes(e.type))&&qf(`projection.latestReport is invalid`),Yf(e.reportId,`projection.latestReport.reportId`,128),e.verdict!==void 0&&![`issues`,`clean`].includes(e.verdict)&&qf(`projection.latestReport.verdict is invalid`),{fromRole:e.fromRole,type:e.type,...e.verdict?{verdict:e.verdict}:{},issueCount:Zf(e.issueCount,`projection.latestReport.issueCount`)}}function ip(e){return(!Array.isArray(e)||e.length>32)&&qf(`projection.timeline is invalid`),e.map((e,t)=>{(!Jf(e)||!Hf.has(e.kind))&&qf(`projection.timeline[${t}] is invalid`);let n=Xf(e.role,`projection.timeline[${t}].role`,16);return n!==void 0&&![`implementer`,`reviewer`].includes(n)&&qf(`projection.timeline[${t}].role is invalid`),{id:Yf(e.id,`projection.timeline[${t}].id`,128),at:Yf(e.at,`projection.timeline[${t}].at`,40),label:Yf(e.label,`projection.timeline[${t}].label`,128),kind:e.kind,...n?{role:n}:{}}})}function ap(e,t={}){let n=$f(e,t);Bf.has(e.status)||qf(`projection.status is invalid`);let r=Zf(e.lapCap,`projection.lapCap`,{min:1,max:6}),i=Zf(e.currentLap,`projection.currentLap`,{max:r});Jf(e.continuationLease)||qf(`projection.continuationLease must be an object`);let a=Zf(e.continuationLease.granted,`projection.continuationLease.granted`,{max:6}),o=Zf(e.continuationLease.consumed,`projection.continuationLease.consumed`,{max:a}),s=np(e.pending,r),c=rp(e.latestReport),l;return e.recovery!==void 0&&(Jf(e.recovery)||qf(`projection.recovery is invalid`),Yf(e.recovery.recoveryId,`projection.recovery.recoveryId`,128),l={reason:Yf(e.recovery.reason,`projection.recovery.reason`,80)}),{identity:{...n,integrity:`verified`},status:e.status,currentLap:i,lapCap:r,lease:{granted:a,consumed:o},cancelRequested:Qf(e.cancelRequested,`projection.cancelRequested`),needsHuman:Qf(e.needsHuman,`projection.needsHuman`),nodes:ep(e.nodes),edges:tp(e.edges),...s?{pending:s}:{},...c?{latestReport:c}:{},...l?{recovery:l}:{},timeline:ip(e.timeline)}}var op=document.getElementById(`looperators-agent-loop-root`),sp=document.getElementById(`looperators-agent-loop-fallback`),cp=document.getElementById(`looperators-agent-loop-data`);function lp(e){return String(e??`SURFACE_REQUEST_FAILED`).slice(0,80)}if(op&&cp){let e=JSON.parse(cp.textContent??`{}`),t=ap(e.projection,{expectedProjectionDigest:e.expectedProjectionDigest,expectedRunId:e.runId});function up(){let[n,r]=(0,y.useState)(t),[i,a]=(0,y.useState)(e.mode===`sidecar`?`connecting`:void 0),[o,s]=(0,y.useState)();return(0,y.useEffect)(()=>(sp?.setAttribute(`hidden`,``),window.looperatorsAgentLoopView=Object.freeze({update(n){r(ap(n,{expectedRunId:t.identity.runId})),s(void 0),a(e.mode===`sidecar`?`live`:void 0)},integrityError(e){s(lp(e))}}),()=>{delete window.looperatorsAgentLoopView}),[]),(0,y.useEffect)(()=>{if(e.mode!==`sidecar`||!e.eventsUrl)return;let t=new EventSource(e.eventsUrl);return t.addEventListener(`open`,()=>a(`live`)),t.addEventListener(`snapshot`,e=>{try{window.looperatorsAgentLoopView?.update(JSON.parse(e.data))}catch{s(`GRAPH_VIEW_PROJECTION_INVALID`)}}),t.addEventListener(`integrity-error`,e=>{try{s(lp(JSON.parse(e.data).code))}catch{s(`HISTORY_CORRUPT`)}}),t.onerror=()=>a(`retrying`),()=>t.close()},[]),(0,x.jsxs)(x.Fragment,{children:[o?(0,x.jsxs)(`p`,{className:`lag-embed-error`,role:`status`,children:[`Snapshot unavailable: `,o]}):null,(0,x.jsx)(Nf,{model:n,mode:e.mode===`sidecar`?`live`:`snapshot`,liveState:i,explainAvailable:!1,controlAvailable:e.mode===`sidecar`&&!!(e.controlUrl&&e.csrfToken),onFollowUp:async t=>{if(t.kind===`explain`||!e.controlUrl||!e.csrfToken)throw Error(`CONTROL_UNAVAILABLE`);let n=await fetch(e.controlUrl,{method:`POST`,credentials:`same-origin`,headers:{"Content-Type":`application/json`,"X-Looperators-CSRF":e.csrfToken},body:JSON.stringify({action:t.kind,requestId:`surface-${crypto.randomUUID()}`})});if(!n.ok)throw Error(lp((await n.json()).code))}})]})}(0,b.createRoot)(op).render((0,x.jsx)(up,{}))}})();
\ No newline at end of file
diff --git a/plugins/looperators-agent-loop/ui/assets/paired-scenarios.json b/plugins/looperators-agent-loop/ui/assets/paired-scenarios.json
new file mode 100644
index 0000000..2e8764c
--- /dev/null
+++ b/plugins/looperators-agent-loop/ui/assets/paired-scenarios.json
@@ -0,0 +1,1411 @@
+[
+  {
+    "name": "draft",
+    "expectedModel": {
+      "identity": {
+        "runId": "run-draft",
+        "revision": 0,
+        "projectionDigest": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+        "integrity": "verified"
+      },
+      "status": "draft",
+      "currentLap": 0,
+      "lapCap": 3,
+      "lease": {
+        "granted": 3,
+        "consumed": 0
+      },
+      "cancelRequested": false,
+      "needsHuman": false,
+      "nodes": [
+        {
+          "id": "root",
+          "kind": "root",
+          "role": "root",
+          "label": "Governor",
+          "state": "active"
+        },
+        {
+          "id": "role:implementer",
+          "kind": "worker-role",
+          "role": "implementer",
+          "label": "Implementer",
+          "state": "unbound"
+        },
+        {
+          "id": "role:reviewer",
+          "kind": "worker-role",
+          "role": "reviewer",
+          "label": "Reviewer",
+          "state": "unbound"
+        }
+      ],
+      "edges": [
+        {
+          "id": "root-governs-implementer",
+          "source": "root",
+          "target": "role:implementer",
+          "kind": "governs",
+          "active": false,
+          "reportCount": 0
+        },
+        {
+          "id": "implementer-handoff-reviewer",
+          "source": "role:implementer",
+          "target": "role:reviewer",
+          "kind": "handoff",
+          "active": false,
+          "reportCount": 0
+        },
+        {
+          "id": "reviewer-feedback-implementer",
+          "source": "role:reviewer",
+          "target": "role:implementer",
+          "kind": "feedback",
+          "active": false,
+          "reportCount": 0
+        },
+        {
+          "id": "reviewer-verdict-root",
+          "source": "role:reviewer",
+          "target": "root",
+          "kind": "verdict",
+          "active": false,
+          "reportCount": 0
+        }
+      ],
+      "timeline": []
+    },
+    "projection": {
+      "schemaVersion": 1,
+      "storeVersion": 1,
+      "projectionVersion": 3,
+      "runId": "run-draft",
+      "revision": 0,
+      "status": "draft",
+      "recipe": "review-until-clean",
+      "currentLap": 0,
+      "lapCap": 3,
+      "continuationLease": {
+        "granted": 3,
+        "consumed": 0
+      },
+      "cancelRequested": false,
+      "needsHuman": false,
+      "integrity": {
+        "status": "verified",
+        "verifiedRevision": 0
+      },
+      "eventWatermark": {
+        "eventCount": 0
+      },
+      "nodes": [
+        {
+          "id": "root",
+          "kind": "root",
+          "label": "Governor",
+          "state": "active"
+        },
+        {
+          "id": "role:implementer",
+          "kind": "worker-role",
+          "label": "Implementer",
+          "state": "unbound",
+          "role": "implementer"
+        },
+        {
+          "id": "role:reviewer",
+          "kind": "worker-role",
+          "label": "Reviewer",
+          "state": "unbound",
+          "role": "reviewer"
+        }
+      ],
+      "edges": [
+        {
+          "id": "root-governs-implementer",
+          "source": "root",
+          "target": "role:implementer",
+          "kind": "governs",
+          "active": false,
+          "reportCount": 0
+        },
+        {
+          "id": "implementer-handoff-reviewer",
+          "source": "role:implementer",
+          "target": "role:reviewer",
+          "kind": "handoff",
+          "active": false,
+          "reportCount": 0
+        },
+        {
+          "id": "reviewer-feedback-implementer",
+          "source": "role:reviewer",
+          "target": "role:implementer",
+          "kind": "feedback",
+          "active": false,
+          "reportCount": 0
+        },
+        {
+          "id": "reviewer-verdict-root",
+          "source": "role:reviewer",
+          "target": "root",
+          "kind": "verdict",
+          "active": false,
+          "reportCount": 0
+        }
+      ],
+      "counts": {
+        "events": 0,
+        "reports": 0,
+        "transitions": 0,
+        "operations": 0,
+        "governorDecisions": 0,
+        "recoveries": 0,
+        "diagnostics": 0,
+        "conflicts": 0,
+        "corrupt": 0
+      },
+      "timeline": [],
+      "projectionDigest": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+    }
+  },
+  {
+    "name": "implementer-active",
+    "expectedModel": {
+      "identity": {
+        "runId": "run-implementer-active",
+        "revision": 1,
+        "projectionDigest": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+        "integrity": "verified"
+      },
+      "status": "running",
+      "currentLap": 0,
+      "lapCap": 3,
+      "lease": {
+        "granted": 3,
+        "consumed": 0
+      },
+      "cancelRequested": false,
+      "needsHuman": false,
+      "nodes": [
+        {
+          "id": "root",
+          "kind": "root",
+          "role": "root",
+          "label": "Governor",
+          "state": "waiting"
+        },
+        {
+          "id": "role:implementer",
+          "kind": "worker-role",
+          "role": "implementer",
+          "label": "Implementer",
+          "state": "active",
+          "nativeAgentId": "native-implementer-fixture",
+          "nativeAgentType": "worker"
+        },
+        {
+          "id": "role:reviewer",
+          "kind": "worker-role",
+          "role": "reviewer",
+          "label": "Reviewer",
+          "state": "unbound",
+          "nativeAgentId": "native-reviewer-fixture",
+          "nativeAgentType": "worker"
+        }
+      ],
+      "edges": [
+        {
+          "id": "root-governs-implementer",
+          "source": "root",
+          "target": "role:implementer",
+          "kind": "governs",
+          "active": true,
+          "reportCount": 0
+        },
+        {
+          "id": "implementer-handoff-reviewer",
+          "source": "role:implementer",
+          "target": "role:reviewer",
+          "kind": "handoff",
+          "active": false,
+          "reportCount": 0
+        },
+        {
+          "id": "reviewer-feedback-implementer",
+          "source": "role:reviewer",
+          "target": "role:implementer",
+          "kind": "feedback",
+          "active": false,
+          "reportCount": 0
+        },
+        {
+          "id": "reviewer-verdict-root",
+          "source": "role:reviewer",
+          "target": "root",
+          "kind": "verdict",
+          "active": false,
+          "reportCount": 0
+        }
+      ],
+      "pending": {
+        "role": "implementer",
+        "kind": "activate-implementer",
+        "lap": 0
+      },
+      "timeline": [
+        {
+          "id": "transition-implementer-active",
+          "at": "2026-07-28T18:00:00.000Z",
+          "label": "activate-implementer",
+          "kind": "transition",
+          "role": "implementer"
+        }
+      ]
+    },
+    "projection": {
+      "schemaVersion": 1,
+      "storeVersion": 1,
+      "projectionVersion": 3,
+      "runId": "run-implementer-active",
+      "revision": 1,
+      "status": "running",
+      "recipe": "review-until-clean",
+      "currentLap": 0,
+      "lapCap": 3,
+      "continuationLease": {
+        "granted": 3,
+        "consumed": 0
+      },
+      "cancelRequested": false,
+      "needsHuman": false,
+      "integrity": {
+        "status": "verified",
+        "verifiedRevision": 1
+      },
+      "eventWatermark": {
+        "eventCount": 0
+      },
+      "nodes": [
+        {
+          "id": "root",
+          "kind": "root",
+          "label": "Governor",
+          "state": "waiting"
+        },
+        {
+          "id": "role:implementer",
+          "kind": "worker-role",
+          "label": "Implementer",
+          "state": "active",
+          "nativeAgentId": "native-implementer-fixture",
+          "nativeAgentType": "worker",
+          "role": "implementer"
+        },
+        {
+          "id": "role:reviewer",
+          "kind": "worker-role",
+          "label": "Reviewer",
+          "state": "unbound",
+          "nativeAgentId": "native-reviewer-fixture",
+          "nativeAgentType": "worker",
+          "role": "reviewer"
+        }
+      ],
+      "edges": [
+        {
+          "id": "root-governs-implementer",
+          "source": "root",
+          "target": "role:implementer",
+          "kind": "governs",
+          "active": true,
+          "reportCount": 0
+        },
+        {
+          "id": "implementer-handoff-reviewer",
+          "source": "role:implementer",
+          "target": "role:reviewer",
+          "kind": "handoff",
+          "active": false,
+          "reportCount": 0
+        },
+        {
+          "id": "reviewer-feedback-implementer",
+          "source": "role:reviewer",
+          "target": "role:implementer",
+          "kind": "feedback",
+          "active": false,
+          "reportCount": 0
+        },
+        {
+          "id": "reviewer-verdict-root",
+          "source": "role:reviewer",
+          "target": "root",
+          "kind": "verdict",
+          "active": false,
+          "reportCount": 0
+        }
+      ],
+      "pending": {
+        "transitionId": "transition-implementer-active",
+        "role": "implementer",
+        "kind": "activate-implementer",
+        "lap": 0
+      },
+      "counts": {
+        "events": 0,
+        "reports": 0,
+        "transitions": 1,
+        "operations": 1,
+        "governorDecisions": 0,
+        "recoveries": 0,
+        "diagnostics": 0,
+        "conflicts": 0,
+        "corrupt": 0
+      },
+      "timeline": [
+        {
+          "id": "transition-implementer-active",
+          "at": "2026-07-28T18:00:00.000Z",
+          "label": "activate-implementer",
+          "kind": "transition",
+          "role": "implementer"
+        }
+      ],
+      "projectionDigest": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
+    }
+  },
+  {
+    "name": "reviewer-issues",
+    "expectedModel": {
+      "identity": {
+        "runId": "run-reviewer-issues",
+        "revision": 4,
+        "projectionDigest": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
+        "integrity": "verified"
+      },
+      "status": "running",
+      "currentLap": 1,
+      "lapCap": 3,
+      "lease": {
+        "granted": 3,
+        "consumed": 1
+      },
+      "cancelRequested": false,
+      "needsHuman": false,
+      "nodes": [
+        {
+          "id": "root",
+          "kind": "root",
+          "role": "root",
+          "label": "Governor",
+          "state": "waiting"
+        },
+        {
+          "id": "role:implementer",
+          "kind": "worker-role",
+          "role": "implementer",
+          "label": "Implementer",
+          "state": "waiting",
+          "nativeAgentId": "native-implementer-fixture",
+          "nativeAgentType": "worker"
+        },
+        {
+          "id": "role:reviewer",
+          "kind": "worker-role",
+          "role": "reviewer",
+          "label": "Reviewer",
+          "state": "active",
+          "nativeAgentId": "native-reviewer-fixture",
+          "nativeAgentType": "worker"
+        }
+      ],
+      "edges": [
+        {
+          "id": "root-governs-implementer",
+          "source": "root",
+          "target": "role:implementer",
+          "kind": "governs",
+          "active": false,
+          "reportCount": 0
+        },
+        {
+          "id": "implementer-handoff-reviewer",
+          "source": "role:implementer",
+          "target": "role:reviewer",
+          "kind": "handoff",
+          "active": false,
+          "reportCount": 1
+        },
+        {
+          "id": "reviewer-feedback-implementer",
+          "source": "role:reviewer",
+          "target": "role:implementer",
+          "kind": "feedback",
+          "active": true,
+          "reportCount": 1
+        },
+        {
+          "id": "reviewer-verdict-root",
+          "source": "role:reviewer",
+          "target": "root",
+          "kind": "verdict",
+          "active": false,
+          "reportCount": 0
+        }
+      ],
+      "pending": {
+        "role": "implementer",
+        "kind": "activate-implementer",
+        "lap": 1
+      },
+      "latestReport": {
+        "fromRole": "reviewer",
+        "type": "verdict",
+        "verdict": "issues",
+        "issueCount": 2
+      },
+      "timeline": [
+        {
+          "id": "transition-reviewer-issues",
+          "at": "2026-07-28T18:00:00.000Z",
+          "label": "activate-implementer",
+          "kind": "transition",
+          "role": "implementer"
+        },
+        {
+          "id": "report-reviewer-issues",
+          "at": "2026-07-28T18:00:01.000Z",
+          "label": "reviewer verdict: issues",
+          "kind": "report",
+          "role": "reviewer"
+        }
+      ]
+    },
+    "projection": {
+      "schemaVersion": 1,
+      "storeVersion": 1,
+      "projectionVersion": 3,
+      "runId": "run-reviewer-issues",
+      "revision": 4,
+      "status": "running",
+      "recipe": "review-until-clean",
+      "currentLap": 1,
+      "lapCap": 3,
+      "continuationLease": {
+        "granted": 3,
+        "consumed": 1
+      },
+      "cancelRequested": false,
+      "needsHuman": false,
+      "integrity": {
+        "status": "verified",
+        "verifiedRevision": 4
+      },
+      "eventWatermark": {
+        "eventCount": 0
+      },
+      "nodes": [
+        {
+          "id": "root",
+          "kind": "root",
+          "label": "Governor",
+          "state": "waiting"
+        },
+        {
+          "id": "role:implementer",
+          "kind": "worker-role",
+          "label": "Implementer",
+          "state": "waiting",
+          "nativeAgentId": "native-implementer-fixture",
+          "nativeAgentType": "worker",
+          "role": "implementer"
+        },
+        {
+          "id": "role:reviewer",
+          "kind": "worker-role",
+          "label": "Reviewer",
+          "state": "active",
+          "nativeAgentId": "native-reviewer-fixture",
+          "nativeAgentType": "worker",
+          "role": "reviewer"
+        }
+      ],
+      "edges": [
+        {
+          "id": "root-governs-implementer",
+          "source": "root",
+          "target": "role:implementer",
+          "kind": "governs",
+          "active": false,
+          "reportCount": 0
+        },
+        {
+          "id": "implementer-handoff-reviewer",
+          "source": "role:implementer",
+          "target": "role:reviewer",
+          "kind": "handoff",
+          "active": false,
+          "reportCount": 1
+        },
+        {
+          "id": "reviewer-feedback-implementer",
+          "source": "role:reviewer",
+          "target": "role:implementer",
+          "kind": "feedback",
+          "active": true,
+          "reportCount": 1
+        },
+        {
+          "id": "reviewer-verdict-root",
+          "source": "role:reviewer",
+          "target": "root",
+          "kind": "verdict",
+          "active": false,
+          "reportCount": 0
+        }
+      ],
+      "pending": {
+        "transitionId": "transition-reviewer-issues",
+        "role": "implementer",
+        "kind": "activate-implementer",
+        "lap": 1
+      },
+      "latestReport": {
+        "reportId": "report-reviewer-issues",
+        "fromRole": "reviewer",
+        "type": "verdict",
+        "verdict": "issues",
+        "issueCount": 2
+      },
+      "counts": {
+        "events": 0,
+        "reports": 1,
+        "transitions": 1,
+        "operations": 4,
+        "governorDecisions": 0,
+        "recoveries": 0,
+        "diagnostics": 0,
+        "conflicts": 0,
+        "corrupt": 0
+      },
+      "timeline": [
+        {
+          "id": "transition-reviewer-issues",
+          "at": "2026-07-28T18:00:00.000Z",
+          "label": "activate-implementer",
+          "kind": "transition",
+          "role": "implementer"
+        },
+        {
+          "id": "report-reviewer-issues",
+          "at": "2026-07-28T18:00:01.000Z",
+          "label": "reviewer verdict: issues",
+          "kind": "report",
+          "role": "reviewer"
+        }
+      ],
+      "projectionDigest": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
+    }
+  },
+  {
+    "name": "paused-needs-human",
+    "expectedModel": {
+      "identity": {
+        "runId": "run-paused-needs-human",
+        "revision": 5,
+        "projectionDigest": "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd",
+        "integrity": "verified"
+      },
+      "status": "paused",
+      "currentLap": 1,
+      "lapCap": 3,
+      "lease": {
+        "granted": 3,
+        "consumed": 2
+      },
+      "cancelRequested": false,
+      "needsHuman": true,
+      "nodes": [
+        {
+          "id": "root",
+          "kind": "root",
+          "role": "root",
+          "label": "Governor",
+          "state": "active"
+        },
+        {
+          "id": "role:implementer",
+          "kind": "worker-role",
+          "role": "implementer",
+          "label": "Implementer",
+          "state": "bound",
+          "nativeAgentId": "native-implementer-fixture",
+          "nativeAgentType": "worker"
+        },
+        {
+          "id": "role:reviewer",
+          "kind": "worker-role",
+          "role": "reviewer",
+          "label": "Reviewer",
+          "state": "bound",
+          "nativeAgentId": "native-reviewer-fixture",
+          "nativeAgentType": "worker"
+        }
+      ],
+      "edges": [
+        {
+          "id": "root-governs-implementer",
+          "source": "root",
+          "target": "role:implementer",
+          "kind": "governs",
+          "active": false,
+          "reportCount": 0
+        },
+        {
+          "id": "implementer-handoff-reviewer",
+          "source": "role:implementer",
+          "target": "role:reviewer",
+          "kind": "handoff",
+          "active": false,
+          "reportCount": 1
+        },
+        {
+          "id": "reviewer-feedback-implementer",
+          "source": "role:reviewer",
+          "target": "role:implementer",
+          "kind": "feedback",
+          "active": false,
+          "reportCount": 1
+        },
+        {
+          "id": "reviewer-verdict-root",
+          "source": "role:reviewer",
+          "target": "root",
+          "kind": "verdict",
+          "active": false,
+          "reportCount": 0
+        }
+      ],
+      "timeline": [
+        {
+          "id": "transition-paused-needs-human",
+          "at": "2026-07-28T18:00:00.000Z",
+          "label": "paused",
+          "kind": "transition"
+        }
+      ]
+    },
+    "projection": {
+      "schemaVersion": 1,
+      "storeVersion": 1,
+      "projectionVersion": 3,
+      "runId": "run-paused-needs-human",
+      "revision": 5,
+      "status": "paused",
+      "recipe": "review-until-clean",
+      "currentLap": 1,
+      "lapCap": 3,
+      "continuationLease": {
+        "granted": 3,
+        "consumed": 2
+      },
+      "cancelRequested": false,
+      "needsHuman": true,
+      "integrity": {
+        "status": "verified",
+        "verifiedRevision": 5
+      },
+      "eventWatermark": {
+        "eventCount": 0
+      },
+      "nodes": [
+        {
+          "id": "root",
+          "kind": "root",
+          "label": "Governor",
+          "state": "active"
+        },
+        {
+          "id": "role:implementer",
+          "kind": "worker-role",
+          "label": "Implementer",
+          "state": "bound",
+          "nativeAgentId": "native-implementer-fixture",
+          "nativeAgentType": "worker",
+          "role": "implementer"
+        },
+        {
+          "id": "role:reviewer",
+          "kind": "worker-role",
+          "label": "Reviewer",
+          "state": "bound",
+          "nativeAgentId": "native-reviewer-fixture",
+          "nativeAgentType": "worker",
+          "role": "reviewer"
+        }
+      ],
+      "edges": [
+        {
+          "id": "root-governs-implementer",
+          "source": "root",
+          "target": "role:implementer",
+          "kind": "governs",
+          "active": false,
+          "reportCount": 0
+        },
+        {
+          "id": "implementer-handoff-reviewer",
+          "source": "role:implementer",
+          "target": "role:reviewer",
+          "kind": "handoff",
+          "active": false,
+          "reportCount": 1
+        },
+        {
+          "id": "reviewer-feedback-implementer",
+          "source": "role:reviewer",
+          "target": "role:implementer",
+          "kind": "feedback",
+          "active": false,
+          "reportCount": 1
+        },
+        {
+          "id": "reviewer-verdict-root",
+          "source": "role:reviewer",
+          "target": "root",
+          "kind": "verdict",
+          "active": false,
+          "reportCount": 0
+        }
+      ],
+      "counts": {
+        "events": 0,
+        "reports": 0,
+        "transitions": 1,
+        "operations": 5,
+        "governorDecisions": 0,
+        "recoveries": 0,
+        "diagnostics": 0,
+        "conflicts": 0,
+        "corrupt": 0
+      },
+      "timeline": [
+        {
+          "id": "transition-paused-needs-human",
+          "at": "2026-07-28T18:00:00.000Z",
+          "label": "paused",
+          "kind": "transition"
+        }
+      ],
+      "projectionDigest": "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
+    }
+  },
+  {
+    "name": "succeeded-clean",
+    "expectedModel": {
+      "identity": {
+        "runId": "run-succeeded-clean",
+        "revision": 7,
+        "projectionDigest": "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+        "integrity": "verified"
+      },
+      "status": "succeeded",
+      "currentLap": 2,
+      "lapCap": 3,
+      "lease": {
+        "granted": 3,
+        "consumed": 2
+      },
+      "cancelRequested": false,
+      "needsHuman": false,
+      "nodes": [
+        {
+          "id": "root",
+          "kind": "root",
+          "role": "root",
+          "label": "Governor",
+          "state": "terminal"
+        },
+        {
+          "id": "role:implementer",
+          "kind": "worker-role",
+          "role": "implementer",
+          "label": "Implementer",
+          "state": "terminal",
+          "nativeAgentId": "native-implementer-fixture",
+          "nativeAgentType": "worker"
+        },
+        {
+          "id": "role:reviewer",
+          "kind": "worker-role",
+          "role": "reviewer",
+          "label": "Reviewer",
+          "state": "terminal",
+          "nativeAgentId": "native-reviewer-fixture",
+          "nativeAgentType": "worker"
+        }
+      ],
+      "edges": [
+        {
+          "id": "root-governs-implementer",
+          "source": "root",
+          "target": "role:implementer",
+          "kind": "governs",
+          "active": false,
+          "reportCount": 0
+        },
+        {
+          "id": "implementer-handoff-reviewer",
+          "source": "role:implementer",
+          "target": "role:reviewer",
+          "kind": "handoff",
+          "active": false,
+          "reportCount": 2
+        },
+        {
+          "id": "reviewer-feedback-implementer",
+          "source": "role:reviewer",
+          "target": "role:implementer",
+          "kind": "feedback",
+          "active": false,
+          "reportCount": 1
+        },
+        {
+          "id": "reviewer-verdict-root",
+          "source": "role:reviewer",
+          "target": "root",
+          "kind": "verdict",
+          "active": true,
+          "reportCount": 1
+        }
+      ],
+      "latestReport": {
+        "fromRole": "reviewer",
+        "type": "verdict",
+        "verdict": "clean",
+        "issueCount": 0
+      },
+      "timeline": [
+        {
+          "id": "transition-succeeded-clean",
+          "at": "2026-07-28T18:00:00.000Z",
+          "label": "activate-verdict",
+          "kind": "transition"
+        },
+        {
+          "id": "report-succeeded-clean",
+          "at": "2026-07-28T18:00:01.000Z",
+          "label": "reviewer verdict: clean",
+          "kind": "report",
+          "role": "reviewer"
+        }
+      ]
+    },
+    "projection": {
+      "schemaVersion": 1,
+      "storeVersion": 1,
+      "projectionVersion": 3,
+      "runId": "run-succeeded-clean",
+      "revision": 7,
+      "status": "succeeded",
+      "recipe": "review-until-clean",
+      "currentLap": 2,
+      "lapCap": 3,
+      "continuationLease": {
+        "granted": 3,
+        "consumed": 2
+      },
+      "cancelRequested": false,
+      "needsHuman": false,
+      "integrity": {
+        "status": "verified",
+        "verifiedRevision": 7
+      },
+      "eventWatermark": {
+        "eventCount": 0
+      },
+      "nodes": [
+        {
+          "id": "root",
+          "kind": "root",
+          "label": "Governor",
+          "state": "terminal"
+        },
+        {
+          "id": "role:implementer",
+          "kind": "worker-role",
+          "label": "Implementer",
+          "state": "terminal",
+          "nativeAgentId": "native-implementer-fixture",
+          "nativeAgentType": "worker",
+          "role": "implementer"
+        },
+        {
+          "id": "role:reviewer",
+          "kind": "worker-role",
+          "label": "Reviewer",
+          "state": "terminal",
+          "nativeAgentId": "native-reviewer-fixture",
+          "nativeAgentType": "worker",
+          "role": "reviewer"
+        }
+      ],
+      "edges": [
+        {
+          "id": "root-governs-implementer",
+          "source": "root",
+          "target": "role:implementer",
+          "kind": "governs",
+          "active": false,
+          "reportCount": 0
+        },
+        {
+          "id": "implementer-handoff-reviewer",
+          "source": "role:implementer",
+          "target": "role:reviewer",
+          "kind": "handoff",
+          "active": false,
+          "reportCount": 2
+        },
+        {
+          "id": "reviewer-feedback-implementer",
+          "source": "role:reviewer",
+          "target": "role:implementer",
+          "kind": "feedback",
+          "active": false,
+          "reportCount": 1
+        },
+        {
+          "id": "reviewer-verdict-root",
+          "source": "role:reviewer",
+          "target": "root",
+          "kind": "verdict",
+          "active": true,
+          "reportCount": 1
+        }
+      ],
+      "latestReport": {
+        "reportId": "report-succeeded-clean",
+        "fromRole": "reviewer",
+        "type": "verdict",
+        "verdict": "clean",
+        "issueCount": 0
+      },
+      "counts": {
+        "events": 0,
+        "reports": 1,
+        "transitions": 1,
+        "operations": 7,
+        "governorDecisions": 0,
+        "recoveries": 0,
+        "diagnostics": 0,
+        "conflicts": 0,
+        "corrupt": 0
+      },
+      "timeline": [
+        {
+          "id": "transition-succeeded-clean",
+          "at": "2026-07-28T18:00:00.000Z",
+          "label": "activate-verdict",
+          "kind": "transition"
+        },
+        {
+          "id": "report-succeeded-clean",
+          "at": "2026-07-28T18:00:01.000Z",
+          "label": "reviewer verdict: clean",
+          "kind": "report",
+          "role": "reviewer"
+        }
+      ],
+      "projectionDigest": "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"
+    }
+  },
+  {
+    "name": "capped",
+    "expectedModel": {
+      "identity": {
+        "runId": "run-capped",
+        "revision": 6,
+        "projectionDigest": "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+        "integrity": "verified"
+      },
+      "status": "capped",
+      "currentLap": 3,
+      "lapCap": 3,
+      "lease": {
+        "granted": 3,
+        "consumed": 3
+      },
+      "cancelRequested": false,
+      "needsHuman": true,
+      "nodes": [
+        {
+          "id": "root",
+          "kind": "root",
+          "role": "root",
+          "label": "Governor",
+          "state": "terminal"
+        },
+        {
+          "id": "role:implementer",
+          "kind": "worker-role",
+          "role": "implementer",
+          "label": "Implementer",
+          "state": "terminal",
+          "nativeAgentId": "native-implementer-fixture",
+          "nativeAgentType": "worker"
+        },
+        {
+          "id": "role:reviewer",
+          "kind": "worker-role",
+          "role": "reviewer",
+          "label": "Reviewer",
+          "state": "terminal",
+          "nativeAgentId": "native-reviewer-fixture",
+          "nativeAgentType": "worker"
+        }
+      ],
+      "edges": [
+        {
+          "id": "root-governs-implementer",
+          "source": "root",
+          "target": "role:implementer",
+          "kind": "governs",
+          "active": false,
+          "reportCount": 0
+        },
+        {
+          "id": "implementer-handoff-reviewer",
+          "source": "role:implementer",
+          "target": "role:reviewer",
+          "kind": "handoff",
+          "active": false,
+          "reportCount": 2
+        },
+        {
+          "id": "reviewer-feedback-implementer",
+          "source": "role:reviewer",
+          "target": "role:implementer",
+          "kind": "feedback",
+          "active": false,
+          "reportCount": 2
+        },
+        {
+          "id": "reviewer-verdict-root",
+          "source": "role:reviewer",
+          "target": "root",
+          "kind": "verdict",
+          "active": false,
+          "reportCount": 0
+        }
+      ],
+      "timeline": [
+        {
+          "id": "transition-capped",
+          "at": "2026-07-28T18:00:00.000Z",
+          "label": "capped",
+          "kind": "transition"
+        }
+      ]
+    },
+    "projection": {
+      "schemaVersion": 1,
+      "storeVersion": 1,
+      "projectionVersion": 3,
+      "runId": "run-capped",
+      "revision": 6,
+      "status": "capped",
+      "recipe": "review-until-clean",
+      "currentLap": 3,
+      "lapCap": 3,
+      "continuationLease": {
+        "granted": 3,
+        "consumed": 3
+      },
+      "cancelRequested": false,
+      "needsHuman": true,
+      "integrity": {
+        "status": "verified",
+        "verifiedRevision": 6
+      },
+      "eventWatermark": {
+        "eventCount": 0
+      },
+      "nodes": [
+        {
+          "id": "root",
+          "kind": "root",
+          "label": "Governor",
+          "state": "terminal"
+        },
+        {
+          "id": "role:implementer",
+          "kind": "worker-role",
+          "label": "Implementer",
+          "state": "terminal",
+          "nativeAgentId": "native-implementer-fixture",
+          "nativeAgentType": "worker",
+          "role": "implementer"
+        },
+        {
+          "id": "role:reviewer",
+          "kind": "worker-role",
+          "label": "Reviewer",
+          "state": "terminal",
+          "nativeAgentId": "native-reviewer-fixture",
+          "nativeAgentType": "worker",
+          "role": "reviewer"
+        }
+      ],
+      "edges": [
+        {
+          "id": "root-governs-implementer",
+          "source": "root",
+          "target": "role:implementer",
+          "kind": "governs",
+          "active": false,
+          "reportCount": 0
+        },
+        {
+          "id": "implementer-handoff-reviewer",
+          "source": "role:implementer",
+          "target": "role:reviewer",
+          "kind": "handoff",
+          "active": false,
+          "reportCount": 2
+        },
+        {
+          "id": "reviewer-feedback-implementer",
+          "source": "role:reviewer",
+          "target": "role:implementer",
+          "kind": "feedback",
+          "active": false,
+          "reportCount": 2
+        },
+        {
+          "id": "reviewer-verdict-root",
+          "source": "role:reviewer",
+          "target": "root",
+          "kind": "verdict",
+          "active": false,
+          "reportCount": 0
+        }
+      ],
+      "counts": {
+        "events": 0,
+        "reports": 0,
+        "transitions": 1,
+        "operations": 6,
+        "governorDecisions": 0,
+        "recoveries": 0,
+        "diagnostics": 0,
+        "conflicts": 0,
+        "corrupt": 0
+      },
+      "timeline": [
+        {
+          "id": "transition-capped",
+          "at": "2026-07-28T18:00:00.000Z",
+          "label": "capped",
+          "kind": "transition"
+        }
+      ],
+      "projectionDigest": "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+    }
+  },
+  {
+    "name": "cancelled",
+    "expectedModel": {
+      "identity": {
+        "runId": "run-cancelled",
+        "revision": 2,
+        "projectionDigest": "1111111111111111111111111111111111111111111111111111111111111111",
+        "integrity": "verified"
+      },
+      "status": "cancelled",
+      "currentLap": 0,
+      "lapCap": 3,
+      "lease": {
+        "granted": 3,
+        "consumed": 0
+      },
+      "cancelRequested": true,
+      "needsHuman": false,
+      "nodes": [
+        {
+          "id": "root",
+          "kind": "root",
+          "role": "root",
+          "label": "Governor",
+          "state": "terminal"
+        },
+        {
+          "id": "role:implementer",
+          "kind": "worker-role",
+          "role": "implementer",
+          "label": "Implementer",
+          "state": "terminal",
+          "nativeAgentId": "native-implementer-fixture",
+          "nativeAgentType": "worker"
+        },
+        {
+          "id": "role:reviewer",
+          "kind": "worker-role",
+          "role": "reviewer",
+          "label": "Reviewer",
+          "state": "terminal",
+          "nativeAgentId": "native-reviewer-fixture",
+          "nativeAgentType": "worker"
+        }
+      ],
+      "edges": [
+        {
+          "id": "root-governs-implementer",
+          "source": "root",
+          "target": "role:implementer",
+          "kind": "governs",
+          "active": false,
+          "reportCount": 0
+        },
+        {
+          "id": "implementer-handoff-reviewer",
+          "source": "role:implementer",
+          "target": "role:reviewer",
+          "kind": "handoff",
+          "active": false,
+          "reportCount": 0
+        },
+        {
+          "id": "reviewer-feedback-implementer",
+          "source": "role:reviewer",
+          "target": "role:implementer",
+          "kind": "feedback",
+          "active": false,
+          "reportCount": 0
+        },
+        {
+          "id": "reviewer-verdict-root",
+          "source": "role:reviewer",
+          "target": "root",
+          "kind": "verdict",
+          "active": false,
+          "reportCount": 0
+        }
+      ],
+      "timeline": [
+        {
+          "id": "transition-cancelled",
+          "at": "2026-07-28T18:00:00.000Z",
+          "label": "cancelled",
+          "kind": "transition"
+        }
+      ]
+    },
+    "projection": {
+      "schemaVersion": 1,
+      "storeVersion": 1,
+      "projectionVersion": 3,
+      "runId": "run-cancelled",
+      "revision": 2,
+      "status": "cancelled",
+      "recipe": "review-until-clean",
+      "currentLap": 0,
+      "lapCap": 3,
+      "continuationLease": {
+        "granted": 3,
+        "consumed": 0
+      },
+      "cancelRequested": true,
+      "needsHuman": false,
+      "integrity": {
+        "status": "verified",
+        "verifiedRevision": 2
+      },
+      "eventWatermark": {
+        "eventCount": 0
+      },
+      "nodes": [
+        {
+          "id": "root",
+          "kind": "root",
+          "label": "Governor",
+          "state": "terminal"
+        },
+        {
+          "id": "role:implementer",
+          "kind": "worker-role",
+          "label": "Implementer",
+          "state": "terminal",
+          "nativeAgentId": "native-implementer-fixture",
+          "nativeAgentType": "worker",
+          "role": "implementer"
+        },
+        {
+          "id": "role:reviewer",
+          "kind": "worker-role",
+          "label": "Reviewer",
+          "state": "terminal",
+          "nativeAgentId": "native-reviewer-fixture",
+          "nativeAgentType": "worker",
+          "role": "reviewer"
+        }
+      ],
+      "edges": [
+        {
+          "id": "root-governs-implementer",
+          "source": "root",
+          "target": "role:implementer",
+          "kind": "governs",
+          "active": false,
+          "reportCount": 0
+        },
+        {
+          "id": "implementer-handoff-reviewer",
+          "source": "role:implementer",
+          "target": "role:reviewer",
+          "kind": "handoff",
+          "active": false,
+          "reportCount": 0
+        },
+        {
+          "id": "reviewer-feedback-implementer",
+          "source": "role:reviewer",
+          "target": "role:implementer",
+          "kind": "feedback",
+          "active": false,
+          "reportCount": 0
+        },
+        {
+          "id": "reviewer-verdict-root",
+          "source": "role:reviewer",
+          "target": "root",
+          "kind": "verdict",
+          "active": false,
+          "reportCount": 0
+        }
+      ],
+      "counts": {
+        "events": 0,
+        "reports": 0,
+        "transitions": 1,
+        "operations": 2,
+        "governorDecisions": 0,
+        "recoveries": 0,
+        "diagnostics": 0,
+        "conflicts": 0,
+        "corrupt": 0
+      },
+      "timeline": [
+        {
+          "id": "transition-cancelled",
+          "at": "2026-07-28T18:00:00.000Z",
+          "label": "cancelled",
+          "kind": "transition"
+        }
+      ],
+      "projectionDigest": "1111111111111111111111111111111111111111111111111111111111111111"
+    }
+  }
+]
diff --git a/plugins/looperators-agent-loop/ui/entry.tsx b/plugins/looperators-agent-loop/ui/entry.tsx
new file mode 100644
index 0000000..712a83d
--- /dev/null
+++ b/plugins/looperators-agent-loop/ui/entry.tsx
@@ -0,0 +1,153 @@
+/* oxlint-disable react/only-export-components -- self-mounting plugin entrypoint */
+import { useEffect, useState } from 'react';
+import { createRoot } from 'react-dom/client';
+import {
+  AgentLoopGraph,
+  type AgentGraphFollowUpIntent,
+  type AgentGraphModel,
+} from '@looperators/agent-graph-ui';
+import { projectionToAgentGraphModel } from '../lib/projection-to-graph-model.mjs';
+import '@xyflow/react/dist/style.css';
+import '@looperators/agent-graph-ui/styles.css';
+
+type PluginEnvelope = {
+  projection: unknown;
+  expectedProjectionDigest: string;
+  runId: string;
+  mode: 'inline' | 'sidecar';
+  driftNote?: string;
+  eventsUrl?: string;
+  controlUrl?: string;
+  csrfToken?: string;
+};
+
+declare global {
+  interface Window {
+    looperatorsAgentLoopView?: {
+      update: (nextVerifiedProjection: unknown) => void;
+      integrityError: (code: string) => void;
+    };
+  }
+}
+
+const rootElement = document.getElementById('looperators-agent-loop-root');
+const fallbackElement = document.getElementById(
+  'looperators-agent-loop-fallback',
+);
+const dataElement = document.getElementById('looperators-agent-loop-data');
+
+function boundedCode(value: unknown) {
+  return String(value ?? 'SURFACE_REQUEST_FAILED').slice(0, 80);
+}
+
+if (rootElement && dataElement) {
+  const envelope = JSON.parse(
+    dataElement.textContent ?? '{}',
+  ) as PluginEnvelope;
+  const initialModel = projectionToAgentGraphModel(envelope.projection, {
+    expectedProjectionDigest: envelope.expectedProjectionDigest,
+    expectedRunId: envelope.runId,
+  });
+
+  function PluginAgentLoopGraph() {
+    const [model, setModel] = useState<AgentGraphModel>(initialModel);
+    const [liveState, setLiveState] = useState<
+      'connecting' | 'live' | 'retrying' | undefined
+    >(envelope.mode === 'sidecar' ? 'connecting' : undefined);
+    const [integrityError, setIntegrityError] = useState<string>();
+
+    useEffect(() => {
+      fallbackElement?.setAttribute('hidden', '');
+      window.looperatorsAgentLoopView = Object.freeze({
+        update(nextVerifiedProjection) {
+          setModel(
+            projectionToAgentGraphModel(nextVerifiedProjection, {
+              expectedRunId: initialModel.identity.runId,
+            }),
+          );
+          setIntegrityError(undefined);
+          setLiveState(envelope.mode === 'sidecar' ? 'live' : undefined);
+        },
+        integrityError(code) {
+          setIntegrityError(boundedCode(code));
+        },
+      });
+      return () => {
+        delete window.looperatorsAgentLoopView;
+      };
+    }, []);
+
+    useEffect(() => {
+      if (envelope.mode !== 'sidecar' || !envelope.eventsUrl) return;
+      const stream = new EventSource(envelope.eventsUrl);
+      stream.addEventListener('open', () => setLiveState('live'));
+      stream.addEventListener('snapshot', (event) => {
+        try {
+          window.looperatorsAgentLoopView?.update(
+            JSON.parse((event as MessageEvent<string>).data),
+          );
+        } catch {
+          setIntegrityError('GRAPH_VIEW_PROJECTION_INVALID');
+        }
+      });
+      stream.addEventListener('integrity-error', (event) => {
+        try {
+          const value = JSON.parse((event as MessageEvent<string>).data);
+          setIntegrityError(boundedCode(value.code));
+        } catch {
+          setIntegrityError('HISTORY_CORRUPT');
+        }
+      });
+      stream.onerror = () => setLiveState('retrying');
+      return () => stream.close();
+    }, []);
+
+    const requestControl = async (intent: AgentGraphFollowUpIntent) => {
+      if (
+        intent.kind === 'explain' ||
+        !envelope.controlUrl ||
+        !envelope.csrfToken
+      ) {
+        throw new Error('CONTROL_UNAVAILABLE');
+      }
+      const response = await fetch(envelope.controlUrl, {
+        method: 'POST',
+        credentials: 'same-origin',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-Looperators-CSRF': envelope.csrfToken,
+        },
+        body: JSON.stringify({
+          action: intent.kind,
+          requestId: `surface-${crypto.randomUUID()}`,
+        }),
+      });
+      if (!response.ok) {
+        throw new Error(boundedCode((await response.json()).code));
+      }
+    };
+
+    return (
+      <>
+        {integrityError ? (
+          <p className="lag-embed-error" role="status">
+            Snapshot unavailable: {integrityError}
+          </p>
+        ) : null}
+        <AgentLoopGraph
+          model={model}
+          mode={envelope.mode === 'sidecar' ? 'live' : 'snapshot'}
+          liveState={liveState}
+          explainAvailable={false}
+          controlAvailable={
+            envelope.mode === 'sidecar' &&
+            Boolean(envelope.controlUrl && envelope.csrfToken)
+          }
+          onFollowUp={requestControl}
+        />
+      </>
+    );
+  }
+
+  createRoot(rootElement).render(<PluginAgentLoopGraph />);
+}
diff --git a/plugins/looperators-agent-loop/ui/tsconfig.json b/plugins/looperators-agent-loop/ui/tsconfig.json
new file mode 100644
index 0000000..e0a9b3a
--- /dev/null
+++ b/plugins/looperators-agent-loop/ui/tsconfig.json
@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "ES2023",
+    "lib": [
+      "ES2023",
+      "DOM",
+      "DOM.Iterable"
+    ],
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "jsx": "react-jsx",
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "types": [
+      "vite/client"
+    ]
+  },
+  "include": [
+    "entry.tsx",
+    "../lib/projection-to-graph-model.d.mts"
+  ]
+}
diff --git a/plugins/looperators-agent-loop/ui/vite.config.ts b/plugins/looperators-agent-loop/ui/vite.config.ts
new file mode 100644
index 0000000..5574c18
--- /dev/null
+++ b/plugins/looperators-agent-loop/ui/vite.config.ts
@@ -0,0 +1,40 @@
+import { defineConfig, type Plugin } from 'vite';
+import { resolve } from 'node:path';
+import { agentGraphScenarios } from '../../../packages/agent-graph-ui/dist/library/agent-graph-ui.js';
+
+function pairedFixtureAsset(): Plugin {
+  return {
+    name: 'looperators-paired-agent-graph-fixtures',
+    generateBundle() {
+      this.emitFile({
+        type: 'asset',
+        fileName: 'paired-scenarios.json',
+        source: `${JSON.stringify(agentGraphScenarios, null, 2)}\n`,
+      });
+    },
+  };
+}
+
+export default defineConfig({
+  publicDir: false,
+  plugins: [pairedFixtureAsset()],
+  define: {
+    'process.env.NODE_ENV': JSON.stringify('production'),
+  },
+  build: {
+    outDir: resolve(import.meta.dirname, 'assets'),
+    emptyOutDir: true,
+    cssCodeSplit: false,
+    assetsInlineLimit: Number.MAX_SAFE_INTEGER,
+    target: 'es2022',
+    minify: 'oxc',
+    sourcemap: false,
+    lib: {
+      entry: resolve(import.meta.dirname, 'entry.tsx'),
+      name: 'LooperatorsAgentLoopUI',
+      formats: ['iife'],
+      fileName: () => 'agent-loop-ui.iife.js',
+      cssFileName: 'agent-loop-ui',
+    },
+  },
+});
diff --git a/scripts/sanitize-looperators-core-control-probes.mjs b/scripts/sanitize-looperators-core-control-probes.mjs
new file mode 100644
index 0000000..f41e7d8
--- /dev/null
+++ b/scripts/sanitize-looperators-core-control-probes.mjs
@@ -0,0 +1,463 @@
+#!/usr/bin/env node
+
+import { readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import {
+  compareCodePoints,
+  sha256,
+} from "../plugins/looperators-agent-loop/lib/canonical-json.mjs";
+import {
+  assertSafeFileId,
+  isNativeSpawnPreToolUse,
+} from "../plugins/looperators-agent-loop/lib/contracts.mjs";
+import { resolveDataRoot } from "../plugins/looperators-agent-loop/lib/data-root.mjs";
+import { atomicReplaceJson } from "../plugins/looperators-agent-loop/lib/fs-utils.mjs";
+import { LoopStore } from "../plugins/looperators-agent-loop/lib/store.mjs";
+
+function argument(name) {
+  const index = process.argv.indexOf(`--${name}`);
+  return index >= 0 ? process.argv[index + 1] : undefined;
+}
+
+function requiredAbsoluteArgument(name) {
+  const value = argument(name);
+  if (!value || !path.isAbsolute(value)) {
+    throw new TypeError(`--${name} must be an absolute path`);
+  }
+  return path.normalize(value);
+}
+
+function addError(errors, condition, code) {
+  if (!condition && !errors.includes(code)) {
+    errors.push(code);
+  }
+}
+
+function countsBy(values, key) {
+  const result = {};
+  for (const value of values) {
+    const label = String(value[key] ?? "unknown");
+    result[label] = (result[label] ?? 0) + 1;
+  }
+  return Object.fromEntries(
+    Object.entries(result).sort(([left], [right]) =>
+      compareCodePoints(left, right),
+    ),
+  );
+}
+
+function facts(read, label, errors) {
+  addError(errors, read.corrupt.length === 0, `CORRUPT_${label}`);
+  return read.facts;
+}
+
+function scanJson(value, result) {
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      scanJson(item, result);
+    }
+    return;
+  }
+  if (value && typeof value === "object") {
+    for (const [key, item] of Object.entries(value)) {
+      if (["capabilityToken", "token"].includes(key)) {
+        result.plaintextCapabilityFields += 1;
+      }
+      scanJson(item, result);
+    }
+    return;
+  }
+  if (
+    typeof value === "string" &&
+    /^[A-Za-z0-9_-]{43}$/.test(value)
+  ) {
+    result.plaintextCapabilityCandidates += 1;
+  }
+}
+
+async function scanStoreJson(directory) {
+  const result = {
+    jsonFiles: 0,
+    plaintextCapabilityFields: 0,
+    plaintextCapabilityCandidates: 0,
+  };
+  async function walk(current) {
+    for (const entry of await readdir(current, {
+      withFileTypes: true,
+    })) {
+      const target = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        await walk(target);
+      } else if (
+        entry.isFile() &&
+        entry.name.endsWith(".json")
+      ) {
+        result.jsonFiles += 1;
+        scanJson(
+          JSON.parse(await readFile(target, "utf8")),
+          result,
+        );
+      }
+    }
+  }
+  await walk(directory);
+  return result;
+}
+
+async function inspectRun(dataRoot, label, errors) {
+  const rootInfo = await resolveDataRoot({
+    env: { LOOPERATORS_DATA_DIR: dataRoot },
+  });
+  const store = new LoopStore(rootInfo);
+  const runIds = (
+    await readdir(path.join(rootInfo.path, "runs"), {
+      withFileTypes: true,
+    })
+  )
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => assertSafeFileId(entry.name, "runId"));
+  addError(
+    errors,
+    runIds.length === 1,
+    `${label}_EXPECTED_ONE_RUN`,
+  );
+  const runId = runIds[0];
+  const state = await store.readState(runId);
+  const definition = await store.readDefinition(runId);
+  const events = facts(
+    await store.listEvents(runId),
+    `${label}_EVENTS`,
+    errors,
+  );
+  const operations = facts(
+    await store.listOperations(runId),
+    `${label}_OPERATIONS`,
+    errors,
+  ).sort((left, right) => left.fromRevision - right.fromRevision);
+  const transitions = facts(
+    await store.listTransitions(runId),
+    `${label}_TRANSITIONS`,
+    errors,
+  ).sort((left, right) => left.fromRevision - right.fromRevision);
+  const decisions = facts(
+    await store.listGovernorDecisions(runId),
+    `${label}_GOVERNOR_DECISIONS`,
+    errors,
+  ).sort((left, right) => left.fromRevision - right.fromRevision);
+  const reports = facts(
+    await store.listReports(runId),
+    `${label}_REPORTS`,
+    errors,
+  );
+  const bindings = facts(
+    await store.listIdentityBindings(runId),
+    `${label}_IDENTITY`,
+    errors,
+  );
+  const observations = facts(
+    await store.listWorkerObservations(runId),
+    `${label}_WORKER_OBSERVATIONS`,
+    errors,
+  );
+  const pendingObservations = facts(
+    await store.readPendingWorkerObservations(runId),
+    `${label}_PENDING_WORKER_OBSERVATIONS`,
+    errors,
+  );
+  const observedWorkers = facts(
+    await store.listObservedSubagentStarts(
+      runId,
+      state.rootSessionId,
+    ),
+    `${label}_OBSERVED_WORKERS`,
+    errors,
+  );
+  const nativeSpawnAttempts = new Set(
+    events
+      .filter(isNativeSpawnPreToolUse)
+      .map((event) => event.toolUseId),
+  );
+  const storeScan = await scanStoreJson(rootInfo.path);
+  addError(
+    errors,
+    storeScan.plaintextCapabilityFields === 0,
+    `${label}_PLAINTEXT_CAPABILITY_FIELD_FOUND`,
+  );
+  addError(
+    errors,
+    storeScan.plaintextCapabilityCandidates === 0,
+    `${label}_PLAINTEXT_CAPABILITY_CANDIDATE_FOUND`,
+  );
+  addError(
+    errors,
+    events.every(
+      (event) => event.sessionId === state.rootSessionId,
+    ),
+    `${label}_SESSION_ROOT_MISMATCH`,
+  );
+  return {
+    rootInfo,
+    runId,
+    state,
+    definition,
+    events,
+    operations,
+    transitions,
+    decisions,
+    reports,
+    bindings,
+    observations,
+    pendingObservations,
+    observedWorkers,
+    nativeSpawnAttempts,
+    storeScan,
+  };
+}
+
+function revisionSteps(factsToMap) {
+  return factsToMap.map((fact) => ({
+    kind: fact.kind,
+    fromRevision: fact.fromRevision,
+    toRevision: fact.toRevision,
+  }));
+}
+
+function assertControl(run, errors) {
+  addError(
+    errors,
+    run.definition.requestId === "core-control-20260728-01" &&
+      run.definition.lapCap === 2,
+    "CONTROL_DEFINITION_MISMATCH",
+  );
+  addError(
+    errors,
+    run.state.status === "cancelled" &&
+      run.state.revision === 4 &&
+      run.state.cancelRequested === true &&
+      run.state.needsHuman === false &&
+      run.state.continuationLease.granted === 2 &&
+      run.state.continuationLease.consumed === 0 &&
+      run.state.pendingTransitionId === undefined,
+    "CONTROL_FINAL_STATE_MISMATCH",
+  );
+  addError(
+    errors,
+    run.operations
+      .map(
+        (fact) =>
+          `${fact.kind}:${fact.fromRevision}:${fact.toRevision}`,
+      )
+      .join(",") ===
+      "start:0:1,pause:1:2,resume:2:3,cancel:3:4",
+    "CONTROL_OPERATION_SEQUENCE_MISMATCH",
+  );
+  addError(
+    errors,
+    run.transitions
+      .map(
+        (fact) =>
+          `${fact.kind}:${fact.fromRevision}:${fact.toRevision}`,
+      )
+      .join(",") ===
+      "activate-implementer:0:1,pause:1:2,resume:2:3,cancel:3:4",
+    "CONTROL_TRANSITION_SEQUENCE_MISMATCH",
+  );
+  addError(
+    errors,
+    run.decisions.length === 0 &&
+      run.reports.length === 0 &&
+      run.bindings.length === 0 &&
+      run.observations.length === 0 &&
+      run.pendingObservations.length === 0 &&
+      run.observedWorkers.length === 0 &&
+      run.nativeSpawnAttempts.size === 0,
+    "CONTROL_UNEXPECTED_WORK_FOUND",
+  );
+}
+
+function assertCap(run, errors) {
+  addError(
+    errors,
+    run.definition.requestId === "core-cap-20260728-01" &&
+      run.definition.lapCap === 1,
+    "CAP_DEFINITION_MISMATCH",
+  );
+  addError(
+    errors,
+    run.state.status === "capped" &&
+      run.state.revision === 4 &&
+      run.state.currentLap === 0 &&
+      run.state.cancelRequested === false &&
+      run.state.needsHuman === true &&
+      run.state.continuationLease.granted === 1 &&
+      run.state.continuationLease.consumed === 1 &&
+      run.state.pendingTransitionId === undefined &&
+      run.state.latestGovernorDecisionId ===
+        run.decisions.at(-1)?.decisionId,
+    "CAP_FINAL_STATE_MISMATCH",
+  );
+  addError(
+    errors,
+    run.operations
+      .map(
+        (fact) =>
+          `${fact.kind}:${fact.fromRevision}:${fact.toRevision}`,
+      )
+      .join(",") === "start:0:1,report:2:3",
+    "CAP_OPERATION_SEQUENCE_MISMATCH",
+  );
+  addError(
+    errors,
+    run.transitions
+      .map(
+        (fact) =>
+          `${fact.kind}:${fact.fromRevision}:${fact.toRevision}`,
+      )
+      .join(",") ===
+      "activate-implementer:0:1,activate-reviewer:2:3",
+    "CAP_TRANSITION_SEQUENCE_MISMATCH",
+  );
+  addError(
+    errors,
+    run.decisions
+      .map(
+        (fact) =>
+          [
+            fact.action,
+            fact.hookEvent,
+            fact.reasonCode,
+            fact.fromRevision,
+            fact.toRevision,
+            fact.leaseEpoch ?? "none",
+          ].join(":"),
+      )
+      .join(",") ===
+      [
+        "block:Stop:pending-root-transition:1:2:1",
+        "cap:Stop:lease-exhausted:3:4:none",
+      ].join(","),
+    "CAP_GOVERNOR_SEQUENCE_MISMATCH",
+  );
+  const report = run.reports[0];
+  const binding = run.bindings[0];
+  addError(
+    errors,
+    run.reports.length === 1 &&
+      report?.type === "info" &&
+      report?.status === "done" &&
+      report?.fromNode === binding?.agentId,
+    "CAP_TYPED_REPORT_MISMATCH",
+  );
+  addError(
+    errors,
+    run.bindings.length === 1 &&
+      binding?.role === "implementer" &&
+      run.observations.length === 1 &&
+      run.pendingObservations.length === 0 &&
+      run.observedWorkers.length === 1 &&
+      run.nativeSpawnAttempts.size === 1 &&
+      run.observedWorkers[0]?.agentId === binding?.agentId,
+    "CAP_WORKER_PROVENANCE_MISMATCH",
+  );
+  const eventById = new Map(
+    run.events.map((event) => [event.eventId, event]),
+  );
+  addError(
+    errors,
+    run.decisions.every(
+      (decision) =>
+        eventById.get(decision.originEventId)?.event ===
+        decision.hookEvent,
+    ),
+    "CAP_DECISION_ORIGIN_MISMATCH",
+  );
+}
+
+function summarize(run) {
+  return {
+    storeInstanceDigest: run.rootInfo.instanceIdDigest,
+    runDigest: sha256(run.runId),
+    rootSessionDigest: sha256(run.state.rootSessionId),
+    status: run.state.status,
+    revision: run.state.revision,
+    currentLap: run.state.currentLap,
+    lapCap: run.definition.lapCap,
+    continuationLease: run.state.continuationLease,
+    cancelRequested: run.state.cancelRequested,
+    needsHuman: run.state.needsHuman ?? false,
+    counts: {
+      events: run.events.length,
+      operations: run.operations.length,
+      transitions: run.transitions.length,
+      governorDecisions: run.decisions.length,
+      reports: run.reports.length,
+      bindings: run.bindings.length,
+      observations: run.observations.length,
+      pendingWorkerObservations:
+        run.pendingObservations.length,
+      observedWorkers: run.observedWorkers.length,
+      nativeSpawnAttempts: run.nativeSpawnAttempts.size,
+    },
+    eventCounts: countsBy(run.events, "event"),
+    operationSteps: revisionSteps(run.operations),
+    transitionSteps: revisionSteps(run.transitions),
+    continuationSteps: run.decisions.map((decision) => ({
+      action: decision.action,
+      hookEvent: decision.hookEvent,
+      reasonCode: decision.reasonCode,
+      fromRevision: decision.fromRevision,
+      toRevision: decision.toRevision,
+      ...(decision.leaseEpoch
+        ? { leaseEpoch: decision.leaseEpoch }
+        : {}),
+      obligationDigest: sha256(decision.obligationId),
+    })),
+    workerRoles: run.bindings.map((binding) => ({
+      role: binding.role,
+      agentDigest: sha256(binding.agentId),
+    })),
+    storeScan: run.storeScan,
+  };
+}
+
+const controlDataRoot = requiredAbsoluteArgument(
+  "control-data-root",
+);
+const capDataRoot = requiredAbsoluteArgument("cap-data-root");
+const output = requiredAbsoluteArgument("output");
+const errors = [];
+const control = await inspectRun(
+  controlDataRoot,
+  "CONTROL",
+  errors,
+);
+const cap = await inspectRun(capDataRoot, "CAP", errors);
+assertControl(control, errors);
+assertCap(cap, errors);
+
+const evidence = {
+  schemaVersion: 1,
+  probe: "trusted-hooks-core-controls",
+  passed: errors.length === 0,
+  errors,
+  control: summarize(control),
+  cap: summarize(cap),
+  finalMarker: "CORE_CONTROL_CAP_OK",
+  privacy: {
+    rawHostIdsIncluded: false,
+    rawPromptIncluded: false,
+    capabilityPlaintextIncluded: false,
+  },
+};
+await atomicReplaceJson(output, evidence);
+process.stdout.write(
+  `${JSON.stringify({
+    passed: evidence.passed,
+    errors: evidence.errors,
+    output,
+  })}\n`,
+);
+if (!evidence.passed) {
+  process.exitCode = 1;
+}
diff --git a/shared/graph-core/index.ts b/shared/graph-core/index.ts
index 7fcb655..a6c2727 100644
--- a/shared/graph-core/index.ts
+++ b/shared/graph-core/index.ts
@@ -1,6 +1,4 @@
 // graph-core: the pure, IO-free logic of the session graph kernel.
-// Baseline design: design-docs/session-graph-kernel.md (§2 math model,
-// §6 operators, §7 schemas). Wired into the runtime in G3.
 
 export * from './types.js'
 export { applyEvent, fold } from './fold.js'
diff --git a/shared/graph-core/types.ts b/shared/graph-core/types.ts
index 77065e4..b7a2d35 100644
--- a/shared/graph-core/types.ts
+++ b/shared/graph-core/types.ts
@@ -1,5 +1,4 @@
 // graph-core: pure, IO-free types for the session graph kernel.
-// Baseline: design-docs/session-graph-kernel.md §7 (schema drafts).
 // This package is the single source of truth for kernel-level shapes;
 // the runtime (kernelStore, sessionManager) imports from here.
 
diff --git a/src/components/terminal.tsx b/src/components/terminal.tsx
index f9b85d3..3c39a32 100644
--- a/src/components/terminal.tsx
+++ b/src/components/terminal.tsx
@@ -5,10 +5,10 @@ import { cn } from '@/lib/utils';
 /**
  * Shared terminal / ink primitives.
  *
- * Design rule (see design-docs/terminal-redesign/HANDOFF.md): the chrome flips
- * light/dark, but ink "stages" (input fields, console surfaces) stay dark in
- * BOTH themes. Field surfaces below use the constant `ink` palette; labels and
- * command-line chrome use the flipping tokens so they read on warm paper too.
+ * The chrome flips light/dark, but ink "stages" (input fields, console surfaces)
+ * stay dark in BOTH themes. Field surfaces below use the constant `ink` palette;
+ * labels and command-line chrome use the flipping tokens so they read on warm
+ * paper too.
  */
 
 /** A command-line section header, e.g. `❯ orrery session new --prompt`. */