Duplicate from markov-ai/autocad-bench

Co-authored-by: Dev Mandal <ShadowPenguin@users.noreply.huggingface.co>

.env.example

@@ -0,0 +1,17 @@
+# Model providers
+OPENAI_API_KEY=
+ANTHROPIC_API_KEY=
+OPENROUTER_API_KEY=
+FIREWORKS_API_KEY=
+
+# AWS control plane
+# AWS_PROFILE=my-profile
+AWS_REGION=us-east-1
+
+# Optional when invoking an installed wheel outside the repository root
+AUTOCAD_BENCH_ROOT=
+
+# Optional dashboard cloud artifact retrieval
+# AUTOCAD_BENCH_S3_BUCKET=your-autocad-bench-bucket
+AUTOCAD_BENCH_S3_RUNS_PREFIX=controller/runs
+AUTOCAD_BENCH_CLOUD_ARTIFACTS=off

.gitattributes

@@ -0,0 +1,37 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.dwg filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,30 @@
+.venv/
+node_modules/
+.env
+.env.*
+!.env.example
+.private/
+.pytest_cache/
+__pycache__/
+*.py[cod]
+.DS_Store
+dist/
+runs/
+artifacts/gold-cache/*/
+artifacts/gold-cache/summary.json
+!artifacts/gold-cache/autocad-2019-r23.0.46-v4/
+!artifacts/gold-cache/autocad-2019-r23.0.46-v4/**
+apps/dashboard/dist/
+apps/dashboard/.tsbuild/
+apps/dashboard/*.tsbuildinfo
+apps/dashboard/*.d.ts
+apps/dashboard/vite.config.js
+apps/dashboard/src/*.js
+apps/results-dashboard/.tsbuild/
+apps/results-dashboard/*.tsbuildinfo
+apps/results-dashboard/*.d.ts
+apps/results-dashboard/vite.config.js
+apps/results-dashboard/src/**/*.js
+apps/results-dashboard/src/**/*.d.ts
+!apps/results-dashboard/src/env.d.ts
+archive/source/*.zip

.python-version

@@ -0,0 +1 @@
+3.12.12

CONTRIBUTING.md

@@ -0,0 +1,89 @@
+# Contributing
+
+AutoCAD Bench separates task data, model execution, trusted evaluation, and infrastructure. Keep changes inside the narrowest applicable boundary and preserve the scorer/model trust split.
+
+## Development setup
+
+```bash
+uv sync --dev
+cd apps/dashboard && npm ci
+```
+
+## Common changes
+
+### Add or update a task
+
+1. Add the reference PNG and gold DWG under `tasks/corpus/2d/` or `tasks/corpus/3d/`.
+2. Add or update the canonical row in `tasks/manifest.jsonl`.
+3. Update `tasks/gold-audit.jsonl` with verified file metadata.
+4. Rebuild the gold cache with the pinned trusted evaluator.
+5. Run corpus, audit, cache, and test validation.
+
+Never expose a gold path through `PublicTaskSpec`, `AutoCADTaskData`, a model prompt, or a model trace.
+
+### Change the harness
+
+Model-provider logic and the agent loop belong under `src/autocad_bench/harness/`. Computer actions must remain typed and fully validated before any broker call. Preserve the 7,000-action rollout budget and the distinction between audit-only intermediate frames and model-visible observations.
+
+### Change evaluation
+
+Trusted evaluation belongs under `src/autocad_bench/evaluation/`. A render-contract change requires a new evaluator version and gold cache; never reinterpret an old version in place. Windows evaluator changes also require a compiled fresh-clone gate before an AMI becomes active.
+
+### Change infrastructure
+
+Backend selection, registration, and lifecycle boundaries belong under
+`src/autocad_bench/infrastructure/`. Keep the batch controller
+backend-neutral. New external backends should implement the public plugin
+contract and register an `autocad_bench.infrastructure` entry point; see
+`docs/infrastructure-plugins.md`. Backends that retain reconnectable workers
+should also implement the optional recovery protocol; do not put
+provider-specific worker inspection back into `orchestration/resume.py`.
+
+The built-in AWS lifecycle and broker-client code remains under
+`src/autocad_bench/sandbox/`. Windows runtime source belongs under
+`sandbox/windows/`; cloud-controller assets belong under
+`infra/cloud-controller/`. Do not launch instances, deploy infrastructure, or
+replace the active AMI without explicit approval.
+
+## Validation
+
+Run the complete offline gate before handing off a change:
+
+```bash
+uv run autocad-bench validate
+uv run autocad-bench validate-audit
+uv run pytest
+
+cd apps/dashboard
+npm test
+npm run build
+```
+
+Before publishing, build the package and corpus into one new release directory,
+then verify that complete directory:
+
+```bash
+uv run autocad-bench-release build \
+  --output dist/releases/0.1.0
+uv run autocad-bench-release verify \
+  --root dist/releases/0.1.0
+```
+
+The builder uses the allowlist-based bundle exporter and pinned PEP 517
+dependencies. It must never be expanded to include configs, environment files,
+controller state, or run outputs. See `docs/releases.md` for the complete
+manual publishing and reproducibility workflow.
+
+When a current evaluator cache is available locally:
+
+```bash
+uv run autocad-bench verify-gold-cache \
+  --evaluator-version autocad-2019-r23.0.46-v4 \
+  --split all
+```
+
+Live provider or AWS checks are separate from the offline suite and require explicit credentials.
+
+## Documentation
+
+Update the relevant contract whenever behavior changes. Release evidence is append-only: add a new release record instead of editing historical results to describe a newer runtime.

README.md

@@ -0,0 +1,182 @@
+---
+tags:
+  - benchmark
+  - computer-use
+  - autocad
+  - cad
+  - multimodal
+---
+
+# AutoCAD Bench
+
+AutoCAD Bench is a computer-use benchmark for evaluating whether multimodal agents can reproduce dimensioned 2D drawings and reconstruct dimensionally accurate 3D models in desktop AutoCAD.
+
+Each rollout receives a task-specific instruction and reference image, operates an isolated AutoCAD session using mouse and keyboard actions, and is evaluated from the final DWG. Gold drawings and evaluator credentials never enter the model-visible session.
+
+## How it works
+
+```text
+tasks/manifest.jsonl + reference PNG
+                 │
+                 ▼
+        model harness + agent loop
+                 │
+                 ▼
+     isolated Windows/AutoCAD sandbox
+                 │
+                 ▼
+           final attempt.dwg
+                 │
+                 ▼
+ trusted inspection + deterministic score + vision judgment
+                 │
+                 ▼
+       runs/<benchmark>/ + dashboard
+```
+
+The benchmark contains exactly 50 tasks, numbered `task-001` through
+`task-050` with no gaps: 21 2D drawings and 29 3D drawings. A 2D task is
+completed in Model Space. A 3D task requires true geometry in Model Space and
+the complete reference sheet on `Layout1`; evaluator v4 renders and compares
+that required layout.
+
+## Getting started
+
+Requirements:
+
+- Python 3.12
+- [uv](https://docs.astral.sh/uv/)
+- Node.js 20+ for the dashboard
+- Infrastructure-backend and model-provider credentials only for live runs
+
+Install the Python environment and validate the corpus:
+
+```bash
+# The development group includes the built-in AWS backend dependencies.
+uv sync --dev
+uv run autocad-bench validate
+uv run autocad-bench validate-audit
+uv run autocad-bench list --split all
+```
+
+Published installations that use the built-in backend should install
+`autocad-bench[aws]`. Custom backends can depend on the base package and their
+own infrastructure plugin without installing the AWS SDK.
+
+The wheel contains code, while scorer-side benchmark data can come from either
+a checkout or a checksum-bound bundle:
+
+```bash
+autocad-bench bundle-validate --root /path/to/autocad-bench-corpus-v1
+export AUTOCAD_BENCH_ROOT=/path/to/autocad-bench-corpus-v1
+```
+
+See [Portable benchmark bundles](docs/benchmark-bundles.md) for the data
+format and [Manual releases](docs/releases.md) for reproducible package and
+corpus publishing.
+
+Run the offline tests:
+
+```bash
+uv run pytest
+cd apps/dashboard
+npm ci
+npm test
+npm run build
+```
+
+## Run a benchmark
+
+Copy the AWS example and replace every infrastructure, bucket, and model
+placeholder with resources you own:
+
+```bash
+cp configs/aws.example.json configs/my-benchmark.json
+
+uv run autocad-bench-batch \
+  --config configs/my-benchmark.json \
+  --skip-direct-model-check
+```
+
+Execute only after provider credentials are exported and preflight passes:
+
+```bash
+export OPENAI_API_KEY=...
+
+uv run autocad-bench-batch \
+  --config configs/my-benchmark.json \
+  --output-dir runs/benchmarks/<run-id> \
+  --execute
+```
+
+Every rollout is evaluated automatically after its final DWG is retrieved and before its sandbox is cleaned up. Evaluation progress is written atomically for the dashboard.
+
+## Inspect results
+
+```bash
+cd apps/dashboard
+npm ci
+npm run build
+npm run preview
+```
+
+Open [http://127.0.0.1:4173](http://127.0.0.1:4173). The viewer reads local `runs/` data and can lazily retrieve missing trace artifacts from the encrypted benchmark bucket when configured.
+
+## Repository layout
+
+```text
+autoCAD-bench/
+├── tasks/                    # Scorer-side manifest, audit inventory, and source corpus
+├── src/autocad_bench/
+│   ├── tasks/                # Task loading, validation, and public task models
+│   ├── harness/              # Agent loop, model calls, and single-run execution
+│   ├── evaluation/           # Trusted DWG evaluation and scoring
+│   ├── infrastructure/       # Backend contract, registry, and built-in AWS plugin
+│   ├── sandbox/              # Broker client and AWS/AutoCAD lifecycle
+│   ├── orchestration/        # Parallel batches, resume, and recovery
+│   └── common/               # Shared utilities
+├── sandbox/windows/          # Windows broker, evaluator, and AMI bootstrap source
+├── infra/cloud-controller/   # Persistent controller deployment assets
+├── configs/                  # Bring-your-own infrastructure examples
+├── apps/dashboard/           # Local benchmark registry and trace viewer
+├── artifacts/gold-cache/     # Versioned trusted evaluator outputs
+├── docs/                     # Contracts, architecture, operations, and releases
+├── tests/                    # Offline regression suite
+└── runs/                     # Generated benchmark results; ignored by git
+```
+
+## Active runtime contract
+
+- Broker: `windows-autocad-2019-v10`
+- Evaluator: `autocad-2019-r23.0.46-v4`
+- Per-task action budget: 5,000
+- Action batch size: bounded only by the remaining rollout budget
+
+Worker images are operator-owned and must satisfy the pinned broker contract.
+Broker v11 adds controller-owned DWG save but remains a separate candidate
+runtime. The complete evaluator-v4 cache contains and verifies all 50 source
+DWGs.
+
+## Documentation
+
+| Guide | Purpose |
+|---|---|
+| [Architecture](docs/architecture.md) | Component boundaries and data flow |
+| [Benchmark contract](docs/benchmark-contract.md) | Model-visible and scorer-side task contract |
+| [Sandbox contract](docs/deterministic-sandbox-contract.md) | AWS lifecycle, admission, and cleanup invariants |
+| [Evaluator contract](docs/autocad-evaluator-contract.md) | DWG inspection and `Layout1` behavior |
+| [Scoring](docs/final-dwg-scorer.md) | Deterministic and vision scoring |
+| [Parallel rollouts](docs/parallel-rollouts.md) | Batch preflight and execution |
+| [Infrastructure plugins](docs/infrastructure-plugins.md) | Bring-your-own worker backend contract |
+| [Benchmark bundles](docs/benchmark-bundles.md) | Portable task and evaluator-data releases |
+| [Manual releases](docs/releases.md) | Reproducible local assembly and verification |
+| [Cloud controller](docs/cloud-controller.md) | Cloud-owned execution and recovery |
+| [Contributing](CONTRIBUTING.md) | Development and validation workflow |
+
+## Security boundary
+
+`tasks/manifest.jsonl` and the corpus are scorer-side inputs and contain paths
+to gold DWGs that are private from the model session. Model-visible task
+serialization excludes gold paths and DWG names. A rollout receives only its
+reference image and task statement; trusted evaluator exchange uses
+request-scoped presigned S3 objects after model execution.

apps/dashboard/README.md

@@ -0,0 +1,17 @@
+# Benchmark dashboard
+
+The Vue dashboard is a read-only registry and trace viewer for every local benchmark under `runs/`. It displays normalized rollout outcomes, live evaluation stages, task evidence, model turns, action receipts, usage, cost, and timing.
+
+```bash
+npm ci
+npm test
+npm run build
+npm run preview
+```
+
+The production viewer binds to `127.0.0.1:4173`. Set
+`AUTOCAD_BENCH_RUNS_ROOT` to inspect another run tree. Optional cloud artifact
+retrieval is disabled unless `AUTOCAD_BENCH_S3_BUCKET` is set. It uses
+`AUTOCAD_BENCH_S3_RUNS_PREFIX`, optional `AWS_PROFILE`, and optional
+`AWS_REGION`; without a named profile, the AWS SDK uses its standard credential
+chain.

apps/dashboard/backfill-trace-summaries.mjs

@@ -0,0 +1,85 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import readline from 'node:readline'
+import { once } from 'node:events'
+import { fileURLToPath } from 'node:url'
+
+import { _test } from './trace-api.mjs'
+
+const dashboardRoot = path.dirname(fileURLToPath(import.meta.url))
+const targetRoot = path.resolve(
+  process.argv[2] || path.join(dashboardRoot, '..', '..', 'runs'),
+)
+
+function discover(directory, output = []) {
+  for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+    const candidate = path.join(directory, entry.name)
+    if (entry.isDirectory()) discover(candidate, output)
+    else if (entry.isFile() && entry.name === 'model_turns.jsonl') output.push(candidate)
+  }
+  return output
+}
+
+async function writeSummary(sourcePath) {
+  const destination = path.join(path.dirname(sourcePath), 'model_turn_summaries.jsonl')
+  const sourceBefore = fs.statSync(sourcePath)
+  try {
+    const existing = fs.statSync(destination)
+    if (existing.mtimeMs >= sourceBefore.mtimeMs && existing.size > 0) {
+      return { sourcePath, destination, status: 'current', turns: null }
+    }
+  } catch {
+    // A missing index is expected on legacy traces.
+  }
+
+  const temporary = `${destination}.tmp`
+  const input = fs.createReadStream(sourcePath, { encoding: 'utf8' })
+  const lines = readline.createInterface({ input, crlfDelay: Infinity })
+  const output = fs.createWriteStream(temporary, { encoding: 'utf8' })
+  let turns = 0
+  try {
+    for await (const line of lines) {
+      if (!line.trim()) continue
+      let turn
+      try {
+        turn = JSON.parse(line.replace(/^\uFEFF/, ''))
+      } catch {
+        continue
+      }
+      if (!output.write(`${JSON.stringify(_test.compactTurn(turn))}\n`)) {
+        await once(output, 'drain')
+      }
+      turns += 1
+    }
+    output.end()
+    await once(output, 'finish')
+    const sourceAfter = fs.statSync(sourcePath)
+    if (
+      sourceAfter.size !== sourceBefore.size
+      || sourceAfter.mtimeMs !== sourceBefore.mtimeMs
+    ) {
+      fs.rmSync(temporary, { force: true })
+      return { sourcePath, destination, status: 'changed_during_index', turns }
+    }
+    fs.renameSync(temporary, destination)
+    return { sourcePath, destination, status: 'indexed', turns }
+  } catch (error) {
+    output.destroy()
+    fs.rmSync(temporary, { force: true })
+    throw error
+  }
+}
+
+const sources = fs.statSync(targetRoot).isFile()
+  ? [targetRoot]
+  : discover(targetRoot)
+
+let indexed = 0
+let current = 0
+for (const source of sources) {
+  const result = await writeSummary(source)
+  if (result.status === 'indexed') indexed += 1
+  if (result.status === 'current') current += 1
+  process.stdout.write(`${JSON.stringify(result)}\n`)
+}
+process.stdout.write(`${JSON.stringify({ indexed, current, total: sources.length })}\n`)

apps/dashboard/cloud-metadata.mjs

@@ -0,0 +1,123 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+const BENCHMARK_ROLLOUT_METADATA = [
+  'run-state.json',
+  'result.json',
+  'evaluation/status.json',
+  'evaluation/score.json',
+  'evaluation/vision-judge/score.json',
+]
+
+const TRACE_METADATA = [
+  'run-state.json',
+  'result.json',
+  'model_turn_summaries.jsonl',
+  'input_receipts.jsonl',
+  'evaluation/status.json',
+  'evaluation/score.json',
+  'evaluation/vision-judge/score.json',
+]
+
+export function benchmarkMetadataPaths(state) {
+  const rolloutIds = state?.rollouts && typeof state.rollouts === 'object'
+    ? Object.keys(state.rollouts)
+    : []
+  return [
+    'batch-state.json',
+    ...rolloutIds.flatMap((rolloutId) => BENCHMARK_ROLLOUT_METADATA.map(
+      (relativePath) => `rollouts/${rolloutId}/${relativePath}`,
+    )),
+  ]
+}
+
+export function traceMetadataPaths() {
+  return [...TRACE_METADATA]
+}
+
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+export function metadataUpdatedAt(filePath) {
+  const value = readJson(filePath)
+  const timestamp = Date.parse(value?.updated_at || '')
+  return Number.isFinite(timestamp) ? timestamp : null
+}
+
+export function evaluatorVersionRank(value) {
+  const match = String(value || '').match(/-v(\d+)$/i)
+  return match ? Number(match[1]) : null
+}
+
+function evaluatorVersionForMetadata(filePath) {
+  const value = readJson(filePath)
+  const direct = value?.evaluator_version || value?.evaluation?.evaluator_version
+  if (direct) return direct
+
+  const marker = `${path.sep}evaluation${path.sep}`
+  const markerIndex = filePath.lastIndexOf(marker)
+  if (markerIndex < 0) return null
+  const evaluationRoot = filePath.slice(0, markerIndex + marker.length - 1)
+  for (const name of ['status.json', 'metadata.json']) {
+    const sibling = readJson(path.join(evaluationRoot, name))
+    if (sibling?.evaluator_version) return sibling.evaluator_version
+  }
+  return null
+}
+
+function rescoreJobForMetadata(filePath) {
+  const value = readJson(filePath)
+  const direct = value?.rescore_job_id || value?.evaluation?.rescore_job_id
+  if (direct) return direct
+
+  const marker = `${path.sep}evaluation${path.sep}`
+  const markerIndex = filePath.lastIndexOf(marker)
+  if (markerIndex < 0) return null
+  const rolloutRoot = filePath.slice(0, markerIndex)
+  return readJson(path.join(rolloutRoot, 'result.json'))?.evaluation
+    ?.rescore_job_id || null
+}
+
+export function shouldPromoteMetadata(source, destination) {
+  if (!fs.existsSync(destination)) return true
+  if (path.extname(source) === '.jsonl') {
+    // Live JSONL traces are append-only. Never let an older S3 snapshot
+    // truncate a controller-local trace when the dashboard runs in-cloud.
+    return fs.statSync(source).size >= fs.statSync(destination).size
+  }
+
+  const sourceRank = evaluatorVersionRank(evaluatorVersionForMetadata(source))
+  const destinationRank = evaluatorVersionRank(
+    evaluatorVersionForMetadata(destination),
+  )
+  if (sourceRank != null && destinationRank != null) {
+    if (sourceRank < destinationRank) return false
+    if (sourceRank > destinationRank) return true
+  }
+
+
+  // A completed local rescore is an immutable, job-bound snapshot. The shared
+  // mirror can temporarily contain an earlier attempt from the same rescore
+  // job, and those files often have no useful top-level updated_at timestamp.
+  // Keep the local terminal snapshot when evaluator versions are equal.
+  const destinationRescoreJob = rescoreJobForMetadata(destination)
+  if (destinationRescoreJob) {
+    const sourceRescoreJob = rescoreJobForMetadata(source)
+    if (sourceRescoreJob !== destinationRescoreJob) return false
+    if (sourceRank == null || destinationRank == null || sourceRank === destinationRank) {
+      return false
+    }
+  }
+
+  const sourceUpdatedAt = metadataUpdatedAt(source)
+  const destinationUpdatedAt = metadataUpdatedAt(destination)
+  if (sourceUpdatedAt != null && destinationUpdatedAt != null) {
+    return sourceUpdatedAt >= destinationUpdatedAt
+  }
+  return true
+}

apps/dashboard/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="dark" />
+    <meta name="description" content="Inspect AutoCAD computer-use rollouts and full benchmark suites." />
+    <title>AutoCAD Evaluation Console</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>

apps/dashboard/package-lock.json

@@ -0,0 +1,1910 @@
+{
+  "name": "autocad-bench-trace-dashboard",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "autocad-bench-trace-dashboard",
+      "version": "0.1.0",
+      "dependencies": {
+        "@aws-sdk/client-s3": "3.1090.0",
+        "@aws-sdk/credential-providers": "3.1090.0",
+        "@aws-sdk/s3-request-presigner": "3.1090.0",
+        "vue": "3.5.40"
+      },
+      "devDependencies": {
+        "@types/node": "20.19.43",
+        "@vitejs/plugin-vue": "5.2.4",
+        "typescript": "5.9.3",
+        "vite": "6.4.3",
+        "vue-tsc": "3.3.7"
+      }
+    },
+    "node_modules/@aws-sdk/checksums": {
+      "version": "3.1000.18",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/checksums/-/checksums-3.1000.18.tgz",
+      "integrity": "sha512-IImkbEyXdV6/uaF5r6Wkk+8718mQw1ll83j0a4a30R3JM/rHVFdWAiT4jtJpFjJiIwM/oJ6SxIxr0z2TaQUGqw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.975.3",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/client-s3": {
+      "version": "3.1090.0",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/client-s3/-/client-s3-3.1090.0.tgz",
+      "integrity": "sha512-R6GX9cd1jljwzZ8xFmgAI/hHCuX1MobIKBdsymv7WL9SENvO9Vgz9KOR6avTnu0Ao+w1LmxnTe+jqmZXEn7Q/Q==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/checksums": "^3.1000.18",
+        "@aws-sdk/core": "^3.975.3",
+        "@aws-sdk/credential-provider-node": "^3.972.70",
+        "@aws-sdk/middleware-sdk-s3": "^3.972.64",
+        "@aws-sdk/signature-v4-multi-region": "^3.996.41",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/fetch-http-handler": "^5.6.6",
+        "@smithy/node-http-handler": "^4.9.6",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/core": {
+      "version": "3.975.3",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/core/-/core-3.975.3.tgz",
+      "integrity": "sha512-7ur3kCKuvPLqlsZ2XlvnNBVQ7KkpSu6Y6dOTwSPHLrFpTEfZM8isLBJc4cgv96WB7GifeVM436mpycwxBd2vEA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/types": "^3.974.2",
+        "@aws-sdk/xml-builder": "^3.972.36",
+        "@aws/lambda-invoke-store": "^0.3.0",
+        "@smithy/core": "^3.29.4",
+        "@smithy/signature-v4": "^5.6.5",
+        "@smithy/types": "^4.16.1",
+        "bowser": "^2.11.0",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-cognito-identity": {
+      "version": "3.972.58",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-cognito-identity/-/credential-provider-cognito-identity-3.972.58.tgz",
+      "integrity": "sha512-s5uoABv5eOzuH/S+XngHjHSrY8mK0UTBUFs8pm1ynBNuxXmYp176zarDyxN9lUS3Rry0wjzNvJUV09QROaO98g==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/nested-clients": "^3.997.33",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-env": {
+      "version": "3.972.59",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-env/-/credential-provider-env-3.972.59.tgz",
+      "integrity": "sha512-Ny5e4Mfh3QPmiAc0AiUe+cbTXDlxkU3Rc+EpWOfyWeWEy6yp7Fa1KmfNeCc+1a8by9zQ9gtohmiQUkMPScF3ng==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.975.3",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-http": {
+      "version": "3.972.61",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-http/-/credential-provider-http-3.972.61.tgz",
+      "integrity": "sha512-8jAjgStl5Ytq4+HF3X/9f+EmRinaRbGRRtQGktlPfBRVx73H+R1y48vIeXerQtYGFaUqkEp3fT6jP854rVO2yQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.975.3",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/fetch-http-handler": "^5.6.6",
+        "@smithy/node-http-handler": "^4.9.6",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-ini": {
+      "version": "3.973.4",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-ini/-/credential-provider-ini-3.973.4.tgz",
+      "integrity": "sha512-e6ZvVsj90aRALf1kHP+J4iqC1496ZpVgqI/+u0LJ5HL7q7ATauGy4gdDvRCP13L1pN/fMiZLah162PGIYkbUVQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.975.3",
+        "@aws-sdk/credential-provider-env": "^3.972.59",
+        "@aws-sdk/credential-provider-http": "^3.972.61",
+        "@aws-sdk/credential-provider-login": "^3.972.66",
+        "@aws-sdk/credential-provider-process": "^3.972.59",
+        "@aws-sdk/credential-provider-sso": "^3.973.3",
+        "@aws-sdk/credential-provider-web-identity": "^3.972.65",
+        "@aws-sdk/nested-clients": "^3.997.33",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/credential-provider-imds": "^4.4.9",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-login": {
+      "version": "3.972.66",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-login/-/credential-provider-login-3.972.66.tgz",
+      "integrity": "sha512-g2fsqm87r/nKthLZ0VkkDBElkGg0PvSa8d97HQ6EilMbJTZ6hxa8FxkSZyJfgPfFdZn0TTmkOffQmTSUcAHIng==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.975.3",
+        "@aws-sdk/nested-clients": "^3.997.33",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-node": {
+      "version": "3.972.70",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-node/-/credential-provider-node-3.972.70.tgz",
+      "integrity": "sha512-3xzvkGdykBunxqh8WudmUpSyLWvIhfI6aBQo1b5rb3mDO5mNLadK+0hiI0qBQBMVynJbfLO+Ajy9dztMwy9O8w==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/credential-provider-env": "^3.972.59",
+        "@aws-sdk/credential-provider-http": "^3.972.61",
+        "@aws-sdk/credential-provider-ini": "^3.973.4",
+        "@aws-sdk/credential-provider-process": "^3.972.59",
+        "@aws-sdk/credential-provider-sso": "^3.973.3",
+        "@aws-sdk/credential-provider-web-identity": "^3.972.65",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/credential-provider-imds": "^4.4.9",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-process": {
+      "version": "3.972.59",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-process/-/credential-provider-process-3.972.59.tgz",
+      "integrity": "sha512-DlZF2/MhLlatDdlrIy3CUCpfdbLrKx+3SMjVo+WyHnPpwzkc/M3vwAHw4OVJf7DMvO+4vfRqSCMc/E9I1auN0g==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.975.3",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-sso": {
+      "version": "3.973.3",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-sso/-/credential-provider-sso-3.973.3.tgz",
+      "integrity": "sha512-hmdDHoy2G5Es2e8IgelNMYUuSQI6uCIAKZMJ2u2PdKDhxvbk1uWD/g4+R7R5c/tJfKEB1+KjjWiaoCr/S+ZTiQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.975.3",
+        "@aws-sdk/nested-clients": "^3.997.33",
+        "@aws-sdk/token-providers": "3.1088.0",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-web-identity": {
+      "version": "3.972.65",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-web-identity/-/credential-provider-web-identity-3.972.65.tgz",
+      "integrity": "sha512-gHQb/Kt0chjk/JQDa/GJDqmAvEuVn8n7z10wK2h0LFM9TUDRkohgOO4aEF+s2sBLM0br7Cl5W6P7phgjrrJvLQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.975.3",
+        "@aws-sdk/nested-clients": "^3.997.33",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-providers": {
+      "version": "3.1090.0",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-providers/-/credential-providers-3.1090.0.tgz",
+      "integrity": "sha512-HEfLv6RdiFu8+HO5CUQjjQ/KCWWAHcQCtSPenaF26lYQSjjzKjgvjwAMGBV9/VMrO8V0faIRyoFWhF548UjTOg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.975.3",
+        "@aws-sdk/credential-provider-cognito-identity": "^3.972.58",
+        "@aws-sdk/credential-provider-env": "^3.972.59",
+        "@aws-sdk/credential-provider-http": "^3.972.61",
+        "@aws-sdk/credential-provider-ini": "^3.973.4",
+        "@aws-sdk/credential-provider-login": "^3.972.66",
+        "@aws-sdk/credential-provider-node": "^3.972.70",
+        "@aws-sdk/credential-provider-process": "^3.972.59",
+        "@aws-sdk/credential-provider-sso": "^3.973.3",
+        "@aws-sdk/credential-provider-web-identity": "^3.972.65",
+        "@aws-sdk/nested-clients": "^3.997.33",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/credential-provider-imds": "^4.4.9",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/middleware-sdk-s3": {
+      "version": "3.972.64",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/middleware-sdk-s3/-/middleware-sdk-s3-3.972.64.tgz",
+      "integrity": "sha512-RBi43anhDBUv+HCfxCOXwGOE7GmT4n7ChV04Mwr22RhXTNcamW/iWnJlOotDPCZSrJ4dEvhZSiWWQMwLX+ZhFA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.975.3",
+        "@aws-sdk/signature-v4-multi-region": "^3.996.41",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/nested-clients": {
+      "version": "3.997.33",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/nested-clients/-/nested-clients-3.997.33.tgz",
+      "integrity": "sha512-dVZOroI/r3/ENvqNGgjMPul+jjlz9GddfVusgTXlVjfZj5isibOxecLkGQbRPp8XOuX+RAfjXLFgPkD1JS5xrw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.975.3",
+        "@aws-sdk/signature-v4-multi-region": "^3.996.41",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/fetch-http-handler": "^5.6.6",
+        "@smithy/node-http-handler": "^4.9.6",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/s3-request-presigner": {
+      "version": "3.1090.0",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/s3-request-presigner/-/s3-request-presigner-3.1090.0.tgz",
+      "integrity": "sha512-DaYXp8GMptWJUDbvpoB51xZztOw6tcbpXjYAZMXTu17E0aR+5g8FWBU3t3t0KEhhrUiKyfLpVi6uNQxNSXfbhg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.975.3",
+        "@aws-sdk/signature-v4-multi-region": "^3.996.41",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/signature-v4-multi-region": {
+      "version": "3.996.41",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/signature-v4-multi-region/-/signature-v4-multi-region-3.996.41.tgz",
+      "integrity": "sha512-QMUytg+FQMGouc8gHS00KoYih3+N6cqmVI/pQGOIo7Nr7OpQaiXjSYOuL+vsPZ1tymY4LAQ8MYcHJmws5LRxng==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/signature-v4": "^5.6.5",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/token-providers": {
+      "version": "3.1088.0",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/token-providers/-/token-providers-3.1088.0.tgz",
+      "integrity": "sha512-4ObatWt2qpJg5FBk4LOOKrTQYzaqeewAtdO3r9ZO8lH9YqLtpTzLyIdy0mJ+nVdfYOnqISkKNfmzP22bNDhwyw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.975.3",
+        "@aws-sdk/nested-clients": "^3.997.33",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/types": {
+      "version": "3.974.2",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/types/-/types-3.974.2.tgz",
+      "integrity": "sha512-3W6IUtSxFbH6X7Wb7DzGCV5QiFQsd0g8bOfntpmDxQlzBoKWUMBu/JPQR0DwkE+Hpnxd6db1tXbOwdeHddG6cA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/xml-builder": {
+      "version": "3.972.36",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/xml-builder/-/xml-builder-3.972.36.tgz",
+      "integrity": "sha512-RdGmS1GLrtaTOLE1ElSluMldNrpk9Emq6uYs8SS8iHlu5xTAmM9rRkM91o48+rIRryBtyO9t+uLYCoMG6jVMVA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws/lambda-invoke-store": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/@aws/lambda-invoke-store/-/lambda-invoke-store-0.3.0.tgz",
+      "integrity": "sha512-sl4Bm6yiMNYrZKkqqDFWN0UfnWhlS8ivKxrYl+6t0gCLrqr8y3B2IqZZbFRkfaVVp7C/baApyh71P+LeE1A2sQ==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@babel/helper-string-parser": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.29.7.tgz",
+      "integrity": "sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-identifier": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.29.7.tgz",
+      "integrity": "sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/parser": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.7.tgz",
+      "integrity": "sha512-hnORnjP/1P/zFEndoeX+n+t1RwWRJiJpM/jO7FW32Kn9r5+sJB2JWOdYo4L6k78j15eCwY3Gm/7364B1EMwtNg==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.29.7"
+      },
+      "bin": {
+        "parser": "bin/babel-parser.js"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@babel/types": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.7.tgz",
+      "integrity": "sha512-4zBIxpPzowiZpusoFkyGVwakdRJUyuH5PxQ/PrqghfdFWWasvnCdPfQXHrenDai+gyLARulZjZowCOj6fjT4pA==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-string-parser": "^7.29.7",
+        "@babel/helper-validator-identifier": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.12.tgz",
+      "integrity": "sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.12.tgz",
+      "integrity": "sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.12.tgz",
+      "integrity": "sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.12.tgz",
+      "integrity": "sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.12.tgz",
+      "integrity": "sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.12.tgz",
+      "integrity": "sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.12.tgz",
+      "integrity": "sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.12.tgz",
+      "integrity": "sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.12.tgz",
+      "integrity": "sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.12.tgz",
+      "integrity": "sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.12.tgz",
+      "integrity": "sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.12.tgz",
+      "integrity": "sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.12.tgz",
+      "integrity": "sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.12.tgz",
+      "integrity": "sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.12.tgz",
+      "integrity": "sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.12.tgz",
+      "integrity": "sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.12.tgz",
+      "integrity": "sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.12.tgz",
+      "integrity": "sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.12.tgz",
+      "integrity": "sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.12.tgz",
+      "integrity": "sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.12.tgz",
+      "integrity": "sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openharmony-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.12.tgz",
+      "integrity": "sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.12.tgz",
+      "integrity": "sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.12.tgz",
+      "integrity": "sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.12.tgz",
+      "integrity": "sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.12.tgz",
+      "integrity": "sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "license": "MIT"
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.62.2.tgz",
+      "integrity": "sha512-6o7ZLZK+BeenkZCFNDXqpbjw9bD6nuWonvS/lwQJp7NoVVxm6p3qE7qQ5jGuBjiFsgvqjD8mZAU5oWxTmbOeOg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.62.2.tgz",
+      "integrity": "sha512-BaH7BllCACHoH1LguOU56UItGfUWjujlO65kS9LAodViaN4bwIKd7oeW/ZHJ/4ljr/7MIiENnNy3HJ0zXv8Zkw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.62.2.tgz",
+      "integrity": "sha512-v39RCCvj4He82I9sFmk+M1VZ0PLM9sfsLVikjfx2hYBNALhrrOR2D3JjQA6AhlaSOgcR+RzrKY7e1+bT6SUO/A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.62.2.tgz",
+      "integrity": "sha512-yl0y2vq3S3lHeuXhEdss6TWfKW8vkujImO12tn4ZkG/4oghr09LvdYm2RElVjokTQiUvDUGXLGsYeLqUMCKpGA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.62.2.tgz",
+      "integrity": "sha512-tT4pvt4qXD+vEoezupCWi+a1F0vvDiksiHc+PxRlYTOH1I6/X4id9jPxTP+Fg+545euaFT1jJVs4CEdHZAU1vw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.62.2.tgz",
+      "integrity": "sha512-6nU5F2wCW+qvCBhTn1pdIU3bzsIoF7EUwsCDRxilWGprQR6yd508YnH9+OKFCwpfS8pjZqDUmnCAr7exax0XCg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.62.2.tgz",
+      "integrity": "sha512-n1GJHPOvpIfhi3TmrCeh6S6URt9BFCt0KQE3qvexyGCTAKpR4Lg+eWvNZEqu7epxwus/8ElT3hacYEucm49SZg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.62.2.tgz",
+      "integrity": "sha512-JqgflS8wEB+UXV/vS1RpRbifGBeN4D5lz8D8oOFbFZw4vedvdOgCFAjfBmIMdW3yL10XpQQ0Ambepw6MXrhOnA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.62.2.tgz",
+      "integrity": "sha512-wnFJkogWvN4jm/hQRF2UBaeUmk20j5+DmHvoyWii2b8HJDyvz1MF2OU/6ynXt2KR63rbZLWkFpoytpdc/yBuSA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.62.2.tgz",
+      "integrity": "sha512-HVu2bp0zhvJ8xHEV9+UUs7S90VadmBSY3LcIMvozbPo4AuMGDWlz3ymHLHZPX4hR67TKTt8Qp5PJ5RBg/i+RMQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.62.2.tgz",
+      "integrity": "sha512-mQqqAV8QaoSgr9I2fKDLY2BAVvmKjWoGiu/cSYQonsLvtqwEn1E4QYfnCOcp5zoEqNhsDYin1s6jx/VJmrxlZg==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-musl": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.62.2.tgz",
+      "integrity": "sha512-IxKLoxCQ2IWi6bT2akyDUBGsOImDKB+sPp4EsTmwFQ/fMwpCKm8uLSSgP/Kx/QYUgKis6SEZ5/Nlhup0DIA0PQ==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.62.2.tgz",
+      "integrity": "sha512-Mk5ha2RQSgyFfmYYLkBpPnUk8D8FriBxesO1u9O75X0mHgXL1UQcH5Itl2lurWL2tj0RxV9b9tJgipac0hRY9A==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-musl": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.62.2.tgz",
+      "integrity": "sha512-CjvEnqJL/0/TQ3TXX3OPIJ/kmBellrWd4heXUmHeJlTnmwjKpSJzoehLaL6Xk0ZnMHBu9dZuFADNOrtjF4v+2w==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.62.2.tgz",
+      "integrity": "sha512-1SiZbzwdkaDURsew/tSOrooKiYy7EQGT6m8ufavAi9NEyQb/6VuIxFXAL1fqa4iZe3g4NbNk4P7J32z2tw5Mgg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.62.2.tgz",
+      "integrity": "sha512-nQts12zJ3NQRoE6uYljOH89v7szzLDvG2JD/vsX+vGXU8w/At1GowTZ5/7qeFQ8m7L55rpR8Okugnuo5bgjy2Q==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.62.2.tgz",
+      "integrity": "sha512-E9/ll019jhPIJgpzfZoIkBGhcz+kKNgVWYRY0zr9srBdPPFVpvOKW8VaJKUbeK+eZXyQF9ltME+Kk6affeaPgg==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.62.2.tgz",
+      "integrity": "sha512-5BqxR/pshjey51iliyzTD5Xi3EN0aLmQ2lZ3lvefVV9c82BvrLo2/6OT55iifpWBufs6kdwWbuOKS841DrmK9A==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.62.2.tgz",
+      "integrity": "sha512-uNN83XxQrRAh/w0/pmAfibcwyb6YWt4gP+dpnQKPVJshAloQ785ii8CT8ZCIxkGg9opVsvAlGhFitSm6D1Jjpg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-openbsd-x64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.62.2.tgz",
+      "integrity": "sha512-srjEIxSH3LRnJN6THczDHWQplqEMFiAJrTab0msUryh9kwNpkICf3Ea6q6MN/2cZwRFUNx5w+h6Hpi4QuHS6Zg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-openharmony-arm64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.62.2.tgz",
+      "integrity": "sha512-8hOJnxgbyObnCm5AlRA3A931xX19xq80RjVTKgJOvEKWqJruP/Uf12IbAOaDjjEXYRewwHLfmF0YRIdK3OwKWA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.62.2.tgz",
+      "integrity": "sha512-mmF4AY1i0hG/bLWUctUq59gtmgaSIRa3cu/A3JFRp/sCNEme2bgDEiDS22P9FbnJB8NJNF4jPJiSP5RHQpUTDg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.62.2.tgz",
+      "integrity": "sha512-DZgkknc6jhHrk46V25vbAM0zZkyP0nSDkJB8/dRkLTxv470dOmWDqGoEJl/9A0dFfS7yE3REOwNDxpHwSLSt0Q==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.62.2.tgz",
+      "integrity": "sha512-T6xr6ucWSFto+VGajA8YH26LdpHRuP4YLHEKAtCWvJDOlnmWcDZVCI2Jmjr+IFHDlt2zRaTAKE4tfjTaWLgJBg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.62.2.tgz",
+      "integrity": "sha512-BfzEnDJOt9T8M989/lA37EcJgat01wLRnoi5dQf3QzOH7jzpqTAzdDbVfRljVr5r+jzKqpbHeyOfAaXxAd0PAA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@smithy/core": {
+      "version": "3.29.5",
+      "resolved": "https://registry.npmjs.org/@smithy/core/-/core-3.29.5.tgz",
+      "integrity": "sha512-i0dk2t5B+CwV/dcJdUHILYkOQF5lof8f44dFCfDWToGCxjT9YQ+CgHqTAvJxzc3+zqQwm2QtVoJ5IqiNar/CnQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@smithy/credential-provider-imds": {
+      "version": "4.4.10",
+      "resolved": "https://registry.npmjs.org/@smithy/credential-provider-imds/-/credential-provider-imds-4.4.10.tgz",
+      "integrity": "sha512-MJenAe4OKRZUo1LdYYFDCsSHxaHvInIU/z52GsheO9vl1/VSySVCr0zkyKD6TFiGkSUaWGxvKZ/70OvgUZR5HQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@smithy/core": "^3.29.5",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@smithy/fetch-http-handler": {
+      "version": "5.6.7",
+      "resolved": "https://registry.npmjs.org/@smithy/fetch-http-handler/-/fetch-http-handler-5.6.7.tgz",
+      "integrity": "sha512-3zpg8yqqyXzoK2TsRDdkqVOj2RDBFfLXwCczOZ5c7TWB4eiaebfSCsbMjDPYB3PJ9ihV62QaeadZ+wLadZtNGA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@smithy/core": "^3.29.5",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@smithy/node-http-handler": {
+      "version": "4.9.7",
+      "resolved": "https://registry.npmjs.org/@smithy/node-http-handler/-/node-http-handler-4.9.7.tgz",
+      "integrity": "sha512-wCU8HCLjAtAVqxxe0j2xff9LcEPw3yjBbg5IdQDIYFnxnPxbxcSLc7rgex7kqm9L/WYOnJEgaWQlfDkZleozMA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@smithy/core": "^3.29.5",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@smithy/signature-v4": {
+      "version": "5.6.6",
+      "resolved": "https://registry.npmjs.org/@smithy/signature-v4/-/signature-v4-5.6.6.tgz",
+      "integrity": "sha512-efP6DN3UTFrzIsGO42/xcabv8jU7+9nwEdphFUH7yL0k010ERyAWaO41KFQIDLcFZLZ8xzIQr4wplFxNzslSGQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@smithy/core": "^3.29.5",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@smithy/types": {
+      "version": "4.16.1",
+      "resolved": "https://registry.npmjs.org/@smithy/types/-/types-4.16.1.tgz",
+      "integrity": "sha512-0JFs3V2y2M9tKW5na/qxe69Zv+uxLMO7QBbhxF/FHu/Gp2NFZAAL9tWl9PU02xxo07pb3G9FTyjNc6D5uZrJIg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.9",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.9.tgz",
+      "integrity": "sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/node": {
+      "version": "20.19.43",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.43.tgz",
+      "integrity": "sha512-6oYBAi5ikg4Pl+kGsoYtawUMBT2zZMCvPNF7pVLnHZfd1zf38DRiWn/gT01RYCdUqkv7Fhr+C9ot4/tb+2sVvA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~6.21.0"
+      }
+    },
+    "node_modules/@vitejs/plugin-vue": {
+      "version": "5.2.4",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-vue/-/plugin-vue-5.2.4.tgz",
+      "integrity": "sha512-7Yx/SXSOcQq5HiiV3orevHUFn+pmMB4cgbEkDYgnkUWb0WfeQ/wa2yFv6D5ICiCQOVpjA7vYDXrC7AGO8yjDHA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "peerDependencies": {
+        "vite": "^5.0.0 || ^6.0.0",
+        "vue": "^3.2.25"
+      }
+    },
+    "node_modules/@volar/language-core": {
+      "version": "2.4.28",
+      "resolved": "https://registry.npmjs.org/@volar/language-core/-/language-core-2.4.28.tgz",
+      "integrity": "sha512-w4qhIJ8ZSitgLAkVay6AbcnC7gP3glYM3fYwKV3srj8m494E3xtrCv6E+bWviiK/8hs6e6t1ij1s2Endql7vzQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@volar/source-map": "2.4.28"
+      }
+    },
+    "node_modules/@volar/source-map": {
+      "version": "2.4.28",
+      "resolved": "https://registry.npmjs.org/@volar/source-map/-/source-map-2.4.28.tgz",
+      "integrity": "sha512-yX2BDBqJkRXfKw8my8VarTyjv48QwxdJtvRgUpNE5erCsgEUdI2DsLbpa+rOQVAJYshY99szEcRDmyHbF10ggQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@volar/typescript": {
+      "version": "2.4.28",
+      "resolved": "https://registry.npmjs.org/@volar/typescript/-/typescript-2.4.28.tgz",
+      "integrity": "sha512-Ja6yvWrbis2QtN4ClAKreeUZPVYMARDYZl9LMEv1iQ1QdepB6wn0jTRxA9MftYmYa4DQ4k/DaSZpFPUfxl8giw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@volar/language-core": "2.4.28",
+        "path-browserify": "^1.0.1",
+        "vscode-uri": "^3.0.8"
+      }
+    },
+    "node_modules/@vue/compiler-core": {
+      "version": "3.5.40",
+      "resolved": "https://registry.npmjs.org/@vue/compiler-core/-/compiler-core-3.5.40.tgz",
+      "integrity": "sha512-39E8IgOhTbVDnoJFMKc2DvYnypcZwUqgUhQkccva/0m6FUwtIKSGV7n1hpVmYcFaoRAwf9pBcwnKlCEsN63ZEQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.29.7",
+        "@vue/shared": "3.5.40",
+        "entities": "^7.0.1",
+        "estree-walker": "^2.0.2",
+        "source-map-js": "^1.2.1"
+      }
+    },
+    "node_modules/@vue/compiler-dom": {
+      "version": "3.5.40",
+      "resolved": "https://registry.npmjs.org/@vue/compiler-dom/-/compiler-dom-3.5.40.tgz",
+      "integrity": "sha512-pwkx4vqlqOspFstrcmzwkKLePVMD3PT65imRzLhanU2V1Fj4K13g6OXjanOyzw3aTAuRk84BOmY8f3rEHqPaVA==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/compiler-core": "3.5.40",
+        "@vue/shared": "3.5.40"
+      }
+    },
+    "node_modules/@vue/compiler-sfc": {
+      "version": "3.5.40",
+      "resolved": "https://registry.npmjs.org/@vue/compiler-sfc/-/compiler-sfc-3.5.40.tgz",
+      "integrity": "sha512-gIf497P4kpuALcvs5n3AEg1Vdn0pSY4XbjASIfHNYF1/MP3T2Mf2STERTubysBxCRxzJGJYtF/O7vwJrxFB3Vw==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.29.7",
+        "@vue/compiler-core": "3.5.40",
+        "@vue/compiler-dom": "3.5.40",
+        "@vue/compiler-ssr": "3.5.40",
+        "@vue/shared": "3.5.40",
+        "estree-walker": "^2.0.2",
+        "magic-string": "^0.30.21",
+        "postcss": "^8.5.19",
+        "source-map-js": "^1.2.1"
+      }
+    },
+    "node_modules/@vue/compiler-ssr": {
+      "version": "3.5.40",
+      "resolved": "https://registry.npmjs.org/@vue/compiler-ssr/-/compiler-ssr-3.5.40.tgz",
+      "integrity": "sha512-rrE5xiXG663+vHCHa3J9p2z5OcBRjXmoqenprJxAFQxg5pSshzeBiCE6pu46axapRJ2Adk0YDA2BRZVjiHXnhg==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/compiler-dom": "3.5.40",
+        "@vue/shared": "3.5.40"
+      }
+    },
+    "node_modules/@vue/language-core": {
+      "version": "3.3.7",
+      "resolved": "https://registry.npmjs.org/@vue/language-core/-/language-core-3.3.7.tgz",
+      "integrity": "sha512-LzmkKinXAMMoh8Jfi/jMUSDUjuPdv8mynH5WJGKfXyZtDw3hQ6GBaoI6Bcnl/Xqlu32q/0Z6i/trp4VXykzyLw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@volar/language-core": "2.4.28",
+        "@vue/compiler-dom": "^3.5.0",
+        "@vue/shared": "^3.5.0",
+        "alien-signals": "^3.2.1",
+        "muggle-string": "^0.4.1",
+        "path-browserify": "^1.0.1",
+        "picomatch": "^4.0.4"
+      }
+    },
+    "node_modules/@vue/reactivity": {
+      "version": "3.5.40",
+      "resolved": "https://registry.npmjs.org/@vue/reactivity/-/reactivity-3.5.40.tgz",
+      "integrity": "sha512-B7ot9UlUZOi1zbq61/LvE88ZLTV8IlajTdiZTAEiDQgrnIMIZoPr9kGw0Zw46ObW62O9+H/Be3kMbfb7kYPQZA==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/shared": "3.5.40"
+      }
+    },
+    "node_modules/@vue/runtime-core": {
+      "version": "3.5.40",
+      "resolved": "https://registry.npmjs.org/@vue/runtime-core/-/runtime-core-3.5.40.tgz",
+      "integrity": "sha512-KAZLweuZ6uUJPK1PMSQPgBU5gCjgrrfjUhSglmU9NhH+Zjepa8cnwSydPWDWHDwOgY4g3VcZ+PljbiHlURNCbw==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/reactivity": "3.5.40",
+        "@vue/shared": "3.5.40"
+      }
+    },
+    "node_modules/@vue/runtime-dom": {
+      "version": "3.5.40",
+      "resolved": "https://registry.npmjs.org/@vue/runtime-dom/-/runtime-dom-3.5.40.tgz",
+      "integrity": "sha512-ZfrX8ssZQds900L9pr8AuK05ddnMsR4MPMZr8cPN9GoqoPWcXLhjvvbIA2SMv+7a97sJ1vv9pj/zxK0Cq/eEFQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/reactivity": "3.5.40",
+        "@vue/runtime-core": "3.5.40",
+        "@vue/shared": "3.5.40",
+        "csstype": "^3.2.3"
+      }
+    },
+    "node_modules/@vue/server-renderer": {
+      "version": "3.5.40",
+      "resolved": "https://registry.npmjs.org/@vue/server-renderer/-/server-renderer-3.5.40.tgz",
+      "integrity": "sha512-XNJym9WpevhTVt1HuwOrCRJ5Q+9z4BjTMrDtjTrvx74SmUll8spNTw6whWJa9mEkO4PKn5TihI/bm/8ds2QVJw==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/compiler-ssr": "3.5.40",
+        "@vue/runtime-dom": "3.5.40",
+        "@vue/shared": "3.5.40"
+      }
+    },
+    "node_modules/@vue/shared": {
+      "version": "3.5.40",
+      "resolved": "https://registry.npmjs.org/@vue/shared/-/shared-3.5.40.tgz",
+      "integrity": "sha512-WxnBtruIqOoV3rA4jeKDWzrYI5h7Cp4+pjwDi8kWGHz+IslhiN+wguLVVhtv2l8VoU02rzDCVfDjgCl1lNpZVg==",
+      "license": "MIT"
+    },
+    "node_modules/alien-signals": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/alien-signals/-/alien-signals-3.2.1.tgz",
+      "integrity": "sha512-I8FjmltrfnDFoZedi5CG8DghVYNhzb/Ijluz7tCSJH0xpd0484Kowhbb1XDYOxfJpU1p5wnM2X54dA+IfGyD1g==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/bowser": {
+      "version": "2.14.1",
+      "resolved": "https://registry.npmjs.org/bowser/-/bowser-2.14.1.tgz",
+      "integrity": "sha512-tzPjzCxygAKWFOJP011oxFHs57HzIhOEracIgAePE4pqB3LikALKnSzUyU4MGs9/iCEUuHlAJTjTc5M+u7YEGg==",
+      "license": "MIT"
+    },
+    "node_modules/csstype": {
+      "version": "3.2.3",
+      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
+      "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
+      "license": "MIT"
+    },
+    "node_modules/entities": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-7.0.1.tgz",
+      "integrity": "sha512-TWrgLOFUQTH994YUyl1yT4uyavY5nNB5muff+RtWaqNVCAK408b5ZnnbNAUEWLTCpum9w6arT70i1XdQ4UeOPA==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.12"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
+    "node_modules/esbuild": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.12.tgz",
+      "integrity": "sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.25.12",
+        "@esbuild/android-arm": "0.25.12",
+        "@esbuild/android-arm64": "0.25.12",
+        "@esbuild/android-x64": "0.25.12",
+        "@esbuild/darwin-arm64": "0.25.12",
+        "@esbuild/darwin-x64": "0.25.12",
+        "@esbuild/freebsd-arm64": "0.25.12",
+        "@esbuild/freebsd-x64": "0.25.12",
+        "@esbuild/linux-arm": "0.25.12",
+        "@esbuild/linux-arm64": "0.25.12",
+        "@esbuild/linux-ia32": "0.25.12",
+        "@esbuild/linux-loong64": "0.25.12",
+        "@esbuild/linux-mips64el": "0.25.12",
+        "@esbuild/linux-ppc64": "0.25.12",
+        "@esbuild/linux-riscv64": "0.25.12",
+        "@esbuild/linux-s390x": "0.25.12",
+        "@esbuild/linux-x64": "0.25.12",
+        "@esbuild/netbsd-arm64": "0.25.12",
+        "@esbuild/netbsd-x64": "0.25.12",
+        "@esbuild/openbsd-arm64": "0.25.12",
+        "@esbuild/openbsd-x64": "0.25.12",
+        "@esbuild/openharmony-arm64": "0.25.12",
+        "@esbuild/sunos-x64": "0.25.12",
+        "@esbuild/win32-arm64": "0.25.12",
+        "@esbuild/win32-ia32": "0.25.12",
+        "@esbuild/win32-x64": "0.25.12"
+      }
+    },
+    "node_modules/estree-walker": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz",
+      "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==",
+      "license": "MIT"
+    },
+    "node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/magic-string": {
+      "version": "0.30.21",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
+      "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.5"
+      }
+    },
+    "node_modules/muggle-string": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/muggle-string/-/muggle-string-0.4.1.tgz",
+      "integrity": "sha512-VNTrAak/KhO2i8dqqnqnAHOa3cYBwXEZe9h+D5h/1ZqFSTEFHdM65lR7RoIqq3tBBYavsOXV84NoHXZ0AkPyqQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.16",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.16.tgz",
+      "integrity": "sha512-bzlKTyNJ7+LdGIIwy8ijFpIqEQIvafahV7eYykJ8Cvh42EdJeODoJ6gUJXpQJvej1BddH8OqTXZNE/KfbWAu8Q==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/path-browserify": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/path-browserify/-/path-browserify-1.0.1.tgz",
+      "integrity": "sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "license": "ISC"
+    },
+    "node_modules/picomatch": {
+      "version": "4.0.5",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.5.tgz",
+      "integrity": "sha512-RvwwcruNjI1ncT5xRakeyS9Lf8lcItv34KD+aif+VH9kduAyfYBipGh12274xtenIPZ119/R9BdTBa8gAwSh0A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/postcss": {
+      "version": "8.5.19",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.19.tgz",
+      "integrity": "sha512-Mz8SaolMd8nB+G13WkORcxQKHZ/NE4xXevtkJHVuG+guo9/wYKlIMTKAqGdEmYOXR2ijPjTYNHssizdaVSUNdQ==",
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.12",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/rollup": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.62.2.tgz",
+      "integrity": "sha512-RFnrW4lhXA3s3eqHDZvN654g8OTjzRfqpIRJYczCGB6HzphckVAi/Qh4tbPUbRuDi7s1Llv8g/NspLkttY3gTA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "1.0.9"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.62.2",
+        "@rollup/rollup-android-arm64": "4.62.2",
+        "@rollup/rollup-darwin-arm64": "4.62.2",
+        "@rollup/rollup-darwin-x64": "4.62.2",
+        "@rollup/rollup-freebsd-arm64": "4.62.2",
+        "@rollup/rollup-freebsd-x64": "4.62.2",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.62.2",
+        "@rollup/rollup-linux-arm-musleabihf": "4.62.2",
+        "@rollup/rollup-linux-arm64-gnu": "4.62.2",
+        "@rollup/rollup-linux-arm64-musl": "4.62.2",
+        "@rollup/rollup-linux-loong64-gnu": "4.62.2",
+        "@rollup/rollup-linux-loong64-musl": "4.62.2",
+        "@rollup/rollup-linux-ppc64-gnu": "4.62.2",
+        "@rollup/rollup-linux-ppc64-musl": "4.62.2",
+        "@rollup/rollup-linux-riscv64-gnu": "4.62.2",
+        "@rollup/rollup-linux-riscv64-musl": "4.62.2",
+        "@rollup/rollup-linux-s390x-gnu": "4.62.2",
+        "@rollup/rollup-linux-x64-gnu": "4.62.2",
+        "@rollup/rollup-linux-x64-musl": "4.62.2",
+        "@rollup/rollup-openbsd-x64": "4.62.2",
+        "@rollup/rollup-openharmony-arm64": "4.62.2",
+        "@rollup/rollup-win32-arm64-msvc": "4.62.2",
+        "@rollup/rollup-win32-ia32-msvc": "4.62.2",
+        "@rollup/rollup-win32-x64-gnu": "4.62.2",
+        "@rollup/rollup-win32-x64-msvc": "4.62.2",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/tinyglobby": {
+      "version": "0.2.17",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.17.tgz",
+      "integrity": "sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.4"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
+      }
+    },
+    "node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "license": "0BSD"
+    },
+    "node_modules/typescript": {
+      "version": "5.9.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "devOptional": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "6.21.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/vite": {
+      "version": "6.4.3",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-6.4.3.tgz",
+      "integrity": "sha512-NTKlcQjlAK7MlQoyb6LgaqHc8sso/pVyUJYWMws3jg21uTJw/LddqIFPcPqP6PzpgbIcZyKI85sFE4HBrQDA8A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "^0.25.0",
+        "fdir": "^6.4.4",
+        "picomatch": "^4.0.2",
+        "postcss": "^8.5.3",
+        "rollup": "^4.34.9",
+        "tinyglobby": "^0.2.13"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0",
+        "jiti": ">=1.21.0",
+        "less": "*",
+        "lightningcss": "^1.21.0",
+        "sass": "*",
+        "sass-embedded": "*",
+        "stylus": "*",
+        "sugarss": "*",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "jiti": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vscode-uri": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/vscode-uri/-/vscode-uri-3.1.0.tgz",
+      "integrity": "sha512-/BpdSx+yCQGnCvecbyXdxHDkuk55/G3xwnC0GqY4gmQ3j+A+g8kzzgB4Nk/SINjqn6+waqw3EgbVF2QKExkRxQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/vue": {
+      "version": "3.5.40",
+      "resolved": "https://registry.npmjs.org/vue/-/vue-3.5.40.tgz",
+      "integrity": "sha512-+8PJ4SJXdn/cHGImF4CKdxlWHIN5Dkt7DoufRREM6h6uVCx2m7QxgcEQmmzyOK8A9mcafg7sFbJFYsdFVubTig==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/compiler-dom": "3.5.40",
+        "@vue/compiler-sfc": "3.5.40",
+        "@vue/runtime-dom": "3.5.40",
+        "@vue/server-renderer": "3.5.40",
+        "@vue/shared": "3.5.40"
+      },
+      "peerDependencies": {
+        "typescript": "*"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vue-tsc": {
+      "version": "3.3.7",
+      "resolved": "https://registry.npmjs.org/vue-tsc/-/vue-tsc-3.3.7.tgz",
+      "integrity": "sha512-+C+rgD49wAQ5bUTl2sp5a8Bzg4YoldMNXM+g7CFe604MYcQ8PrZPMQhIjJSzKXtPBCa+C5ayMipqjbA7splekQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@volar/typescript": "2.4.28",
+        "@vue/language-core": "3.3.7"
+      },
+      "bin": {
+        "vue-tsc": "bin/vue-tsc.js"
+      },
+      "peerDependencies": {
+        "typescript": ">=5.0.0"
+      }
+    }
+  }
+}

apps/dashboard/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "autocad-bench-trace-dashboard",
+  "private": true,
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite --host 127.0.0.1",
+    "build": "vue-tsc -b && vite build",
+    "index-traces": "node backfill-trace-summaries.mjs",
+    "test": "node --test tests/*.test.mjs",
+    "preview": "node server.mjs"
+  },
+  "dependencies": {
+    "@aws-sdk/client-s3": "3.1090.0",
+    "@aws-sdk/credential-providers": "3.1090.0",
+    "@aws-sdk/s3-request-presigner": "3.1090.0",
+    "vue": "3.5.40"
+  },
+  "devDependencies": {
+    "@types/node": "20.19.43",
+    "@vitejs/plugin-vue": "5.2.4",
+    "typescript": "5.9.3",
+    "vite": "6.4.3",
+    "vue-tsc": "3.3.7"
+  }
+}

apps/dashboard/server.d.mts

@@ -0,0 +1 @@
+export {};

apps/dashboard/server.mjs

@@ -0,0 +1,372 @@
+import fs from 'node:fs'
+import http from 'node:http'
+import os from 'node:os'
+import path from 'node:path'
+import { execFile } from 'node:child_process'
+import { createHash } from 'node:crypto'
+import { fileURLToPath } from 'node:url'
+import { promisify } from 'node:util'
+import { GetObjectCommand, S3Client } from '@aws-sdk/client-s3'
+import { fromIni } from '@aws-sdk/credential-providers'
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner'
+import { createTraceApi } from './trace-api.mjs'
+import {
+  benchmarkMetadataPaths,
+  shouldPromoteMetadata,
+  traceMetadataPaths,
+} from './cloud-metadata.mjs'
+
+const root = path.dirname(fileURLToPath(import.meta.url))
+const dist = path.join(root, 'dist')
+const execFileAsync = promisify(execFile)
+const cloudDownloads = new Map()
+const cloudBucket = process.env.AUTOCAD_BENCH_S3_BUCKET || ''
+const cloudPrefix = (process.env.AUTOCAD_BENCH_S3_RUNS_PREFIX || 'controller/runs')
+  .replace(/^\/+|\/+$/g, '')
+const awsProfile = process.env.AWS_PROFILE || ''
+const awsRegion = process.env.AWS_REGION || ''
+const cloudArtifactsEnabled = Boolean(cloudBucket)
+  && process.env.AUTOCAD_BENCH_CLOUD_ARTIFACTS !== 'off'
+const signedArtifactLifetimeSeconds = 300
+const s3 = new S3Client({
+  ...(awsRegion ? { region: awsRegion } : {}),
+  ...(awsProfile ? { credentials: fromIni({ profile: awsProfile }) } : {}),
+})
+const cloudMetadataDownloads = new Map()
+const cloudMetadataFreshAt = new Map()
+const cloudArtifactAttempts = Math.max(
+  1,
+  Math.min(5, Number(process.env.AUTOCAD_BENCH_CLOUD_ARTIFACT_ATTEMPTS || 3)),
+)
+const cloudArtifactTimeoutMs = Math.max(
+  5_000,
+  Math.min(60_000, Number(process.env.AUTOCAD_BENCH_CLOUD_ARTIFACT_TIMEOUT_MS || 15_000)),
+)
+const cloudMetadataCache = path.join(
+  os.tmpdir(),
+  `autocad-bench-dashboard-${createHash('sha256')
+    .update(`${cloudBucket}/${cloudPrefix}`)
+    .digest('hex')
+    .slice(0, 16)}`,
+)
+
+const cloudMetadataConcurrency = Math.max(
+  1,
+  Math.min(64, Number(process.env.AUTOCAD_BENCH_CLOUD_METADATA_CONCURRENCY || 24)),
+)
+
+function promoteCloudMetadata(shadowDirectory, destinationDirectory) {
+  if (!fs.existsSync(shadowDirectory)) return
+  const visit = (directory) => {
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+      const source = path.join(directory, entry.name)
+      if (entry.isDirectory()) {
+        visit(source)
+        continue
+      }
+      if (!entry.isFile()) continue
+      const relativePath = path.relative(shadowDirectory, source)
+      const destination = path.resolve(destinationDirectory, relativePath)
+      if (!destination.startsWith(path.resolve(destinationDirectory) + path.sep)) continue
+      if (!shouldPromoteMetadata(source, destination)) continue
+      fs.mkdirSync(path.dirname(destination), { recursive: true })
+      const temporary = `${destination}.cloud-update-${process.pid}-${Date.now()}`
+      try {
+        fs.copyFileSync(source, temporary)
+        fs.renameSync(temporary, destination)
+      } finally {
+        try {
+          if (fs.existsSync(temporary)) fs.unlinkSync(temporary)
+        } catch {
+          // A failed cleanup cannot invalidate a successful atomic promotion.
+        }
+      }
+    }
+  }
+  visit(shadowDirectory)
+}
+
+function wait(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds))
+}
+
+async function cloudMetadataLoader({
+  id,
+  destinationDirectory,
+  relativePaths,
+  maxAgeMs = 0,
+}) {
+  if (!cloudArtifactsEnabled) return
+  const safeRelativePaths = [...new Set(relativePaths)].filter((relativePath) => {
+    if (!relativePath || relativePath.includes('\\')) return false
+    return !relativePath.split('/').some((segment) => !segment || segment === '.' || segment === '..')
+  })
+  if (!safeRelativePaths.length) return
+  const downloadKey = `${id}\0${safeRelativePaths.join('\0')}`
+  const refreshedAt = cloudMetadataFreshAt.get(downloadKey) || 0
+  if (maxAgeMs > 0 && Date.now() - refreshedAt < maxAgeMs) return
+  if (cloudMetadataDownloads.has(downloadKey)) {
+    return cloudMetadataDownloads.get(downloadKey)
+  }
+  const download = (async () => {
+    const pathNamespace = createHash('sha256')
+      .update(safeRelativePaths.join('\0'))
+      .digest('hex')
+      .slice(0, 12)
+    const shadowDirectory = path.resolve(cloudMetadataCache, pathNamespace, id)
+    if (!shadowDirectory.startsWith(path.resolve(cloudMetadataCache) + path.sep)) {
+      throw new Error('Unsafe cloud metadata cache path')
+    }
+    if (
+      maxAgeMs > 0
+      && fs.existsSync(shadowDirectory)
+      && Date.now() - fs.statSync(shadowDirectory).mtimeMs < maxAgeMs
+    ) {
+      cloudMetadataFreshAt.set(downloadKey, Date.now())
+      return
+    }
+    fs.mkdirSync(shadowDirectory, { recursive: true })
+    let nextIndex = 0
+    const errors = []
+    const workers = Array.from({
+      length: Math.min(cloudMetadataConcurrency, safeRelativePaths.length),
+    }, async () => {
+      while (nextIndex < safeRelativePaths.length) {
+        const relativePath = safeRelativePaths[nextIndex]
+        nextIndex += 1
+        const destination = path.resolve(shadowDirectory, relativePath)
+        if (!destination.startsWith(path.resolve(shadowDirectory) + path.sep)) continue
+        const key = [cloudPrefix, id, relativePath]
+          .join('/')
+          .replaceAll('\\', '/')
+          .replace(/\/{2,}/g, '/')
+        try {
+          const object = await s3.send(new GetObjectCommand({
+            Bucket: cloudBucket,
+            Key: key,
+          }))
+          if (!object.Body) continue
+          const bytes = await object.Body.transformToByteArray()
+          fs.mkdirSync(path.dirname(destination), { recursive: true })
+          const temporary = `${destination}.cloud-download-${process.pid}-${Date.now()}`
+          try {
+            fs.writeFileSync(temporary, bytes)
+            fs.renameSync(temporary, destination)
+          } finally {
+            try {
+              if (fs.existsSync(temporary)) fs.unlinkSync(temporary)
+            } catch {
+              // A failed temporary-file cleanup cannot invalidate the cache.
+            }
+          }
+        } catch (error) {
+          const statusCode = error?.$metadata?.httpStatusCode
+          if (statusCode === 404 || ['NoSuchKey', 'NotFound'].includes(error?.name)) continue
+          errors.push(error)
+        }
+      }
+    })
+    await Promise.all(workers)
+    promoteCloudMetadata(shadowDirectory, destinationDirectory)
+    if (errors.length) throw errors[0]
+    const refreshed = new Date()
+    fs.utimesSync(shadowDirectory, refreshed, refreshed)
+    cloudMetadataFreshAt.set(downloadKey, refreshed.valueOf())
+  })()
+  cloudMetadataDownloads.set(downloadKey, download)
+  try {
+    await download
+  } finally {
+    cloudMetadataDownloads.delete(downloadKey)
+  }
+}
+
+async function cloudBenchmarkLoader({ benchmarkId, benchmarkDirectory }) {
+  let state = null
+  try {
+    state = JSON.parse(fs.readFileSync(
+      path.join(benchmarkDirectory, 'batch-state.json'),
+      'utf8',
+    ))
+  } catch {
+    // A new cloud-only benchmark still needs a blocking first bootstrap.
+  }
+  if (!state) {
+    // Fetch the one authoritative suite index directly. Returning as soon as
+    // this file is present makes a cold benchmark visible immediately; the
+    // rollout metadata is hydrated concurrently below.
+    await cloudMetadataLoader({
+      id: benchmarkId,
+      destinationDirectory: benchmarkDirectory,
+      relativePaths: ['batch-state.json'],
+    })
+    try {
+      state = JSON.parse(fs.readFileSync(
+        path.join(benchmarkDirectory, 'batch-state.json'),
+        'utf8',
+      ))
+    } catch {
+      return
+    }
+  }
+  const terminal = !['starting', 'running'].includes(String(state?.state || ''))
+  const refresh = cloudMetadataLoader({
+    id: benchmarkId,
+    destinationDirectory: benchmarkDirectory,
+    relativePaths: benchmarkMetadataPaths(state),
+    maxAgeMs: state ? (terminal ? 5 * 60_000 : 10_000) : 0,
+  })
+  // Benchmark detail is always local-first. The direct metadata GETs continue
+  // in the background and the next 15-second UI refresh promotes the snapshot.
+  void refresh.catch(() => {})
+}
+
+async function cloudTraceLoader({ runId, runDirectory }) {
+  let state = null
+  try {
+    state = JSON.parse(fs.readFileSync(path.join(runDirectory, 'run-state.json'), 'utf8'))
+  } catch {
+    // A not-yet-mirrored rollout should always attempt its first refresh.
+  }
+  const terminal = [
+    'completed', 'recovered', 'budget_exhausted', 'model_failed',
+    'infrastructure_failed', 'artifact_missing', 'interrupted',
+  ].includes(String(state?.state || state?.execution_status || ''))
+  const refresh = cloudMetadataLoader({
+    id: runId,
+    destinationDirectory: runDirectory,
+    relativePaths: traceMetadataPaths(),
+    maxAgeMs: state ? (terminal ? 5 * 60_000 : 5_000) : 0,
+  })
+  if (state) {
+    void refresh.catch(() => {})
+    return
+  }
+  await refresh
+}
+
+async function cloudArtifactLoader({
+  runId,
+  relativePath,
+  artifact,
+  expectedSha256 = null,
+  force = false,
+}) {
+  if (!cloudArtifactsEnabled) return
+  if (!force && fs.existsSync(artifact) && fs.statSync(artifact).isFile()) return
+  if (cloudDownloads.has(artifact)) return cloudDownloads.get(artifact)
+  const download = (async () => {
+    fs.mkdirSync(path.dirname(artifact), { recursive: true })
+    let lastError = null
+    const key = [cloudPrefix, runId, relativePath]
+      .join('/')
+      .replaceAll('\\', '/')
+      .replace(/\/{2,}/g, '/')
+    for (let attempt = 1; attempt <= cloudArtifactAttempts; attempt += 1) {
+      const temporary = `${artifact}.download-${process.pid}-${Date.now()}-${attempt}`
+      try {
+        const awsArguments = [
+          's3', 'cp', `s3://${cloudBucket}/${key}`, temporary,
+          '--only-show-errors',
+        ]
+        if (awsProfile) awsArguments.push('--profile', awsProfile)
+        if (awsRegion) awsArguments.push('--region', awsRegion)
+        await execFileAsync('aws', awsArguments, {
+          timeout: cloudArtifactTimeoutMs,
+          maxBuffer: 1024 * 1024,
+        })
+        if (expectedSha256) {
+          const actualSha256 = createHash('sha256')
+            .update(fs.readFileSync(temporary))
+            .digest('hex')
+          if (actualSha256 !== expectedSha256) {
+            throw new Error(
+              `Cloud artifact checksum mismatch for ${relativePath}: expected ${expectedSha256}, got ${actualSha256}`,
+            )
+          }
+        }
+        fs.renameSync(temporary, artifact)
+        return
+      } catch (error) {
+        lastError = error
+      } finally {
+        try {
+          if (fs.existsSync(temporary)) fs.unlinkSync(temporary)
+        } catch {
+          // A failed cleanup cannot change the artifact response.
+        }
+      }
+      if (attempt < cloudArtifactAttempts) {
+        await wait(150 * attempt * attempt)
+      }
+    }
+    throw lastError || new Error(`Cloud artifact download failed for ${relativePath}`)
+  })()
+  cloudDownloads.set(artifact, download)
+  try {
+    await download
+  } finally {
+    cloudDownloads.delete(artifact)
+  }
+}
+
+async function cloudArtifactUrl({ runId, relativePath }) {
+  if (!cloudArtifactsEnabled) return null
+  const key = [cloudPrefix, runId, relativePath]
+    .join('/')
+    .replaceAll('\\', '/')
+    .replace(/\/{2,}/g, '/')
+  const extension = path.extname(relativePath).toLowerCase()
+  const responseContentType = {
+    '.png': 'image/png',
+    '.json': 'application/json',
+    '.jsonl': 'application/x-ndjson',
+    '.dwg': 'application/acad',
+  }[extension] || 'application/octet-stream'
+  return getSignedUrl(
+    s3,
+    new GetObjectCommand({
+      Bucket: cloudBucket,
+      Key: key,
+      ResponseCacheControl: 'private, max-age=31536000, immutable',
+      ResponseContentType: responseContentType,
+    }),
+    { expiresIn: signedArtifactLifetimeSeconds },
+  )
+}
+
+const api = createTraceApi({
+  cloudArtifactLoader,
+  cloudArtifactUrl,
+  cloudBenchmarkLoader,
+  cloudTraceLoader,
+})
+const host = process.env.HOST || '127.0.0.1'
+const port = Number(process.env.PORT || 4173)
+
+const mime = {
+  '.css': 'text/css; charset=utf-8',
+  '.html': 'text/html; charset=utf-8',
+  '.js': 'text/javascript; charset=utf-8',
+  '.json': 'application/json; charset=utf-8',
+  '.png': 'image/png',
+  '.svg': 'image/svg+xml',
+  '.woff2': 'font/woff2',
+}
+
+http
+  .createServer(async (request, response) => {
+    if (await api(request, response)) return
+    const pathname = decodeURIComponent(new URL(request.url || '/', `http://${host}`).pathname)
+    const requested = path.resolve(dist, pathname.replace(/^\/+/, ''))
+    const safe = requested.startsWith(dist + path.sep) ? requested : null
+    const filePath = safe && fs.existsSync(safe) && fs.statSync(safe).isFile()
+      ? safe
+      : path.join(dist, 'index.html')
+    response.statusCode = 200
+    response.setHeader('Content-Type', mime[path.extname(filePath)] || 'application/octet-stream')
+    fs.createReadStream(filePath).pipe(response)
+  })
+  .listen(port, host, () => {
+    process.stdout.write(`AutoCAD Trace Console: http://${host}:${port}\n`)
+  })

apps/dashboard/src/App.vue

@@ -0,0 +1,722 @@
+<script setup lang="ts">
+import { computed, onBeforeUnmount, onMounted, ref } from 'vue'
+import type {
+  BenchmarkDetail,
+  BenchmarkSummary,
+  BenchmarkTask,
+  EvaluationScoreSummary,
+  FrameArtifact,
+  InputReceipt,
+  ModelTurn,
+  TraceDetail,
+} from './types'
+
+type ExpandedImage = { src: string; label: string }
+type BenchmarkStatusFilter = 'all' | 'live' | 'completed' | 'failed'
+type TaskTypeFilter = 'all' | '2d' | '3d'
+
+const benchmarks = ref<BenchmarkSummary[]>([])
+const selectedBenchmarkId = ref('')
+const benchmark = ref<BenchmarkDetail | null>(null)
+const selectedTaskId = ref('')
+const trace = ref<TraceDetail | null>(null)
+const selectedTurn = ref(0)
+
+const benchmarkQuery = ref('')
+const benchmarkStatus = ref<BenchmarkStatusFilter>('all')
+const benchmarkModel = ref('all')
+const taskQuery = ref('')
+const taskType = ref<TaskTypeFilter>('all')
+const taskLevel = ref('all')
+const taskState = ref('all')
+
+const loading = ref(true)
+const detailLoading = ref(false)
+const traceLoading = ref(false)
+const error = ref('')
+const lastRefresh = ref<Date | null>(null)
+const expandedImage = ref<ExpandedImage | null>(null)
+let refreshTimer: number | undefined
+let refreshInFlight = false
+let benchmarkLoadVersion = 0
+let traceLoadVersion = 0
+let routeSyncVersion = 0
+const imageRetryTimers = new Set<number>()
+const IMAGE_RETRY_LIMIT = 4
+const API_TIMEOUT_MS = 20_000
+
+async function fetchJson<T>(url: string): Promise<T> {
+  const controller = new AbortController()
+  const timeout = window.setTimeout(() => controller.abort(), API_TIMEOUT_MS)
+  try {
+    const response = await fetch(url, {
+      cache: 'no-store',
+      signal: controller.signal,
+    })
+    if (!response.ok) throw new Error(`Request failed (HTTP ${response.status})`)
+    return await response.json() as T
+  } catch (reason) {
+    if (reason instanceof DOMException && reason.name === 'AbortError') {
+      throw new Error('The dashboard request timed out. Retry to refresh the local cloud cache.')
+    }
+    throw reason
+  } finally {
+    window.clearTimeout(timeout)
+  }
+}
+
+const activeStatuses = new Set(['starting', 'resetting', 'handoff_ready', 'running', 'finalizing'])
+
+const modelOptions = computed(() =>
+  [...new Set(benchmarks.value.flatMap((item) => item.models || [item.modelId]))].sort(),
+)
+
+const globalSummary = computed(() => {
+  const totalTasks = benchmarks.value.reduce((sum, item) => sum + item.aggregate.totalTasks, 0)
+  const scoredTasks = benchmarks.value.reduce((sum, item) => sum + item.aggregate.scoredTasks, 0)
+  const weightedScore = benchmarks.value.reduce(
+    (sum, item) => sum + (item.aggregate.meanScore || 0) * item.aggregate.scoredTasks,
+    0,
+  )
+  const visionScoredTasks = benchmarks.value.reduce(
+    (sum, item) => sum + item.aggregate.visionScoredTasks,
+    0,
+  )
+  const visionWeightedScore = benchmarks.value.reduce(
+    (sum, item) => sum
+      + (item.aggregate.visionMeanScore || 0) * item.aggregate.visionScoredTasks,
+    0,
+  )
+  const deterministicScoredTasks = benchmarks.value.reduce(
+    (sum, item) => sum + item.aggregate.deterministicScoredTasks,
+    0,
+  )
+  const deterministicWeightedScore = benchmarks.value.reduce(
+    (sum, item) => sum
+      + (item.aggregate.deterministicMeanScore || 0)
+        * item.aggregate.deterministicScoredTasks,
+    0,
+  )
+  return {
+    suites: benchmarks.value.length,
+    live: benchmarks.value.filter((item) => ['starting', 'running'].includes(item.status)).length,
+    totalTasks,
+    scoredTasks,
+    meanScore: scoredTasks ? weightedScore / scoredTasks : null,
+    visionScoredTasks,
+    visionMeanScore: visionScoredTasks ? visionWeightedScore / visionScoredTasks : null,
+    deterministicScoredTasks,
+    deterministicMeanScore: deterministicScoredTasks
+      ? deterministicWeightedScore / deterministicScoredTasks
+      : null,
+    models: new Set(benchmarks.value.flatMap((item) => item.models || [item.modelId])).size,
+  }
+})
+
+const filteredBenchmarks = computed(() => {
+  const query = benchmarkQuery.value.trim().toLowerCase()
+  return benchmarks.value.filter((item) => {
+    const statusMatches = benchmarkStatus.value === 'all'
+      || (benchmarkStatus.value === 'live' && ['starting', 'running'].includes(item.status))
+      || (benchmarkStatus.value === 'completed' && ['completed', 'completed_with_issues'].includes(item.status))
+      || (benchmarkStatus.value === 'failed' && ['failed', 'interrupted', 'error'].includes(item.status))
+    const modelMatches = benchmarkModel.value === 'all'
+      || (item.models || [item.modelId]).includes(benchmarkModel.value)
+    const queryMatches = !query || [
+      item.name,
+      item.batchId,
+      item.modelId,
+      item.provider,
+      ...(item.models || []),
+    ].some((value) => String(value || '').toLowerCase().includes(query))
+    return statusMatches && modelMatches && queryMatches
+  })
+})
+
+const selectedTask = computed(() =>
+  benchmark.value?.tasks.find((task) => task.taskId === selectedTaskId.value) || null,
+)
+
+const taskLevelOptions = computed(() =>
+  [...new Set(benchmark.value?.tasks.map((task) => task.level) || [])].sort(),
+)
+
+const taskStateOptions = computed(() =>
+  [...new Set(benchmark.value?.tasks.map((task) => task.status) || [])].sort(),
+)
+
+const filteredTasks = computed(() => {
+  const query = taskQuery.value.trim().toLowerCase()
+  return (benchmark.value?.tasks || []).filter((task) => {
+    const queryMatches = !query || [
+      task.taskId,
+      task.displayName,
+      task.modelId,
+      task.provider,
+    ].some((value) => value.toLowerCase().includes(query))
+    return queryMatches
+      && (taskType.value === 'all' || task.drawingType === taskType.value)
+      && (taskLevel.value === 'all' || task.level === taskLevel.value)
+      && (taskState.value === 'all' || task.status === taskState.value)
+  })
+})
+
+const currentTurn = computed<ModelTurn | null>(() =>
+  trace.value?.turns[selectedTurn.value] || null,
+)
+
+const currentReceipts = computed<InputReceipt[]>(() => {
+  const toolUseId = currentTurn.value?.tool_use_id
+  const receipts = trace.value?.receipts || []
+  if (toolUseId && receipts.some((receipt) => receipt.tool_use_id)) {
+    return receipts.filter((receipt) => receipt.tool_use_id === toolUseId)
+  }
+  const legacy = receipts.find((receipt) => receipt.action_index === selectedTurn.value + 1)
+  return legacy ? [legacy] : []
+})
+
+const currentActions = computed<Record<string, unknown>[]>(() => {
+  const payload = currentTurn.value?.action
+  if (Array.isArray(payload?.actions)) {
+    return payload.actions.filter(
+      (action): action is Record<string, unknown> => Boolean(action) && typeof action === 'object',
+    )
+  }
+  return payload ? [payload] : []
+})
+
+function frameAt(sequence: number): FrameArtifact | null {
+  const name = `frame_${String(sequence).padStart(4, '0')}.png`
+  return trace.value?.frames.find((frame) => frame.name === name) || null
+}
+
+const latestFrame = computed(() => trace.value?.frames.at(-1) || null)
+
+const turnInputFrame = computed(() => {
+  const match = JSON.stringify(currentTurn.value?.model_input || {}).match(/frames\/frame_(\d+)\.png/)
+  if (match) return frameAt(Number(match[1]))
+  const actionIndex = currentReceipts.value[0]?.action_index
+  return actionIndex != null ? frameAt(actionIndex - 1) : null
+})
+
+const turnOutputFrame = computed(() => {
+  const receipt = currentReceipts.value.at(-1)
+  if (receipt) return frameAt(receipt.action_index)
+  const nextTurn = trace.value?.turns[selectedTurn.value + 1]
+  const match = JSON.stringify(nextTurn?.model_input || {}).match(/frames\/frame_(\d+)\.png/)
+  return match ? frameAt(Number(match[1])) : latestFrame.value
+})
+
+function formatDate(value: string | null): string {
+  if (!value) return 'Unknown date'
+  const date = new Date(value)
+  return Number.isNaN(date.valueOf())
+    ? value
+    : new Intl.DateTimeFormat(undefined, {
+        month: 'short',
+        day: 'numeric',
+        year: 'numeric',
+        hour: 'numeric',
+        minute: '2-digit',
+      }).format(date)
+}
+
+function formatDuration(seconds: number | null): string {
+  if (seconds == null) return '—'
+  if (seconds < 60) return `${Math.round(seconds)}s`
+  const hours = Math.floor(seconds / 3600)
+  const minutes = Math.floor((seconds % 3600) / 60)
+  return hours ? `${hours}h ${minutes}m` : `${minutes}m ${Math.round(seconds % 60)}s`
+}
+
+function formatCost(value: number | null): string {
+  if (value == null) return '—'
+  return new Intl.NumberFormat(undefined, {
+    style: 'currency',
+    currency: 'USD',
+    minimumFractionDigits: value < 1 ? 3 : 2,
+    maximumFractionDigits: value < 1 ? 3 : 2,
+  }).format(value)
+}
+
+function formatNumber(value: number): string {
+  return new Intl.NumberFormat().format(value)
+}
+
+function formatScore(score: number | null): string {
+  return score == null ? '—' : (score * 100).toFixed(1)
+}
+
+function readable(value: string): string {
+  return value.replaceAll('_', ' ')
+}
+
+function benchmarkProgress(item: BenchmarkSummary): number {
+  if (!item.aggregate.totalTasks) return 0
+  const settled = item.aggregate.settledTasks
+  return Math.max(0, Math.min(100, settled / item.aggregate.totalTasks * 100))
+}
+
+function stateTone(value: string): string {
+  if (['target_acquired', 'scored', 'completed', 'recovered'].includes(value)) return 'positive'
+  if (['mostly_acquired', 'awaiting_score', 'partial', 'budget_exhausted', 'completed_with_issues'].includes(value)) return 'warning'
+  if (['not_acquired', 'candidate_invalid', 'evaluation_failed', 'evaluation_interrupted', 'run_failed', 'model_failed', 'infrastructure_failed', 'artifact_missing', 'failed', 'error', 'interrupted', 'no_artifact'].includes(value)) return 'negative'
+  if (['running', 'evaluating', 'evaluation_retrying', 'starting', 'resetting', 'handoff_ready', 'finalizing'].includes(value)) return 'live'
+  return 'neutral'
+}
+
+function taskOutcome(task: BenchmarkTask): string {
+  return task.verdict ? readable(task.verdict) : readable(task.evaluationState)
+}
+
+function scoreSourceLabel(task: BenchmarkTask): string {
+  if (task.scoreSource === 'vision_judge') return 'Vision judge'
+  if (task.scoreSource === 'deterministic') return 'Deterministic'
+  if (task.evaluationState === 'evaluating') return readable(task.evaluationStage || 'evaluating')
+  if (task.evaluationState === 'evaluation_failed') return 'Automatic evaluation failed'
+  if (task.evaluationState === 'evaluation_interrupted') return 'Automatic evaluation interrupted'
+  if (task.evaluationState === 'evaluation_retrying') return 'Vision judge retry queued'
+  if (task.evaluationState === 'candidate_invalid') return 'Invalid saved DWG'
+  return 'Not scored'
+}
+
+function judgeResultLabel(score: EvaluationScoreSummary | null): string {
+  if (!score) return 'Not available'
+  if (score.valid === false) return readable(score.failureReason || 'invalid candidate')
+  if (score.verdict) return readable(score.verdict)
+  return score.score != null ? 'Valid diagnostic' : 'Not scored'
+}
+
+function judgeResultTone(score: EvaluationScoreSummary | null): string {
+  if (!score) return 'neutral'
+  if (score.valid === false) return 'negative'
+  return stateTone(score.verdict || (score.score != null ? 'scored' : 'neutral'))
+}
+
+function resetTaskFilters() {
+  taskQuery.value = ''
+  taskType.value = 'all'
+  taskLevel.value = 'all'
+  taskState.value = 'all'
+}
+
+function updateHash() {
+  const params = new URLSearchParams()
+  if (selectedBenchmarkId.value) params.set('benchmark', selectedBenchmarkId.value)
+  if (selectedTaskId.value) params.set('task', selectedTaskId.value)
+  window.history.replaceState(null, '', params.size ? `#${params.toString()}` : window.location.pathname)
+}
+
+async function loadBenchmarks(silent = false) {
+  if (!silent) loading.value = true
+  try {
+    const payload = await fetchJson<{ benchmarks: BenchmarkSummary[] }>('/api/benchmarks')
+    benchmarks.value = payload.benchmarks
+    lastRefresh.value = new Date()
+    error.value = ''
+  } catch (reason) {
+    error.value = reason instanceof Error ? reason.message : String(reason)
+  } finally {
+    loading.value = false
+  }
+}
+
+async function loadBenchmark(id: string, silent = false) {
+  const requestVersion = ++benchmarkLoadVersion
+  if (!id) {
+    benchmark.value = null
+    return
+  }
+  if (!silent) detailLoading.value = true
+  try {
+    const payload = await fetchJson<BenchmarkDetail>(
+      `/api/benchmarks/${encodeURIComponent(id)}`,
+    )
+    if (requestVersion !== benchmarkLoadVersion || selectedBenchmarkId.value !== id) return
+    benchmark.value = payload
+    error.value = ''
+  } catch (reason) {
+    if (requestVersion !== benchmarkLoadVersion || selectedBenchmarkId.value !== id) return
+    error.value = reason instanceof Error ? reason.message : String(reason)
+  } finally {
+    if (requestVersion === benchmarkLoadVersion) detailLoading.value = false
+  }
+}
+
+async function loadTrace(runId: string, silent = false) {
+  const requestVersion = ++traceLoadVersion
+  if (!runId) {
+    trace.value = null
+    return
+  }
+  if (!silent) traceLoading.value = true
+  try {
+    const payload = await fetchJson<TraceDetail>(`/api/runs/${encodeURIComponent(runId)}`)
+    if (requestVersion !== traceLoadVersion || selectedTask.value?.runId !== runId) return
+    trace.value = payload
+    selectedTurn.value = Math.min(selectedTurn.value, Math.max(0, trace.value.turns.length - 1))
+    error.value = ''
+  } catch (reason) {
+    if (requestVersion !== traceLoadVersion || selectedTask.value?.runId !== runId) return
+    trace.value = null
+    error.value = reason instanceof Error ? reason.message : String(reason)
+  } finally {
+    if (requestVersion === traceLoadVersion) traceLoading.value = false
+  }
+}
+
+async function syncRouteFromHash(force = false) {
+  const requestVersion = ++routeSyncVersion
+  const hash = new URLSearchParams(window.location.hash.replace(/^#/, ''))
+  const nextBenchmarkId = hash.get('benchmark') || ''
+  const nextTaskId = hash.get('task') || ''
+  const benchmarkChanged = nextBenchmarkId !== selectedBenchmarkId.value
+  const taskChanged = nextTaskId !== selectedTaskId.value
+
+  if (!force && !benchmarkChanged && !taskChanged) return
+
+  selectedBenchmarkId.value = nextBenchmarkId
+  selectedTaskId.value = nextTaskId
+  selectedTurn.value = 0
+  trace.value = null
+  if (benchmarkChanged) {
+    benchmark.value = null
+    resetTaskFilters()
+  }
+
+  if (!nextBenchmarkId) return
+  if (benchmarkChanged || force || !benchmark.value) await loadBenchmark(nextBenchmarkId)
+  if (requestVersion !== routeSyncVersion) return
+
+  const task = selectedTask.value
+  if (task && task.status !== 'queued') await loadTrace(task.runId)
+}
+
+function onHashChange() {
+  void syncRouteFromHash()
+}
+
+async function openBenchmark(id: string) {
+  selectedBenchmarkId.value = id
+  selectedTaskId.value = ''
+  benchmark.value = null
+  trace.value = null
+  resetTaskFilters()
+  updateHash()
+  await loadBenchmark(id)
+  window.scrollTo({ top: 0, behavior: 'smooth' })
+}
+
+function closeBenchmark() {
+  selectedBenchmarkId.value = ''
+  selectedTaskId.value = ''
+  benchmark.value = null
+  trace.value = null
+  updateHash()
+  requestAnimationFrame(() => window.scrollTo({ top: 0, behavior: 'smooth' }))
+}
+
+async function openTask(task: BenchmarkTask) {
+  if (task.status === 'queued') return
+  selectedTaskId.value = task.taskId
+  selectedTurn.value = 0
+  trace.value = null
+  updateHash()
+  await loadTrace(task.runId)
+  requestAnimationFrame(() => document.querySelector('#task-inspector')?.scrollIntoView({
+    behavior: 'smooth',
+    block: 'start',
+  }))
+}
+
+function closeTask() {
+  selectedTaskId.value = ''
+  trace.value = null
+  updateHash()
+}
+
+function chooseTurn(index: number) {
+  selectedTurn.value = Math.max(0, Math.min(index, Math.max(0, (trace.value?.turns.length || 1) - 1)))
+}
+
+function openImage(src: string | null | undefined, label: string) {
+  if (src) expandedImage.value = { src, label }
+}
+
+function artifactImageLoaded(event: Event) {
+  const image = event.currentTarget as HTMLImageElement
+  image.dataset.retryAttempts = '0'
+  image.dataset.loadState = 'loaded'
+}
+
+function retryArtifactImage(event: Event) {
+  const image = event.currentTarget as HTMLImageElement
+  const source = image.dataset.source || image.getAttribute('src') || ''
+  const attempts = Number(image.dataset.retryAttempts || 0)
+  if (!source || attempts >= IMAGE_RETRY_LIMIT) {
+    image.dataset.loadState = 'failed'
+    return
+  }
+  const nextAttempt = attempts + 1
+  image.dataset.retryAttempts = String(nextAttempt)
+  image.dataset.loadState = 'retrying'
+  const retryDelay = Math.min(2_000, 200 * 2 ** (nextAttempt - 1))
+  const timer = window.setTimeout(() => {
+    imageRetryTimers.delete(timer)
+    const retryUrl = new URL(source, window.location.origin)
+    retryUrl.searchParams.set('_image_retry', `${nextAttempt}-${Date.now()}`)
+    image.src = retryUrl.toString()
+  }, retryDelay)
+  imageRetryTimers.add(timer)
+}
+
+async function refresh() {
+  if (refreshInFlight || document.hidden) return
+  refreshInFlight = true
+  try {
+    await loadBenchmarks(true)
+    if (selectedBenchmarkId.value) await loadBenchmark(selectedBenchmarkId.value, true)
+    const task = selectedTask.value
+    if (task && (
+      activeStatuses.has(task.status) || task.evaluationState === 'evaluating'
+    )) {
+      await loadTrace(task.runId, true)
+    }
+  } finally {
+    refreshInFlight = false
+  }
+}
+
+function onKeydown(event: KeyboardEvent) {
+  if (event.key === 'Escape') {
+    if (expandedImage.value) expandedImage.value = null
+    else if (selectedTaskId.value) closeTask()
+    return
+  }
+  if (expandedImage.value) return
+  if (event.target instanceof HTMLInputElement || event.target instanceof HTMLSelectElement) return
+  if (event.key === 'ArrowLeft') chooseTurn(selectedTurn.value - 1)
+  if (event.key === 'ArrowRight') chooseTurn(selectedTurn.value + 1)
+}
+
+onMounted(async () => {
+  window.addEventListener('hashchange', onHashChange)
+  window.addEventListener('keydown', onKeydown)
+  await Promise.all([
+    loadBenchmarks(),
+    syncRouteFromHash(true),
+  ])
+  refreshTimer = window.setInterval(refresh, 15_000)
+})
+
+onBeforeUnmount(() => {
+  if (refreshTimer) window.clearInterval(refreshTimer)
+  for (const timer of imageRetryTimers) window.clearTimeout(timer)
+  imageRetryTimers.clear()
+  window.removeEventListener('hashchange', onHashChange)
+  window.removeEventListener('keydown', onKeydown)
+})
+</script>
+
+<template>
+  <div class="app">
+    <header class="app-header">
+      <button class="brand" type="button" @click="closeBenchmark">
+        <span class="brand-cube" aria-hidden="true"><i></i><i></i><i></i></span>
+        <span>
+          <strong>AutoCAD Bench</strong>
+          <small>Model evaluation registry</small>
+        </span>
+      </button>
+      <div class="header-actions">
+        <span v-if="globalSummary.live" class="live-indicator"><i></i>{{ globalSummary.live }} live</span>
+        <span class="refresh-time">Updated {{ lastRefresh ? formatDate(lastRefresh.toISOString()) : '—' }}</span>
+        <button class="icon-button" type="button" title="Refresh benchmark data" @click="refresh">↻</button>
+      </div>
+    </header>
+
+    <main class="page">
+      <div v-if="error" class="error-banner">{{ error }}</div>
+
+      <template v-if="!selectedBenchmarkId">
+        <section class="page-heading">
+          <div>
+            <p class="kicker">BENCHMARK HISTORY</p>
+            <h1>Every AutoCAD evaluation,<br><span>in one place.</span></h1>
+            <p class="heading-copy">
+              Follow live suites, compare model outcomes, and inspect any task without switching between benchmark and rollout views.
+            </p>
+          </div>
+          <div class="corpus-badge">
+            <span>Current corpus</span>
+            <strong>65 tasks</strong>
+            <small>34 2D · 31 3D</small>
+          </div>
+        </section>
+
+        <section class="overview-grid" aria-label="Benchmark totals">
+          <article><span>Benchmark suites</span><strong>{{ globalSummary.suites }}</strong><small>{{ globalSummary.live ? `${globalSummary.live} currently live` : 'No active suites' }}</small></article>
+          <article><span>Task attempts</span><strong>{{ formatNumber(globalSummary.totalTasks) }}</strong><small>Across every recorded suite</small></article>
+          <article><span>Scored results</span><strong>{{ formatNumber(globalSummary.scoredTasks) }}</strong><small>{{ globalSummary.totalTasks ? Math.round(globalSummary.scoredTasks / globalSummary.totalTasks * 100) : 0 }}% evaluation coverage</small></article>
+          <article class="score-overview vision-score"><span>Vision mean</span><strong>{{ formatScore(globalSummary.visionMeanScore) }}<small v-if="globalSummary.visionMeanScore != null">/100</small></strong><small>{{ globalSummary.visionScoredTasks }} vision judgments</small></article>
+          <article class="score-overview deterministic-score"><span>Deterministic mean</span><strong>{{ formatScore(globalSummary.deterministicMeanScore) }}<small v-if="globalSummary.deterministicMeanScore != null">/100</small></strong><small>{{ globalSummary.deterministicScoredTasks }} diagnostics</small></article>
+          <article><span>Models evaluated</span><strong>{{ globalSummary.models }}</strong><small>Unique provider model IDs</small></article>
+        </section>
+
+        <section class="registry-panel">
+          <div class="registry-heading">
+            <div><p class="kicker">ALL RUNS</p><h2>Benchmark registry</h2></div>
+            <span>{{ filteredBenchmarks.length }} of {{ benchmarks.length }} suites</span>
+          </div>
+          <div class="filter-bar">
+            <label class="search-field"><span>Search</span><input v-model="benchmarkQuery" type="search" placeholder="Name, model, provider, batch ID…" /></label>
+            <label><span>Status</span><select v-model="benchmarkStatus"><option value="all">All statuses</option><option value="live">Live</option><option value="completed">Completed</option><option value="failed">Failed / interrupted</option></select></label>
+            <label><span>Model</span><select v-model="benchmarkModel"><option value="all">All models</option><option v-for="model in modelOptions" :key="model" :value="model">{{ model }}</option></select></label>
+          </div>
+          <div v-if="loading" class="empty-panel">Loading benchmark history…</div>
+          <div v-else-if="!filteredBenchmarks.length" class="empty-panel"><strong>No matching benchmarks</strong><span>Clear the filters to see the complete history.</span></div>
+          <div v-else class="benchmark-list">
+            <button v-for="item in filteredBenchmarks" :key="item.id" type="button" class="benchmark-row" @click="openBenchmark(item.id)">
+              <span class="row-status" :class="stateTone(item.status)"><i></i>{{ readable(item.status) }}</span>
+              <span class="row-identity"><strong>{{ item.name }}</strong><small>{{ item.modelId }} · {{ item.provider }} · {{ formatDate(item.startedAt || item.updatedAt) }}</small></span>
+              <span class="row-progress"><span><strong>{{ item.aggregate.settledTasks }}</strong>/{{ item.aggregate.totalTasks }} settled</span><i><b :style="{ width: `${benchmarkProgress(item)}%` }"></b></i></span>
+              <span class="row-result row-vision-score"><strong>{{ formatScore(item.aggregate.visionMeanScore) }}</strong><small>Vision · {{ item.aggregate.visionScoredTasks }} judged</small></span>
+              <span class="row-result row-deterministic-score"><strong>{{ formatScore(item.aggregate.deterministicMeanScore) }}</strong><small>Deterministic · {{ item.aggregate.deterministicScoredTasks }}</small></span>
+              <span class="row-coverage"><strong>{{ item.aggregate.evaluationStates?.evaluating || item.aggregate.evaluationStates?.awaiting_score || 0 }}</strong><small>{{ item.aggregate.evaluationStates?.evaluating ? 'evaluating now' : 'awaiting score' }}</small></span>
+              <span class="row-cost"><strong>{{ formatCost(item.aggregate.usage.apiCost) }}</strong><small>model spend</small></span>
+              <span class="row-arrow">→</span>
+            </button>
+          </div>
+        </section>
+      </template>
+
+      <template v-else>
+        <button class="back-button" type="button" @click="closeBenchmark">← All benchmarks</button>
+        <section v-if="detailLoading && !benchmark" class="empty-panel">Loading benchmark…</section>
+        <section v-else-if="!benchmark" class="empty-panel"><strong>Benchmark unavailable</strong><span>{{ error || 'The benchmark metadata could not be loaded.' }}</span><button type="button" @click="loadBenchmark(selectedBenchmarkId)">Retry</button></section>
+        <template v-else-if="benchmark">
+          <section class="detail-heading">
+            <div><div class="detail-meta"><span class="status-chip" :class="stateTone(benchmark.status)"><i></i>{{ readable(benchmark.status) }}</span><span>{{ formatDate(benchmark.startedAt) }}</span><span v-if="benchmark.batchId">{{ benchmark.batchId }}</span></div><h1>{{ benchmark.name }}</h1><p>{{ benchmark.modelId }} · {{ benchmark.provider }} · up to {{ benchmark.maxConcurrency || '—' }} concurrent desktops</p></div>
+            <div class="detail-score-pair">
+              <div class="vision-score"><span>Vision mean · official</span><strong>{{ formatScore(benchmark.aggregate.visionMeanScore) }}</strong><small>{{ benchmark.aggregate.visionScoredTasks }}/{{ benchmark.aggregate.totalTasks }} judged</small></div>
+              <div class="deterministic-score"><span>Deterministic mean</span><strong>{{ formatScore(benchmark.aggregate.deterministicMeanScore) }}</strong><small>{{ benchmark.aggregate.deterministicScoredTasks }}/{{ benchmark.aggregate.totalTasks }} diagnostics</small></div>
+            </div>
+          </section>
+
+          <section class="detail-metrics">
+            <article><span>Suite progress</span><strong>{{ benchmark.aggregate.settledTasks }}/{{ benchmark.aggregate.totalTasks }}</strong><small>{{ benchmark.aggregate.activeTasks }} active · {{ benchmark.aggregate.queuedTasks }} queued</small></article>
+            <article><span>Artifacts</span><strong>{{ benchmark.aggregate.artifactTasks }}</strong><small>{{ benchmark.aggregate.evaluationStates.evaluating || 0 }} evaluating · {{ benchmark.aggregate.evaluationStates.awaiting_score || 0 }} waiting</small></article>
+            <article><span>Acquired targets</span><strong>{{ benchmark.aggregate.verdicts.target_acquired || 0 }}</strong><small>{{ benchmark.aggregate.verdicts.mostly_acquired || 0 }} mostly acquired</small></article>
+            <article><span>Execution issues</span><strong>{{ benchmark.aggregate.failedTasks + benchmark.aggregate.infrastructureFailedTasks + benchmark.aggregate.artifactMissingTasks }}</strong><small>{{ benchmark.aggregate.failedTasks }} model · {{ benchmark.aggregate.infrastructureFailedTasks }} infrastructure · {{ benchmark.aggregate.artifactMissingTasks }} artifact</small></article>
+            <article><span>Actions</span><strong>{{ formatNumber(benchmark.aggregate.acceptedActions) }}</strong><small>{{ benchmark.aggregate.invalidActions }} rejected</small></article>
+            <article><span>Model spend</span><strong>{{ formatCost(benchmark.aggregate.usage.apiCost) }}</strong><small>{{ formatNumber(benchmark.aggregate.usage.totalTokens) }} tokens</small></article>
+          </section>
+
+          <section class="coverage-strip" aria-label="Evaluation result states">
+            <div><span>Execution outcomes</span><strong>{{ benchmark.aggregate.settledTasks }} settled</strong></div>
+            <span v-for="(count, state) in benchmark.aggregate.executionStates" :key="`execution-${state}`" class="coverage-chip" :class="stateTone(String(state))">{{ count }} {{ readable(String(state)) }}</span>
+          </section>
+
+          <section class="coverage-strip" aria-label="Evaluation result states">
+            <div><span>Evaluation coverage</span><strong>{{ benchmark.aggregate.scoredTasks }} scored</strong></div>
+            <span class="coverage-chip positive">{{ benchmark.aggregate.visionScoredTasks }} vision judged</span>
+            <span class="coverage-chip neutral">{{ benchmark.aggregate.deterministicScoredTasks }} deterministic</span>
+            <span v-for="(count, state) in benchmark.aggregate.evaluationStates" :key="state" class="coverage-chip" :class="stateTone(String(state))">{{ count }} {{ readable(String(state)) }}</span>
+            <span class="corpus-split">{{ benchmark.aggregate.drawingTypes['2d']?.total || 0 }} 2D · {{ benchmark.aggregate.drawingTypes['3d']?.total || 0 }} 3D</span>
+          </section>
+
+          <section class="task-panel">
+            <div class="registry-heading"><div><p class="kicker">TASK RESULTS</p><h2>All attempts</h2></div><span>{{ filteredTasks.length }} of {{ benchmark.tasks.length }} tasks</span></div>
+            <div class="filter-bar task-filters">
+              <label class="search-field"><span>Find task</span><input v-model="taskQuery" type="search" placeholder="Task ID or model…" /></label>
+              <label><span>Type</span><select v-model="taskType"><option value="all">2D + 3D</option><option value="2d">2D only</option><option value="3d">3D only</option></select></label>
+              <label><span>Level</span><select v-model="taskLevel"><option value="all">All levels</option><option v-for="level in taskLevelOptions" :key="level" :value="level">{{ readable(level) }}</option></select></label>
+              <label><span>Result</span><select v-model="taskState"><option value="all">All results</option><option v-for="state in taskStateOptions" :key="state" :value="state">{{ readable(state) }}</option></select></label>
+            </div>
+
+            <div class="task-table-head"><span>Task</span><span>Run state</span><span>Outcome</span><span>Vision score</span><span>Deterministic score</span><span>Official components</span><span>Actions</span><span>Time</span><span>Cost</span><span></span></div>
+            <div class="task-list">
+              <button v-for="task in filteredTasks" :key="task.rolloutId" type="button" class="task-row" :class="{ selected: task.taskId === selectedTaskId, disabled: task.status === 'queued' }" :disabled="task.status === 'queued'" @click="openTask(task)">
+                <span class="task-identity"><strong>{{ task.taskId }}</strong><small><b>{{ task.drawingType.toUpperCase() }}</b> {{ readable(task.level) }} · {{ task.split }}</small></span>
+                <span><em class="state-dot" :class="stateTone(task.status)"></em>{{ readable(task.status) }}</span>
+                <span><strong class="outcome" :class="stateTone(task.verdict || task.evaluationState)">{{ taskOutcome(task) }}</strong><small>{{ scoreSourceLabel(task) }}</small></span>
+                <span class="numeric-score vision-score">{{ formatScore(task.visionScore?.score ?? null) }}</span>
+                <span class="numeric-score deterministic-score">{{ formatScore(task.deterministicScore?.score ?? null) }}</span>
+                <span class="component-mini"><small v-if="task.geometrySimilarity != null">G {{ formatScore(task.geometrySimilarity) }}</small><small v-if="task.dimensionSimilarity != null">D {{ formatScore(task.dimensionSimilarity) }}</small><small v-if="task.geometrySimilarity == null">—</small></span>
+                <span>{{ formatNumber(task.acceptedActions) }}</span><span>{{ formatDuration(task.rolloutElapsedSeconds ?? task.elapsedSeconds) }}</span><span>{{ formatCost(task.usage.apiCost) }}</span><span class="row-arrow">→</span>
+              </button>
+            </div>
+          </section>
+
+          <section v-if="selectedTask" id="task-inspector" class="inspector-panel">
+            <header class="inspector-heading">
+              <div><p class="kicker">TASK INSPECTOR</p><h2>{{ selectedTask.taskId }}</h2><p>{{ selectedTask.modelId }} · {{ selectedTask.provider }} · {{ selectedTask.drawingType.toUpperCase() }} {{ selectedTask.level }}</p></div>
+              <div class="inspector-actions"><a v-if="trace?.artifacts.dwg" class="button secondary" :href="trace.artifacts.dwg">Download DWG</a><button class="icon-button" type="button" title="Close task inspector" @click="closeTask">×</button></div>
+            </header>
+
+            <div class="judge-results">
+              <section class="judge-result vision-result">
+                <header><div><span>Vision judge</span><strong>Official result</strong></div><div class="judge-total"><strong>{{ formatScore(selectedTask.visionScore?.score ?? null) }}</strong><small>/100</small></div></header>
+                <div v-if="selectedTask.visionScore" class="judge-result-body">
+                  <p :class="judgeResultTone(selectedTask.visionScore)">{{ judgeResultLabel(selectedTask.visionScore) }}</p>
+                  <div class="judge-components">
+                    <div><span>Geometry</span><strong>{{ formatScore(selectedTask.visionScore.geometry) }}</strong></div>
+                    <div><span>Dimensions</span><strong>{{ formatScore(selectedTask.visionScore.dimensions) }}</strong></div>
+                    <div><span>Annotations</span><strong>{{ formatScore(selectedTask.visionScore.annotations) }}</strong></div>
+                    <div><span>Presentation</span><strong>{{ formatScore(selectedTask.visionScore.presentation) }}</strong></div>
+                  </div>
+                  <small>{{ selectedTask.visionScore.confidence != null ? `${Math.round(selectedTask.visionScore.confidence * 100)}% confidence` : 'No confidence value' }}<template v-if="selectedTask.visionScore.needsHumanReview"> · human review flagged</template></small>
+                </div>
+                <div v-else class="judge-unavailable">No completed vision judgment</div>
+              </section>
+
+              <section class="judge-result deterministic-result">
+                <header><div><span>Deterministic scorer</span><strong>Diagnostic result</strong></div><div class="judge-total"><strong>{{ formatScore(selectedTask.deterministicScore?.score ?? null) }}</strong><small>/100</small></div></header>
+                <div v-if="selectedTask.deterministicScore" class="judge-result-body">
+                  <p :class="judgeResultTone(selectedTask.deterministicScore)">{{ judgeResultLabel(selectedTask.deterministicScore) }}</p>
+                  <div class="judge-components">
+                    <div><span>Geometry</span><strong>{{ formatScore(selectedTask.deterministicScore.geometry) }}</strong></div>
+                    <div><span>Dimensions</span><strong>{{ formatScore(selectedTask.deterministicScore.dimensions) }}</strong></div>
+                    <div><span>Annotations</span><strong>{{ formatScore(selectedTask.deterministicScore.annotations) }}</strong></div>
+                    <div><span>Visual</span><strong>{{ formatScore(selectedTask.deterministicScore.presentation) }}</strong></div>
+                  </div>
+                  <small>{{ selectedTask.deterministicScore.method || 'Unknown deterministic method' }}</small>
+                </div>
+                <div v-else class="judge-unavailable">No deterministic diagnostic</div>
+              </section>
+            </div>
+
+            <div v-if="traceLoading" class="empty-panel">Loading task artifacts…</div>
+            <template v-else-if="trace">
+              <div class="artifact-grid">
+                <figure><figcaption><span>Reference target</span><small>Task authority</small></figcaption><button type="button" @click="openImage(trace.referenceUrl, 'Reference target')"><img :src="trace.referenceUrl" :data-source="trace.referenceUrl" alt="Reference drawing" loading="eager" decoding="async" fetchpriority="high" @load="artifactImageLoaded" @error="retryArtifactImage" /></button></figure>
+                <figure><figcaption><span>Saved candidate</span><small>{{ trace.artifacts.candidateRender ? 'Trusted evaluator render' : 'Final desktop frame' }}</small></figcaption><button v-if="trace.artifacts.candidateRender" type="button" @click="openImage(trace.artifacts.candidateRender, 'Saved candidate render')"><img :src="trace.artifacts.candidateRender" :data-source="trace.artifacts.candidateRender" alt="Candidate DWG render" loading="eager" decoding="async" fetchpriority="high" @load="artifactImageLoaded" @error="retryArtifactImage" /></button><button v-else-if="latestFrame" type="button" @click="openImage(latestFrame.url, 'Final desktop frame')"><img :src="latestFrame.url" :data-source="latestFrame.url" alt="Final desktop frame" loading="eager" decoding="async" fetchpriority="high" @load="artifactImageLoaded" @error="retryArtifactImage" /></button><div v-else class="artifact-missing">No candidate render or frame yet</div></figure>
+                <figure v-if="trace.artifacts.diffRender"><figcaption><span>Deterministic diff</span><small>Diagnostic only</small></figcaption><button type="button" @click="openImage(trace.artifacts.diffRender, 'Deterministic diff')"><img :src="trace.artifacts.diffRender" :data-source="trace.artifacts.diffRender" alt="Candidate and gold diff" loading="eager" decoding="async" @load="artifactImageLoaded" @error="retryArtifactImage" /></button></figure>
+              </div>
+
+              <section v-if="trace.turns.length" class="trace-section">
+                <header><div><p class="kicker">MODEL TRACE</p><h3>Turn {{ selectedTurn + 1 }} of {{ trace.turns.length }}</h3></div><div class="turn-controls"><button type="button" :disabled="selectedTurn === 0" @click="chooseTurn(selectedTurn - 1)">←</button><select v-model.number="selectedTurn"><option v-for="(turn, index) in trace.turns" :key="turn.tool_use_id || index" :value="index">Turn {{ index + 1 }} · {{ Array.isArray(turn.action?.actions) ? turn.action.actions.length : 1 }} action(s)</option></select><button type="button" :disabled="selectedTurn >= trace.turns.length - 1" @click="chooseTurn(selectedTurn + 1)">→</button></div></header>
+                <div class="turn-frame-grid">
+                  <figure><figcaption><span>Frame shown to model</span><small v-if="turnInputFrame">{{ turnInputFrame.name }}</small></figcaption><button v-if="turnInputFrame" :key="turnInputFrame.url" type="button" @click="openImage(turnInputFrame.url, 'Frame shown to model')"><img :src="turnInputFrame.url" :data-source="turnInputFrame.url" alt="Desktop frame shown to model" loading="eager" decoding="async" @load="artifactImageLoaded" @error="retryArtifactImage" /></button><div v-else class="artifact-missing">Frame unavailable</div></figure>
+                  <figure><figcaption><span>Final frame after batch</span><small v-if="turnOutputFrame">{{ turnOutputFrame.name }}</small></figcaption><button v-if="turnOutputFrame" :key="turnOutputFrame.url" type="button" @click="openImage(turnOutputFrame.url, 'Final frame after batch')"><img :src="turnOutputFrame.url" :data-source="turnOutputFrame.url" alt="Final desktop frame after action batch" loading="eager" decoding="async" @load="artifactImageLoaded" @error="retryArtifactImage" /></button><div v-else class="artifact-missing">Frame unavailable</div></figure>
+                </div>
+                <div class="action-list"><article v-for="(action, index) in currentActions" :key="index"><span>{{ index + 1 }}</span><div><strong>{{ readable(String(action.action || 'unknown')) }}</strong><p>{{ String(action.intent || 'No intent recorded') }}</p></div><code>{{ Object.fromEntries(Object.entries(action).filter(([key]) => !['action', 'intent'].includes(key))) }}</code></article></div>
+                <details class="raw-details"><summary>Raw turn, both scores, and controller receipts</summary><div><pre>{{ JSON.stringify(currentTurn, null, 2) }}</pre><pre>{{ JSON.stringify(currentReceipts, null, 2) }}</pre><pre>{{ JSON.stringify(trace.scores, null, 2) }}</pre></div></details>
+              </section>
+              <div v-else class="empty-panel">
+                {{ trace.traceNotice || 'No model turns were recorded for this task.' }}
+              </div>
+            </template>
+            <div v-else class="empty-panel"><strong>No trace directory is available</strong><span>The batch row exists, but its rollout never produced inspectable artifacts.</span></div>
+          </section>
+        </template>
+      </template>
+    </main>
+
+    <Transition name="lightbox">
+      <div v-if="expandedImage" class="lightbox" role="dialog" aria-modal="true" @click.self="expandedImage = null">
+        <div><header><strong>{{ expandedImage.label }}</strong><button type="button" @click="expandedImage = null">×</button></header><img :src="expandedImage.src" :data-source="expandedImage.src" :alt="expandedImage.label" loading="eager" decoding="async" @load="artifactImageLoaded" @error="retryArtifactImage" /><small>Press Escape to close</small></div>
+      </div>
+    </Transition>
+  </div>
+</template>

apps/dashboard/src/main.ts

@@ -0,0 +1,5 @@
+import { createApp } from 'vue'
+import App from './App.vue'
+import './styles.css'
+
+createApp(App).mount('#app')

apps/dashboard/src/styles.css

@@ -0,0 +1,451 @@
+@import url('https://fonts.googleapis.com/css2?family=DM+Mono:wght@400;500&family=Manrope:wght@400;500;600;700;800&display=swap');
+
+:root {
+  color-scheme: dark;
+  font-family: 'Manrope', system-ui, sans-serif;
+  --bg: #080b0f;
+  --panel: #10151b;
+  --panel-2: #151b22;
+  --panel-3: #0c1116;
+  --line: #252d36;
+  --line-soft: #1c232b;
+  --text: #f5f7f8;
+  --muted: #8996a3;
+  --muted-2: #b1bbc4;
+  --lime: #c9f66b;
+  --cyan: #6dd7e8;
+  --amber: #f2bc66;
+  --red: #ff7676;
+  --green: #72dfa5;
+  background: var(--bg);
+  color: var(--text);
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+}
+* { box-sizing: border-box; }
+html { min-width: 320px; background: var(--bg); }
+body { min-width: 320px; min-height: 100vh; margin: 0; background:
+  radial-gradient(circle at 20% -10%, rgba(109, 215, 232, .09), transparent 28rem),
+  radial-gradient(circle at 85% 10%, rgba(201, 246, 107, .055), transparent 24rem),
+  var(--bg); }
+button, input, select { font: inherit; }
+button, a { -webkit-tap-highlight-color: transparent; }
+button { color: inherit; }
+a { color: inherit; }
+#app, .app { min-height: 100vh; }
+
+.app-header {
+  position: sticky;
+  top: 0;
+  z-index: 20;
+  height: 72px;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 0 max(24px, calc((100vw - 1500px) / 2));
+  border-bottom: 1px solid rgba(71, 82, 94, .55);
+  background: rgba(8, 11, 15, .88);
+  backdrop-filter: blur(18px);
+}
+.brand {
+  display: flex;
+  align-items: center;
+  gap: 13px;
+  padding: 0;
+  border: 0;
+  background: transparent;
+  cursor: pointer;
+  text-align: left;
+}
+.brand > span:last-child { display: grid; gap: 2px; }
+.brand strong { font-size: 14px; font-weight: 800; letter-spacing: -.01em; }
+.brand small { color: var(--muted); font-size: 10px; }
+.brand-cube { position: relative; width: 27px; height: 27px; display: block; transform: rotate(30deg); }
+.brand-cube i { position: absolute; display: block; border: 1.5px solid var(--lime); background: rgba(201, 246, 107, .055); }
+.brand-cube i:nth-child(1) { inset: 4px 9px 4px 1px; }
+.brand-cube i:nth-child(2) { inset: 4px 1px 4px 17px; }
+.brand-cube i:nth-child(3) { inset: 1px 5px 16px; }
+.header-actions { display: flex; align-items: center; gap: 16px; }
+.refresh-time { color: var(--muted); font-size: 10px; }
+.live-indicator, .status-chip, .row-status {
+  display: inline-flex;
+  align-items: center;
+  gap: 7px;
+  color: var(--muted-2);
+  font-size: 10px;
+  font-weight: 700;
+  text-transform: capitalize;
+}
+.live-indicator i, .status-chip i, .row-status i, .state-dot {
+  width: 7px;
+  height: 7px;
+  display: inline-block;
+  flex: none;
+  border-radius: 50%;
+  background: #6d7883;
+}
+.live-indicator i, .live i, .state-dot.live { background: var(--cyan); box-shadow: 0 0 0 4px rgba(109, 215, 232, .1); }
+.icon-button {
+  width: 34px;
+  height: 34px;
+  display: grid;
+  place-items: center;
+  padding: 0;
+  border: 1px solid var(--line);
+  border-radius: 9px;
+  background: var(--panel);
+  cursor: pointer;
+  font-size: 18px;
+}
+.icon-button:hover { border-color: #46535f; background: var(--panel-2); }
+
+.page { width: min(1500px, calc(100% - 48px)); margin: 0 auto; padding: 46px 0 80px; }
+.error-banner { margin-bottom: 20px; padding: 13px 15px; border: 1px solid rgba(255, 118, 118, .35); border-radius: 10px; background: rgba(255, 118, 118, .08); color: #ffaaaa; font-size: 12px; }
+
+.page-heading { display: flex; align-items: flex-end; justify-content: space-between; gap: 40px; margin: 18px 0 40px; }
+.kicker { margin: 0 0 9px; color: var(--lime); font: 500 9px 'DM Mono', monospace; letter-spacing: .16em; }
+.page-heading h1, .detail-heading h1 {
+  margin: 0;
+  font-size: clamp(38px, 5vw, 68px);
+  font-weight: 600;
+  letter-spacing: -.055em;
+  line-height: 1.01;
+}
+.page-heading h1 span { color: #7e8b96; }
+.heading-copy { max-width: 650px; margin: 20px 0 0; color: var(--muted-2); font-size: 14px; line-height: 1.65; }
+.corpus-badge {
+  min-width: 210px;
+  padding: 21px 23px;
+  border: 1px solid rgba(201, 246, 107, .28);
+  border-radius: 14px;
+  background: linear-gradient(145deg, rgba(201, 246, 107, .09), rgba(201, 246, 107, .015));
+}
+.corpus-badge span, .corpus-badge small { display: block; color: var(--muted); font-size: 10px; }
+.corpus-badge strong { display: block; margin: 7px 0 3px; font-size: 27px; letter-spacing: -.04em; }
+
+.overview-grid { display: grid; grid-template-columns: repeat(6, minmax(0, 1fr)); margin-bottom: 24px; border: 1px solid var(--line); border-radius: 14px; overflow: hidden; background: var(--panel); }
+.overview-grid article, .detail-metrics article, .task-score-grid article {
+  min-width: 0;
+  padding: 19px 20px;
+  border-right: 1px solid var(--line);
+}
+.overview-grid article:last-child, .detail-metrics article:last-child, .task-score-grid article:last-child { border-right: 0; }
+.overview-grid span, .detail-metrics span, .task-score-grid span, .detail-score span, .detail-score-pair span {
+  display: block;
+  margin-bottom: 8px;
+  color: var(--muted);
+  font-size: 9px;
+  font-weight: 700;
+  letter-spacing: .07em;
+  text-transform: uppercase;
+}
+.overview-grid strong, .detail-metrics strong, .task-score-grid strong { display: block; font-size: 25px; font-weight: 650; letter-spacing: -.035em; }
+.overview-grid small, .detail-metrics small, .task-score-grid small, .detail-score small, .detail-score-pair small { display: block; margin-top: 6px; overflow: hidden; color: #778491; font-size: 9px; text-overflow: ellipsis; white-space: nowrap; }
+.score-overview { background: linear-gradient(145deg, rgba(201, 246, 107, .07), transparent); }
+.score-overview strong { color: var(--lime); }
+.score-overview strong small { display: inline; margin-left: 3px; color: #788462; font-size: 11px; }
+.score-overview.deterministic-score { background: linear-gradient(145deg, rgba(109, 215, 232, .07), transparent); }
+.score-overview.deterministic-score strong { color: var(--cyan); }
+
+.registry-panel, .task-panel, .inspector-panel {
+  border: 1px solid var(--line);
+  border-radius: 14px;
+  background: rgba(16, 21, 27, .9);
+  box-shadow: 0 22px 60px rgba(0, 0, 0, .18);
+  overflow: hidden;
+}
+.registry-heading { min-height: 76px; display: flex; align-items: center; justify-content: space-between; gap: 20px; padding: 16px 20px; border-bottom: 1px solid var(--line); }
+.registry-heading .kicker { margin-bottom: 5px; }
+.registry-heading h2 { margin: 0; font-size: 18px; letter-spacing: -.02em; }
+.registry-heading > span { color: var(--muted); font-size: 10px; }
+
+.filter-bar { display: grid; grid-template-columns: minmax(260px, 1fr) 190px 230px; gap: 10px; padding: 13px; border-bottom: 1px solid var(--line); background: var(--panel-3); }
+.filter-bar label { min-width: 0; display: grid; gap: 5px; }
+.filter-bar label > span { padding-left: 2px; color: #6f7b86; font-size: 8px; font-weight: 700; letter-spacing: .08em; text-transform: uppercase; }
+.filter-bar input, .filter-bar select, .turn-controls select {
+  width: 100%;
+  height: 38px;
+  padding: 0 12px;
+  border: 1px solid var(--line);
+  border-radius: 8px;
+  outline: none;
+  background: #11171d;
+  color: var(--text);
+  font-size: 11px;
+}
+.filter-bar input:focus, .filter-bar select:focus, .turn-controls select:focus { border-color: var(--cyan); box-shadow: 0 0 0 3px rgba(109, 215, 232, .08); }
+
+.benchmark-list { display: grid; }
+.benchmark-row {
+  width: 100%;
+  min-height: 87px;
+  display: grid;
+  grid-template-columns: 92px minmax(280px, 2.2fr) minmax(150px, .9fr) 92px 112px 96px 92px 24px;
+  align-items: center;
+  gap: 18px;
+  padding: 14px 20px;
+  border: 0;
+  border-bottom: 1px solid var(--line-soft);
+  background: transparent;
+  cursor: pointer;
+  text-align: left;
+  transition: background .14s, transform .14s;
+}
+.benchmark-row:last-child { border-bottom: 0; }
+.benchmark-row:hover { background: rgba(109, 215, 232, .035); }
+.benchmark-row:focus-visible { outline: 2px solid var(--cyan); outline-offset: -2px; }
+.row-status.positive i, .status-chip.positive i, .state-dot.positive { background: var(--green); }
+.row-status.negative i, .status-chip.negative i, .state-dot.negative { background: var(--red); }
+.row-status.warning i, .status-chip.warning i, .state-dot.warning { background: var(--amber); }
+.row-identity { min-width: 0; }
+.row-identity strong { display: block; overflow: hidden; font-size: 12px; text-overflow: ellipsis; white-space: nowrap; }
+.row-identity small, .row-result small, .row-coverage small, .row-cost small { display: block; margin-top: 6px; overflow: hidden; color: var(--muted); font-size: 9px; text-overflow: ellipsis; white-space: nowrap; }
+.row-progress > span { display: block; margin-bottom: 8px; color: var(--muted-2); font-size: 9px; }
+.row-progress > span strong { color: var(--text); }
+.row-progress > i { height: 4px; display: block; overflow: hidden; border-radius: 9px; background: #252d35; }
+.row-progress > i b { height: 100%; display: block; border-radius: inherit; background: linear-gradient(90deg, var(--cyan), var(--lime)); }
+.row-result strong, .row-coverage strong, .row-cost strong { display: block; font-size: 14px; font-weight: 650; }
+.row-result strong { color: var(--lime); }
+.row-result strong { font: 650 17px 'DM Mono', monospace; }
+.row-deterministic-score strong { color: var(--cyan); }
+.row-arrow { color: #596671; font-size: 18px; transition: transform .14s, color .14s; }
+.benchmark-row:hover .row-arrow, .task-row:hover .row-arrow { color: var(--cyan); transform: translateX(3px); }
+
+.empty-panel { min-height: 150px; display: grid; place-content: center; gap: 7px; padding: 30px; color: var(--muted); font-size: 12px; text-align: center; }
+.empty-panel strong { color: var(--text); font-size: 14px; }
+.back-button { margin-bottom: 22px; padding: 7px 0; border: 0; background: transparent; color: var(--muted-2); cursor: pointer; font-size: 11px; }
+.back-button:hover { color: var(--lime); }
+
+.detail-heading { display: flex; align-items: flex-end; justify-content: space-between; gap: 40px; margin-bottom: 30px; }
+.detail-heading h1 { max-width: 950px; margin-top: 14px; font-size: clamp(32px, 4vw, 55px); }
+.detail-heading p { margin: 14px 0 0; color: var(--muted); font-size: 12px; }
+.detail-meta { display: flex; flex-wrap: wrap; align-items: center; gap: 14px; color: var(--muted); font: 9px 'DM Mono', monospace; }
+.status-chip { padding: 6px 9px; border: 1px solid var(--line); border-radius: 20px; background: var(--panel); }
+.detail-score { min-width: 190px; padding: 18px 20px; border-left: 1px solid var(--line); }
+.detail-score strong { display: block; color: var(--lime); font-size: 45px; font-weight: 600; letter-spacing: -.06em; line-height: 1; }
+.detail-score-pair { min-width: 370px; display: grid; grid-template-columns: 1fr 1fr; overflow: hidden; border: 1px solid var(--line); border-radius: 12px; background: var(--panel); }
+.detail-score-pair > div { min-width: 0; padding: 17px 18px; }
+.detail-score-pair > div + div { border-left: 1px solid var(--line); }
+.detail-score-pair strong { display: block; color: var(--lime); font-size: 35px; font-weight: 600; letter-spacing: -.06em; line-height: 1; }
+.detail-score-pair .deterministic-score strong { color: var(--cyan); }
+
+.detail-metrics { display: grid; grid-template-columns: repeat(6, minmax(0, 1fr)); margin-bottom: 12px; border: 1px solid var(--line); border-radius: 14px; overflow: hidden; background: var(--panel); }
+.detail-metrics article { padding: 17px 16px; }
+.detail-metrics strong { font-size: 20px; }
+.coverage-strip { min-height: 60px; display: flex; align-items: center; gap: 8px; margin-bottom: 24px; padding: 10px 13px; border: 1px solid var(--line); border-radius: 12px; background: var(--panel-3); }
+.coverage-strip > div { min-width: 145px; padding: 0 8px; }
+.coverage-strip > div span { display: block; color: var(--muted); font-size: 8px; text-transform: uppercase; }
+.coverage-strip > div strong { display: block; margin-top: 3px; font-size: 12px; }
+.coverage-chip { padding: 7px 9px; border: 1px solid var(--line); border-radius: 7px; color: var(--muted-2); font-size: 9px; text-transform: capitalize; }
+.coverage-chip.positive { border-color: rgba(114, 223, 165, .26); color: var(--green); }
+.coverage-chip.warning { border-color: rgba(242, 188, 102, .28); color: var(--amber); }
+.coverage-chip.negative { border-color: rgba(255, 118, 118, .26); color: var(--red); }
+.coverage-chip.live { border-color: rgba(109, 215, 232, .26); color: var(--cyan); }
+.corpus-split { margin-left: auto; padding: 0 8px; color: var(--muted); font: 9px 'DM Mono', monospace; }
+
+.task-panel { margin-bottom: 24px; }
+.task-filters { grid-template-columns: minmax(230px, 1fr) 150px 170px 190px; }
+.task-table-head, .task-row {
+  display: grid;
+  grid-template-columns: minmax(160px, 1.3fr) 100px 140px 76px 96px 105px 62px 72px 72px 20px;
+  align-items: center;
+  gap: 14px;
+}
+.task-table-head { min-height: 38px; padding: 0 17px; border-bottom: 1px solid var(--line); background: #0d1217; color: #697681; font-size: 8px; font-weight: 700; letter-spacing: .06em; text-transform: uppercase; }
+.task-row {
+  width: 100%;
+  min-height: 67px;
+  padding: 10px 17px;
+  border: 0;
+  border-bottom: 1px solid var(--line-soft);
+  background: transparent;
+  cursor: pointer;
+  color: var(--muted-2);
+  font-size: 10px;
+  text-align: left;
+}
+.task-row:last-child { border-bottom: 0; }
+.task-row:hover, .task-row.selected { background: rgba(109, 215, 232, .04); }
+.task-row.selected { box-shadow: inset 3px 0 var(--cyan); }
+.task-row.disabled { cursor: default; opacity: .52; }
+.task-row > span { min-width: 0; }
+.task-identity strong, .task-row > span > strong { display: block; color: var(--text); font-size: 10px; }
+.task-identity small, .task-row > span > small { display: block; margin-top: 4px; color: var(--muted); font-size: 8px; text-transform: capitalize; }
+.task-identity small b { margin-right: 4px; color: var(--cyan); }
+.state-dot { margin-right: 7px; vertical-align: 1px; }
+.outcome { color: var(--muted-2) !important; text-transform: capitalize; }
+.outcome.positive, .task-score-grid strong.positive { color: var(--green) !important; }
+.outcome.warning, .task-score-grid strong.warning { color: var(--amber) !important; }
+.outcome.negative, .task-score-grid strong.negative { color: var(--red) !important; }
+.outcome.live, .task-score-grid strong.live { color: var(--cyan) !important; }
+.numeric-score { color: var(--lime); font: 650 17px 'DM Mono', monospace; letter-spacing: -.03em; }
+.numeric-score.deterministic-score { color: var(--cyan); }
+.component-mini { display: flex; gap: 6px; }
+.component-mini small { margin: 0 !important; font-family: 'DM Mono', monospace; }
+
+.inspector-panel { scroll-margin-top: 88px; }
+.inspector-heading { min-height: 90px; display: flex; align-items: center; justify-content: space-between; gap: 20px; padding: 17px 20px; border-bottom: 1px solid var(--line); }
+.inspector-heading .kicker { margin-bottom: 5px; }
+.inspector-heading h2 { margin: 0; font-size: 22px; }
+.inspector-heading p { margin: 6px 0 0; color: var(--muted); font-size: 10px; text-transform: capitalize; }
+.inspector-actions { display: flex; align-items: center; gap: 8px; }
+.button { min-height: 34px; display: inline-flex; align-items: center; justify-content: center; padding: 0 13px; border: 1px solid var(--line); border-radius: 8px; text-decoration: none; font-size: 10px; font-weight: 700; }
+.button:hover { border-color: var(--cyan); }
+.task-score-grid { display: grid; grid-template-columns: repeat(6, minmax(0, 1fr)); border-bottom: 1px solid var(--line); background: var(--panel-3); }
+.task-score-grid strong { font-size: 18px; text-transform: capitalize; }
+.judge-results { display: grid; grid-template-columns: 1fr 1fr; border-bottom: 1px solid var(--line); background: var(--panel-3); }
+.judge-result { min-width: 0; }
+.judge-result + .judge-result { border-left: 1px solid var(--line); }
+.judge-result > header { min-height: 78px; display: flex; align-items: center; justify-content: space-between; gap: 20px; padding: 15px 19px; border-bottom: 1px solid var(--line-soft); }
+.judge-result > header span { display: block; margin-bottom: 6px; color: var(--muted); font-size: 8px; font-weight: 700; letter-spacing: .08em; text-transform: uppercase; }
+.judge-result > header > div:first-child strong { font-size: 13px; }
+.judge-total { display: flex; align-items: baseline; gap: 4px; }
+.judge-total strong { color: var(--lime); font-size: 32px; letter-spacing: -.05em; }
+.deterministic-result .judge-total strong { color: var(--cyan); }
+.judge-total small { color: var(--muted); font-size: 9px; }
+.judge-result-body { padding: 14px 19px 16px; }
+.judge-result-body > p { margin: 0 0 12px; color: var(--muted-2); font-size: 10px; font-weight: 700; text-transform: capitalize; }
+.judge-result-body > p.positive { color: var(--green); }
+.judge-result-body > p.warning { color: var(--amber); }
+.judge-result-body > p.negative { color: var(--red); }
+.judge-result-body > small { display: block; margin-top: 12px; color: var(--muted); font: 9px 'DM Mono', monospace; }
+.judge-components { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); overflow: hidden; border: 1px solid var(--line-soft); border-radius: 8px; background: #0b1015; }
+.judge-components > div { min-width: 0; padding: 10px; border-right: 1px solid var(--line-soft); }
+.judge-components > div:last-child { border-right: 0; }
+.judge-components span { display: block; overflow: hidden; color: var(--muted); font-size: 7px; font-weight: 700; letter-spacing: .05em; text-overflow: ellipsis; text-transform: uppercase; white-space: nowrap; }
+.judge-components strong { display: block; margin-top: 5px; font: 650 14px 'DM Mono', monospace; }
+.judge-unavailable { min-height: 92px; display: grid; place-items: center; padding: 20px; color: var(--muted); font-size: 10px; }
+
+.artifact-grid { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 1px; border-bottom: 1px solid var(--line); background: var(--line); }
+.artifact-grid figure, .turn-frame-grid figure { min-width: 0; margin: 0; background: #090d11; }
+.artifact-grid figcaption { height: 43px; display: flex; align-items: center; justify-content: space-between; padding: 0 12px; border-bottom: 1px solid var(--line-soft); font-size: 9px; }
+.artifact-grid figcaption small { color: var(--muted); }
+.artifact-grid figure > button, .turn-frame-grid figure > button { position: relative; width: 100%; height: 310px; display: block; overflow: hidden; padding: 0; border: 0; background: #050709; cursor: zoom-in; }
+.artifact-grid img, .turn-frame-grid img { width: 100%; height: 100%; display: block; object-fit: contain; transition: opacity .18s; }
+.artifact-grid img[data-load-state="retrying"], .turn-frame-grid img[data-load-state="retrying"], .lightbox img[data-load-state="retrying"] { opacity: .3; }
+.artifact-grid img[data-load-state="failed"], .turn-frame-grid img[data-load-state="failed"], .lightbox img[data-load-state="failed"] { opacity: .08; }
+.artifact-grid button:has(img[data-load-state="retrying"])::after, .turn-frame-grid button:has(img[data-load-state="retrying"])::after,
+.artifact-grid button:has(img[data-load-state="failed"])::after, .turn-frame-grid button:has(img[data-load-state="failed"])::after {
+  position: absolute;
+  inset: 0;
+  display: grid;
+  place-items: center;
+  color: var(--muted-2);
+  font: 500 10px 'DM Mono', monospace;
+  pointer-events: none;
+}
+.artifact-grid button:has(img[data-load-state="retrying"])::after, .turn-frame-grid button:has(img[data-load-state="retrying"])::after { content: 'Retrying image…'; }
+.artifact-grid button:has(img[data-load-state="failed"])::after, .turn-frame-grid button:has(img[data-load-state="failed"])::after { content: 'Image unavailable · refresh to retry'; color: var(--red); }
+.artifact-missing { height: 310px; display: grid; place-items: center; color: #56616c; font-size: 10px; }
+
+.trace-section { background: #0d1217; }
+.trace-section > header { min-height: 72px; display: flex; align-items: center; justify-content: space-between; padding: 13px 17px; border-bottom: 1px solid var(--line); }
+.trace-section > header .kicker { margin-bottom: 4px; }
+.trace-section h3 { margin: 0; font-size: 15px; }
+.turn-controls { display: flex; align-items: center; gap: 6px; }
+.turn-controls button { width: 35px; height: 35px; border: 1px solid var(--line); border-radius: 8px; background: var(--panel); cursor: pointer; }
+.turn-controls button:disabled { opacity: .3; cursor: default; }
+.turn-controls select { width: 180px; height: 35px; }
+.turn-frame-grid { display: grid; grid-template-columns: 1fr 1fr; gap: 1px; border-bottom: 1px solid var(--line); background: var(--line); }
+.turn-frame-grid figcaption { height: 37px; display: flex; align-items: center; justify-content: space-between; gap: 12px; padding: 0 12px; color: var(--muted-2); font-size: 9px; }
+.turn-frame-grid figcaption small { overflow: hidden; color: var(--muted); font-family: var(--mono); text-overflow: ellipsis; white-space: nowrap; }
+.turn-frame-grid figure > button, .turn-frame-grid .artifact-missing { height: 360px; }
+
+.action-list { display: grid; padding: 12px; }
+.action-list article { display: grid; grid-template-columns: 24px minmax(180px, 1fr) minmax(160px, .7fr); align-items: center; gap: 12px; padding: 11px 10px; border-bottom: 1px solid var(--line-soft); }
+.action-list article:last-child { border-bottom: 0; }
+.action-list article > span { width: 22px; height: 22px; display: grid; place-items: center; border: 1px solid var(--line); border-radius: 6px; color: var(--muted); font: 9px 'DM Mono', monospace; }
+.action-list strong { display: block; font-size: 10px; text-transform: capitalize; }
+.action-list p { margin: 4px 0 0; color: var(--muted-2); font-size: 10px; }
+.action-list code { overflow: hidden; color: #74818c; font: 9px 'DM Mono', monospace; text-overflow: ellipsis; white-space: nowrap; }
+.raw-details { border-top: 1px solid var(--line); }
+.raw-details summary { padding: 13px 17px; color: var(--muted-2); cursor: pointer; font-size: 10px; }
+.raw-details > div { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 10px; padding: 0 13px 13px; }
+pre { max-height: 380px; margin: 0; padding: 12px; overflow: auto; border: 1px solid var(--line); border-radius: 8px; background: #070a0d; color: #aebac4; font: 9px/1.55 'DM Mono', monospace; white-space: pre-wrap; word-break: break-word; }
+
+.lightbox { position: fixed; inset: 0; z-index: 100; display: grid; place-items: center; padding: 24px; background: rgba(2, 4, 6, .94); backdrop-filter: blur(15px); }
+.lightbox > div { width: min(94vw, 1700px); height: min(92vh, 1100px); display: grid; grid-template-rows: 54px minmax(0, 1fr) 34px; border: 1px solid #394550; border-radius: 12px; overflow: hidden; background: #080c0f; box-shadow: 0 30px 100px rgba(0, 0, 0, .7); }
+.lightbox header { display: flex; align-items: center; justify-content: space-between; padding: 0 15px; border-bottom: 1px solid var(--line); }
+.lightbox header strong { font-size: 11px; }
+.lightbox header button { border: 0; background: transparent; cursor: pointer; font-size: 24px; }
+.lightbox img { width: 100%; height: 100%; min-height: 0; display: block; object-fit: contain; background: #030506; }
+.lightbox small { display: grid; place-items: center; border-top: 1px solid var(--line); color: var(--muted); font-size: 9px; }
+.lightbox-enter-active, .lightbox-leave-active { transition: opacity .16s; }
+.lightbox-enter-from, .lightbox-leave-to { opacity: 0; }
+
+@media (max-width: 1200px) {
+  .overview-grid { grid-template-columns: repeat(3, 1fr); }
+  .overview-grid article:nth-child(3) { border-right: 0; }
+  .overview-grid article:nth-child(n+4) { border-top: 1px solid var(--line); }
+  .benchmark-row { grid-template-columns: 85px minmax(250px, 2fr) minmax(135px, 1fr) 82px 98px 80px 20px; }
+  .row-coverage { display: none; }
+  .detail-metrics { grid-template-columns: repeat(3, 1fr); }
+  .detail-metrics article:nth-child(3) { border-right: 0; }
+  .detail-metrics article:nth-child(n+4) { border-top: 1px solid var(--line); }
+  .task-table-head, .task-row { grid-template-columns: minmax(150px, 1.3fr) 90px 130px 68px 80px 85px 60px 70px 18px; }
+  .task-table-head > span:nth-child(8), .task-row > span:nth-child(8) { display: none; }
+  .task-score-grid { grid-template-columns: repeat(3, 1fr); }
+  .task-score-grid article:nth-child(3) { border-right: 0; }
+  .task-score-grid article:nth-child(n+4) { border-top: 1px solid var(--line); }
+}
+
+@media (max-width: 860px) {
+  .app-header { padding: 0 16px; }
+  .refresh-time { display: none; }
+  .page { width: min(100% - 28px, 720px); padding-top: 28px; }
+  .page-heading, .detail-heading { align-items: flex-start; flex-direction: column; }
+  .corpus-badge { width: 100%; }
+  .overview-grid { grid-template-columns: 1fr 1fr; }
+  .overview-grid article { border-top: 1px solid var(--line); }
+  .overview-grid article:nth-child(odd) { border-right: 1px solid var(--line); }
+  .overview-grid article:nth-child(even) { border-right: 0; }
+  .overview-grid article:first-child, .overview-grid article:nth-child(2) { border-top: 0; }
+  .filter-bar, .task-filters { grid-template-columns: 1fr 1fr; }
+  .search-field { grid-column: 1 / -1; }
+  .benchmark-row { grid-template-columns: 82px minmax(0, 1fr) 62px 72px 20px; gap: 12px; }
+  .row-progress, .row-coverage, .row-cost { display: none; }
+  .detail-score { width: 100%; border-top: 1px solid var(--line); border-left: 0; }
+  .detail-score-pair { width: 100%; min-width: 0; }
+  .detail-metrics { grid-template-columns: 1fr 1fr; }
+  .detail-metrics article { border-top: 1px solid var(--line); }
+  .detail-metrics article:nth-child(odd) { border-right: 1px solid var(--line); }
+  .detail-metrics article:nth-child(even) { border-right: 0; }
+  .detail-metrics article:first-child, .detail-metrics article:nth-child(2) { border-top: 0; }
+  .coverage-strip { flex-wrap: wrap; }
+  .corpus-split { width: 100%; margin: 5px 0 0; }
+  .task-table-head { display: none; }
+  .task-row { grid-template-columns: minmax(130px, 1fr) 100px 58px 68px 18px; gap: 10px; padding: 12px 14px; }
+  .task-row > span:nth-child(2), .task-row > span:nth-child(6), .task-row > span:nth-child(7), .task-row > span:nth-child(8), .task-row > span:nth-child(9) { display: none; }
+  .artifact-grid, .turn-frame-grid { grid-template-columns: 1fr; }
+  .judge-results { grid-template-columns: 1fr; }
+  .judge-result + .judge-result { border-top: 1px solid var(--line); border-left: 0; }
+  .artifact-grid figure > button, .artifact-missing { height: 280px; }
+  .turn-frame-grid figure > button, .turn-frame-grid .artifact-missing { height: 280px; }
+  .raw-details > div { grid-template-columns: 1fr; }
+}
+
+@media (max-width: 540px) {
+  .brand small, .live-indicator { display: none; }
+  .page-heading h1 { font-size: 38px; }
+  .overview-grid { grid-template-columns: 1fr; }
+  .overview-grid article { border-right: 0 !important; border-top: 1px solid var(--line) !important; }
+  .overview-grid article:first-child { border-top: 0 !important; }
+  .filter-bar, .task-filters { grid-template-columns: 1fr; }
+  .search-field { grid-column: auto; }
+  .benchmark-row { grid-template-columns: 68px minmax(0, 1fr) 52px 60px 18px; gap: 8px; }
+  .row-result strong { font-size: 14px; }
+  .row-result small { font-size: 7px; }
+  .detail-metrics, .task-score-grid { grid-template-columns: 1fr 1fr; }
+  .detail-score-pair { grid-template-columns: 1fr; }
+  .detail-score-pair > div + div { border-top: 1px solid var(--line); border-left: 0; }
+  .judge-components { grid-template-columns: 1fr 1fr; }
+  .judge-components > div:nth-child(2) { border-right: 0; }
+  .judge-components > div:nth-child(n+3) { border-top: 1px solid var(--line-soft); }
+  .detail-metrics article, .task-score-grid article { border-top: 1px solid var(--line); }
+  .detail-metrics article:nth-child(odd), .task-score-grid article:nth-child(odd) { border-right: 1px solid var(--line); }
+  .detail-metrics article:nth-child(even), .task-score-grid article:nth-child(even) { border-right: 0; }
+  .detail-metrics article:first-child, .detail-metrics article:nth-child(2), .task-score-grid article:first-child, .task-score-grid article:nth-child(2) { border-top: 0; }
+  .inspector-heading { align-items: flex-start; }
+  .action-list article { grid-template-columns: 24px 1fr; }
+  .action-list code { grid-column: 2; }
+}

apps/dashboard/src/types.ts

@@ -0,0 +1,223 @@
+export interface EvaluationScoreSummary {
+  source: string | null
+  score: number | null
+  valid: boolean | null
+  failureReason: string | null
+  method: string | null
+  verdict: string | null
+  targetAcquired: boolean | null
+  confidence: number | null
+  needsHumanReview: boolean
+  geometry: number | null
+  dimensions: number | null
+  annotations: number | null
+  presentation: number | null
+}
+
+export interface RunSummary {
+  id: string
+  taskId: string
+  attemptId: string | null
+  modelId: string
+  provider: string
+  reasoningEffort: string | null
+  status: string
+  stopReason: string | null
+  failure: string | null
+  acceptedActions: number
+  invalidActions: number
+  screenshots: number
+  elapsedSeconds: number | null
+  artifactBytes: number
+  score: number | null
+  valid: boolean | null
+  scoreFailure: string | null
+  scoreMethod: string | null
+  scoreSource: string | null
+  verdict: string | null
+  targetAcquired: boolean | null
+  judgeConfidence: number | null
+  needsHumanReview: boolean
+  visionScore: EvaluationScoreSummary | null
+  deterministicScore: EvaluationScoreSummary | null
+  evaluationState: string
+  evaluationStage: string | null
+  evaluationError: string | null
+  updatedAt: string
+}
+
+export interface FrameArtifact {
+  name: string
+  sha256: string | null
+  url: string
+}
+
+export interface ModelTurn {
+  turn: number
+  tool_use_id?: string
+  action: Record<string, unknown>
+  stop_reason: string
+  usage: Record<string, number>
+  latency_ms: number
+  text: string[]
+  discarded_tool_uses: number
+  model_input?: Record<string, unknown> | null
+}
+
+export interface InputReceipt {
+  action_index: number
+  request_id?: string | null
+  idempotent_replay?: boolean
+  receipt: Record<string, unknown> | null
+  action?: Record<string, unknown> | null
+  tool_use_id?: string | null
+  batch_index?: number
+  batch_size?: number
+  batch_start_action_index?: number
+}
+
+export interface TraceDetail {
+  summary: RunSummary
+  state: Record<string, unknown> | null
+  result: Record<string, unknown> | null
+  score: Record<string, unknown> | null
+  scores: {
+    vision: Record<string, unknown> | null
+    deterministic: Record<string, unknown> | null
+  }
+  turns: ModelTurn[]
+  receipts: InputReceipt[]
+  traceIndexed: boolean
+  traceNotice: string | null
+  frames: FrameArtifact[]
+  referenceUrl: string
+  artifacts: {
+    dwg: string | null
+    candidateRender: string | null
+    diffRender: string | null
+  }
+}
+
+export interface BenchmarkUsage {
+  inputTokens: number
+  cachedInputTokens: number
+  outputTokens: number
+  reasoningOutputTokens: number
+  totalTokens: number
+  modelTurns: number
+  apiCost: number | null
+}
+
+export interface BenchmarkLevelSummary {
+  total: number
+  completed: number
+  scored: number
+  meanScore: number | null
+  cost: number
+}
+
+export interface BenchmarkDrawingTypeSummary {
+  total: number
+  scored: number
+  meanScore: number | null
+}
+
+export interface BenchmarkAggregate {
+  totalTasks: number
+  queuedTasks: number
+  activeTasks: number
+  settledTasks: number
+  completedTasks: number
+  recoveredTasks: number
+  budgetExhaustedTasks: number
+  failedTasks: number
+  infrastructureFailedTasks: number
+  artifactMissingTasks: number
+  artifactTasks: number
+  scoredTasks: number
+  meanScore: number | null
+  visionScoredTasks: number
+  visionMeanScore: number | null
+  deterministicScoredTasks: number
+  deterministicMeanScore: number | null
+  acceptedActions: number
+  invalidActions: number
+  aggregateElapsedSeconds: number
+  usage: BenchmarkUsage
+  levels: Record<string, BenchmarkLevelSummary>
+  drawingTypes: Record<string, BenchmarkDrawingTypeSummary>
+  evaluationStates: Record<string, number>
+  executionStates: Record<string, number>
+  verdicts: Record<string, number>
+}
+
+export interface BenchmarkSummary {
+  id: string
+  batchId: string | null
+  name: string
+  status: string
+  modelId: string
+  provider: string
+  models: string[]
+  providers: string[]
+  startedAt: string | null
+  updatedAt: string | null
+  maxConcurrency: number | null
+  aggregate: BenchmarkAggregate
+}
+
+export interface BenchmarkTask {
+  rolloutId: string
+  runId: string
+  taskId: string
+  level: string
+  drawingType: string
+  split: string
+  displayName: string
+  modelId: string
+  provider: string
+  status: string
+  stopReason: string | null
+  failure: string | null
+  acceptedActions: number
+  invalidActions: number
+  elapsedSeconds: number | null
+  setupElapsedSeconds: number | null
+  rolloutElapsedSeconds: number | null
+  artifactBytes: number
+  score: number | null
+  valid: boolean | null
+  scoreFailure: string | null
+  scoreMethod: string | null
+  scoreSource: string | null
+  verdict: string | null
+  targetAcquired: boolean | null
+  judgeConfidence: number | null
+  needsHumanReview: boolean
+  visionScore: EvaluationScoreSummary | null
+  deterministicScore: EvaluationScoreSummary | null
+  geometrySimilarity: number | null
+  dimensionSimilarity: number | null
+  annotationSimilarity: number | null
+  visualSimilarity: number | null
+  evaluationState: string
+  evaluationStage: string | null
+  evaluationError: string | null
+  startedAt: string | null
+  finishedAt: string | null
+  updatedAt: string | null
+  usage: BenchmarkUsage
+}
+
+export interface BenchmarkDetail extends BenchmarkSummary {
+  finishedAt: string | null
+  pricing: {
+    currency?: string
+    input_per_million: number
+    cached_input_per_million: number
+    output_per_million: number
+    source_url?: string | null
+    effective_date?: string | null
+  } | null
+  tasks: BenchmarkTask[]
+}

apps/dashboard/tests/cloud-metadata.test.mjs

@@ -0,0 +1,117 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import test from 'node:test'
+
+import {
+  benchmarkMetadataPaths,
+  shouldPromoteMetadata,
+  traceMetadataPaths,
+} from '../cloud-metadata.mjs'
+
+function writeJson(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true })
+  fs.writeFileSync(filePath, JSON.stringify(value))
+}
+
+test('plans direct benchmark metadata reads without wildcard prefix scans', () => {
+  const paths = benchmarkMetadataPaths({
+    rollouts: {
+      'task-001': {},
+      'task-022': {},
+    },
+  })
+
+  assert.equal(paths[0], 'batch-state.json')
+  assert.equal(paths.length, 11)
+  assert(paths.includes('rollouts/task-001/run-state.json'))
+  assert(paths.includes('rollouts/task-022/evaluation/vision-judge/score.json'))
+  assert.equal(paths.some((value) => value.includes('*')), false)
+})
+
+test('plans the compact trace metadata set without frame downloads', () => {
+  const paths = traceMetadataPaths()
+
+  assert(paths.includes('model_turn_summaries.jsonl'))
+  assert(paths.includes('input_receipts.jsonl'))
+  assert.equal(paths.some((value) => value.startsWith('frames/')), false)
+})
+
+test('shared V3 result cannot overwrite a local V4 rescore at the same timestamp', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'autocad-dashboard-version-'))
+  const source = path.join(root, 'source', 'result.json')
+  const destination = path.join(root, 'destination', 'result.json')
+  writeJson(source, {
+    updated_at: '2026-07-19T00:00:00Z',
+    evaluation: { evaluator_version: 'autocad-2019-r23.0.46-v3' },
+  })
+  writeJson(destination, {
+    updated_at: '2026-07-19T00:00:00Z',
+    evaluation: { evaluator_version: 'autocad-2019-r23.0.46-v4' },
+  })
+
+  assert.equal(shouldPromoteMetadata(source, destination), false)
+})
+
+test('nested vision artifact inherits the evaluator version from status', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'autocad-dashboard-vision-'))
+  const source = path.join(root, 'source', 'evaluation', 'vision-judge', 'score.json')
+  const destination = path.join(
+    root,
+    'destination',
+    'evaluation',
+    'vision-judge',
+    'score.json',
+  )
+  writeJson(source, { overall_score: 0.2 })
+  writeJson(path.join(root, 'source', 'evaluation', 'status.json'), {
+    evaluator_version: 'autocad-2019-r23.0.46-v3',
+  })
+  writeJson(destination, { overall_score: 0.8 })
+  writeJson(path.join(root, 'destination', 'evaluation', 'status.json'), {
+    evaluator_version: 'autocad-2019-r23.0.46-v4',
+  })
+
+  assert.equal(shouldPromoteMetadata(source, destination), false)
+})
+
+test('a higher evaluator version is promoted even with an older timestamp', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'autocad-dashboard-upgrade-'))
+  const source = path.join(root, 'source', 'evaluation', 'status.json')
+  const destination = path.join(root, 'destination', 'evaluation', 'status.json')
+  writeJson(source, {
+    updated_at: '2026-07-18T00:00:00Z',
+    evaluator_version: 'autocad-2019-r23.0.46-v4',
+  })
+  writeJson(destination, {
+    updated_at: '2026-07-19T00:00:00Z',
+    evaluator_version: 'autocad-2019-r23.0.46-v3',
+  })
+
+  assert.equal(shouldPromoteMetadata(source, destination), true)
+})
+
+test('an earlier snapshot from the same rescore job cannot replace the local result', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'autocad-dashboard-rescore-'))
+  const source = path.join(root, 'source', 'result.json')
+  const destination = path.join(root, 'destination', 'result.json')
+  writeJson(source, {
+    evaluation: {
+      evaluator_version: 'autocad-2019-r23.0.46-v4',
+      rescore_job_id: 'rescore-v4-test',
+      status: 'completed',
+      vision_score: 0.4,
+    },
+  })
+  writeJson(destination, {
+    evaluation: {
+      evaluator_version: 'autocad-2019-r23.0.46-v4',
+      rescore_job_id: 'rescore-v4-test',
+      status: 'completed',
+      vision_score: 0.8,
+    },
+  })
+
+  assert.equal(shouldPromoteMetadata(source, destination), false)
+})

apps/dashboard/tests/trace-api.test.mjs

@@ -0,0 +1,872 @@
+import assert from 'node:assert/strict'
+import { createHash } from 'node:crypto'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { once } from 'node:events'
+import { Writable } from 'node:stream'
+import test from 'node:test'
+
+import { _test, createTraceApi } from '../trace-api.mjs'
+
+class TestResponse extends Writable {
+  constructor() {
+    super()
+    this.headers = {}
+    this.body = []
+    this.statusCode = 0
+  }
+
+  setHeader(name, value) {
+    this.headers[name] = value
+  }
+
+  _write(chunk, _encoding, callback) {
+    this.body.push(Buffer.from(chunk))
+    callback()
+  }
+}
+
+test('reads complete JSONL rows while a writer is appending a partial row', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'autocad-trace-jsonl-'))
+  const file = path.join(root, 'events.json')
+  fs.writeFileSync(file, '{"actionIndex":1}\n{"actionIndex":2')
+  assert.deepEqual(_test.readJsonl(file), [{ actionIndex: 1 }])
+})
+
+test('rejects run and artifact path traversal', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'autocad-trace-safe-'))
+  const run = path.join(root, 'run-001')
+  fs.mkdirSync(run)
+  assert.equal(_test.safeRunDirectory(root, '../outside'), null)
+  assert.equal(_test.safeRunDirectory(root, 'run-001'), run)
+  assert.equal(_test.safeRunDirectory(root, 'batch/rollouts/run-001'), path.join(root, 'batch', 'rollouts', 'run-001'))
+  assert.equal(_test.safeRunDirectory(root, 'batch//run-001'), null)
+  assert.equal(_test.safeArtifact(run, '../../secret'), null)
+  assert.equal(_test.safeArtifact(run, 'frames/frame_0000.png'), path.join(run, 'frames', 'frame_0000.png'))
+})
+
+test('recursively indexes batch rollout directories', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'autocad-trace-batch-'))
+  const rollout = path.join(root, 'batch-001', 'rollouts', 'model-a')
+  fs.mkdirSync(rollout, { recursive: true })
+  fs.writeFileSync(path.join(rollout, 'run-state.json'), JSON.stringify({
+    task_id: 'task-001',
+    model_id: 'model-a',
+    provider: 'openai',
+    state: 'running',
+    updated_at: '2026-07-16T00:00:00Z',
+  }))
+
+  const runs = _test.listRuns(root)
+
+  assert.equal(runs.length, 1)
+  assert.equal(runs[0].id, 'batch-001/rollouts/model-a')
+  assert.equal(runs[0].status, 'running')
+})
+
+test('indexes an unsuccessful wall-time rollout as budget exhausted', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'autocad-trace-run-'))
+  const run = path.join(root, 'gpt-run')
+  fs.mkdirSync(run)
+  fs.writeFileSync(path.join(run, 'result.json'), JSON.stringify({
+    task_id: 'task-001',
+    model_id: 'gpt-5.6-sol',
+    provider: 'openai',
+    reasoning_effort: 'xhigh',
+    completed: false,
+    stop_reason: 'wall_timeout',
+    accepted_actions: 40,
+    invalid_actions: 0,
+    screenshots: 41,
+    artifact_bytes: 0,
+  }))
+  const summary = _test.runSummary(root, 'gpt-run')
+  assert.equal(summary.status, 'budget_exhausted')
+  assert.equal(summary.stopReason, 'wall_timeout')
+  assert.equal(summary.acceptedActions, 40)
+  assert.equal(summary.evaluationState, 'no_artifact')
+})
+
+test('prefers the versioned vision judgment over the legacy deterministic score', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'autocad-trace-vision-score-'))
+  const run = path.join(root, 'vision-run')
+  fs.mkdirSync(path.join(run, 'evaluation', 'vision-judge'), { recursive: true })
+  fs.writeFileSync(path.join(run, 'run-state.json'), JSON.stringify({
+    task_id: 'task-001',
+    model_id: 'gpt-5.6-sol',
+    provider: 'openai',
+    state: 'completed',
+  }))
+  fs.writeFileSync(path.join(run, 'evaluation', 'score.json'), JSON.stringify({
+    score: 0.52,
+    valid: true,
+    scoring_method: 'vector-semantic-v2',
+  }))
+  fs.writeFileSync(
+    path.join(run, 'evaluation', 'vision-judge', 'score.json'),
+    JSON.stringify({
+      prompt_version: 'autocad-vision-judge-v1',
+      overall_score: 0.93,
+      target_acquired: true,
+      confidence: 0.91,
+      needs_human_review: false,
+      component_scores: {
+        geometry: 0.98,
+        dimensions: 0.96,
+        annotations: 0.75,
+        presentation: 0.70,
+      },
+    }),
+  )
+
+  const summary = _test.runSummary(root, 'vision-run')
+  const detail = _test.traceDetail(root, 'vision-run')
+
+  assert.equal(summary.score, 0.93)
+  assert.equal(summary.scoreMethod, 'vision:autocad-vision-judge-v1')
+  assert.equal(summary.scoreSource, 'vision_judge')
+  assert.equal(summary.visionScore.score, 0.93)
+  assert.equal(summary.visionScore.geometry, 0.98)
+  assert.equal(summary.deterministicScore.score, 0.52)
+  assert.equal(summary.deterministicScore.method, 'vector-semantic-v2')
+  assert.equal(summary.targetAcquired, true)
+  assert.equal(summary.evaluationState, 'scored')
+  assert.equal(detail.score.geometry_similarity, 0.98)
+  assert.equal(detail.score.score_source, 'vision_judge')
+  assert.equal(detail.scores.vision.overall_score, 0.93)
+  assert.equal(detail.scores.deterministic.score, 0.52)
+})
+
+test('shows automatic evaluation progress immediately after model completion', () => {
+  const heartbeat = new Date().toISOString()
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'autocad-trace-evaluating-'))
+  const run = path.join(root, 'evaluating-run')
+  fs.mkdirSync(path.join(run, 'evaluation'), { recursive: true })
+  fs.writeFileSync(path.join(run, 'result.json'), JSON.stringify({
+    task_id: 'task-001',
+    model_id: 'gpt-test',
+    provider: 'openai',
+    completed: true,
+    artifact_bytes: 1234,
+  }))
+  fs.writeFileSync(path.join(run, 'evaluation', 'status.json'), JSON.stringify({
+    stage: 'vision_judging',
+    updated_at: heartbeat,
+  }))
+
+  const summary = _test.runSummary(root, 'evaluating-run')
+
+  assert.equal(summary.evaluationState, 'evaluating')
+  assert.equal(summary.evaluationStage, 'vision_judging')
+  assert.equal(summary.updatedAt, heartbeat)
+})
+
+test('reports independent vision and deterministic benchmark means', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'autocad-dual-score-'))
+  const benchmark = path.join(root, 'benchmarks', 'dual-score')
+  const run = path.join(benchmark, 'rollouts', 'task-001')
+  fs.mkdirSync(path.join(run, 'evaluation', 'vision-judge'), { recursive: true })
+  fs.writeFileSync(path.join(benchmark, 'batch-state.json'), JSON.stringify({
+    state: 'completed',
+    rollouts: {
+      'task-001': {
+        task_id: 'task-001', model_id: 'model', provider: 'openai', state: 'completed',
+      },
+    },
+  }))
+  fs.writeFileSync(path.join(run, 'result.json'), JSON.stringify({
+    task_id: 'task-001', model_id: 'model', provider: 'openai',
+    completed: true, artifact_bytes: 100,
+  }))
+  fs.writeFileSync(path.join(run, 'evaluation', 'score.json'), JSON.stringify({
+    score: 0.4,
+    valid: true,
+    scoring_method: 'vector-semantic-v2',
+    geometry_similarity: 0.5,
+  }))
+  fs.writeFileSync(
+    path.join(run, 'evaluation', 'vision-judge', 'score.json'),
+    JSON.stringify({
+      overall_score: 0.8,
+      verdict: 'mostly_acquired',
+      component_scores: { geometry: 0.9, dimensions: 0.7, annotations: 0.6, presentation: 0.5 },
+    }),
+  )
+
+  const detail = _test.benchmarkDetail(root, 'benchmarks/dual-score')
+
+  assert.equal(detail.aggregate.meanScore, 0.8)
+  assert.equal(detail.aggregate.visionMeanScore, 0.8)
+  assert.equal(detail.aggregate.visionScoredTasks, 1)
+  assert.equal(detail.aggregate.deterministicMeanScore, 0.4)
+  assert.equal(detail.aggregate.deterministicScoredTasks, 1)
+  assert.equal(detail.tasks[0].visionScore.score, 0.8)
+  assert.equal(detail.tasks[0].deterministicScore.score, 0.4)
+})
+
+test('does not show a stale evaluator heartbeat as live forever', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'autocad-trace-stale-evaluation-'))
+  const run = path.join(root, 'stale-evaluation')
+  fs.mkdirSync(path.join(run, 'evaluation'), { recursive: true })
+  fs.writeFileSync(path.join(run, 'result.json'), JSON.stringify({
+    task_id: 'task-001',
+    completed: true,
+    stop_reason: 'done',
+    artifact_bytes: 100,
+  }))
+  fs.writeFileSync(path.join(run, 'evaluation', 'status.json'), JSON.stringify({
+    stage: 'vision_judging',
+    updated_at: '2020-01-01T00:00:00Z',
+  }))
+
+  assert.equal(_test.runSummary(root, 'stale-evaluation').evaluationState, 'evaluation_interrupted')
+})
+
+test('labels a batch process without a pilot trace as startup, not handoff', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'autocad-trace-startup-'))
+  const benchmark = path.join(root, 'benchmark-starting')
+  fs.mkdirSync(benchmark, { recursive: true })
+  fs.writeFileSync(path.join(benchmark, 'batch-state.json'), JSON.stringify({
+    batch_id: 'batch-starting',
+    state: 'running',
+    rollouts: {
+      'task-002': {
+        task_id: 'task-002',
+        model_id: 'model-test',
+        provider: 'openrouter',
+        state: 'running',
+      },
+    },
+  }))
+
+  const detail = _test.benchmarkDetail(root, 'benchmark-starting')
+
+  assert.equal(detail.tasks[0].status, 'starting')
+  assert.equal(detail.tasks[0].evaluationState, 'running')
+})
+
+test('retains batch grouping receipts and intermediate audit frames', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'autocad-trace-batch-turn-'))
+  const run = path.join(root, 'batched-run')
+  const frames = path.join(run, 'frames')
+  fs.mkdirSync(frames, { recursive: true })
+  fs.writeFileSync(path.join(run, 'run-state.json'), JSON.stringify({
+    task_id: 'task-001',
+    model_id: 'gpt-test',
+    provider: 'openai',
+    state: 'running',
+  }))
+  fs.writeFileSync(path.join(run, 'model_turns.jsonl'), `${JSON.stringify({
+    turn: 1,
+    tool_use_id: 'call-batch',
+    action: {
+      actions: [
+        { action: 'type', text: 'LINE', intent: 'Type LINE.' },
+        { action: 'key', keys: ['ENTER'], intent: 'Submit LINE.' },
+      ],
+    },
+  })}\n`)
+  fs.writeFileSync(path.join(run, 'input_receipts.jsonl'), [
+    { action_index: 1, tool_use_id: 'call-batch', batch_index: 1, batch_size: 2 },
+    { action_index: 2, tool_use_id: 'call-batch', batch_index: 2, batch_size: 2 },
+  ].map(JSON.stringify).join('\n') + '\n')
+  for (const name of ['frame_0000.png', 'frame_0001.png', 'frame_0002.png']) {
+    fs.writeFileSync(path.join(frames, name), 'png')
+  }
+
+  const detail = _test.traceDetail(root, 'batched-run')
+
+  assert.equal(detail.turns[0].action.actions.length, 2)
+  assert.deepEqual(detail.receipts.map((receipt) => receipt.batch_index), [1, 2])
+  assert.deepEqual(detail.frames.map((frame) => frame.name), [
+    'frame_0000.png',
+    'frame_0001.png',
+    'frame_0002.png',
+  ])
+})
+
+test('indexes cloud-backed frames referenced by compact resumed traces', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'autocad-trace-cloud-frames-'))
+  const run = path.join(root, 'cloud-frame-run')
+  const frames = path.join(run, 'frames')
+  fs.mkdirSync(frames, { recursive: true })
+  fs.writeFileSync(path.join(frames, 'frame_0000.png'), 'png')
+  fs.writeFileSync(path.join(run, 'run-state.json'), JSON.stringify({
+    task_id: 'task-001',
+    model_id: 'gpt-test',
+    provider: 'openai',
+    state: 'completed',
+    accepted_actions: 12,
+  }))
+  fs.writeFileSync(path.join(run, 'model_turn_summaries.jsonl'), `${JSON.stringify({
+    turn: 2,
+    model_input: {
+      artifacts: [{ artifact_path: 'frames/frame_0010.png', sequence: 10 }],
+    },
+  })}\n`)
+
+  const detail = _test.traceDetail(root, 'cloud-frame-run')
+
+  assert.deepEqual(detail.frames.map((frame) => frame.name), [
+    'frame_0000.png',
+    'frame_0010.png',
+    'frame_0012.png',
+  ])
+})
+
+test('advertises and lazily hydrates cloud reference and trusted render images', async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'autocad-trace-cloud-images-'))
+  const runId = 'benchmarks/sol/rollouts/task-022'
+  const run = path.join(root, runId)
+  fs.mkdirSync(path.join(run, 'evaluation', 'vision-judge'), { recursive: true })
+  fs.writeFileSync(path.join(run, 'run-state.json'), JSON.stringify({
+    task_id: 'cloud-only-task',
+    model_id: 'gpt-test',
+    provider: 'openai',
+    state: 'completed',
+  }))
+  fs.writeFileSync(
+    path.join(run, 'evaluation', 'vision-judge', 'score.json'),
+    JSON.stringify({
+      prompt_version: 'autocad-vision-judge-v3',
+      overall_score: 0.9,
+      component_scores: { geometry: 0.9 },
+    }),
+  )
+
+  const detail = _test.traceDetail(root, runId)
+  assert.equal(
+    detail.referenceUrl,
+    `/api/runs/${encodeURIComponent(runId)}/file/reference.png`,
+  )
+  assert.equal(
+    detail.artifacts.candidateRender,
+    `/api/runs/${encodeURIComponent(runId)}/file/evaluation/render.png`,
+  )
+
+  const hydrated = []
+  const api = createTraceApi({
+    runsRoot: root,
+    cloudArtifactLoader: async (request) => {
+      hydrated.push(request.relativePath)
+      fs.mkdirSync(path.dirname(request.artifact), { recursive: true })
+      fs.writeFileSync(request.artifact, `cloud:${request.relativePath}`)
+    },
+  })
+  for (const relativePath of ['reference.png', 'evaluation/render.png']) {
+    const response = new TestResponse()
+    const finished = once(response, 'finish')
+    await api({
+      method: 'GET',
+      url: `/api/runs/${encodeURIComponent(runId)}/file/${relativePath}`,
+    }, response)
+    await finished
+    assert.equal(response.statusCode, 200)
+    assert.equal(response.headers['Content-Type'], 'image/png')
+    assert.equal(response.headers['Cache-Control'], 'private, max-age=31536000, immutable')
+    assert.equal(Buffer.concat(response.body).toString(), `cloud:${relativePath}`)
+  }
+  assert.deepEqual(hydrated, ['reference.png', 'evaluation/render.png'])
+})
+
+test('hydrates a missing frame from the cloud artifact loader on demand', async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'autocad-trace-cloud-fetch-'))
+  const run = path.join(root, 'batch', 'rollouts', 'task-001')
+  fs.mkdirSync(run, { recursive: true })
+  let hydrated = null
+  const api = createTraceApi({
+    runsRoot: root,
+    cloudArtifactLoader: async (request) => {
+      hydrated = request
+      fs.mkdirSync(path.dirname(request.artifact), { recursive: true })
+      fs.writeFileSync(request.artifact, 'cloud-png')
+    },
+  })
+  const response = new TestResponse()
+  const finished = once(response, 'finish')
+
+  const handled = await api({
+    method: 'GET',
+    url: '/api/runs/batch%2Frollouts%2Ftask-001/file/frames/frame_0042.png',
+  }, response)
+  await finished
+
+  assert.equal(handled, true)
+  assert.equal(response.statusCode, 200)
+  assert.equal(response.headers['Content-Type'], 'image/png')
+  assert.equal(Buffer.concat(response.body).toString(), 'cloud-png')
+  assert.equal(hydrated.runId, 'batch/rollouts/task-001')
+  assert.equal(hydrated.relativePath, 'frames/frame_0042.png')
+})
+
+test('redirects a cold cloud image directly to a short-lived private URL', async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'autocad-trace-cloud-redirect-'))
+  const runId = 'batch/rollouts/task-001'
+  fs.mkdirSync(path.join(root, runId), { recursive: true })
+  let signed = null
+  const api = createTraceApi({
+    runsRoot: root,
+    cloudArtifactUrl: async (request) => {
+      signed = request
+      return 'https://private-origin.example/signed-frame'
+    },
+    cloudArtifactLoader: async () => {
+      assert.fail('the proxy loader must not run after a successful signed redirect')
+    },
+  })
+  const response = new TestResponse()
+  const finished = once(response, 'finish')
+
+  await api({
+    method: 'GET',
+    url: `/api/runs/${encodeURIComponent(runId)}/file/frames/frame_0042.png`,
+  }, response)
+  await finished
+
+  assert.equal(response.statusCode, 307)
+  assert.equal(response.headers.Location, 'https://private-origin.example/signed-frame')
+  assert.equal(response.headers['Cache-Control'], 'private, max-age=240')
+  assert.deepEqual(signed, {
+    runId,
+    relativePath: 'frames/frame_0042.png',
+  })
+})
+
+test('bootstraps a missing live rollout trace from cloud metadata', async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'autocad-trace-cloud-index-'))
+  const runId = 'benchmarks/live-suite/rollouts/task-004'
+  const run = path.join(root, runId)
+  let hydration = null
+  const api = createTraceApi({
+    runsRoot: root,
+    cloudTraceLoader: async (request) => {
+      hydration = request
+      fs.mkdirSync(request.runDirectory, { recursive: true })
+      fs.writeFileSync(path.join(request.runDirectory, 'run-state.json'), JSON.stringify({
+        task_id: 'task-004',
+        model_id: 'claude-fable-5',
+        provider: 'anthropic',
+        state: 'running',
+        accepted_actions: 42,
+      }))
+      fs.writeFileSync(path.join(request.runDirectory, 'model_turn_summaries.jsonl'), `${JSON.stringify({
+        turn: 1,
+        tool_use_id: 'tool-1',
+        action: { actions: [{ action: 'click', x: 1, y: 2 }] },
+        model_input: {
+          artifacts: [{ artifact_path: 'frames/frame_0041.png' }],
+        },
+      })}\n`)
+    },
+  })
+  const response = new TestResponse()
+  const finished = once(response, 'finish')
+
+  await api({
+    method: 'GET',
+    url: `/api/runs/${encodeURIComponent(runId)}`,
+  }, response)
+  await finished
+
+  assert.equal(response.statusCode, 200)
+  assert.equal(hydration.runId, runId)
+  assert.equal(hydration.runDirectory, run)
+  const detail = JSON.parse(Buffer.concat(response.body).toString())
+  assert.equal(detail.summary.acceptedActions, 42)
+  assert.equal(detail.turns.length, 1)
+  assert.deepEqual(detail.frames.map((frame) => frame.name), [
+    'frame_0041.png',
+    'frame_0042.png',
+  ])
+})
+
+test('refreshes stale live benchmark metadata before returning its detail', async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'autocad-benchmark-cloud-refresh-'))
+  const benchmarkId = 'benchmarks/live-suite'
+  const benchmark = path.join(root, benchmarkId)
+  const run = path.join(benchmark, 'rollouts', 'task-004')
+  fs.mkdirSync(run, { recursive: true })
+  fs.writeFileSync(path.join(benchmark, 'batch-state.json'), JSON.stringify({
+    state: 'running',
+    updated_at: '2026-07-18T00:00:00Z',
+    rollouts: {
+      'task-004': {
+        task_id: 'task-004',
+        model_id: 'claude-fable-5',
+        provider: 'anthropic',
+        state: 'running',
+      },
+    },
+  }))
+  fs.writeFileSync(path.join(run, 'run-state.json'), JSON.stringify({
+    task_id: 'task-004',
+    model_id: 'claude-fable-5',
+    provider: 'anthropic',
+    state: 'running',
+    accepted_actions: 1,
+  }))
+  let refreshCount = 0
+  const api = createTraceApi({
+    runsRoot: root,
+    cloudBenchmarkLoader: async ({ benchmarkDirectory }) => {
+      refreshCount += 1
+      fs.writeFileSync(path.join(
+        benchmarkDirectory, 'rollouts', 'task-004', 'run-state.json',
+      ), JSON.stringify({
+        task_id: 'task-004',
+        model_id: 'claude-fable-5',
+        provider: 'anthropic',
+        state: 'running',
+        accepted_actions: 87,
+        turn_count: 21,
+      }))
+    },
+  })
+  const response = new TestResponse()
+  const finished = once(response, 'finish')
+
+  await api({
+    method: 'GET',
+    url: `/api/benchmarks/${encodeURIComponent(benchmarkId)}`,
+  }, response)
+  await finished
+
+  assert.equal(response.statusCode, 200)
+  assert.equal(refreshCount, 1)
+  const detail = JSON.parse(Buffer.concat(response.body).toString())
+  assert.equal(detail.tasks[0].acceptedActions, 87)
+  assert.equal(detail.aggregate.acceptedActions, 87)
+  assert.equal(detail.aggregate.usage.modelTurns, 21)
+})
+
+test('content-addresses model frames and replaces a stale local frame', async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'autocad-trace-stale-frame-'))
+  const runId = 'batch/rollouts/task-001'
+  const run = path.join(root, runId)
+  const frames = path.join(run, 'frames')
+  fs.mkdirSync(frames, { recursive: true })
+  const freshFrame = Buffer.from('fresh-cloud-frame')
+  const expectedSha256 = createHash('sha256').update(freshFrame).digest('hex')
+  fs.writeFileSync(path.join(frames, 'frame_0042.png'), 'stale-local-frame')
+  fs.writeFileSync(path.join(run, 'run-state.json'), JSON.stringify({
+    task_id: 'task-001',
+    model_id: 'gpt-test',
+    provider: 'openai',
+    state: 'completed',
+  }))
+  fs.writeFileSync(path.join(run, 'model_turn_summaries.jsonl'), `${JSON.stringify({
+    turn: 1,
+    model_input: {
+      artifacts: [{
+        artifact_path: 'frames/frame_0042.png',
+        sha256: expectedSha256,
+        sequence: 42,
+      }],
+    },
+  })}\n`)
+
+  const detail = _test.traceDetail(root, runId)
+  assert.equal(detail.frames[0].sha256, expectedSha256)
+  assert.equal(
+    detail.frames[0].url,
+    `/api/runs/batch%2Frollouts%2Ftask-001/file/frames/frame_0042.png?sha256=${expectedSha256}`,
+  )
+
+  let hydration = null
+  const api = createTraceApi({
+    runsRoot: root,
+    cloudArtifactLoader: async (request) => {
+      hydration = request
+      fs.writeFileSync(request.artifact, freshFrame)
+    },
+  })
+  const response = new TestResponse()
+  const finished = once(response, 'finish')
+  await api({
+    method: 'GET',
+    url: `${detail.frames[0].url}`,
+  }, response)
+  await finished
+
+  assert.equal(response.statusCode, 200)
+  assert.equal(Buffer.concat(response.body).toString(), freshFrame.toString())
+  assert.equal(response.headers['Cache-Control'], 'private, max-age=31536000, immutable')
+  assert.equal(hydration.force, true)
+  assert.equal(hydration.expectedSha256, expectedSha256)
+})
+
+test('never serves a stale frame when cloud refresh does not match its checksum', async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'autocad-trace-reject-stale-frame-'))
+  const runId = 'batch/rollouts/task-001'
+  const run = path.join(root, runId)
+  const frames = path.join(run, 'frames')
+  fs.mkdirSync(frames, { recursive: true })
+  const expectedSha256 = createHash('sha256').update('expected-frame').digest('hex')
+  fs.writeFileSync(path.join(frames, 'frame_0001.png'), 'stale-frame')
+
+  const api = createTraceApi({
+    runsRoot: root,
+    cloudArtifactLoader: async () => {},
+  })
+  const response = new TestResponse()
+  const finished = once(response, 'finish')
+  await api({
+    method: 'GET',
+    url: `/api/runs/${encodeURIComponent(runId)}/file/frames/frame_0001.png?sha256=${expectedSha256}`,
+  }, response)
+  await finished
+
+  assert.equal(response.statusCode, 404)
+  assert.match(Buffer.concat(response.body).toString(), /artifact_not_found/)
+})
+
+test('uses compact turn summaries without returning repeated request history', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'autocad-trace-compact-'))
+  const run = path.join(root, 'compact-run')
+  fs.mkdirSync(run)
+  fs.writeFileSync(path.join(run, 'run-state.json'), JSON.stringify({
+    task_id: 'task-001',
+    model_id: 'claude-test',
+    provider: 'anthropic',
+    state: 'completed',
+    turn_count: 1,
+  }))
+  fs.writeFileSync(path.join(run, 'model_turns.jsonl'), 'x'.repeat(9 * 1024 * 1024))
+  fs.writeFileSync(path.join(run, 'model_turn_summaries.jsonl'), `${JSON.stringify({
+    turn: 1,
+    tool_use_id: 'call-compact',
+    action: { action: 'done' },
+    model_input: {
+      model: 'claude-test',
+      artifacts: [{ artifact_path: 'frames/frame_0000.png' }],
+    },
+  })}\n`)
+
+  const detail = _test.traceDetail(root, 'compact-run')
+
+  assert.equal(detail.traceIndexed, true)
+  assert.equal(detail.turns.length, 1)
+  assert.equal(detail.turns[0].tool_use_id, 'call-compact')
+  assert.equal(JSON.stringify(detail).includes('repeated request history'), false)
+  assert.equal('events' in detail, false)
+  assert.equal('frameEvents' in detail, false)
+})
+
+test('does not synchronously parse a large unindexed trace for benchmark usage', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'autocad-trace-large-'))
+  const run = path.join(root, 'large-run')
+  fs.mkdirSync(run)
+  const trace = path.join(run, 'model_turns.jsonl')
+  fs.writeFileSync(trace, '')
+  fs.truncateSync(trace, 9 * 1024 * 1024)
+
+  const usage = _test.runUsage(run, { input_per_million: 5 }, {
+    turn_count: 42,
+    usage: { input_tokens: 1200, output_tokens: 30, total_tokens: 1230 },
+  })
+
+  assert.equal(usage.modelTurns, 42)
+  assert.equal(usage.inputTokens, 1200)
+  assert.equal(usage.totalTokens, 1230)
+  assert.equal(usage.apiCost, null)
+})
+
+test('uses the live aggregate instead of parsing a large compact usage index', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'autocad-summary-large-'))
+  const run = path.join(root, 'large-summary-run')
+  fs.mkdirSync(run)
+  const summary = path.join(run, 'model_turn_summaries.jsonl')
+  fs.writeFileSync(summary, '')
+  fs.truncateSync(summary, 600 * 1024)
+
+  const usage = _test.runUsage(run, { input_per_million: 5 }, {
+    turn_count: 77,
+    usage: { input_tokens: 9000, output_tokens: 80, total_tokens: 9080 },
+  })
+
+  assert.equal(usage.modelTurns, 77)
+  assert.equal(usage.inputTokens, 9000)
+  assert.equal(usage.totalTokens, 9080)
+  assert.equal(usage.apiCost, null)
+})
+
+test('reconciles a stale running batch row with a completed rollout trace', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'autocad-trace-stale-batch-'))
+  const benchmark = path.join(root, 'stale-batch')
+  const run = path.join(benchmark, 'rollouts', 'task-001')
+  fs.mkdirSync(run, { recursive: true })
+  fs.writeFileSync(path.join(benchmark, 'batch-state.json'), JSON.stringify({
+    state: 'running',
+    updated_at: '2020-01-01T00:00:00Z',
+    rollouts: {
+      'task-001': {
+        task_id: 'task-001',
+        model_id: 'claude-test',
+        provider: 'anthropic',
+        state: 'running',
+      },
+      'task-002': {
+        task_id: 'task-002',
+        model_id: 'claude-test',
+        provider: 'anthropic',
+        state: 'queued',
+      },
+    },
+  }))
+  fs.writeFileSync(path.join(run, 'run-state.json'), JSON.stringify({
+    task_id: 'task-001',
+    model_id: 'claude-test',
+    provider: 'anthropic',
+    state: 'completed',
+    turn_count: 1,
+  }))
+
+  const detail = _test.benchmarkDetail(root, 'stale-batch')
+
+  assert.equal(detail.tasks[0].status, 'completed')
+  assert.equal(detail.aggregate.completedTasks, 1)
+  assert.equal(detail.aggregate.activeTasks, 0)
+  assert.equal(detail.status, 'interrupted')
+})
+
+test('calculates cached and long-context token costs per model turn', () => {
+  const pricing = {
+    input_per_million: 5,
+    cached_input_per_million: 0.5,
+    output_per_million: 30,
+    long_context_threshold_tokens: 272000,
+    long_context_input_multiplier: 2,
+    long_context_output_multiplier: 1.5,
+  }
+  const usage = _test.usageSummary([
+    { usage: {
+      input_tokens: 1000,
+      cached_input_tokens: 400,
+      output_tokens: 100,
+      reasoning_output_tokens: 60,
+      total_tokens: 1100,
+    } },
+    { usage: { input_tokens: 300000, output_tokens: 1000, total_tokens: 301000 } },
+  ], pricing)
+
+  assert.equal(usage.inputTokens, 301000)
+  assert.equal(usage.cachedInputTokens, 400)
+  assert.equal(usage.outputTokens, 1100)
+  assert.equal(usage.reasoningOutputTokens, 60)
+  assert.ok(Math.abs(usage.apiCost - 3.0512) < 1e-12)
+})
+
+test('aggregates a live multi-task benchmark from batch state and rollout traces', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'autocad-benchmark-'))
+  const benchmark = path.join(root, 'benchmarks', 'full-suite')
+  const completed = path.join(benchmark, 'rollouts', 'task-001')
+  fs.mkdirSync(completed, { recursive: true })
+  fs.writeFileSync(path.join(benchmark, 'batch-state.json'), JSON.stringify({
+    schema_version: 2,
+    batch_id: 'batch-full',
+    benchmark_name: 'Full suite',
+    state: 'running',
+    started_at: '2026-07-16T00:00:00Z',
+    updated_at: '2026-07-16T00:10:00Z',
+    max_concurrency: 10,
+    pricing: {
+      input_per_million: 5,
+      cached_input_per_million: 0.5,
+      output_per_million: 30,
+    },
+    rollouts: {
+      'task-001': {
+        task_id: 'task-001',
+        model_id: 'gpt-5.6-sol',
+        provider: 'openai',
+        state: 'completed',
+      },
+      'task-022': {
+        task_id: 'task-022',
+        model_id: 'gpt-5.6-sol',
+        provider: 'openai',
+        state: 'queued',
+      },
+    },
+  }))
+  fs.writeFileSync(path.join(completed, 'result.json'), JSON.stringify({
+    task_id: 'task-001',
+    model_id: 'gpt-5.6-sol',
+    provider: 'openai',
+    completed: true,
+    accepted_actions: 20,
+    artifact_bytes: 1234,
+  }))
+  fs.writeFileSync(path.join(completed, 'model_turns.jsonl'), `${JSON.stringify({
+    usage: { input_tokens: 1000, cached_input_tokens: 400, output_tokens: 100 },
+  })}\n`)
+
+  const detail = _test.benchmarkDetail(root, 'benchmarks/full-suite')
+
+  assert.equal(detail.name, 'Full suite')
+  assert.equal(detail.aggregate.totalTasks, 2)
+  assert.equal(detail.aggregate.completedTasks, 1)
+  assert.equal(detail.aggregate.queuedTasks, 1)
+  assert.equal(detail.aggregate.artifactTasks, 1)
+  assert.equal(detail.aggregate.usage.inputTokens, 1000)
+  assert.ok(Math.abs(detail.aggregate.usage.apiCost - 0.0062) < 1e-12)
+  assert.deepEqual(detail.tasks.map((task) => task.level), ['basic', 'basic'])
+  assert.deepEqual(detail.tasks.map((task) => task.drawingType), ['2d', '3d'])
+  assert.deepEqual(detail.aggregate.drawingTypes, {
+    '2d': { total: 1, scored: 0, meanScore: null },
+    '3d': { total: 1, scored: 0, meanScore: null },
+  })
+  assert.deepEqual(detail.aggregate.evaluationStates, {
+    awaiting_score: 1,
+    queued: 1,
+  })
+  assert.equal(_test.listBenchmarks(root)[0].id, 'benchmarks/full-suite')
+})
+
+test('keeps execution, recovery, budget, infrastructure, and evaluation states separate', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'autocad-outcomes-'))
+  const benchmark = path.join(root, 'benchmarks', 'outcomes')
+  const cases = {
+    completed: { completed: true, stop_reason: 'done', artifact_bytes: 10 },
+    recovered: { completed: false, stop_reason: 'recovered_finalized_session', artifact_bytes: 10 },
+    budget: { completed: false, stop_reason: 'max_actions', artifact_bytes: 10 },
+    infra: { completed: false, stop_reason: 'rollout_error', failure: 'ConnectError', artifact_bytes: 10 },
+    model: { completed: false, stop_reason: 'invalid_action_limit', failure: 'invalid', artifact_bytes: 10 },
+  }
+  fs.mkdirSync(benchmark, { recursive: true })
+  fs.writeFileSync(path.join(benchmark, 'batch-state.json'), JSON.stringify({
+    state: 'running',
+    updated_at: '2020-01-01T00:00:00Z',
+    rollouts: Object.fromEntries(Object.keys(cases).map((task) => [task, {
+      task_id: 'task-001', model_id: 'model', provider: 'openai', state: 'failed',
+      failure: 'stale wrapper failure',
+    }])),
+  }))
+  for (const [name, result] of Object.entries(cases)) {
+    const run = path.join(benchmark, 'rollouts', name)
+    fs.mkdirSync(path.join(run, 'evaluation'), { recursive: true })
+    fs.writeFileSync(path.join(run, 'result.json'), JSON.stringify({
+      task_id: 'task-001', model_id: 'model', provider: 'openai', ...result,
+    }))
+  }
+  fs.writeFileSync(
+    path.join(benchmark, 'rollouts', 'completed', 'evaluation', 'status.json'),
+    JSON.stringify({ stage: 'failed', error: 'VisionJudgeError: ReadTimeout' }),
+  )
+
+  const detail = _test.benchmarkDetail(root, 'benchmarks/outcomes')
+
+  assert.equal(detail.status, 'completed_with_issues')
+  assert.equal(detail.aggregate.settledTasks, 5)
+  assert.equal(detail.aggregate.completedTasks, 1)
+  assert.equal(detail.aggregate.recoveredTasks, 1)
+  assert.equal(detail.aggregate.budgetExhaustedTasks, 1)
+  assert.equal(detail.aggregate.infrastructureFailedTasks, 1)
+  assert.equal(detail.aggregate.failedTasks, 1)
+  assert.equal(detail.tasks.find((task) => task.rolloutId === 'completed').status, 'completed')
+  assert.equal(detail.tasks.find((task) => task.rolloutId === 'completed').failure, null)
+  assert.equal(detail.tasks.find((task) => task.rolloutId === 'budget').failure, null)
+  assert.equal(detail.tasks.find((task) => task.rolloutId === 'infra').failure, 'ConnectError')
+  assert.equal(detail.tasks.find((task) => task.rolloutId === 'completed').evaluationState, 'evaluation_failed')
+})

apps/dashboard/trace-api.d.mts

@@ -0,0 +1,71 @@
+export function createTraceApi(options?: {}): (request: any, response: any) => Promise<boolean>;
+export namespace _test {
+    export { readJsonl };
+    export { safeRunDirectory };
+    export { safeArtifact };
+    export { runSummary };
+    export { traceDetail };
+}
+declare function readJsonl(filePath: any): any[];
+declare function safeRunDirectory(runsRoot: any, runId: any): string;
+declare function safeArtifact(runDirectory: any, relativePath: any): string;
+declare function runSummary(runsRoot: any, runId: any): {
+    id: any;
+    taskId: any;
+    attemptId: any;
+    modelId: any;
+    provider: any;
+    reasoningEffort: any;
+    status: any;
+    stopReason: any;
+    failure: any;
+    acceptedActions: any;
+    invalidActions: any;
+    screenshots: any;
+    elapsedSeconds: any;
+    artifactBytes: any;
+    score: any;
+    valid: any;
+    scoreFailure: any;
+    updatedAt: any;
+};
+declare function traceDetail(runsRoot: any, runId: any): {
+    summary: {
+        id: any;
+        taskId: any;
+        attemptId: any;
+        modelId: any;
+        provider: any;
+        reasoningEffort: any;
+        status: any;
+        stopReason: any;
+        failure: any;
+        acceptedActions: any;
+        invalidActions: any;
+        screenshots: any;
+        elapsedSeconds: any;
+        artifactBytes: any;
+        score: any;
+        valid: any;
+        scoreFailure: any;
+        updatedAt: any;
+    };
+    state: any;
+    result: any;
+    score: any;
+    turns: any[];
+    receipts: any[];
+    events: any[];
+    frameEvents: any[];
+    frames: {
+        name: string;
+        url: string;
+    }[];
+    referenceUrl: string;
+    artifacts: {
+        dwg: string;
+        candidateRender: string;
+        diffRender: string;
+    };
+};
+export {};

apps/dashboard/trace-api.mjs

@@ -0,0 +1,1080 @@
+import fs from 'node:fs'
+import { createHash } from 'node:crypto'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const DASHBOARD_ROOT = path.dirname(fileURLToPath(import.meta.url))
+const CHECKOUT_ROOT = path.resolve(DASHBOARD_ROOT, '..', '..')
+const BENCHMARK_DATA_ROOT = path.resolve(
+  process.env.AUTOCAD_BENCH_ROOT || CHECKOUT_ROOT,
+)
+const DEFAULT_RUNS_ROOT = path.join(CHECKOUT_ROOT, 'runs')
+const MANIFEST_PATH = path.join(BENCHMARK_DATA_ROOT, 'tasks', 'manifest.jsonl')
+const TRACE_SUMMARY_NAME = 'model_turn_summaries.jsonl'
+const MAX_INLINE_LEGACY_TRACE_BYTES = 8 * 1024 * 1024
+const MAX_INLINE_USAGE_SUMMARY_BYTES = 512 * 1024
+const usageCache = new Map()
+
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8').replace(/^\uFEFF/, ''))
+  } catch {
+    return null
+  }
+}
+
+function readJsonl(filePath) {
+  try {
+    return fs
+      .readFileSync(filePath, 'utf8')
+      .split(/\r?\n/)
+      .filter((line) => line.trim())
+      .flatMap((line) => {
+        try {
+          return [JSON.parse(line.replace(/^\uFEFF/, ''))]
+        } catch {
+          return []
+        }
+      })
+  } catch {
+    return []
+  }
+}
+
+function modelInputArtifacts(value, output = []) {
+  if (Array.isArray(value)) {
+    for (const item of value) modelInputArtifacts(item, output)
+    return output
+  }
+  if (!value || typeof value !== 'object') return output
+  if (typeof value.artifact_path === 'string') {
+    output.push(Object.fromEntries(Object.entries(value).filter(([key]) => [
+      'type', 'artifact_path', 'sha256', 'bytes', 'width', 'height', 'sequence',
+    ].includes(key))))
+  }
+  for (const item of Object.values(value)) modelInputArtifacts(item, output)
+  return output
+}
+
+function compactTurn(turn) {
+  if (!turn || typeof turn !== 'object') return turn
+  const compact = Object.fromEntries(
+    Object.entries(turn).filter(([key]) => key !== 'model_input'),
+  )
+  if (turn.model_input && typeof turn.model_input === 'object') {
+    compact.model_input = {
+      model: turn.model_input.model || null,
+      artifacts: modelInputArtifacts(turn.model_input),
+    }
+  }
+  return compact
+}
+
+function traceSummaryPath(runDirectory) {
+  return path.join(runDirectory, TRACE_SUMMARY_NAME)
+}
+
+function traceTurns(runDirectory) {
+  const summaryPath = traceSummaryPath(runDirectory)
+  if (fs.existsSync(summaryPath)) return readJsonl(summaryPath)
+  const legacyPath = path.join(runDirectory, 'model_turns.jsonl')
+  try {
+    if (fs.statSync(legacyPath).size <= MAX_INLINE_LEGACY_TRACE_BYTES) {
+      return readJsonl(legacyPath).map(compactTurn)
+    }
+  } catch {
+    // Missing or actively-created traces simply have no turns yet.
+  }
+  return []
+}
+
+function manifestByTask() {
+  const entries = readJsonl(MANIFEST_PATH)
+  return new Map(entries.map((entry) => [entry.task_id, entry]))
+}
+
+function safeRunDirectory(runsRoot, runId) {
+  if (!runId || runId.includes('\\')) {
+    return null
+  }
+  const segments = runId.split('/')
+  if (segments.some((segment) => !segment || segment === '.' || segment === '..')) return null
+  const candidate = path.resolve(runsRoot, runId)
+  return candidate.startsWith(path.resolve(runsRoot) + path.sep) ? candidate : null
+}
+
+function safeArtifact(runDirectory, relativePath) {
+  const candidate = path.resolve(runDirectory, relativePath)
+  return candidate.startsWith(path.resolve(runDirectory) + path.sep) ? candidate : null
+}
+
+function normalizeSha256(value) {
+  const sha256 = String(value || '').toLowerCase()
+  return /^[a-f0-9]{64}$/.test(sha256) ? sha256 : null
+}
+
+function fileSha256(filePath) {
+  try {
+    if (!fs.statSync(filePath).isFile()) return null
+    return createHash('sha256').update(fs.readFileSync(filePath)).digest('hex')
+  } catch {
+    return null
+  }
+}
+
+function contentType(filePath) {
+  const extension = path.extname(filePath).toLowerCase()
+  return {
+    '.png': 'image/png',
+    '.json': 'application/json; charset=utf-8',
+    '.jsonl': 'application/x-ndjson; charset=utf-8',
+    '.dwg': 'application/acad',
+  }[extension] || 'application/octet-stream'
+}
+
+function sendJson(response, status, value) {
+  response.statusCode = status
+  response.setHeader('Content-Type', 'application/json; charset=utf-8')
+  response.setHeader('Cache-Control', 'no-store')
+  response.end(JSON.stringify(value))
+}
+
+function sendFile(response, filePath, { immutable = false } = {}) {
+  if (!filePath || !fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) {
+    sendJson(response, 404, { error: 'artifact_not_found' })
+    return
+  }
+  response.statusCode = 200
+  response.setHeader('Content-Type', contentType(filePath))
+  response.setHeader(
+    'Cache-Control',
+    immutable ? 'private, max-age=31536000, immutable' : 'no-store',
+  )
+  fs.createReadStream(filePath).pipe(response)
+}
+
+function sendPrivateRedirect(response, location) {
+  response.statusCode = 307
+  response.setHeader('Location', location)
+  // Keep the stable local URL cached only inside this browser and comfortably
+  // below the five-minute lifetime of the signed origin URL.
+  response.setHeader('Cache-Control', 'private, max-age=240')
+  response.end()
+}
+
+function readRunScores(runDirectory) {
+  const visionArtifact = readJson(path.join(
+    runDirectory, 'evaluation', 'vision-judge', 'score.json',
+  ))
+  const vision = visionArtifact
+    ? {
+      ...visionArtifact,
+      score: visionArtifact.overall_score ?? null,
+      valid: true,
+      failure_reason: null,
+      scoring_method: `vision:${visionArtifact.prompt_version || 'unknown'}`,
+      geometry_similarity: visionArtifact.component_scores?.geometry ?? null,
+      dimension_similarity: visionArtifact.component_scores?.dimensions ?? null,
+      annotation_similarity: visionArtifact.component_scores?.annotations ?? null,
+      visual_similarity: visionArtifact.component_scores?.presentation ?? null,
+      score_source: 'vision_judge',
+    }
+    : null
+  const deterministicArtifact = readJson(path.join(
+    runDirectory, 'evaluation', 'score.json',
+  ))
+  const deterministic = deterministicArtifact
+    ? { ...deterministicArtifact, score_source: 'deterministic' }
+    : null
+  return {
+    vision,
+    deterministic,
+    displayed: vision || deterministic,
+  }
+}
+
+function readRunScore(runDirectory) {
+  return readRunScores(runDirectory).displayed
+}
+
+function scoreSummary(score) {
+  if (!score) return null
+  return {
+    source: score.score_source ?? null,
+    score: score.score ?? null,
+    valid: score.valid ?? null,
+    failureReason: score.failure_reason ?? null,
+    method: score.scoring_method ?? null,
+    verdict: score.verdict ?? null,
+    targetAcquired: score.target_acquired ?? null,
+    confidence: score.confidence ?? null,
+    needsHumanReview: score.needs_human_review ?? false,
+    geometry: score.geometry_similarity ?? null,
+    dimensions: score.dimension_similarity ?? null,
+    annotations: score.annotation_similarity ?? null,
+    presentation: score.visual_similarity ?? null,
+  }
+}
+
+const ACTIVE_STATES = new Set([
+  'starting', 'resetting', 'handoff_ready', 'running', 'finalizing',
+])
+const TERMINAL_EXECUTION_STATES = new Set([
+  'completed', 'recovered', 'budget_exhausted', 'model_failed',
+  'infrastructure_failed', 'artifact_missing', 'interrupted',
+])
+const ACTIVE_EVALUATION_STAGES = new Set([
+  'inspecting', 'deterministic_scoring', 'vision_judging',
+])
+
+function executionState(result, state = null) {
+  if (TERMINAL_EXECUTION_STATES.has(result?.execution_status)) {
+    return result.execution_status
+  }
+  const stopReason = String(result?.stop_reason || '').toLowerCase()
+  const failure = String(result?.failure || '').toLowerCase()
+  const artifactBytes = Number(result?.artifact_bytes || 0)
+  if (result?.completed === true || stopReason === 'done') {
+    return artifactBytes > 0 ? 'completed' : 'artifact_missing'
+  }
+  if (stopReason === 'recovered_finalized_session' && artifactBytes > 0) return 'recovered'
+  if (['max_actions', 'wall_timeout'].includes(stopReason)) return 'budget_exhausted'
+  if (['operator_stopped', 'interrupted'].includes(stopReason)) return 'interrupted'
+  if (stopReason === 'rollout_error' || [
+    'brokererror', 'connecterror', 'connection attempts failed',
+    'nodename nor servname', 'transport unavailable', 'ssm',
+  ].some((marker) => failure.includes(marker))) return 'infrastructure_failed'
+  if (result && artifactBytes <= 0 && !failure) return 'artifact_missing'
+  if (result) return 'model_failed'
+  if (ACTIVE_STATES.has(state?.state)) return state.state
+  if (TERMINAL_EXECUTION_STATES.has(state?.state)) return state.state
+  return state?.state || 'running'
+}
+
+function evaluationState({ status, artifactBytes, score, evaluationStatus = null }) {
+  if (status === 'queued') return 'queued'
+  if (ACTIVE_STATES.has(status)) return 'running'
+  if (ACTIVE_EVALUATION_STAGES.has(evaluationStatus?.stage)) {
+    const updatedAt = Date.parse(evaluationStatus?.updated_at || '')
+    if (Number.isFinite(updatedAt) && Date.now() - updatedAt > 30 * 60 * 1000) {
+      return 'evaluation_interrupted'
+    }
+    return 'evaluating'
+  }
+  if (evaluationStatus?.stage === 'retry_pending') return 'evaluation_retrying'
+  if (evaluationStatus?.stage === 'failed') return 'evaluation_failed'
+  if (score?.valid === false || score?.failure_reason) return 'candidate_invalid'
+  if (Number.isFinite(score?.score)) return 'scored'
+  if (artifactBytes > 0) return 'awaiting_score'
+  if (['model_failed', 'infrastructure_failed', 'artifact_missing', 'interrupted'].includes(status)) return 'run_failed'
+  return 'no_artifact'
+}
+
+function runSummary(runsRoot, runId) {
+  const runDirectory = safeRunDirectory(runsRoot, runId)
+  if (!runDirectory) return null
+  const result = readJson(path.join(runDirectory, 'result.json'))
+  const state = readJson(path.join(runDirectory, 'run-state.json'))
+  const evaluationStatus = readJson(path.join(
+    runDirectory, 'evaluation', 'status.json',
+  ))
+  const scores = readRunScores(runDirectory)
+  const score = scores.displayed
+  const stats = fs.statSync(runDirectory)
+  const status = executionState(result, state)
+  const artifactBytes = result?.artifact_bytes ?? 0
+  const executionCanCarryFailure = [
+    'model_failed', 'infrastructure_failed', 'artifact_missing', 'interrupted',
+  ].includes(status)
+  return {
+    id: runId,
+    taskId: state?.task_id || result?.task_id || 'unknown',
+    attemptId: state?.attempt_id || result?.attempt_id || null,
+    modelId: state?.model_id || result?.model_id || 'unknown',
+    provider: state?.provider || result?.provider || (String(result?.model_id || '').includes('nova') ? 'bedrock' : 'unknown'),
+    reasoningEffort: state?.reasoning_effort || result?.reasoning_effort || null,
+    status,
+    stopReason: result?.stop_reason || state?.stop_reason || null,
+    failure: executionCanCarryFailure
+      ? (result?.failure || state?.failure || null)
+      : (result?.failure || null),
+    acceptedActions: state?.accepted_actions ?? result?.accepted_actions ?? readJsonl(path.join(runDirectory, 'input_receipts.jsonl')).length,
+    invalidActions: state?.invalid_actions ?? result?.invalid_actions ?? 0,
+    screenshots: state?.screenshots ?? result?.screenshots ?? 0,
+    elapsedSeconds: result?.elapsed_s ?? null,
+    artifactBytes,
+    score: score?.score ?? null,
+    valid: score?.valid ?? null,
+    scoreFailure: score?.failure_reason ?? null,
+    scoreMethod: score?.scoring_method ?? null,
+    scoreSource: score?.score_source ?? null,
+    verdict: score?.verdict ?? null,
+    targetAcquired: score?.target_acquired ?? null,
+    judgeConfidence: score?.confidence ?? null,
+    needsHumanReview: score?.needs_human_review ?? false,
+    visionScore: scoreSummary(scores.vision),
+    deterministicScore: scoreSummary(scores.deterministic),
+    evaluationState: evaluationState({
+      status, artifactBytes, score, evaluationStatus,
+    }),
+    evaluationStage: evaluationStatus?.stage || null,
+    evaluationError: evaluationStatus?.error || null,
+    updatedAt: evaluationStatus?.updated_at || state?.updated_at || stats.mtime.toISOString(),
+  }
+}
+
+function listRuns(runsRoot) {
+  if (!fs.existsSync(runsRoot)) return []
+  const runIds = []
+  const visit = (directory, relativeDirectory, depth) => {
+    if (depth > 4) return
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue
+      const relativePath = relativeDirectory
+        ? `${relativeDirectory}/${entry.name}`
+        : entry.name
+      const child = path.join(directory, entry.name)
+      const isRun = ['run-state.json', 'result.json', 'model_turns.jsonl']
+        .some((name) => fs.existsSync(path.join(child, name)))
+      if (isRun) runIds.push(relativePath)
+      else visit(child, relativePath, depth + 1)
+    }
+  }
+  visit(runsRoot, '', 1)
+  return runIds
+    .map((runId) => runSummary(runsRoot, runId))
+    .filter(Boolean)
+    .sort((left, right) => String(right.updatedAt).localeCompare(String(left.updatedAt)))
+}
+
+function usageSummary(turns, pricing = null) {
+  const totals = {
+    inputTokens: 0,
+    cachedInputTokens: 0,
+    outputTokens: 0,
+    reasoningOutputTokens: 0,
+    totalTokens: 0,
+    modelTurns: turns.length,
+    apiCost: pricing ? 0 : null,
+  }
+  for (const turn of turns) {
+    const usage = turn?.usage || {}
+    const input = Number(usage.input_tokens ?? usage.inputTokens ?? 0) || 0
+    const cached = Math.min(
+      input,
+      Number(usage.cached_input_tokens ?? usage.cachedInputTokens ?? 0) || 0,
+    )
+    const output = Number(usage.output_tokens ?? usage.outputTokens ?? 0) || 0
+    const reasoning = Number(
+      usage.reasoning_output_tokens ?? usage.reasoningOutputTokens ?? 0,
+    ) || 0
+    totals.inputTokens += input
+    totals.cachedInputTokens += cached
+    totals.outputTokens += output
+    totals.reasoningOutputTokens += reasoning
+    totals.totalTokens += Number(usage.total_tokens ?? usage.totalTokens ?? input + output) || 0
+    if (pricing) {
+      const isLong = pricing.long_context_threshold_tokens != null
+        && input > Number(pricing.long_context_threshold_tokens)
+      const inputMultiplier = isLong
+        ? Number(pricing.long_context_input_multiplier ?? 1)
+        : 1
+      const outputMultiplier = isLong
+        ? Number(pricing.long_context_output_multiplier ?? 1)
+        : 1
+      const uncached = Math.max(0, input - cached)
+      totals.apiCost += inputMultiplier * (
+        uncached * Number(pricing.input_per_million ?? 0)
+        + cached * Number(pricing.cached_input_per_million ?? 0)
+      ) / 1_000_000
+      totals.apiCost += outputMultiplier
+        * output * Number(pricing.output_per_million ?? 0) / 1_000_000
+    }
+  }
+  return totals
+}
+
+function cachedUsageSummary(filePath, pricing) {
+  let stats
+  try {
+    stats = fs.statSync(filePath)
+  } catch {
+    return null
+  }
+  const cacheKey = JSON.stringify([
+    stats.size, stats.mtimeMs, pricing || null,
+  ])
+  const cached = usageCache.get(filePath)
+  if (cached?.key === cacheKey) return cached.value
+  const value = usageSummary(readJsonl(filePath), pricing)
+  usageCache.set(filePath, { key: cacheKey, value })
+  if (usageCache.size > 64) usageCache.delete(usageCache.keys().next().value)
+  return value
+}
+
+function runUsage(
+  runDirectory,
+  pricing,
+  runState = null,
+  result = null,
+  { preferAggregate = false } = {},
+) {
+  const summaryPath = traceSummaryPath(runDirectory)
+  if (!preferAggregate) {
+    try {
+      if (fs.statSync(summaryPath).size <= MAX_INLINE_USAGE_SUMMARY_BYTES) {
+        const compact = cachedUsageSummary(summaryPath, pricing)
+        if (compact) return compact
+      }
+    } catch {
+      // Fall through to the legacy trace or live aggregate.
+    }
+  }
+
+  const legacyPath = path.join(runDirectory, 'model_turns.jsonl')
+  if (!preferAggregate) {
+    try {
+      if (fs.statSync(legacyPath).size <= MAX_INLINE_LEGACY_TRACE_BYTES) {
+        return cachedUsageSummary(legacyPath, pricing)
+      }
+    } catch {
+      // Fall through to the live aggregate written by newer pilots.
+    }
+  }
+
+  const raw = runState?.usage || result?.usage
+  const modelTurns = Number(runState?.turn_count ?? 0) || 0
+  if (!raw || typeof raw !== 'object') {
+    return {
+      inputTokens: 0,
+      cachedInputTokens: 0,
+      outputTokens: 0,
+      reasoningOutputTokens: 0,
+      totalTokens: 0,
+      modelTurns,
+      apiCost: modelTurns ? null : (pricing ? 0 : null),
+    }
+  }
+  const inputTokens = Number(raw.input_tokens ?? raw.inputTokens ?? 0) || 0
+  const outputTokens = Number(raw.output_tokens ?? raw.outputTokens ?? 0) || 0
+  return {
+    inputTokens,
+    cachedInputTokens: Number(
+      raw.cached_input_tokens ?? raw.cache_read_input_tokens
+      ?? raw.cachedInputTokens ?? 0,
+    ) || 0,
+    outputTokens,
+    reasoningOutputTokens: Number(
+      raw.reasoning_output_tokens ?? raw.reasoningOutputTokens ?? 0,
+    ) || 0,
+    totalTokens: Number(
+      raw.total_tokens ?? raw.totalTokens ?? inputTokens + outputTokens,
+    ) || 0,
+    modelTurns,
+    // Exact cost can depend on per-request long-context thresholds. The compact
+    // per-turn sidecar is authoritative whenever pricing is configured.
+    apiCost: null,
+  }
+}
+
+function listBenchmarkIds(runsRoot) {
+  if (!fs.existsSync(runsRoot)) return []
+  const ids = []
+  const visit = (directory, relativeDirectory, depth) => {
+    if (depth > 4) return
+    if (fs.existsSync(path.join(directory, 'batch-state.json'))) {
+      ids.push(relativeDirectory)
+      return
+    }
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue
+      const relativePath = relativeDirectory
+        ? `${relativeDirectory}/${entry.name}`
+        : entry.name
+      visit(path.join(directory, entry.name), relativePath, depth + 1)
+    }
+  }
+  visit(runsRoot, '', 0)
+  return ids.filter(Boolean)
+}
+
+function benchmarkDetail(
+  runsRoot,
+  benchmarkId,
+  { preferAggregateUsage = false } = {},
+) {
+  const directory = safeRunDirectory(runsRoot, benchmarkId)
+  if (!directory || !fs.existsSync(directory)) return null
+  const state = readJson(path.join(directory, 'batch-state.json'))
+  if (!state || !state.rollouts || typeof state.rollouts !== 'object') return null
+  const manifest = manifestByTask()
+  const pricing = state.pricing || null
+  const tasks = Object.entries(state.rollouts).map(([rolloutId, row]) => {
+    const runId = `${benchmarkId}/rollouts/${rolloutId}`
+    const runDirectory = path.join(directory, 'rollouts', rolloutId)
+    const hasRun = fs.existsSync(runDirectory)
+    const summary = hasRun ? runSummary(runsRoot, runId) : null
+    const runState = hasRun ? readJson(path.join(runDirectory, 'run-state.json')) : null
+    const result = hasRun ? readJson(path.join(runDirectory, 'result.json')) : null
+    const evaluationStatus = hasRun ? readJson(path.join(
+      runDirectory, 'evaluation', 'status.json',
+    )) : null
+    const scores = hasRun
+      ? readRunScores(runDirectory)
+      : { vision: null, deterministic: null, displayed: null }
+    const score = scores.displayed
+    const usage = hasRun
+      ? runUsage(runDirectory, pricing, runState, result, {
+        preferAggregate: preferAggregateUsage,
+      })
+      : usageSummary([], pricing)
+    const taskId = row.task_id || summary?.taskId || state.task_id || 'unknown'
+    const task = manifest.get(taskId)
+    // Batch state covers the complete sandbox lifecycle, including automatic
+    // evaluation. The pilot's local result can say completed while its wrapper
+    // is still judging or has failed evaluation.
+    const rowStatus = row.state || 'queued'
+    const summaryIsTerminal = TERMINAL_EXECUTION_STATES.has(summary?.status)
+    const status = !hasRun && rowStatus === 'running'
+      ? 'starting'
+      : summaryIsTerminal
+        ? summary.status
+        : summary?.status || rowStatus || 'queued'
+    const artifactBytes = summary?.artifactBytes ?? result?.artifact_bytes ?? 0
+    const executionCanCarryFailure = [
+      'model_failed', 'infrastructure_failed', 'artifact_missing', 'interrupted',
+    ].includes(status)
+    return {
+      rolloutId,
+      runId,
+      taskId,
+      level: task?.level || 'unknown',
+      drawingType: task?.drawing_type || '2d',
+      split: task?.split || 'unknown',
+      displayName: row.display_name || rolloutId,
+      modelId: row.model_id || summary?.modelId || 'unknown',
+      provider: row.provider || summary?.provider || 'unknown',
+      status,
+      stopReason: summary?.stopReason || result?.stop_reason || null,
+      failure: executionCanCarryFailure
+        ? (summary?.failure || result?.failure || row.failure || null)
+        : (result?.failure || null),
+      acceptedActions: summary?.acceptedActions ?? result?.accepted_actions ?? 0,
+      invalidActions: summary?.invalidActions ?? result?.invalid_actions ?? 0,
+      elapsedSeconds: summary?.elapsedSeconds ?? result?.elapsed_s ?? null,
+      setupElapsedSeconds: result?.setup_elapsed_s ?? null,
+      rolloutElapsedSeconds: result?.rollout_elapsed_s ?? null,
+      artifactBytes,
+      score: score?.score ?? null,
+      valid: score?.valid ?? null,
+      scoreFailure: score?.failure_reason ?? null,
+      scoreMethod: score?.scoring_method ?? null,
+      scoreSource: score?.score_source ?? null,
+      verdict: score?.verdict ?? null,
+      targetAcquired: score?.target_acquired ?? null,
+      judgeConfidence: score?.confidence ?? null,
+      needsHumanReview: score?.needs_human_review ?? false,
+      visionScore: scoreSummary(scores.vision),
+      deterministicScore: scoreSummary(scores.deterministic),
+      geometrySimilarity: score?.geometry_similarity ?? null,
+      dimensionSimilarity: score?.dimension_similarity ?? null,
+      annotationSimilarity: score?.annotation_similarity ?? null,
+      visualSimilarity: score?.visual_similarity ?? null,
+      evaluationState: summary?.evaluationState || evaluationState({
+        status, artifactBytes, score, evaluationStatus,
+      }),
+      evaluationStage: summary?.evaluationStage || evaluationStatus?.stage || null,
+      evaluationError: summary?.evaluationError || evaluationStatus?.error || null,
+      startedAt: row.started_at || null,
+      finishedAt: row.finished_at || null,
+      updatedAt: summary?.updatedAt || row.finished_at || row.started_at || state.updated_at,
+      usage,
+    }
+  })
+  const numericScores = tasks
+    .map((task) => task.score)
+    .filter((score) => Number.isFinite(score))
+  const visionScores = tasks
+    .map((task) => task.visionScore?.score)
+    .filter((score) => Number.isFinite(score))
+  const deterministicScores = tasks
+    .map((task) => task.deterministicScore?.score)
+    .filter((score) => Number.isFinite(score))
+  const levels = {}
+  const drawingTypes = {}
+  const evaluationStates = {}
+  const executionStates = {}
+  const verdicts = {}
+  for (const task of tasks) {
+    const level = task.level
+    levels[level] ||= { total: 0, completed: 0, scored: 0, scoreSum: 0, cost: 0 }
+    levels[level].total += 1
+    if (task.status === 'completed') levels[level].completed += 1
+    if (Number.isFinite(task.score)) {
+      levels[level].scored += 1
+      levels[level].scoreSum += task.score
+    }
+    levels[level].cost += task.usage.apiCost || 0
+    const drawingType = task.drawingType
+    drawingTypes[drawingType] ||= { total: 0, scored: 0, scoreSum: 0 }
+    drawingTypes[drawingType].total += 1
+    if (Number.isFinite(task.score)) {
+      drawingTypes[drawingType].scored += 1
+      drawingTypes[drawingType].scoreSum += task.score
+    }
+    evaluationStates[task.evaluationState] = (
+      evaluationStates[task.evaluationState] || 0
+    ) + 1
+    executionStates[task.status] = (executionStates[task.status] || 0) + 1
+    if (task.verdict) verdicts[task.verdict] = (verdicts[task.verdict] || 0) + 1
+  }
+  for (const level of Object.values(levels)) {
+    level.meanScore = level.scored ? level.scoreSum / level.scored : null
+    delete level.scoreSum
+  }
+  for (const drawingType of Object.values(drawingTypes)) {
+    drawingType.meanScore = drawingType.scored
+      ? drawingType.scoreSum / drawingType.scored
+      : null
+    delete drawingType.scoreSum
+  }
+  const aggregateUsage = tasks.reduce((aggregate, task) => {
+    for (const key of [
+      'inputTokens', 'cachedInputTokens', 'outputTokens',
+      'reasoningOutputTokens', 'totalTokens', 'modelTurns',
+    ]) aggregate[key] += task.usage[key]
+    if (aggregate.apiCost != null) {
+      if (task.usage.apiCost == null && task.usage.modelTurns > 0) {
+        aggregate.apiCost = null
+      } else {
+        aggregate.apiCost += task.usage.apiCost || 0
+      }
+    }
+    return aggregate
+  }, {
+    inputTokens: 0,
+    cachedInputTokens: 0,
+    outputTokens: 0,
+    reasoningOutputTokens: 0,
+    totalTokens: 0,
+    modelTurns: 0,
+    apiCost: pricing ? 0 : null,
+  })
+  const aggregate = {
+    totalTasks: tasks.length,
+    queuedTasks: tasks.filter((task) => task.status === 'queued').length,
+    activeTasks: tasks.filter((task) => ACTIVE_STATES.has(task.status)).length,
+    settledTasks: tasks.filter((task) => TERMINAL_EXECUTION_STATES.has(task.status)).length,
+    completedTasks: tasks.filter((task) => task.status === 'completed').length,
+    recoveredTasks: tasks.filter((task) => task.status === 'recovered').length,
+    budgetExhaustedTasks: tasks.filter((task) => task.status === 'budget_exhausted').length,
+    failedTasks: tasks.filter((task) => task.status === 'model_failed').length,
+    infrastructureFailedTasks: tasks.filter((task) => task.status === 'infrastructure_failed').length,
+    artifactMissingTasks: tasks.filter((task) => task.status === 'artifact_missing').length,
+    artifactTasks: tasks.filter((task) => task.artifactBytes > 0).length,
+    scoredTasks: numericScores.length,
+    meanScore: numericScores.length
+      ? numericScores.reduce((sum, score) => sum + score, 0) / numericScores.length
+      : null,
+    visionScoredTasks: visionScores.length,
+    visionMeanScore: visionScores.length
+      ? visionScores.reduce((sum, score) => sum + score, 0) / visionScores.length
+      : null,
+    deterministicScoredTasks: deterministicScores.length,
+    deterministicMeanScore: deterministicScores.length
+      ? deterministicScores.reduce((sum, score) => sum + score, 0)
+        / deterministicScores.length
+      : null,
+    acceptedActions: tasks.reduce((sum, task) => sum + task.acceptedActions, 0),
+    invalidActions: tasks.reduce((sum, task) => sum + task.invalidActions, 0),
+    aggregateElapsedSeconds: tasks.reduce(
+      (sum, task) => sum + (task.elapsedSeconds || 0), 0,
+    ),
+    usage: aggregateUsage,
+    levels,
+    drawingTypes,
+    evaluationStates,
+    executionStates,
+    verdicts,
+  }
+  const models = [...new Set(tasks.map((task) => task.modelId))].sort()
+  const providers = [...new Set(tasks.map((task) => task.provider))].sort()
+  const reportedStatus = state.state || 'running'
+  const updatedAtMs = Date.parse(state.updated_at || '')
+  const controllerIsStale = ['starting', 'running'].includes(reportedStatus)
+    && aggregate.activeTasks === 0
+    && aggregate.queuedTasks > 0
+    && !aggregate.evaluationStates.evaluating
+    && Number.isFinite(updatedAtMs)
+    && Date.now() - updatedAtMs > 5 * 60 * 1000
+  const hasExecutionIssues = aggregate.failedTasks > 0
+    || aggregate.infrastructureFailedTasks > 0
+    || aggregate.artifactMissingTasks > 0
+    || aggregate.evaluationStates.evaluation_failed > 0
+    || aggregate.evaluationStates.evaluation_interrupted > 0
+  const derivedStatus = aggregate.activeTasks > 0
+    ? 'running'
+    : aggregate.queuedTasks > 0
+      ? (controllerIsStale ? 'interrupted' : reportedStatus)
+      : aggregate.settledTasks === aggregate.totalTasks
+        ? (hasExecutionIssues ? 'completed_with_issues' : 'completed')
+        : reportedStatus
+  return {
+    id: benchmarkId,
+    batchId: state.batch_id || null,
+    name: state.benchmark_name || state.batch_id || benchmarkId,
+    status: derivedStatus,
+    modelId: models.length === 1 ? models[0] : `${models.length} models`,
+    provider: providers.length === 1 ? providers[0] : `${providers.length} providers`,
+    models,
+    providers,
+    startedAt: state.started_at || null,
+    finishedAt: state.finished_at || null,
+    updatedAt: state.updated_at || null,
+    maxConcurrency: state.max_concurrency || state.preflight?.quota?.requested_instances || null,
+    pricing,
+    aggregate,
+    tasks,
+  }
+}
+
+function listBenchmarks(runsRoot) {
+  return listBenchmarkIds(runsRoot)
+    // Registry refreshes must never synchronously parse every model-turn file
+    // across every historical run. Live run-state aggregates are sufficient
+    // for registry totals; exact per-turn cost remains available in traces.
+    .map((id) => benchmarkDetail(runsRoot, id, { preferAggregateUsage: true }))
+    .filter(Boolean)
+    .map((benchmark) => ({
+      id: benchmark.id,
+      batchId: benchmark.batchId,
+      name: benchmark.name,
+      status: benchmark.status,
+      modelId: benchmark.modelId,
+      provider: benchmark.provider,
+      models: benchmark.models,
+      providers: benchmark.providers,
+      startedAt: benchmark.startedAt,
+      updatedAt: benchmark.updatedAt,
+      maxConcurrency: benchmark.maxConcurrency,
+      aggregate: benchmark.aggregate,
+    }))
+    .sort((left, right) => String(right.updatedAt).localeCompare(String(left.updatedAt)))
+}
+
+function traceDetail(runsRoot, runId) {
+  const runDirectory = safeRunDirectory(runsRoot, runId)
+  if (!runDirectory || !fs.existsSync(runDirectory)) return null
+  const summary = runSummary(runsRoot, runId)
+  const frameDirectory = path.join(runDirectory, 'frames')
+  const localFrames = fs.existsSync(frameDirectory)
+    ? fs.readdirSync(frameDirectory).filter((name) => /^frame_\d+\.png$/.test(name)).sort()
+    : []
+  const turns = traceTurns(runDirectory)
+  const state = readJson(path.join(runDirectory, 'run-state.json'))
+  const frameNames = new Set(localFrames)
+  const frameSha256 = new Map()
+  let referenceSha256 = null
+  for (const turn of turns) {
+    for (const artifact of modelInputArtifacts(turn?.model_input)) {
+      if (String(artifact.artifact_path || '') === 'reference.png') {
+        referenceSha256 ||= normalizeSha256(artifact.sha256)
+      }
+      const match = String(artifact.artifact_path || '').match(/^frames\/(frame_\d+\.png)$/)
+      if (match) {
+        frameNames.add(match[1])
+        const sha256 = normalizeSha256(artifact.sha256)
+        if (sha256) frameSha256.set(match[1], sha256)
+      }
+    }
+  }
+  const acceptedActions = Number(state?.accepted_actions)
+  if (Number.isInteger(acceptedActions) && acceptedActions >= 0) {
+    frameNames.add(`frame_${String(acceptedActions).padStart(4, '0')}.png`)
+  }
+  const frames = [...frameNames].sort()
+  const fullTracePath = path.join(runDirectory, 'model_turns.jsonl')
+  const scores = readRunScores(runDirectory)
+  const score = scores.displayed
+  const hasTrustedRender = Boolean(
+    fs.existsSync(path.join(runDirectory, 'evaluation', 'render.png'))
+    || fs.existsSync(path.join(runDirectory, 'evaluation', 'candidate-render.png'))
+    || score?.score_source === 'vision_judge',
+  )
+  const traceIndexed = fs.existsSync(traceSummaryPath(runDirectory))
+    || !fs.existsSync(fullTracePath)
+    || fs.statSync(fullTracePath).size <= MAX_INLINE_LEGACY_TRACE_BYTES
+  return {
+    summary,
+    state,
+    result: readJson(path.join(runDirectory, 'result.json')),
+    score,
+    scores: {
+      vision: scores.vision,
+      deterministic: scores.deterministic,
+    },
+    turns,
+    receipts: readJsonl(path.join(runDirectory, 'input_receipts.jsonl')),
+    traceIndexed,
+    traceNotice: traceIndexed
+      ? null
+      : 'This legacy trace needs a compact viewer index before its turns can be displayed.',
+    frames: frames.map((name) => {
+      const sha256 = frameSha256.get(name) || null
+      const version = sha256 ? `?sha256=${encodeURIComponent(sha256)}` : ''
+      return {
+        name,
+        sha256,
+        url: `/api/runs/${encodeURIComponent(runId)}/file/frames/${encodeURIComponent(name)}${version}`,
+      }
+    }),
+    // A rollout always publishes its exact model-visible reference to cloud
+    // storage. Keep the URL run-scoped so lightweight dashboard deployments do
+    // not need a second copy of the private task corpus. The file route falls
+    // back to the local manifest image for local-only development runs.
+    referenceUrl: `/api/runs/${encodeURIComponent(runId)}/file/reference.png${
+      referenceSha256 ? `?sha256=${encodeURIComponent(referenceSha256)}` : ''
+    }`,
+    artifacts: {
+      dwg: fs.existsSync(path.join(runDirectory, 'attempt.dwg'))
+        ? `/api/runs/${encodeURIComponent(runId)}/file/attempt.dwg`
+        : null,
+      candidateRender: hasTrustedRender
+        ? `/api/runs/${encodeURIComponent(runId)}/file/evaluation/render.png`
+        : null,
+      diffRender: fs.existsSync(path.join(runDirectory, 'evaluation', 'diff.png'))
+        ? `/api/runs/${encodeURIComponent(runId)}/file/evaluation/diff.png`
+        : null,
+    },
+  }
+}
+
+export function createTraceApi(options = {}) {
+  const runsRoot = path.resolve(options.runsRoot || process.env.AUTOCAD_BENCH_RUNS_ROOT || DEFAULT_RUNS_ROOT)
+  const manifest = manifestByTask()
+  async function refreshCloudMetadata(loader, request) {
+    if (typeof loader !== 'function') return
+    try {
+      await loader(request)
+    } catch {
+      // Cloud mirroring is best effort. A transient AWS/auth failure must not
+      // hide an already-synchronized local trace or take down the registry.
+    }
+  }
+  return async function handleTraceApi(request, response) {
+    const url = new URL(request.url || '/', 'http://127.0.0.1')
+    if (!url.pathname.startsWith('/api/')) return false
+    if (request.method !== 'GET') {
+      sendJson(response, 405, { error: 'method_not_allowed' })
+      return true
+    }
+    if (url.pathname === '/api/health') {
+      sendJson(response, 200, { status: 'ok', runsRoot })
+      return true
+    }
+    if (url.pathname === '/api/runs') {
+      sendJson(response, 200, { runs: listRuns(runsRoot) })
+      return true
+    }
+    if (url.pathname === '/api/benchmarks') {
+      sendJson(response, 200, { benchmarks: listBenchmarks(runsRoot) })
+      return true
+    }
+    const benchmarkMatch = url.pathname.match(/^\/api\/benchmarks\/([^/]+)$/)
+    if (benchmarkMatch) {
+      const benchmarkId = decodeURIComponent(benchmarkMatch[1])
+      const benchmarkDirectory = safeRunDirectory(runsRoot, benchmarkId)
+      if (benchmarkDirectory) {
+        await refreshCloudMetadata(options.cloudBenchmarkLoader, {
+          benchmarkId,
+          benchmarkDirectory,
+        })
+      }
+      const detail = benchmarkDetail(runsRoot, benchmarkId)
+      sendJson(response, detail ? 200 : 404, detail || { error: 'benchmark_not_found' })
+      return true
+    }
+    const runFileMatch = url.pathname.match(/^\/api\/runs\/([^/]+)\/file\/(.+)$/)
+    if (runFileMatch) {
+      const runId = decodeURIComponent(runFileMatch[1])
+      const relativePath = decodeURIComponent(runFileMatch[2])
+      const runDirectory = safeRunDirectory(runsRoot, runId)
+      const artifact = runDirectory
+        ? safeArtifact(runDirectory, relativePath)
+        : null
+      const requestedSha256 = normalizeSha256(url.searchParams.get('sha256'))
+      const artifactExists = Boolean(
+        artifact && fs.existsSync(artifact) && fs.statSync(artifact).isFile(),
+      )
+      const artifactMatches = artifactExists && (
+        !requestedSha256 || fileSha256(artifact) === requestedSha256
+      )
+      if (artifactMatches) {
+        sendFile(response, artifact, {
+          immutable: Boolean(requestedSha256) || relativePath.toLowerCase().endsWith('.png'),
+        })
+        return true
+      }
+      if (relativePath === 'reference.png' && runDirectory) {
+        const taskId = readJson(path.join(runDirectory, 'run-state.json'))?.task_id
+          || readJson(path.join(runDirectory, 'result.json'))?.task_id
+        const entry = manifest.get(taskId)
+        const manifestImage = entry ? path.resolve(BENCHMARK_DATA_ROOT, entry.image_path) : null
+        if (
+          manifestImage
+          && manifestImage.startsWith(BENCHMARK_DATA_ROOT + path.sep)
+          && fs.existsSync(manifestImage)
+          && fs.statSync(manifestImage).isFile()
+          && (!requestedSha256 || fileSha256(manifestImage) === requestedSha256)
+        ) {
+          sendFile(response, manifestImage, { immutable: true })
+          return true
+        }
+      }
+      if (relativePath === 'evaluation/render.png' && runDirectory) {
+        const legacyRender = safeArtifact(runDirectory, 'evaluation/candidate-render.png')
+        if (legacyRender && fs.existsSync(legacyRender) && fs.statSync(legacyRender).isFile()) {
+          sendFile(response, legacyRender, { immutable: true })
+          return true
+        }
+      }
+      if (
+        artifact
+        && !artifactExists
+        && typeof options.cloudArtifactUrl === 'function'
+      ) {
+        try {
+          const location = await options.cloudArtifactUrl({ runId, relativePath })
+          if (location) {
+            sendPrivateRedirect(response, location)
+            return true
+          }
+        } catch {
+          // Fall through to the local caching proxy if signing is unavailable.
+        }
+      }
+      if (
+        artifact
+        && !artifactMatches
+        && typeof options.cloudArtifactLoader === 'function'
+      ) {
+        try {
+          await options.cloudArtifactLoader({
+            runId,
+            relativePath,
+            artifact,
+            expectedSha256: requestedSha256,
+            force: artifactExists,
+          })
+        } catch {
+          // The normal 404 below is the stable contract when the cloud mirror
+          // also lacks an artifact or AWS is temporarily unavailable.
+        }
+      }
+      const refreshedMatches = Boolean(
+        artifact
+        && fs.existsSync(artifact)
+        && fs.statSync(artifact).isFile()
+        && (!requestedSha256 || fileSha256(artifact) === requestedSha256),
+      )
+      let servedArtifact = refreshedMatches ? artifact : null
+      if (!servedArtifact && relativePath === 'evaluation/render.png' && runDirectory) {
+        const fallbackRelativePath = 'evaluation/candidate-render.png'
+        const fallbackArtifact = safeArtifact(runDirectory, fallbackRelativePath)
+        if (
+          fallbackArtifact
+          && !fs.existsSync(fallbackArtifact)
+          && typeof options.cloudArtifactLoader === 'function'
+        ) {
+          try {
+            await options.cloudArtifactLoader({
+              runId,
+              relativePath: fallbackRelativePath,
+              artifact: fallbackArtifact,
+            })
+          } catch {
+            // Older evaluator runs may not have either render filename.
+          }
+        }
+        if (
+          fallbackArtifact
+          && fs.existsSync(fallbackArtifact)
+          && fs.statSync(fallbackArtifact).isFile()
+        ) {
+          servedArtifact = fallbackArtifact
+        }
+      }
+      if (!servedArtifact && relativePath === 'reference.png') {
+        const taskId = runDirectory
+          ? readJson(path.join(runDirectory, 'run-state.json'))?.task_id
+            || readJson(path.join(runDirectory, 'result.json'))?.task_id
+          : null
+        const entry = manifest.get(taskId)
+        const manifestImage = entry ? path.resolve(BENCHMARK_DATA_ROOT, entry.image_path) : null
+        if (
+          manifestImage
+          && manifestImage.startsWith(BENCHMARK_DATA_ROOT + path.sep)
+          && fs.existsSync(manifestImage)
+          && fs.statSync(manifestImage).isFile()
+        ) {
+          servedArtifact = manifestImage
+        }
+      }
+      sendFile(response, servedArtifact, {
+        // Run-scoped PNGs are append-only/final artifacts. Browser caching
+        // makes reopening a rollout instant and avoids repeated S3 downloads.
+        immutable: Boolean(requestedSha256) || relativePath.toLowerCase().endsWith('.png'),
+      })
+      return true
+    }
+    const runMatch = url.pathname.match(/^\/api\/runs\/([^/]+)$/)
+    if (runMatch) {
+      const runId = decodeURIComponent(runMatch[1])
+      const runDirectory = safeRunDirectory(runsRoot, runId)
+      if (runDirectory) {
+        // Live cloud-controller runs may be present in batch-state before their
+        // rollout directory has ever been mirrored locally. Bootstrap and
+        // refresh the small trace index here; frame PNGs remain lazy-loaded by
+        // the /file route below.
+        await refreshCloudMetadata(options.cloudTraceLoader, {
+          runId,
+          runDirectory,
+        })
+      }
+      const detail = traceDetail(runsRoot, runId)
+      sendJson(response, detail ? 200 : 404, detail || { error: 'run_not_found' })
+      return true
+    }
+    const referenceMatch = url.pathname.match(/^\/api\/reference\/([^/]+)$/)
+    if (referenceMatch) {
+      const taskId = decodeURIComponent(referenceMatch[1])
+      const entry = manifest.get(taskId)
+      const imagePath = entry ? path.resolve(BENCHMARK_DATA_ROOT, entry.image_path) : null
+      const safeImage = imagePath && imagePath.startsWith(BENCHMARK_DATA_ROOT + path.sep) ? imagePath : null
+      sendFile(response, safeImage)
+      return true
+    }
+    sendJson(response, 404, { error: 'not_found' })
+    return true
+  }
+}
+
+export const _test = {
+  readJsonl,
+  safeRunDirectory,
+  safeArtifact,
+  runSummary,
+  traceDetail,
+  traceTurns,
+  listRuns,
+  usageSummary,
+  runUsage,
+  compactTurn,
+  normalizeSha256,
+  fileSha256,
+  benchmarkDetail,
+  listBenchmarks,
+  executionState,
+  readRunScores,
+  scoreSummary,
+}

apps/dashboard/tsconfig.app.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "jsx": "preserve",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "esModuleInterop": true,
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "types": ["vite/client"],
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*.ts", "src/**/*.vue"]
+}

apps/dashboard/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "files": [],
+  "references": [
+    { "path": "./tsconfig.app.json" },
+    { "path": "./tsconfig.node.json" }
+  ]
+}

apps/dashboard/tsconfig.node.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "allowJs": true,
+    "checkJs": false,
+    "outDir": ".tsbuild/node",
+    "rootDir": ".",
+    "types": ["node"],
+    "skipLibCheck": true
+  },
+  "include": ["vite.config.ts", "trace-api.mjs", "server.mjs"]
+}

apps/dashboard/vite.config.ts

@@ -0,0 +1,22 @@
+import { defineConfig, type Plugin } from 'vite'
+import vue from '@vitejs/plugin-vue'
+import { createTraceApi } from './trace-api.mjs'
+
+function traceApiPlugin(): Plugin {
+  const handle = createTraceApi()
+  return {
+    name: 'autocad-trace-api',
+    configureServer(server) {
+      server.middlewares.use(async (request, response, next) => {
+        if (await handle(request, response)) return
+        next()
+      })
+    },
+  }
+}
+
+export default defineConfig({
+  plugins: [vue(), traceApiPlugin()],
+  server: { port: 5173 },
+  build: { target: 'es2022' },
+})

apps/results-dashboard/.env.example

@@ -0,0 +1,6 @@
+AUTOCAD_RESULTS_BUCKET=your-autocad-results-bucket
+# AWS_PROFILE=my-profile
+AWS_REGION=us-east-1
+HOST=127.0.0.1
+PORT=4273
+AUTOCAD_RESULTS_SIGNED_URL_TTL_SECONDS=3600

apps/results-dashboard/README.md

@@ -0,0 +1,17 @@
+# AutoCAD benchmark results dashboard
+
+Read-only dashboard for the finalized, model-level aggregates in the AutoCAD benchmark results bucket. It discovers aggregate manifests, compares models and categories, and exposes each canonical rollout's trace, receipts, renders, DWG, and full screenshot sequence.
+
+Media is served with short-lived S3 URLs and immutable browser cache headers. The dashboard server only signs requests; image bytes travel directly from S3 to the browser.
+
+```bash
+npm ci
+npm test
+npm run build
+npm run preview
+```
+
+The local viewer listens on `http://127.0.0.1:4273`.
+`AUTOCAD_RESULTS_BUCKET` is required and must name a bucket you own.
+`AWS_PROFILE` and `AWS_REGION` are optional; the AWS SDK uses its standard
+credential and region chains when they are omitted. See `.env.example`.

apps/results-dashboard/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="dark" />
+    <meta name="theme-color" content="#0a0d0f" />
+    <title>AutoCAD Bench Results</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>

apps/results-dashboard/package-lock.json

@@ -0,0 +1,1910 @@
+{
+  "name": "autocad-bench-results-dashboard",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "autocad-bench-results-dashboard",
+      "version": "0.1.0",
+      "dependencies": {
+        "@aws-sdk/client-s3": "3.1090.0",
+        "@aws-sdk/credential-providers": "3.1090.0",
+        "@aws-sdk/s3-request-presigner": "3.1090.0",
+        "vue": "3.5.40"
+      },
+      "devDependencies": {
+        "@types/node": "20.19.43",
+        "@vitejs/plugin-vue": "5.2.4",
+        "typescript": "5.9.3",
+        "vite": "6.4.3",
+        "vue-tsc": "3.3.7"
+      }
+    },
+    "node_modules/@aws-sdk/checksums": {
+      "version": "3.1000.19",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/checksums/-/checksums-3.1000.19.tgz",
+      "integrity": "sha512-Hc4N100RdkuWshKBnhPzmpdftfi9mCLz+OHFELHM1QIgMH4QRUUWyWgfiebta/YX2Bd62wTcm3EqAP8TeXv0gA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.976.0",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/client-s3": {
+      "version": "3.1090.0",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/client-s3/-/client-s3-3.1090.0.tgz",
+      "integrity": "sha512-R6GX9cd1jljwzZ8xFmgAI/hHCuX1MobIKBdsymv7WL9SENvO9Vgz9KOR6avTnu0Ao+w1LmxnTe+jqmZXEn7Q/Q==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/checksums": "^3.1000.18",
+        "@aws-sdk/core": "^3.975.3",
+        "@aws-sdk/credential-provider-node": "^3.972.70",
+        "@aws-sdk/middleware-sdk-s3": "^3.972.64",
+        "@aws-sdk/signature-v4-multi-region": "^3.996.41",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/fetch-http-handler": "^5.6.6",
+        "@smithy/node-http-handler": "^4.9.6",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/core": {
+      "version": "3.976.0",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/core/-/core-3.976.0.tgz",
+      "integrity": "sha512-0cjRaEdlVoOrsNb9pP5q1Syyc8pXw5xSj2Np2ryReRTr9FppIIRVSdZK4lbnfmc2Hvgux/xBOUU6baB7z8//uA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/types": "^3.974.2",
+        "@aws-sdk/xml-builder": "^3.972.36",
+        "@aws/lambda-invoke-store": "^0.3.0",
+        "@smithy/core": "^3.29.4",
+        "@smithy/signature-v4": "^5.6.5",
+        "@smithy/types": "^4.16.1",
+        "bowser": "^2.11.0",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-cognito-identity": {
+      "version": "3.972.59",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-cognito-identity/-/credential-provider-cognito-identity-3.972.59.tgz",
+      "integrity": "sha512-iWPfye2ZOCmAHKmN1EwAyeHZdZxZymctAnEOD+7jzwqc5gZlK1lwG1lzGVtpH0+d/NnyrK670ycqBNKD4zUGZA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/nested-clients": "^3.997.34",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-env": {
+      "version": "3.972.60",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-env/-/credential-provider-env-3.972.60.tgz",
+      "integrity": "sha512-BAkxdoe7tpDDqCghGpuOeHQRbm/2znVvOQm0AvpQbA2tbfMN46doN4zx65fv85ImP3KADwc2zQPmbrlI9MPfMg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.976.0",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-http": {
+      "version": "3.972.62",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-http/-/credential-provider-http-3.972.62.tgz",
+      "integrity": "sha512-g/0fGqKTb9xpKdd9AtpmV5Eo3DFKbnkpA2+w0peISSlu7NfAoWOuYBFxsu+yWBtxU89ka55ezoZBCbFaS8pjYQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.976.0",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/fetch-http-handler": "^5.6.6",
+        "@smithy/node-http-handler": "^4.9.6",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-ini": {
+      "version": "3.973.5",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-ini/-/credential-provider-ini-3.973.5.tgz",
+      "integrity": "sha512-ylubazcRfq2TVus/qXucSXeC42Qdjp5HQxTu68K/BsdMiZlcSLD1zkpoCgApXZX1Y6YJhtGGs7ZHhO/GuIgBlw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.976.0",
+        "@aws-sdk/credential-provider-env": "^3.972.60",
+        "@aws-sdk/credential-provider-http": "^3.972.62",
+        "@aws-sdk/credential-provider-login": "^3.972.67",
+        "@aws-sdk/credential-provider-process": "^3.972.60",
+        "@aws-sdk/credential-provider-sso": "^3.973.4",
+        "@aws-sdk/credential-provider-web-identity": "^3.972.66",
+        "@aws-sdk/nested-clients": "^3.997.34",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/credential-provider-imds": "^4.4.9",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-login": {
+      "version": "3.972.67",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-login/-/credential-provider-login-3.972.67.tgz",
+      "integrity": "sha512-CCygIKJ9YbI3n84OClSaSppkgKKHVj2TGT33c6FRORZrYNZQ1POmD+ip0FLYokiJAK7sSdc3YVkOsBm90oxWMQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.976.0",
+        "@aws-sdk/nested-clients": "^3.997.34",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-node": {
+      "version": "3.972.71",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-node/-/credential-provider-node-3.972.71.tgz",
+      "integrity": "sha512-HIg7Q2osBzajQwL+1Vkyh2E7Gim3eTNb9RHIsOxDGjW0eZg4oEKtRs5sioCnc73ilhaOm4gX2lHVF8J7+nt2rg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/credential-provider-env": "^3.972.60",
+        "@aws-sdk/credential-provider-http": "^3.972.62",
+        "@aws-sdk/credential-provider-ini": "^3.973.5",
+        "@aws-sdk/credential-provider-process": "^3.972.60",
+        "@aws-sdk/credential-provider-sso": "^3.973.4",
+        "@aws-sdk/credential-provider-web-identity": "^3.972.66",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/credential-provider-imds": "^4.4.9",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-process": {
+      "version": "3.972.60",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-process/-/credential-provider-process-3.972.60.tgz",
+      "integrity": "sha512-YIo3f99hM43QdYG8hDzwGemnR/pU95b0kramqSJUTleCqaB7+HwKf7YZFHqvOgTqZTPx/mRmNIqoDRr3U0Z3Tw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.976.0",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-sso": {
+      "version": "3.973.4",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-sso/-/credential-provider-sso-3.973.4.tgz",
+      "integrity": "sha512-BPdmL8sSBOCv4ngZ+3LHxyc3CNqDCEK37CHioCk7zGrTMY5sUtkH8q+o6qA80nn6w3/fyBPGNE7OIRlmoOxRQA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.976.0",
+        "@aws-sdk/nested-clients": "^3.997.34",
+        "@aws-sdk/token-providers": "3.1092.0",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-provider-web-identity": {
+      "version": "3.972.66",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-provider-web-identity/-/credential-provider-web-identity-3.972.66.tgz",
+      "integrity": "sha512-kSAziJboOmZmsR9/MTbiNjowl2BPes1bQuJpne4qAZ62ubi8fjfr/aupJSQje6udBoYxXTQbsL0e0kby2la3ng==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.976.0",
+        "@aws-sdk/nested-clients": "^3.997.34",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/credential-providers": {
+      "version": "3.1090.0",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/credential-providers/-/credential-providers-3.1090.0.tgz",
+      "integrity": "sha512-HEfLv6RdiFu8+HO5CUQjjQ/KCWWAHcQCtSPenaF26lYQSjjzKjgvjwAMGBV9/VMrO8V0faIRyoFWhF548UjTOg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.975.3",
+        "@aws-sdk/credential-provider-cognito-identity": "^3.972.58",
+        "@aws-sdk/credential-provider-env": "^3.972.59",
+        "@aws-sdk/credential-provider-http": "^3.972.61",
+        "@aws-sdk/credential-provider-ini": "^3.973.4",
+        "@aws-sdk/credential-provider-login": "^3.972.66",
+        "@aws-sdk/credential-provider-node": "^3.972.70",
+        "@aws-sdk/credential-provider-process": "^3.972.59",
+        "@aws-sdk/credential-provider-sso": "^3.973.3",
+        "@aws-sdk/credential-provider-web-identity": "^3.972.65",
+        "@aws-sdk/nested-clients": "^3.997.33",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/credential-provider-imds": "^4.4.9",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/middleware-sdk-s3": {
+      "version": "3.972.65",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/middleware-sdk-s3/-/middleware-sdk-s3-3.972.65.tgz",
+      "integrity": "sha512-udwNhRfDTfCB98mAHjjgsnKQlxygB4e0X+Obne/XjJpvVsF0YCQC8ZErd/8Z6IPoLQjtiKHzwqEDbZiLrJEnOg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.976.0",
+        "@aws-sdk/signature-v4-multi-region": "^3.996.41",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/nested-clients": {
+      "version": "3.997.34",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/nested-clients/-/nested-clients-3.997.34.tgz",
+      "integrity": "sha512-Y9REVrSwmLM+Qy6sZJ7ofMC2S3Hr3tPP/4CzL5U1olPP7OGoF+6+Px0E49cVQBtSxJtyeLJMf0UaBErfeSahAA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.976.0",
+        "@aws-sdk/signature-v4-multi-region": "^3.996.41",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/fetch-http-handler": "^5.6.6",
+        "@smithy/node-http-handler": "^4.9.6",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/s3-request-presigner": {
+      "version": "3.1090.0",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/s3-request-presigner/-/s3-request-presigner-3.1090.0.tgz",
+      "integrity": "sha512-DaYXp8GMptWJUDbvpoB51xZztOw6tcbpXjYAZMXTu17E0aR+5g8FWBU3t3t0KEhhrUiKyfLpVi6uNQxNSXfbhg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.975.3",
+        "@aws-sdk/signature-v4-multi-region": "^3.996.41",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/signature-v4-multi-region": {
+      "version": "3.996.41",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/signature-v4-multi-region/-/signature-v4-multi-region-3.996.41.tgz",
+      "integrity": "sha512-QMUytg+FQMGouc8gHS00KoYih3+N6cqmVI/pQGOIo7Nr7OpQaiXjSYOuL+vsPZ1tymY4LAQ8MYcHJmws5LRxng==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/signature-v4": "^5.6.5",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/token-providers": {
+      "version": "3.1092.0",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/token-providers/-/token-providers-3.1092.0.tgz",
+      "integrity": "sha512-hBYUAr6iBLNFcsiWTgtBb0stdSw39VOUq4Sp4A5caCNf66BAZplWN4FleKrVpJx5li2YgdnK2DqoFSMWC642FQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@aws-sdk/core": "^3.976.0",
+        "@aws-sdk/nested-clients": "^3.997.34",
+        "@aws-sdk/types": "^3.974.2",
+        "@smithy/core": "^3.29.4",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/types": {
+      "version": "3.974.2",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/types/-/types-3.974.2.tgz",
+      "integrity": "sha512-3W6IUtSxFbH6X7Wb7DzGCV5QiFQsd0g8bOfntpmDxQlzBoKWUMBu/JPQR0DwkE+Hpnxd6db1tXbOwdeHddG6cA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws-sdk/xml-builder": {
+      "version": "3.972.36",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/xml-builder/-/xml-builder-3.972.36.tgz",
+      "integrity": "sha512-RdGmS1GLrtaTOLE1ElSluMldNrpk9Emq6uYs8SS8iHlu5xTAmM9rRkM91o48+rIRryBtyO9t+uLYCoMG6jVMVA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@aws/lambda-invoke-store": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/@aws/lambda-invoke-store/-/lambda-invoke-store-0.3.0.tgz",
+      "integrity": "sha512-sl4Bm6yiMNYrZKkqqDFWN0UfnWhlS8ivKxrYl+6t0gCLrqr8y3B2IqZZbFRkfaVVp7C/baApyh71P+LeE1A2sQ==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@babel/helper-string-parser": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.29.7.tgz",
+      "integrity": "sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-identifier": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.29.7.tgz",
+      "integrity": "sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/parser": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.7.tgz",
+      "integrity": "sha512-hnORnjP/1P/zFEndoeX+n+t1RwWRJiJpM/jO7FW32Kn9r5+sJB2JWOdYo4L6k78j15eCwY3Gm/7364B1EMwtNg==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.29.7"
+      },
+      "bin": {
+        "parser": "bin/babel-parser.js"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@babel/types": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.7.tgz",
+      "integrity": "sha512-4zBIxpPzowiZpusoFkyGVwakdRJUyuH5PxQ/PrqghfdFWWasvnCdPfQXHrenDai+gyLARulZjZowCOj6fjT4pA==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-string-parser": "^7.29.7",
+        "@babel/helper-validator-identifier": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.12.tgz",
+      "integrity": "sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.12.tgz",
+      "integrity": "sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.12.tgz",
+      "integrity": "sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.12.tgz",
+      "integrity": "sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.12.tgz",
+      "integrity": "sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.12.tgz",
+      "integrity": "sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.12.tgz",
+      "integrity": "sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.12.tgz",
+      "integrity": "sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.12.tgz",
+      "integrity": "sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.12.tgz",
+      "integrity": "sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.12.tgz",
+      "integrity": "sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.12.tgz",
+      "integrity": "sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.12.tgz",
+      "integrity": "sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.12.tgz",
+      "integrity": "sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.12.tgz",
+      "integrity": "sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.12.tgz",
+      "integrity": "sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.12.tgz",
+      "integrity": "sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.12.tgz",
+      "integrity": "sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.12.tgz",
+      "integrity": "sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.12.tgz",
+      "integrity": "sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.12.tgz",
+      "integrity": "sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openharmony-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.12.tgz",
+      "integrity": "sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.12.tgz",
+      "integrity": "sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.12.tgz",
+      "integrity": "sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.12.tgz",
+      "integrity": "sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.12.tgz",
+      "integrity": "sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "license": "MIT"
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.62.2.tgz",
+      "integrity": "sha512-6o7ZLZK+BeenkZCFNDXqpbjw9bD6nuWonvS/lwQJp7NoVVxm6p3qE7qQ5jGuBjiFsgvqjD8mZAU5oWxTmbOeOg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.62.2.tgz",
+      "integrity": "sha512-BaH7BllCACHoH1LguOU56UItGfUWjujlO65kS9LAodViaN4bwIKd7oeW/ZHJ/4ljr/7MIiENnNy3HJ0zXv8Zkw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.62.2.tgz",
+      "integrity": "sha512-v39RCCvj4He82I9sFmk+M1VZ0PLM9sfsLVikjfx2hYBNALhrrOR2D3JjQA6AhlaSOgcR+RzrKY7e1+bT6SUO/A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.62.2.tgz",
+      "integrity": "sha512-yl0y2vq3S3lHeuXhEdss6TWfKW8vkujImO12tn4ZkG/4oghr09LvdYm2RElVjokTQiUvDUGXLGsYeLqUMCKpGA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.62.2.tgz",
+      "integrity": "sha512-tT4pvt4qXD+vEoezupCWi+a1F0vvDiksiHc+PxRlYTOH1I6/X4id9jPxTP+Fg+545euaFT1jJVs4CEdHZAU1vw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.62.2.tgz",
+      "integrity": "sha512-6nU5F2wCW+qvCBhTn1pdIU3bzsIoF7EUwsCDRxilWGprQR6yd508YnH9+OKFCwpfS8pjZqDUmnCAr7exax0XCg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.62.2.tgz",
+      "integrity": "sha512-n1GJHPOvpIfhi3TmrCeh6S6URt9BFCt0KQE3qvexyGCTAKpR4Lg+eWvNZEqu7epxwus/8ElT3hacYEucm49SZg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.62.2.tgz",
+      "integrity": "sha512-JqgflS8wEB+UXV/vS1RpRbifGBeN4D5lz8D8oOFbFZw4vedvdOgCFAjfBmIMdW3yL10XpQQ0Ambepw6MXrhOnA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.62.2.tgz",
+      "integrity": "sha512-wnFJkogWvN4jm/hQRF2UBaeUmk20j5+DmHvoyWii2b8HJDyvz1MF2OU/6ynXt2KR63rbZLWkFpoytpdc/yBuSA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.62.2.tgz",
+      "integrity": "sha512-HVu2bp0zhvJ8xHEV9+UUs7S90VadmBSY3LcIMvozbPo4AuMGDWlz3ymHLHZPX4hR67TKTt8Qp5PJ5RBg/i+RMQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.62.2.tgz",
+      "integrity": "sha512-mQqqAV8QaoSgr9I2fKDLY2BAVvmKjWoGiu/cSYQonsLvtqwEn1E4QYfnCOcp5zoEqNhsDYin1s6jx/VJmrxlZg==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-musl": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.62.2.tgz",
+      "integrity": "sha512-IxKLoxCQ2IWi6bT2akyDUBGsOImDKB+sPp4EsTmwFQ/fMwpCKm8uLSSgP/Kx/QYUgKis6SEZ5/Nlhup0DIA0PQ==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.62.2.tgz",
+      "integrity": "sha512-Mk5ha2RQSgyFfmYYLkBpPnUk8D8FriBxesO1u9O75X0mHgXL1UQcH5Itl2lurWL2tj0RxV9b9tJgipac0hRY9A==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-musl": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.62.2.tgz",
+      "integrity": "sha512-CjvEnqJL/0/TQ3TXX3OPIJ/kmBellrWd4heXUmHeJlTnmwjKpSJzoehLaL6Xk0ZnMHBu9dZuFADNOrtjF4v+2w==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.62.2.tgz",
+      "integrity": "sha512-1SiZbzwdkaDURsew/tSOrooKiYy7EQGT6m8ufavAi9NEyQb/6VuIxFXAL1fqa4iZe3g4NbNk4P7J32z2tw5Mgg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.62.2.tgz",
+      "integrity": "sha512-nQts12zJ3NQRoE6uYljOH89v7szzLDvG2JD/vsX+vGXU8w/At1GowTZ5/7qeFQ8m7L55rpR8Okugnuo5bgjy2Q==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.62.2.tgz",
+      "integrity": "sha512-E9/ll019jhPIJgpzfZoIkBGhcz+kKNgVWYRY0zr9srBdPPFVpvOKW8VaJKUbeK+eZXyQF9ltME+Kk6affeaPgg==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.62.2.tgz",
+      "integrity": "sha512-5BqxR/pshjey51iliyzTD5Xi3EN0aLmQ2lZ3lvefVV9c82BvrLo2/6OT55iifpWBufs6kdwWbuOKS841DrmK9A==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.62.2.tgz",
+      "integrity": "sha512-uNN83XxQrRAh/w0/pmAfibcwyb6YWt4gP+dpnQKPVJshAloQ785ii8CT8ZCIxkGg9opVsvAlGhFitSm6D1Jjpg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-openbsd-x64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.62.2.tgz",
+      "integrity": "sha512-srjEIxSH3LRnJN6THczDHWQplqEMFiAJrTab0msUryh9kwNpkICf3Ea6q6MN/2cZwRFUNx5w+h6Hpi4QuHS6Zg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-openharmony-arm64": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.62.2.tgz",
+      "integrity": "sha512-8hOJnxgbyObnCm5AlRA3A931xX19xq80RjVTKgJOvEKWqJruP/Uf12IbAOaDjjEXYRewwHLfmF0YRIdK3OwKWA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.62.2.tgz",
+      "integrity": "sha512-mmF4AY1i0hG/bLWUctUq59gtmgaSIRa3cu/A3JFRp/sCNEme2bgDEiDS22P9FbnJB8NJNF4jPJiSP5RHQpUTDg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.62.2.tgz",
+      "integrity": "sha512-DZgkknc6jhHrk46V25vbAM0zZkyP0nSDkJB8/dRkLTxv470dOmWDqGoEJl/9A0dFfS7yE3REOwNDxpHwSLSt0Q==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-gnu": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.62.2.tgz",
+      "integrity": "sha512-T6xr6ucWSFto+VGajA8YH26LdpHRuP4YLHEKAtCWvJDOlnmWcDZVCI2Jmjr+IFHDlt2zRaTAKE4tfjTaWLgJBg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.62.2.tgz",
+      "integrity": "sha512-BfzEnDJOt9T8M989/lA37EcJgat01wLRnoi5dQf3QzOH7jzpqTAzdDbVfRljVr5r+jzKqpbHeyOfAaXxAd0PAA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@smithy/core": {
+      "version": "3.29.7",
+      "resolved": "https://registry.npmjs.org/@smithy/core/-/core-3.29.7.tgz",
+      "integrity": "sha512-BiEE2bnnGoPKdlGe3L+gOYORDHFGPuYVRLP7iUow/Sflm0B4hC4XY3FC1MRuc7ltzpW2xNnXopKi34TTkULlKQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@smithy/credential-provider-imds": {
+      "version": "4.4.12",
+      "resolved": "https://registry.npmjs.org/@smithy/credential-provider-imds/-/credential-provider-imds-4.4.12.tgz",
+      "integrity": "sha512-ZZPDbl/aRp77aycuoMlo3BTayT4CE2a3uoqETYZU5ySnVbhpl5IJiY7dCZedn+ZusyDLqVv44IvKBiXd2/nK0Q==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@smithy/core": "^3.29.7",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@smithy/fetch-http-handler": {
+      "version": "5.6.9",
+      "resolved": "https://registry.npmjs.org/@smithy/fetch-http-handler/-/fetch-http-handler-5.6.9.tgz",
+      "integrity": "sha512-EJktha5m5MXCwzdXrlWyqb9UCNHNFKlg+PmTpRsdX3dncJPTiqYleM9OKj2mLgdVJHR01d2tU4alG+z2NdH5rQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@smithy/core": "^3.29.7",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@smithy/node-http-handler": {
+      "version": "4.9.9",
+      "resolved": "https://registry.npmjs.org/@smithy/node-http-handler/-/node-http-handler-4.9.9.tgz",
+      "integrity": "sha512-xVBZ3hptB99iNO9XyWqEhC7KD9bP9UPXhuy3h5Y2ItCfBv160D9IIC/Fmmp3EbnWwit4C+KVqlSE+E29Nk/pPg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@smithy/core": "^3.29.7",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@smithy/signature-v4": {
+      "version": "5.6.8",
+      "resolved": "https://registry.npmjs.org/@smithy/signature-v4/-/signature-v4-5.6.8.tgz",
+      "integrity": "sha512-iGBm6hIwD2MGvVRSgrjVWa4FXtXDq3akxu0DCpnkmBo0xtEHZ/siMRt7ycfZAefYr2UdywUgmGtoRLaq5u56pg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@smithy/core": "^3.29.7",
+        "@smithy/types": "^4.16.1",
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@smithy/types": {
+      "version": "4.16.1",
+      "resolved": "https://registry.npmjs.org/@smithy/types/-/types-4.16.1.tgz",
+      "integrity": "sha512-0JFs3V2y2M9tKW5na/qxe69Zv+uxLMO7QBbhxF/FHu/Gp2NFZAAL9tWl9PU02xxo07pb3G9FTyjNc6D5uZrJIg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "tslib": "^2.6.2"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.9",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.9.tgz",
+      "integrity": "sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/node": {
+      "version": "20.19.43",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.43.tgz",
+      "integrity": "sha512-6oYBAi5ikg4Pl+kGsoYtawUMBT2zZMCvPNF7pVLnHZfd1zf38DRiWn/gT01RYCdUqkv7Fhr+C9ot4/tb+2sVvA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~6.21.0"
+      }
+    },
+    "node_modules/@vitejs/plugin-vue": {
+      "version": "5.2.4",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-vue/-/plugin-vue-5.2.4.tgz",
+      "integrity": "sha512-7Yx/SXSOcQq5HiiV3orevHUFn+pmMB4cgbEkDYgnkUWb0WfeQ/wa2yFv6D5ICiCQOVpjA7vYDXrC7AGO8yjDHA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "peerDependencies": {
+        "vite": "^5.0.0 || ^6.0.0",
+        "vue": "^3.2.25"
+      }
+    },
+    "node_modules/@volar/language-core": {
+      "version": "2.4.28",
+      "resolved": "https://registry.npmjs.org/@volar/language-core/-/language-core-2.4.28.tgz",
+      "integrity": "sha512-w4qhIJ8ZSitgLAkVay6AbcnC7gP3glYM3fYwKV3srj8m494E3xtrCv6E+bWviiK/8hs6e6t1ij1s2Endql7vzQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@volar/source-map": "2.4.28"
+      }
+    },
+    "node_modules/@volar/source-map": {
+      "version": "2.4.28",
+      "resolved": "https://registry.npmjs.org/@volar/source-map/-/source-map-2.4.28.tgz",
+      "integrity": "sha512-yX2BDBqJkRXfKw8my8VarTyjv48QwxdJtvRgUpNE5erCsgEUdI2DsLbpa+rOQVAJYshY99szEcRDmyHbF10ggQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@volar/typescript": {
+      "version": "2.4.28",
+      "resolved": "https://registry.npmjs.org/@volar/typescript/-/typescript-2.4.28.tgz",
+      "integrity": "sha512-Ja6yvWrbis2QtN4ClAKreeUZPVYMARDYZl9LMEv1iQ1QdepB6wn0jTRxA9MftYmYa4DQ4k/DaSZpFPUfxl8giw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@volar/language-core": "2.4.28",
+        "path-browserify": "^1.0.1",
+        "vscode-uri": "^3.0.8"
+      }
+    },
+    "node_modules/@vue/compiler-core": {
+      "version": "3.5.40",
+      "resolved": "https://registry.npmjs.org/@vue/compiler-core/-/compiler-core-3.5.40.tgz",
+      "integrity": "sha512-39E8IgOhTbVDnoJFMKc2DvYnypcZwUqgUhQkccva/0m6FUwtIKSGV7n1hpVmYcFaoRAwf9pBcwnKlCEsN63ZEQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.29.7",
+        "@vue/shared": "3.5.40",
+        "entities": "^7.0.1",
+        "estree-walker": "^2.0.2",
+        "source-map-js": "^1.2.1"
+      }
+    },
+    "node_modules/@vue/compiler-dom": {
+      "version": "3.5.40",
+      "resolved": "https://registry.npmjs.org/@vue/compiler-dom/-/compiler-dom-3.5.40.tgz",
+      "integrity": "sha512-pwkx4vqlqOspFstrcmzwkKLePVMD3PT65imRzLhanU2V1Fj4K13g6OXjanOyzw3aTAuRk84BOmY8f3rEHqPaVA==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/compiler-core": "3.5.40",
+        "@vue/shared": "3.5.40"
+      }
+    },
+    "node_modules/@vue/compiler-sfc": {
+      "version": "3.5.40",
+      "resolved": "https://registry.npmjs.org/@vue/compiler-sfc/-/compiler-sfc-3.5.40.tgz",
+      "integrity": "sha512-gIf497P4kpuALcvs5n3AEg1Vdn0pSY4XbjASIfHNYF1/MP3T2Mf2STERTubysBxCRxzJGJYtF/O7vwJrxFB3Vw==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.29.7",
+        "@vue/compiler-core": "3.5.40",
+        "@vue/compiler-dom": "3.5.40",
+        "@vue/compiler-ssr": "3.5.40",
+        "@vue/shared": "3.5.40",
+        "estree-walker": "^2.0.2",
+        "magic-string": "^0.30.21",
+        "postcss": "^8.5.19",
+        "source-map-js": "^1.2.1"
+      }
+    },
+    "node_modules/@vue/compiler-ssr": {
+      "version": "3.5.40",
+      "resolved": "https://registry.npmjs.org/@vue/compiler-ssr/-/compiler-ssr-3.5.40.tgz",
+      "integrity": "sha512-rrE5xiXG663+vHCHa3J9p2z5OcBRjXmoqenprJxAFQxg5pSshzeBiCE6pu46axapRJ2Adk0YDA2BRZVjiHXnhg==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/compiler-dom": "3.5.40",
+        "@vue/shared": "3.5.40"
+      }
+    },
+    "node_modules/@vue/language-core": {
+      "version": "3.3.7",
+      "resolved": "https://registry.npmjs.org/@vue/language-core/-/language-core-3.3.7.tgz",
+      "integrity": "sha512-LzmkKinXAMMoh8Jfi/jMUSDUjuPdv8mynH5WJGKfXyZtDw3hQ6GBaoI6Bcnl/Xqlu32q/0Z6i/trp4VXykzyLw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@volar/language-core": "2.4.28",
+        "@vue/compiler-dom": "^3.5.0",
+        "@vue/shared": "^3.5.0",
+        "alien-signals": "^3.2.1",
+        "muggle-string": "^0.4.1",
+        "path-browserify": "^1.0.1",
+        "picomatch": "^4.0.4"
+      }
+    },
+    "node_modules/@vue/reactivity": {
+      "version": "3.5.40",
+      "resolved": "https://registry.npmjs.org/@vue/reactivity/-/reactivity-3.5.40.tgz",
+      "integrity": "sha512-B7ot9UlUZOi1zbq61/LvE88ZLTV8IlajTdiZTAEiDQgrnIMIZoPr9kGw0Zw46ObW62O9+H/Be3kMbfb7kYPQZA==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/shared": "3.5.40"
+      }
+    },
+    "node_modules/@vue/runtime-core": {
+      "version": "3.5.40",
+      "resolved": "https://registry.npmjs.org/@vue/runtime-core/-/runtime-core-3.5.40.tgz",
+      "integrity": "sha512-KAZLweuZ6uUJPK1PMSQPgBU5gCjgrrfjUhSglmU9NhH+Zjepa8cnwSydPWDWHDwOgY4g3VcZ+PljbiHlURNCbw==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/reactivity": "3.5.40",
+        "@vue/shared": "3.5.40"
+      }
+    },
+    "node_modules/@vue/runtime-dom": {
+      "version": "3.5.40",
+      "resolved": "https://registry.npmjs.org/@vue/runtime-dom/-/runtime-dom-3.5.40.tgz",
+      "integrity": "sha512-ZfrX8ssZQds900L9pr8AuK05ddnMsR4MPMZr8cPN9GoqoPWcXLhjvvbIA2SMv+7a97sJ1vv9pj/zxK0Cq/eEFQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/reactivity": "3.5.40",
+        "@vue/runtime-core": "3.5.40",
+        "@vue/shared": "3.5.40",
+        "csstype": "^3.2.3"
+      }
+    },
+    "node_modules/@vue/server-renderer": {
+      "version": "3.5.40",
+      "resolved": "https://registry.npmjs.org/@vue/server-renderer/-/server-renderer-3.5.40.tgz",
+      "integrity": "sha512-XNJym9WpevhTVt1HuwOrCRJ5Q+9z4BjTMrDtjTrvx74SmUll8spNTw6whWJa9mEkO4PKn5TihI/bm/8ds2QVJw==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/compiler-ssr": "3.5.40",
+        "@vue/runtime-dom": "3.5.40",
+        "@vue/shared": "3.5.40"
+      }
+    },
+    "node_modules/@vue/shared": {
+      "version": "3.5.40",
+      "resolved": "https://registry.npmjs.org/@vue/shared/-/shared-3.5.40.tgz",
+      "integrity": "sha512-WxnBtruIqOoV3rA4jeKDWzrYI5h7Cp4+pjwDi8kWGHz+IslhiN+wguLVVhtv2l8VoU02rzDCVfDjgCl1lNpZVg==",
+      "license": "MIT"
+    },
+    "node_modules/alien-signals": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/alien-signals/-/alien-signals-3.2.1.tgz",
+      "integrity": "sha512-I8FjmltrfnDFoZedi5CG8DghVYNhzb/Ijluz7tCSJH0xpd0484Kowhbb1XDYOxfJpU1p5wnM2X54dA+IfGyD1g==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/bowser": {
+      "version": "2.14.1",
+      "resolved": "https://registry.npmjs.org/bowser/-/bowser-2.14.1.tgz",
+      "integrity": "sha512-tzPjzCxygAKWFOJP011oxFHs57HzIhOEracIgAePE4pqB3LikALKnSzUyU4MGs9/iCEUuHlAJTjTc5M+u7YEGg==",
+      "license": "MIT"
+    },
+    "node_modules/csstype": {
+      "version": "3.2.3",
+      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
+      "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
+      "license": "MIT"
+    },
+    "node_modules/entities": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-7.0.1.tgz",
+      "integrity": "sha512-TWrgLOFUQTH994YUyl1yT4uyavY5nNB5muff+RtWaqNVCAK408b5ZnnbNAUEWLTCpum9w6arT70i1XdQ4UeOPA==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.12"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
+    "node_modules/esbuild": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.12.tgz",
+      "integrity": "sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.25.12",
+        "@esbuild/android-arm": "0.25.12",
+        "@esbuild/android-arm64": "0.25.12",
+        "@esbuild/android-x64": "0.25.12",
+        "@esbuild/darwin-arm64": "0.25.12",
+        "@esbuild/darwin-x64": "0.25.12",
+        "@esbuild/freebsd-arm64": "0.25.12",
+        "@esbuild/freebsd-x64": "0.25.12",
+        "@esbuild/linux-arm": "0.25.12",
+        "@esbuild/linux-arm64": "0.25.12",
+        "@esbuild/linux-ia32": "0.25.12",
+        "@esbuild/linux-loong64": "0.25.12",
+        "@esbuild/linux-mips64el": "0.25.12",
+        "@esbuild/linux-ppc64": "0.25.12",
+        "@esbuild/linux-riscv64": "0.25.12",
+        "@esbuild/linux-s390x": "0.25.12",
+        "@esbuild/linux-x64": "0.25.12",
+        "@esbuild/netbsd-arm64": "0.25.12",
+        "@esbuild/netbsd-x64": "0.25.12",
+        "@esbuild/openbsd-arm64": "0.25.12",
+        "@esbuild/openbsd-x64": "0.25.12",
+        "@esbuild/openharmony-arm64": "0.25.12",
+        "@esbuild/sunos-x64": "0.25.12",
+        "@esbuild/win32-arm64": "0.25.12",
+        "@esbuild/win32-ia32": "0.25.12",
+        "@esbuild/win32-x64": "0.25.12"
+      }
+    },
+    "node_modules/estree-walker": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz",
+      "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==",
+      "license": "MIT"
+    },
+    "node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/magic-string": {
+      "version": "0.30.21",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
+      "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.5"
+      }
+    },
+    "node_modules/muggle-string": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/muggle-string/-/muggle-string-0.4.1.tgz",
+      "integrity": "sha512-VNTrAak/KhO2i8dqqnqnAHOa3cYBwXEZe9h+D5h/1ZqFSTEFHdM65lR7RoIqq3tBBYavsOXV84NoHXZ0AkPyqQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.16",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.16.tgz",
+      "integrity": "sha512-bzlKTyNJ7+LdGIIwy8ijFpIqEQIvafahV7eYykJ8Cvh42EdJeODoJ6gUJXpQJvej1BddH8OqTXZNE/KfbWAu8Q==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/path-browserify": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/path-browserify/-/path-browserify-1.0.1.tgz",
+      "integrity": "sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "license": "ISC"
+    },
+    "node_modules/picomatch": {
+      "version": "4.0.5",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.5.tgz",
+      "integrity": "sha512-RvwwcruNjI1ncT5xRakeyS9Lf8lcItv34KD+aif+VH9kduAyfYBipGh12274xtenIPZ119/R9BdTBa8gAwSh0A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/postcss": {
+      "version": "8.5.22",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.22.tgz",
+      "integrity": "sha512-KBDEIpLrvpv16pp3K0Fw+UCoZfopFjjgeB+0tA/aaThfEE74kKDLrgg603YvOWJyg3+WYtyq3xYsQWsIyZlPqQ==",
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.16",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/rollup": {
+      "version": "4.62.2",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.62.2.tgz",
+      "integrity": "sha512-RFnrW4lhXA3s3eqHDZvN654g8OTjzRfqpIRJYczCGB6HzphckVAi/Qh4tbPUbRuDi7s1Llv8g/NspLkttY3gTA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "1.0.9"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.62.2",
+        "@rollup/rollup-android-arm64": "4.62.2",
+        "@rollup/rollup-darwin-arm64": "4.62.2",
+        "@rollup/rollup-darwin-x64": "4.62.2",
+        "@rollup/rollup-freebsd-arm64": "4.62.2",
+        "@rollup/rollup-freebsd-x64": "4.62.2",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.62.2",
+        "@rollup/rollup-linux-arm-musleabihf": "4.62.2",
+        "@rollup/rollup-linux-arm64-gnu": "4.62.2",
+        "@rollup/rollup-linux-arm64-musl": "4.62.2",
+        "@rollup/rollup-linux-loong64-gnu": "4.62.2",
+        "@rollup/rollup-linux-loong64-musl": "4.62.2",
+        "@rollup/rollup-linux-ppc64-gnu": "4.62.2",
+        "@rollup/rollup-linux-ppc64-musl": "4.62.2",
+        "@rollup/rollup-linux-riscv64-gnu": "4.62.2",
+        "@rollup/rollup-linux-riscv64-musl": "4.62.2",
+        "@rollup/rollup-linux-s390x-gnu": "4.62.2",
+        "@rollup/rollup-linux-x64-gnu": "4.62.2",
+        "@rollup/rollup-linux-x64-musl": "4.62.2",
+        "@rollup/rollup-openbsd-x64": "4.62.2",
+        "@rollup/rollup-openharmony-arm64": "4.62.2",
+        "@rollup/rollup-win32-arm64-msvc": "4.62.2",
+        "@rollup/rollup-win32-ia32-msvc": "4.62.2",
+        "@rollup/rollup-win32-x64-gnu": "4.62.2",
+        "@rollup/rollup-win32-x64-msvc": "4.62.2",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/tinyglobby": {
+      "version": "0.2.17",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.17.tgz",
+      "integrity": "sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.4"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
+      }
+    },
+    "node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "license": "0BSD"
+    },
+    "node_modules/typescript": {
+      "version": "5.9.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "devOptional": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "6.21.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/vite": {
+      "version": "6.4.3",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-6.4.3.tgz",
+      "integrity": "sha512-NTKlcQjlAK7MlQoyb6LgaqHc8sso/pVyUJYWMws3jg21uTJw/LddqIFPcPqP6PzpgbIcZyKI85sFE4HBrQDA8A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "^0.25.0",
+        "fdir": "^6.4.4",
+        "picomatch": "^4.0.2",
+        "postcss": "^8.5.3",
+        "rollup": "^4.34.9",
+        "tinyglobby": "^0.2.13"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0",
+        "jiti": ">=1.21.0",
+        "less": "*",
+        "lightningcss": "^1.21.0",
+        "sass": "*",
+        "sass-embedded": "*",
+        "stylus": "*",
+        "sugarss": "*",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "jiti": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vscode-uri": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/vscode-uri/-/vscode-uri-3.1.0.tgz",
+      "integrity": "sha512-/BpdSx+yCQGnCvecbyXdxHDkuk55/G3xwnC0GqY4gmQ3j+A+g8kzzgB4Nk/SINjqn6+waqw3EgbVF2QKExkRxQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/vue": {
+      "version": "3.5.40",
+      "resolved": "https://registry.npmjs.org/vue/-/vue-3.5.40.tgz",
+      "integrity": "sha512-+8PJ4SJXdn/cHGImF4CKdxlWHIN5Dkt7DoufRREM6h6uVCx2m7QxgcEQmmzyOK8A9mcafg7sFbJFYsdFVubTig==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/compiler-dom": "3.5.40",
+        "@vue/compiler-sfc": "3.5.40",
+        "@vue/runtime-dom": "3.5.40",
+        "@vue/server-renderer": "3.5.40",
+        "@vue/shared": "3.5.40"
+      },
+      "peerDependencies": {
+        "typescript": "*"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vue-tsc": {
+      "version": "3.3.7",
+      "resolved": "https://registry.npmjs.org/vue-tsc/-/vue-tsc-3.3.7.tgz",
+      "integrity": "sha512-+C+rgD49wAQ5bUTl2sp5a8Bzg4YoldMNXM+g7CFe604MYcQ8PrZPMQhIjJSzKXtPBCa+C5ayMipqjbA7splekQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@volar/typescript": "2.4.28",
+        "@vue/language-core": "3.3.7"
+      },
+      "bin": {
+        "vue-tsc": "bin/vue-tsc.js"
+      },
+      "peerDependencies": {
+        "typescript": ">=5.0.0"
+      }
+    }
+  }
+}

apps/results-dashboard/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "autocad-bench-results-dashboard",
+  "private": true,
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite --host 127.0.0.1 --port 4273",
+    "build": "vue-tsc -b && vite build",
+    "test": "node --test tests/*.test.mjs",
+    "preview": "node server.mjs"
+  },
+  "dependencies": {
+    "@aws-sdk/client-s3": "3.1090.0",
+    "@aws-sdk/credential-providers": "3.1090.0",
+    "@aws-sdk/s3-request-presigner": "3.1090.0",
+    "vue": "3.5.40"
+  },
+  "devDependencies": {
+    "@types/node": "20.19.43",
+    "@vitejs/plugin-vue": "5.2.4",
+    "typescript": "5.9.3",
+    "vite": "6.4.3",
+    "vue-tsc": "3.3.7"
+  }
+}

apps/results-dashboard/results-api.mjs

@@ -0,0 +1,714 @@
+import {
+  GetObjectCommand,
+  ListObjectsV2Command,
+} from '@aws-sdk/client-s3'
+
+const MANIFEST_SUFFIX = 'aggregate/manifest.json'
+const DEFAULT_CACHE_TTL_MS = 5 * 60_000
+const DEFAULT_TRACE_CACHE_ENTRIES = 12
+
+function asNumber(value) {
+  if (value == null || value === '') return null
+  const parsed = Number(value)
+  return Number.isFinite(parsed) ? parsed : null
+}
+
+function mean(values) {
+  const usable = values.filter((value) => Number.isFinite(value))
+  return usable.length ? usable.reduce((sum, value) => sum + value, 0) / usable.length : null
+}
+
+function median(values) {
+  const usable = values.filter((value) => Number.isFinite(value)).sort((a, b) => a - b)
+  if (!usable.length) return null
+  const middle = Math.floor(usable.length / 2)
+  return usable.length % 2 ? usable[middle] : (usable[middle - 1] + usable[middle]) / 2
+}
+
+function slugify(value) {
+  return String(value || 'model')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+}
+
+const CANONICAL_TASK_RANGES = [
+  { first: 1, last: 3, drawingType: '2d', level: 'basic' },
+  { first: 4, last: 9, drawingType: '2d', level: 'intermediate' },
+  { first: 10, last: 15, drawingType: '2d', level: 'advanced' },
+  { first: 16, last: 21, drawingType: '2d', level: 'project' },
+  { first: 22, last: 28, drawingType: '3d', level: 'basic' },
+  { first: 29, last: 34, drawingType: '3d', level: 'intermediate' },
+  { first: 35, last: 42, drawingType: '3d', level: 'advanced' },
+  { first: 43, last: 50, drawingType: '3d', level: 'project' },
+]
+
+function taskDimensions(taskId) {
+  const canonical = String(taskId).match(/^task-(\d{3})$/)
+  if (canonical) {
+    const number = Number(canonical[1])
+    const range = CANONICAL_TASK_RANGES.find(
+      (candidate) => number >= candidate.first && number <= candidate.last,
+    )
+    if (range) return { drawingType: range.drawingType, level: range.level }
+  }
+
+  // Preserve readability for imported result manifests created before the
+  // benchmark switched to opaque, globally consecutive IDs.
+  const drawingType = taskId.startsWith('3d-') ? '3d' : '2d'
+  const withoutDimension = taskId.replace(/^3d-/, '')
+  const level = withoutDimension.split('-')[0] || 'other'
+  return { drawingType, level }
+}
+
+function scoreStats(values) {
+  const usable = values.filter((value) => Number.isFinite(value))
+  return {
+    count: usable.length,
+    mean: mean(usable),
+    median: median(usable),
+    min: usable.length ? Math.min(...usable) : null,
+    max: usable.length ? Math.max(...usable) : null,
+  }
+}
+
+function histogram(values, buckets = 10) {
+  const counts = Array.from({ length: buckets }, () => 0)
+  for (const value of values) {
+    if (!Number.isFinite(value)) continue
+    const index = Math.max(0, Math.min(buckets - 1, Math.floor(value * buckets)))
+    counts[index] += 1
+  }
+  return counts
+}
+
+export function normalizeManifest(manifest, { manifestKey = MANIFEST_SUFFIX } = {}) {
+  const modelPrefix = manifestKey.slice(0, -MANIFEST_SUFFIX.length)
+  const modelId = String(manifest.model_id || modelPrefix.replace(/\/$/, '') || 'unknown')
+  const slug = modelPrefix ? slugify(modelPrefix.replace(/\/$/, '')) : slugify(modelId)
+  const tasks = (Array.isArray(manifest.tasks) ? manifest.tasks : []).map((task, index) => {
+    const taskId = String(task.task_id || `task-${index + 1}`)
+    const derivedDimensions = taskDimensions(taskId)
+    const drawingType = String(task.drawing_type || derivedDimensions.drawingType).toLowerCase() === '3d'
+      ? '3d'
+      : '2d'
+    const level = String(task.level || derivedDimensions.level)
+    const executionStatus = String(
+      task.execution_status || task.execution_state || task.controller_state || 'unknown',
+    )
+    const scoreIsVision = !task.score_source || task.score_source === 'vision_judge'
+    return {
+      index,
+      taskId,
+      drawingType,
+      level,
+      category: `${drawingType}-${level}`,
+      included: task.included !== false,
+      executionStatus,
+      evaluationStatus: String(task.evaluation_status || task.evaluation_stage || 'unknown'),
+      selectedAttempt: String(task.selected_attempt || 'selected'),
+      selectedRunId: String(task.selected_run_id || ''),
+      destinationPrefix: String(task.destination_prefix || ''),
+      sourcePrefix: String(task.source_prefix || ''),
+      objectCount: asNumber(task.object_count) || 0,
+      bytes: asNumber(task.bytes) || 0,
+      deterministicScore: asNumber(task.deterministic_score),
+      deterministicValid: task.deterministic_valid !== false,
+      visionScore: asNumber(task.vision_score ?? (scoreIsVision ? task.score : null)),
+      visionVerdict: String(task.vision_verdict || task.outcome || 'unavailable'),
+      evaluatorVersion: String(task.evaluator_version || ''),
+      controllerClean: typeof task.controller_clean === 'boolean'
+        ? task.controller_clean
+        : executionStatus === 'completed',
+      exclusionReason: task.exclusion_reason ? String(task.exclusion_reason) : null,
+    }
+  })
+  const included = tasks.filter((task) => task.included)
+  const categoryMap = new Map()
+  for (const task of included) {
+    if (!categoryMap.has(task.category)) categoryMap.set(task.category, [])
+    categoryMap.get(task.category).push(task)
+  }
+  const categories = [...categoryMap.entries()]
+    .map(([category, members]) => ({
+      category,
+      drawingType: members[0].drawingType,
+      level: members[0].level,
+      tasks: members.length,
+      deterministic: scoreStats(members.map((task) => task.deterministicScore)),
+      vision: scoreStats(members.map((task) => task.visionScore)),
+    }))
+    .sort((a, b) => a.category.localeCompare(b.category))
+  const deterministicValues = included.map((task) => task.deterministicScore)
+  const visionValues = included.map((task) => task.visionScore)
+  return {
+    slug,
+    manifestKey,
+    modelPrefix,
+    modelId,
+    aggregateId: String(manifest.aggregate_id || ''),
+    createdAt: manifest.created_at ? String(manifest.created_at) : null,
+    sourceBucket: String(manifest.source_bucket || ''),
+    destinationBucket: String(manifest.destination_bucket || ''),
+    evaluatorVersion: String(included.find((task) => task.evaluatorVersion)?.evaluatorVersion || ''),
+    tasks,
+    categories,
+    totals: {
+      expected: asNumber(manifest.summary?.expected_tasks) ?? tasks.length,
+      included: included.length,
+      excluded: tasks.length - included.length,
+      clean: included.filter((task) => task.controllerClean).length,
+      budgetExhausted: included.filter((task) => task.executionStatus === 'budget_exhausted').length,
+      bytes: included.reduce((sum, task) => sum + task.bytes, 0),
+      objects: included.reduce((sum, task) => sum + task.objectCount, 0),
+    },
+    scores: {
+      deterministic: scoreStats(deterministicValues),
+      vision: scoreStats(visionValues),
+      deterministicHistogram: histogram(deterministicValues),
+      visionHistogram: histogram(visionValues),
+    },
+    selectionPolicy: manifest.selection_policy || null,
+    sourceRuns: Array.isArray(manifest.source_runs) ? manifest.source_runs : [],
+  }
+}
+
+function parseJsonLines(text) {
+  const rows = []
+  for (const line of String(text || '').split(/\r?\n/)) {
+    if (!line.trim()) continue
+    try {
+      rows.push(JSON.parse(line))
+    } catch {
+      // A partially written final line must not hide the rest of the trace.
+    }
+  }
+  return rows
+}
+
+function imageSequence(value) {
+  const match = String(value || '').match(/frames\/frame_(\d+)\.png/)
+  return match ? Number(match[1]) : null
+}
+
+function compactReceipt(receipt) {
+  return {
+    actionIndex: asNumber(receipt?.action_index),
+    batchIndex: asNumber(receipt?.batch_index),
+    batchSize: asNumber(receipt?.batch_size),
+    toolUseId: receipt?.tool_use_id || null,
+    action: receipt?.action || null,
+    receipt: receipt?.receipt || null,
+    requestId: receipt?.request_id || null,
+    idempotentReplay: Boolean(receipt?.idempotent_replay),
+  }
+}
+
+async function mapConcurrent(items, concurrency, mapper) {
+  const results = new Array(items.length)
+  let next = 0
+  await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, async () => {
+    while (next < items.length) {
+      const index = next
+      next += 1
+      results[index] = await mapper(items[index], index)
+    }
+  }))
+  return results
+}
+
+function notFound(error) {
+  return error?.name === 'NoSuchKey'
+    || error?.name === 'NotFound'
+    || error?.$metadata?.httpStatusCode === 404
+}
+
+export class ResultsRepository {
+  constructor({
+    s3,
+    bucket,
+    signUrl,
+    cacheTtlMs = DEFAULT_CACHE_TTL_MS,
+    traceCacheEntries = DEFAULT_TRACE_CACHE_ENTRIES,
+    signedUrlTtlSeconds = 3600,
+  }) {
+    this.s3 = s3
+    this.bucket = bucket
+    this.signUrl = signUrl
+    this.cacheTtlMs = cacheTtlMs
+    this.traceCacheEntries = traceCacheEntries
+    this.signedUrlTtlSeconds = signedUrlTtlSeconds
+    this.cache = new Map()
+    this.traceCache = new Map()
+  }
+
+  async cached(key, loader, ttlMs = this.cacheTtlMs) {
+    const current = this.cache.get(key)
+    if (current && current.expiresAt > Date.now()) return current.value
+    const promise = Promise.resolve().then(loader)
+    this.cache.set(key, { expiresAt: Date.now() + ttlMs, value: promise })
+    try {
+      return await promise
+    } catch (error) {
+      this.cache.delete(key)
+      throw error
+    }
+  }
+
+  async text(key, { optional = false, ttlMs = this.cacheTtlMs } = {}) {
+    return this.cached(`object:${key}`, async () => {
+      try {
+        const response = await this.s3.send(new GetObjectCommand({
+          Bucket: this.bucket,
+          Key: key,
+        }))
+        if (!response.Body) return ''
+        if (typeof response.Body.transformToString === 'function') {
+          return response.Body.transformToString()
+        }
+        return String(response.Body)
+      } catch (error) {
+        if (optional && notFound(error)) return null
+        throw error
+      }
+    }, ttlMs)
+  }
+
+  async json(key, options = {}) {
+    const value = await this.text(key, options)
+    if (value == null || value === '') return null
+    return JSON.parse(value)
+  }
+
+  async discoverModels({ force = false } = {}) {
+    if (force) this.cache.delete('models')
+    return this.cached('models', async () => {
+      const root = await this.s3.send(new ListObjectsV2Command({
+        Bucket: this.bucket,
+        Delimiter: '/',
+        MaxKeys: 1000,
+      }))
+      const prefixes = (root.CommonPrefixes || [])
+        .map((entry) => String(entry.Prefix || ''))
+        .filter((prefix) => prefix && !['aggregate/', 'artifacts/', 'batch/'].includes(prefix))
+      const candidates = [MANIFEST_SUFFIX, ...prefixes.map((prefix) => `${prefix}${MANIFEST_SUFFIX}`)]
+      const manifests = await Promise.all(candidates.map(async (manifestKey) => {
+        try {
+          const manifest = await this.json(manifestKey)
+          return manifest ? normalizeManifest(manifest, { manifestKey }) : null
+        } catch (error) {
+          if (notFound(error)) return null
+          throw error
+        }
+      }))
+      return manifests.filter(Boolean).sort((a, b) => a.modelId.localeCompare(b.modelId))
+    }, 60_000)
+  }
+
+  async model(slug) {
+    const models = await this.discoverModels()
+    return models.find((model) => model.slug === slug) || null
+  }
+
+  async task(slug, taskId) {
+    const model = await this.model(slug)
+    if (!model) return { model: null, task: null }
+    return { model, task: model.tasks.find((candidate) => candidate.taskId === taskId) || null }
+  }
+
+  taskKey(task, relativePath) {
+    const clean = String(relativePath || '').replace(/^\/+/, '')
+    if (!clean || clean.includes('\\') || clean.split('/').some((part) => part === '..' || part === '.')) {
+      throw new Error('Unsafe task artifact path')
+    }
+    if (!task.destinationPrefix) throw new Error('Task has no finalized artifact prefix')
+    return `${task.destinationPrefix}${clean}`
+  }
+
+  async taskJson(task, relativePath, { optional = true } = {}) {
+    return this.json(this.taskKey(task, relativePath), { optional })
+  }
+
+  async modelMetrics(slug) {
+    const model = await this.model(slug)
+    if (!model) return null
+    const included = model.tasks.filter((task) => task.included && task.destinationPrefix)
+    const taskMetrics = await mapConcurrent(included, 12, async (task) => {
+      const [result, state, evaluationScore, evaluationStatus] = await Promise.all([
+        this.taskJson(task, 'result.json'),
+        this.taskJson(task, 'run-state.json'),
+        this.taskJson(task, 'evaluation/score.json'),
+        this.taskJson(task, 'evaluation/status.json'),
+      ])
+      const usage = result?.usage || state?.usage || {}
+      const inputTokens = asNumber(usage.input_tokens)
+      const cachedInputTokens = asNumber(usage.cached_input_tokens ?? usage.cache_read_input_tokens)
+      const cacheCreationTokens = asNumber(usage.cache_creation_input_tokens)
+      const outputTokens = asNumber(usage.output_tokens)
+      const reportedTotalTokens = asNumber(usage.total_tokens)
+      return {
+        taskId: task.taskId,
+        drawingType: task.drawingType,
+        level: task.level,
+        acceptedActions: asNumber(result?.accepted_actions ?? state?.accepted_actions),
+        elapsedSeconds: asNumber(result?.elapsed_s),
+        rolloutSeconds: asNumber(result?.rollout_elapsed_s),
+        turns: asNumber(state?.turn_count),
+        screenshots: asNumber(result?.screenshots ?? state?.screenshots),
+        inputTokens,
+        cachedInputTokens,
+        cacheCreationTokens,
+        outputTokens,
+        reasoningTokens: asNumber(usage.reasoning_output_tokens),
+        totalTokens: reportedTotalTokens
+          ?? [inputTokens, cachedInputTokens, cacheCreationTokens, outputTokens]
+            .reduce((total, value) => total + (value || 0), 0),
+        artifactBytes: asNumber(result?.artifact_bytes),
+        stopReason: String(result?.stop_reason || state?.stop_reason || ''),
+        deterministicScore: task.deterministicScore ?? asNumber(evaluationScore?.score),
+        visionScore: task.visionScore
+          ?? asNumber(evaluationStatus?.vision_score ?? result?.evaluation?.vision_score),
+        visionVerdict: task.visionVerdict !== 'unavailable'
+          ? task.visionVerdict
+          : String(evaluationStatus?.vision_verdict || result?.evaluation?.vision_verdict || 'unavailable'),
+      }
+    })
+    const sum = (key) => taskMetrics.reduce((total, task) => total + (task[key] || 0), 0)
+    const categoryMap = new Map()
+    for (const task of taskMetrics) {
+      const category = `${task.drawingType}-${task.level}`
+      if (!categoryMap.has(category)) categoryMap.set(category, [])
+      categoryMap.get(category).push(task)
+    }
+    const deterministicValues = taskMetrics.map((task) => task.deterministicScore)
+    const visionValues = taskMetrics.map((task) => task.visionScore)
+    return {
+      tasks: taskMetrics,
+      totals: {
+        acceptedActions: sum('acceptedActions'),
+        elapsedSeconds: sum('elapsedSeconds'),
+        turns: sum('turns'),
+        screenshots: sum('screenshots'),
+        inputTokens: sum('inputTokens'),
+        cachedInputTokens: sum('cachedInputTokens'),
+        cacheCreationTokens: sum('cacheCreationTokens'),
+        outputTokens: sum('outputTokens'),
+        reasoningTokens: sum('reasoningTokens'),
+        totalTokens: sum('totalTokens'),
+      },
+      medians: {
+        acceptedActions: median(taskMetrics.map((task) => task.acceptedActions)),
+        elapsedSeconds: median(taskMetrics.map((task) => task.elapsedSeconds)),
+        turns: median(taskMetrics.map((task) => task.turns)),
+      },
+      scores: {
+        deterministic: scoreStats(deterministicValues),
+        vision: scoreStats(visionValues),
+        deterministicHistogram: histogram(deterministicValues),
+        visionHistogram: histogram(visionValues),
+      },
+      categories: [...categoryMap.entries()].map(([category, members]) => ({
+        category,
+        drawingType: members[0].drawingType,
+        level: members[0].level,
+        tasks: members.length,
+        deterministic: scoreStats(members.map((task) => task.deterministicScore)),
+        vision: scoreStats(members.map((task) => task.visionScore)),
+      })).sort((a, b) => a.category.localeCompare(b.category)),
+    }
+  }
+
+  async taskDetail(slug, taskId) {
+    const { model, task } = await this.task(slug, taskId)
+    if (!model || !task) return null
+    const [result, runState, evaluationScore, evaluationStatus, visionScore] = await Promise.all([
+      this.taskJson(task, 'result.json'),
+      this.taskJson(task, 'run-state.json'),
+      this.taskJson(task, 'evaluation/score.json'),
+      this.taskJson(task, 'evaluation/status.json'),
+      this.taskJson(task, 'evaluation/vision-judge/score.json'),
+    ])
+    return {
+      model: {
+        slug: model.slug,
+        modelId: model.modelId,
+        aggregateId: model.aggregateId,
+      },
+      task,
+      result,
+      runState,
+      evaluationScore,
+      evaluationStatus,
+      visionScore,
+      frameCount: asNumber(result?.screenshots ?? runState?.screenshots) || 0,
+      turnCount: asNumber(runState?.turn_count) || 0,
+      media: {
+        reference: 'reference.png',
+        final: 'evaluation/render.png',
+        diff: 'evaluation/diff.png',
+        dwg: 'attempt.dwg',
+      },
+      downloads: [
+        ['Final DWG', 'attempt.dwg'],
+        ['Result', 'result.json'],
+        ['Run state', 'run-state.json'],
+        ['Model turns', 'model_turns.jsonl'],
+        ['Turn summaries', 'model_turn_summaries.jsonl'],
+        ['Action receipts', 'input_receipts.jsonl'],
+        ['Events', 'events.json'],
+        ['Frame events', 'frame_events.json'],
+        ['Evaluator score', 'evaluation/score.json'],
+        ['Evaluator metadata', 'evaluation/metadata.json'],
+      ].map(([label, path]) => ({ label, path })),
+    }
+  }
+
+  async traceBundle(task) {
+    const key = task.destinationPrefix
+    if (this.traceCache.has(key)) {
+      const cached = this.traceCache.get(key)
+      this.traceCache.delete(key)
+      this.traceCache.set(key, cached)
+      return cached
+    }
+    const bundle = Promise.all([
+      this.text(this.taskKey(task, 'model_turn_summaries.jsonl'), { optional: true }),
+      this.text(this.taskKey(task, 'input_receipts.jsonl'), { optional: true }),
+    ]).then(async ([turnText, receiptText]) => {
+      const completeTurnText = turnText || await this.text(
+        this.taskKey(task, 'model_turns.jsonl'),
+        { optional: true },
+      )
+      return {
+        turns: parseJsonLines(completeTurnText),
+        receipts: parseJsonLines(receiptText),
+      }
+    })
+    this.traceCache.set(key, bundle)
+    while (this.traceCache.size > this.traceCacheEntries) {
+      this.traceCache.delete(this.traceCache.keys().next().value)
+    }
+    try {
+      return await bundle
+    } catch (error) {
+      this.traceCache.delete(key)
+      throw error
+    }
+  }
+
+  async traceIndex(slug, taskId) {
+    const { model, task } = await this.task(slug, taskId)
+    if (!model || !task) return null
+    const bundle = await this.traceBundle(task)
+    const receiptsByTool = new Map()
+    for (const receipt of bundle.receipts) {
+      const key = String(receipt.tool_use_id || '')
+      if (!receiptsByTool.has(key)) receiptsByTool.set(key, [])
+      receiptsByTool.get(key).push(receipt)
+    }
+    const turns = bundle.turns.map((turn, index) => {
+      const toolUseId = String(turn.tool_use_id || '')
+      const receipts = receiptsByTool.get(toolUseId) || []
+      const actionIndices = receipts.map((receipt) => asNumber(receipt.action_index)).filter(Number.isFinite)
+      const artifacts = Array.isArray(turn.model_input?.artifacts) ? turn.model_input.artifacts : []
+      const inputArtifact = artifacts.find((artifact) => imageSequence(artifact?.artifact_path) != null)
+      const declaredActions = Array.isArray(turn.action?.actions)
+        ? turn.action.actions
+        : (turn.action ? [turn.action] : [])
+      return {
+        index,
+        turn: asNumber(turn.turn) ?? index + 1,
+        toolUseId,
+        latencyMs: asNumber(turn.latency_ms),
+        stopReason: String(turn.stop_reason || ''),
+        requestAttempts: asNumber(turn.request_attempts),
+        validationRetries: asNumber(turn.response_validation_retries),
+        discardedToolUses: asNumber(turn.discarded_tool_uses),
+        usage: turn.usage || null,
+        text: turn.text || null,
+        actions: declaredActions,
+        actionCount: receipts.length || declaredActions.length,
+        inputFrameSequence: imageSequence(inputArtifact?.artifact_path),
+        outputFrameSequence: actionIndices.length ? Math.max(...actionIndices) : null,
+        firstActionIndex: actionIndices.length ? Math.min(...actionIndices) : null,
+        lastActionIndex: actionIndices.length ? Math.max(...actionIndices) : null,
+      }
+    })
+    return { taskId, turns, receiptCount: bundle.receipts.length }
+  }
+
+  async turnDetail(slug, taskId, turnNumber) {
+    const { task } = await this.task(slug, taskId)
+    if (!task) return null
+    const bundle = await this.traceBundle(task)
+    const index = Math.max(0, Number(turnNumber) - 1)
+    const turn = bundle.turns.find((candidate) => Number(candidate.turn) === Number(turnNumber))
+      || bundle.turns[index]
+    if (!turn) return null
+    const toolUseId = String(turn.tool_use_id || '')
+    const receipts = bundle.receipts
+      .filter((receipt) => String(receipt.tool_use_id || '') === toolUseId)
+      .map(compactReceipt)
+    return { turn, receipts }
+  }
+
+  async framePage(slug, taskId, { offset = 0, limit = 120 } = {}) {
+    const detail = await this.taskDetail(slug, taskId)
+    if (!detail) return null
+    const safeOffset = Math.max(0, Math.floor(Number(offset) || 0))
+    const safeLimit = Math.max(1, Math.min(240, Math.floor(Number(limit) || 120)))
+    const end = Math.min(detail.frameCount, safeOffset + safeLimit)
+    return {
+      offset: safeOffset,
+      limit: safeLimit,
+      total: detail.frameCount,
+      hasMore: end < detail.frameCount,
+      frames: Array.from({ length: Math.max(0, end - safeOffset) }, (_, index) => {
+        const sequence = safeOffset + index
+        return {
+          sequence,
+          name: `frame_${String(sequence).padStart(4, '0')}.png`,
+          path: `frames/frame_${String(sequence).padStart(4, '0')}.png`,
+        }
+      }),
+    }
+  }
+
+  async mediaUrl(slug, taskId, relativePath, { download = false } = {}) {
+    const { task } = await this.task(slug, taskId)
+    if (!task) return null
+    const key = this.taskKey(task, relativePath)
+    const extension = relativePath.split('.').at(-1)?.toLowerCase()
+    const contentType = {
+      png: 'image/png',
+      json: 'application/json',
+      jsonl: 'application/x-ndjson',
+      dwg: 'application/acad',
+    }[extension] || 'application/octet-stream'
+    const command = new GetObjectCommand({
+      Bucket: this.bucket,
+      Key: key,
+      ResponseContentType: contentType,
+      ResponseCacheControl: relativePath.endsWith('.png')
+        ? 'private, max-age=31536000, immutable'
+        : 'private, max-age=3600',
+      ...(download ? {
+        ResponseContentDisposition: `attachment; filename="${relativePath.split('/').at(-1)}"`,
+      } : {}),
+    })
+    const cacheLifetime = Math.max(
+      60_000,
+      Math.min(10 * 60_000, (this.signedUrlTtlSeconds - 60) * 1000),
+    )
+    return this.cached(
+      `signed:${key}:${download ? 'download' : 'inline'}`,
+      () => this.signUrl(command, { expiresIn: this.signedUrlTtlSeconds }),
+      cacheLifetime,
+    )
+  }
+}
+
+function sendJson(response, status, body, cacheControl = 'private, no-store') {
+  const payload = JSON.stringify(body)
+  response.statusCode = status
+  response.setHeader('Content-Type', 'application/json; charset=utf-8')
+  response.setHeader('Content-Length', Buffer.byteLength(payload))
+  response.setHeader('Cache-Control', cacheControl)
+  response.end(payload)
+}
+
+function decode(value) {
+  try {
+    return decodeURIComponent(value)
+  } catch {
+    return ''
+  }
+}
+
+export function createResultsApi({ repository }) {
+  return async (request, response) => {
+    const url = new URL(request.url || '/', 'http://results.local')
+    if (!url.pathname.startsWith('/api/results')) return false
+    try {
+      if (url.pathname === '/api/results/health') {
+        sendJson(response, 200, { ok: true, bucket: repository.bucket })
+        return true
+      }
+      if (url.pathname === '/api/results/models') {
+        const models = await repository.discoverModels({ force: url.searchParams.get('refresh') === '1' })
+        sendJson(response, 200, { models }, 'private, max-age=30')
+        return true
+      }
+      const modelMatch = url.pathname.match(/^\/api\/results\/models\/([^/]+)$/)
+      if (modelMatch) {
+        const model = await repository.model(decode(modelMatch[1]))
+        sendJson(response, model ? 200 : 404, model || { error: 'model_not_found' })
+        return true
+      }
+      const metricsMatch = url.pathname.match(/^\/api\/results\/models\/([^/]+)\/metrics$/)
+      if (metricsMatch) {
+        const metrics = await repository.modelMetrics(decode(metricsMatch[1]))
+        sendJson(response, metrics ? 200 : 404, metrics || { error: 'model_not_found' })
+        return true
+      }
+      const taskMatch = url.pathname.match(/^\/api\/results\/models\/([^/]+)\/tasks\/([^/]+)$/)
+      if (taskMatch) {
+        const detail = await repository.taskDetail(decode(taskMatch[1]), decode(taskMatch[2]))
+        sendJson(response, detail ? 200 : 404, detail || { error: 'task_not_found' })
+        return true
+      }
+      const traceMatch = url.pathname.match(/^\/api\/results\/models\/([^/]+)\/tasks\/([^/]+)\/trace$/)
+      if (traceMatch) {
+        const trace = await repository.traceIndex(decode(traceMatch[1]), decode(traceMatch[2]))
+        sendJson(response, trace ? 200 : 404, trace || { error: 'trace_not_found' })
+        return true
+      }
+      const turnMatch = url.pathname.match(/^\/api\/results\/models\/([^/]+)\/tasks\/([^/]+)\/turns\/(\d+)$/)
+      if (turnMatch) {
+        const turn = await repository.turnDetail(
+          decode(turnMatch[1]),
+          decode(turnMatch[2]),
+          Number(turnMatch[3]),
+        )
+        sendJson(response, turn ? 200 : 404, turn || { error: 'turn_not_found' })
+        return true
+      }
+      const framesMatch = url.pathname.match(/^\/api\/results\/models\/([^/]+)\/tasks\/([^/]+)\/frames$/)
+      if (framesMatch) {
+        const frames = await repository.framePage(decode(framesMatch[1]), decode(framesMatch[2]), {
+          offset: url.searchParams.get('offset'),
+          limit: url.searchParams.get('limit'),
+        })
+        sendJson(response, frames ? 200 : 404, frames || { error: 'task_not_found' }, 'private, max-age=300')
+        return true
+      }
+      const mediaMatch = url.pathname.match(/^\/api\/results\/models\/([^/]+)\/tasks\/([^/]+)\/media$/)
+      if (mediaMatch) {
+        const relativePath = url.searchParams.get('path') || ''
+        const signedUrl = await repository.mediaUrl(
+          decode(mediaMatch[1]),
+          decode(mediaMatch[2]),
+          relativePath,
+          { download: url.searchParams.get('download') === '1' },
+        )
+        if (!signedUrl) {
+          sendJson(response, 404, { error: 'task_not_found' })
+          return true
+        }
+        response.statusCode = 307
+        response.setHeader('Location', signedUrl)
+        response.setHeader('Cache-Control', 'private, max-age=300, stale-while-revalidate=60')
+        response.end()
+        return true
+      }
+      sendJson(response, 404, { error: 'route_not_found' })
+      return true
+    } catch (error) {
+      sendJson(response, 500, {
+        error: 'results_api_failed',
+        message: error instanceof Error ? error.message : String(error),
+      })
+      return true
+    }
+  }
+}

apps/results-dashboard/server.mjs

@@ -0,0 +1,71 @@
+import fs from 'node:fs'
+import http from 'node:http'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { S3Client } from '@aws-sdk/client-s3'
+import { fromIni } from '@aws-sdk/credential-providers'
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner'
+import { createResultsApi, ResultsRepository } from './results-api.mjs'
+
+const root = path.dirname(fileURLToPath(import.meta.url))
+const dist = path.join(root, 'dist')
+const host = process.env.HOST || '127.0.0.1'
+const port = Number(process.env.PORT || 4273)
+const region = process.env.AWS_REGION || ''
+const profile = process.env.AWS_PROFILE || ''
+const bucket = process.env.AUTOCAD_RESULTS_BUCKET || ''
+if (!bucket) {
+  throw new Error('AUTOCAD_RESULTS_BUCKET is required')
+}
+const signedUrlTtlSeconds = Math.max(
+  300,
+  Math.min(604800, Number(process.env.AUTOCAD_RESULTS_SIGNED_URL_TTL_SECONDS || 3600)),
+)
+
+const s3 = new S3Client({
+  ...(region ? { region } : {}),
+  ...(profile ? { credentials: fromIni({ profile }) } : {}),
+  maxAttempts: 5,
+})
+const repository = new ResultsRepository({
+  s3,
+  bucket,
+  signedUrlTtlSeconds,
+  signUrl: (command, options) => getSignedUrl(s3, command, options),
+})
+const api = createResultsApi({ repository })
+
+const mime = {
+  '.css': 'text/css; charset=utf-8',
+  '.html': 'text/html; charset=utf-8',
+  '.js': 'text/javascript; charset=utf-8',
+  '.json': 'application/json; charset=utf-8',
+  '.map': 'application/json; charset=utf-8',
+  '.png': 'image/png',
+  '.woff2': 'font/woff2',
+}
+
+http.createServer(async (request, response) => {
+  if (await api(request, response)) return
+  const pathname = decodeURIComponent(new URL(request.url || '/', `http://${host}`).pathname)
+  const requested = path.resolve(dist, pathname.replace(/^\/+/, ''))
+  const safe = requested.startsWith(`${dist}${path.sep}`) ? requested : null
+  const file = safe && fs.existsSync(safe) && fs.statSync(safe).isFile()
+    ? safe
+    : path.join(dist, 'index.html')
+  if (!fs.existsSync(file)) {
+    response.statusCode = 503
+    response.setHeader('Content-Type', 'text/plain; charset=utf-8')
+    response.end('Dashboard build not found. Run npm run build first.')
+    return
+  }
+  response.statusCode = 200
+  response.setHeader('Content-Type', mime[path.extname(file)] || 'application/octet-stream')
+  response.setHeader(
+    'Cache-Control',
+    path.basename(file) === 'index.html' ? 'no-cache' : 'public, max-age=31536000, immutable',
+  )
+  fs.createReadStream(file).pipe(response)
+}).listen(port, host, () => {
+  process.stdout.write(`AutoCAD Results: http://${host}:${port}\n`)
+})

apps/results-dashboard/src/App.vue

@@ -0,0 +1,831 @@
+<script setup lang="ts">
+import { computed, nextTick, onBeforeUnmount, onMounted, ref } from 'vue'
+import ReliableImage from './components/ReliableImage.vue'
+import type {
+  Frame,
+  FramePage,
+  ModelMetrics,
+  ModelResult,
+  ResultTask,
+  TaskDetail,
+  TraceIndex,
+  TraceTurn,
+  TurnDetail,
+} from './types'
+
+type View = 'overview' | 'tasks' | 'trace' | 'frames'
+type ExpandedImage = { src: string; label: string }
+
+const models = ref<ModelResult[]>([])
+const selectedModelSlug = ref('')
+const selectedTaskId = ref('')
+const view = ref<View>('overview')
+const metrics = ref<ModelMetrics | null>(null)
+const taskDetail = ref<TaskDetail | null>(null)
+const trace = ref<TraceIndex | null>(null)
+const selectedTurnIndex = ref(0)
+const turnDetail = ref<TurnDetail | null>(null)
+const frames = ref<Frame[]>([])
+const frameTotal = ref(0)
+const frameHasMore = ref(false)
+
+const loadingModels = ref(true)
+const loadingMetrics = ref(false)
+const loadingTask = ref(false)
+const loadingTurn = ref(false)
+const loadingFrames = ref(false)
+const error = ref('')
+const expandedImage = ref<ExpandedImage | null>(null)
+const taskSearch = ref('')
+const taskDimension = ref('all')
+const taskLevel = ref('all')
+const taskStatus = ref('all')
+const taskSort = ref('task')
+
+let taskLoadVersion = 0
+let turnLoadVersion = 0
+
+async function fetchJson<T>(url: string, timeoutMs = 30_000): Promise<T> {
+  let lastError: unknown
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    const controller = new AbortController()
+    const timeout = window.setTimeout(() => controller.abort(), timeoutMs)
+    try {
+      const response = await fetch(url, { cache: 'no-store', signal: controller.signal })
+      if (!response.ok) throw new Error(`Request failed (HTTP ${response.status})`)
+      return await response.json() as T
+    } catch (reason) {
+      lastError = reason
+      if (attempt < 2) await new Promise((resolve) => window.setTimeout(resolve, 250 * 2 ** attempt))
+    } finally {
+      window.clearTimeout(timeout)
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error(String(lastError))
+}
+
+const selectedModel = computed(() =>
+  models.value.find((model) => model.slug === selectedModelSlug.value) || null,
+)
+
+const selectedTask = computed(() =>
+  selectedModel.value?.tasks.find((task) => task.taskId === selectedTaskId.value) || null,
+)
+
+const selectedTurn = computed<TraceTurn | null>(() =>
+  trace.value?.turns[selectedTurnIndex.value] || null,
+)
+
+const metricByTask = computed(() => new Map(
+  (metrics.value?.tasks || []).map((metric) => [metric.taskId, metric]),
+))
+
+const activeScores = computed(() => metrics.value?.scores || selectedModel.value?.scores || null)
+const activeCategories = computed(() => metrics.value?.categories || selectedModel.value?.categories || [])
+
+const selectedVisionScore = computed(() => {
+  if (!selectedTask.value) return null
+  return metricByTask.value.get(selectedTask.value.taskId)?.visionScore
+    ?? selectedTask.value.visionScore
+    ?? numberField(taskDetail.value?.evaluationStatus || null, 'vision_score')
+})
+
+const selectedDeterministicScore = computed(() => {
+  if (!selectedTask.value) return null
+  return metricByTask.value.get(selectedTask.value.taskId)?.deterministicScore
+    ?? selectedTask.value.deterministicScore
+    ?? numberField(taskDetail.value?.evaluationScore || null, 'score')
+})
+
+const levels = computed(() =>
+  [...new Set(selectedModel.value?.tasks.map((task) => task.level) || [])].sort(),
+)
+
+const statuses = computed(() =>
+  [...new Set(selectedModel.value?.tasks.map((task) => task.executionStatus) || [])].sort(),
+)
+
+const filteredTasks = computed(() => {
+  const query = taskSearch.value.trim().toLowerCase()
+  const result = (selectedModel.value?.tasks || []).filter((task) => (
+    (!query || task.taskId.toLowerCase().includes(query))
+    && (taskDimension.value === 'all' || task.drawingType === taskDimension.value)
+    && (taskLevel.value === 'all' || task.level === taskLevel.value)
+    && (taskStatus.value === 'all' || task.executionStatus === taskStatus.value)
+  ))
+  return [...result].sort((a, b) => {
+    if (taskSort.value === 'vision') return (taskVisionScore(b) ?? -1) - (taskVisionScore(a) ?? -1)
+    if (taskSort.value === 'deterministic') {
+      return (taskDeterministicScore(b) ?? -1) - (taskDeterministicScore(a) ?? -1)
+    }
+    if (taskSort.value === 'actions') {
+      return (metricByTask.value.get(b.taskId)?.acceptedActions ?? -1)
+        - (metricByTask.value.get(a.taskId)?.acceptedActions ?? -1)
+    }
+    return a.taskId.localeCompare(b.taskId, undefined, { numeric: true })
+  })
+})
+
+const suiteTotals = computed(() => ({
+  models: models.value.length,
+  tasks: models.value.reduce((sum, model) => sum + model.totals.included, 0),
+  objects: models.value.reduce((sum, model) => sum + model.totals.objects, 0),
+  bytes: models.value.reduce((sum, model) => sum + model.totals.bytes, 0),
+}))
+
+const scoreBreakdown = computed(() => {
+  const score = taskDetail.value?.evaluationScore || {}
+  return [
+    ['Linework', numberField(score, 'linework_similarity')],
+    ['Geometry', numberField(score, 'geometry_similarity')],
+    ['Extents', numberField(score, 'geometry_extent_similarity') ?? numberField(score, 'extent_similarity')],
+    ['Dimensions', numberField(score, 'dimension_similarity')],
+    ['Annotations', numberField(score, 'annotation_similarity')],
+  ] as Array<[string, number | null]>
+})
+
+function numberField(value: Record<string, unknown> | null, key: string): number | null {
+  const number = Number(value?.[key])
+  return Number.isFinite(number) ? number : null
+}
+
+function readRoute() {
+  const params = new URLSearchParams(window.location.hash.replace(/^#/, ''))
+  return {
+    model: params.get('model') || '',
+    task: params.get('task') || '',
+    view: (params.get('view') || 'overview') as View,
+    turn: Math.max(1, Number(params.get('turn') || 1)),
+  }
+}
+
+function writeRoute() {
+  const params = new URLSearchParams()
+  if (selectedModelSlug.value) params.set('model', selectedModelSlug.value)
+  if (selectedTaskId.value) params.set('task', selectedTaskId.value)
+  params.set('view', view.value)
+  if (view.value === 'trace' && selectedTurn.value) params.set('turn', String(selectedTurn.value.turn))
+  window.history.replaceState(null, '', `${window.location.pathname}${window.location.search}#${params}`)
+}
+
+async function loadModels() {
+  loadingModels.value = true
+  error.value = ''
+  try {
+    const response = await fetchJson<{ models: ModelResult[] }>('/api/results/models')
+    models.value = response.models
+    const route = readRoute()
+    selectedModelSlug.value = models.value.some((model) => model.slug === route.model)
+      ? route.model
+      : (models.value[0]?.slug || '')
+    view.value = ['overview', 'tasks', 'trace', 'frames'].includes(route.view)
+      ? route.view
+      : 'overview'
+    await loadMetrics()
+    if (route.task && selectedModel.value?.tasks.some((task) => task.taskId === route.task)) {
+      selectedTaskId.value = route.task
+      await loadTask(route.turn)
+      if (view.value === 'frames') await loadFrames(true)
+    } else if (view.value === 'trace' || view.value === 'frames') {
+      view.value = 'tasks'
+    }
+    writeRoute()
+  } catch (reason) {
+    error.value = reason instanceof Error ? reason.message : String(reason)
+  } finally {
+    loadingModels.value = false
+  }
+}
+
+async function refreshModels() {
+  loadingModels.value = true
+  try {
+    const response = await fetchJson<{ models: ModelResult[] }>('/api/results/models?refresh=1')
+    models.value = response.models
+    if (!selectedModel.value) selectedModelSlug.value = models.value[0]?.slug || ''
+    await loadMetrics()
+  } catch (reason) {
+    error.value = reason instanceof Error ? reason.message : String(reason)
+  } finally {
+    loadingModels.value = false
+  }
+}
+
+async function loadMetrics() {
+  metrics.value = null
+  if (!selectedModelSlug.value) return
+  loadingMetrics.value = true
+  try {
+    metrics.value = await fetchJson<ModelMetrics>(
+      `/api/results/models/${encodeURIComponent(selectedModelSlug.value)}/metrics`,
+      60_000,
+    )
+  } catch {
+    // The manifest scores remain fully usable when optional usage enrichment fails.
+  } finally {
+    loadingMetrics.value = false
+  }
+}
+
+async function selectModel(slug: string) {
+  if (slug === selectedModelSlug.value) return
+  selectedModelSlug.value = slug
+  selectedTaskId.value = ''
+  taskDetail.value = null
+  trace.value = null
+  frames.value = []
+  view.value = 'overview'
+  writeRoute()
+  await loadMetrics()
+}
+
+async function openTask(taskId: string) {
+  selectedTaskId.value = taskId
+  view.value = 'trace'
+  writeRoute()
+  await loadTask(1)
+}
+
+async function loadTask(preferredTurn = 1) {
+  const version = ++taskLoadVersion
+  loadingTask.value = true
+  taskDetail.value = null
+  trace.value = null
+  turnDetail.value = null
+  frames.value = []
+  error.value = ''
+  const base = `/api/results/models/${encodeURIComponent(selectedModelSlug.value)}`
+    + `/tasks/${encodeURIComponent(selectedTaskId.value)}`
+  try {
+    const [detail, traceIndex] = await Promise.all([
+      fetchJson<TaskDetail>(base),
+      fetchJson<TraceIndex>(`${base}/trace`, 60_000),
+    ])
+    if (version !== taskLoadVersion) return
+    taskDetail.value = detail
+    trace.value = traceIndex
+    const preferredIndex = Math.max(0, traceIndex.turns.findIndex((turn) => turn.turn === preferredTurn))
+    await selectTurn(preferredIndex)
+  } catch (reason) {
+    if (version === taskLoadVersion) {
+      error.value = reason instanceof Error ? reason.message : String(reason)
+    }
+  } finally {
+    if (version === taskLoadVersion) loadingTask.value = false
+  }
+}
+
+async function selectTurn(index: number) {
+  if (!trace.value?.turns.length) return
+  const safe = Math.max(0, Math.min(trace.value.turns.length - 1, index))
+  selectedTurnIndex.value = safe
+  turnDetail.value = null
+  const turn = trace.value.turns[safe]
+  const version = ++turnLoadVersion
+  loadingTurn.value = true
+  writeRoute()
+  prefetchTurnFrames(turn)
+  try {
+    const detail = await fetchJson<TurnDetail>(
+      `/api/results/models/${encodeURIComponent(selectedModelSlug.value)}`
+        + `/tasks/${encodeURIComponent(selectedTaskId.value)}/turns/${turn.turn}`,
+    )
+    if (version === turnLoadVersion) turnDetail.value = detail
+  } catch {
+    // Turn actions remain visible from the compact trace index.
+  } finally {
+    if (version === turnLoadVersion) loadingTurn.value = false
+  }
+}
+
+async function showView(nextView: View) {
+  view.value = nextView
+  writeRoute()
+  if (nextView === 'frames' && selectedTaskId.value && !frames.value.length) {
+    await loadFrames(true)
+  }
+}
+
+async function loadFrames(reset = false) {
+  if (!selectedTaskId.value || loadingFrames.value) return
+  if (reset) frames.value = []
+  loadingFrames.value = true
+  try {
+    const offset = frames.value.length
+    const page = await fetchJson<FramePage>(
+      `/api/results/models/${encodeURIComponent(selectedModelSlug.value)}`
+        + `/tasks/${encodeURIComponent(selectedTaskId.value)}/frames?offset=${offset}&limit=120`,
+    )
+    frames.value.push(...page.frames)
+    frameTotal.value = page.total
+    frameHasMore.value = page.hasMore
+  } catch (reason) {
+    error.value = reason instanceof Error ? reason.message : String(reason)
+  } finally {
+    loadingFrames.value = false
+  }
+}
+
+function mediaUrl(path: string, download = false): string {
+  if (!selectedModelSlug.value || !selectedTaskId.value) return ''
+  const base = `/api/results/models/${encodeURIComponent(selectedModelSlug.value)}`
+    + `/tasks/${encodeURIComponent(selectedTaskId.value)}/media`
+  return `${base}?path=${encodeURIComponent(path)}${download ? '&download=1' : ''}`
+}
+
+function frameUrl(sequence: number | null): string {
+  if (sequence == null) return ''
+  return mediaUrl(`frames/frame_${String(sequence).padStart(4, '0')}.png`)
+}
+
+function prefetchTurnFrames(turn: TraceTurn) {
+  const sequences = new Set([
+    turn.inputFrameSequence,
+    turn.outputFrameSequence,
+    turn.outputFrameSequence == null ? null : turn.outputFrameSequence + 1,
+  ])
+  for (const sequence of sequences) {
+    if (sequence == null || sequence < 0) continue
+    const image = new Image()
+    image.decoding = 'async'
+    image.src = frameUrl(sequence)
+  }
+}
+
+function formatScore(value: number | null | undefined): string {
+  return value == null ? '—' : `${(value * 100).toFixed(1)}`
+}
+
+function formatNumber(value: number | null | undefined): string {
+  return value == null ? '—' : new Intl.NumberFormat().format(Math.round(value))
+}
+
+function formatBytes(value: number | null | undefined): string {
+  if (value == null) return '—'
+  const units = ['B', 'KB', 'MB', 'GB', 'TB']
+  let size = value
+  let unit = 0
+  while (size >= 1000 && unit < units.length - 1) {
+    size /= 1000
+    unit += 1
+  }
+  return `${size.toFixed(unit > 1 ? 1 : 0)} ${units[unit]}`
+}
+
+function formatDuration(seconds: number | null | undefined): string {
+  if (seconds == null) return '—'
+  const hours = Math.floor(seconds / 3600)
+  const minutes = Math.floor((seconds % 3600) / 60)
+  return hours ? `${hours}h ${minutes}m` : `${minutes}m`
+}
+
+function formatLatency(milliseconds: number | null | undefined): string {
+  if (milliseconds == null) return '—'
+  return milliseconds > 1000 ? `${(milliseconds / 1000).toFixed(1)}s` : `${Math.round(milliseconds)}ms`
+}
+
+function formatDate(value: string | null): string {
+  if (!value) return 'Unknown date'
+  const date = new Date(value)
+  return Number.isNaN(date.valueOf())
+    ? value
+    : new Intl.DateTimeFormat(undefined, { month: 'short', day: 'numeric', year: 'numeric' }).format(date)
+}
+
+function readable(value: string): string {
+  return value.replaceAll('_', ' ')
+}
+
+function pretty(value: unknown): string {
+  return JSON.stringify(value, null, 2)
+}
+
+function scoreWidth(value: number | null | undefined): string {
+  return `${Math.max(0, Math.min(100, (value || 0) * 100))}%`
+}
+
+function histogramHeight(count: number, values: number[]): string {
+  const maximum = Math.max(...values, 1)
+  return `${Math.max(3, count / maximum * 100)}%`
+}
+
+function taskVisionScore(task: ResultTask): number | null {
+  return metricByTask.value.get(task.taskId)?.visionScore ?? task.visionScore
+}
+
+function taskDeterministicScore(task: ResultTask): number | null {
+  return metricByTask.value.get(task.taskId)?.deterministicScore ?? task.deterministicScore
+}
+
+function taskDeterministicVerdict(task: ResultTask): string {
+  const score = taskDeterministicScore(task)
+  if (score == null) return 'unavailable'
+  if (score >= 0.9) return 'target_acquired'
+  if (score >= 0.75) return 'mostly_acquired'
+  if (score >= 0.4) return 'partial'
+  return 'not_acquired'
+}
+
+function verdictTone(value: string): string {
+  if (value === 'target_acquired') return 'positive'
+  if (value === 'mostly_acquired') return 'good'
+  if (value === 'partial') return 'warning'
+  if (value === 'not_acquired') return 'negative'
+  return 'neutral'
+}
+
+function statusTone(task: ResultTask): string {
+  if (!task.included) return 'neutral'
+  if (task.executionStatus === 'completed') return 'positive'
+  if (task.executionStatus === 'budget_exhausted') return 'warning'
+  return 'negative'
+}
+
+function openExpanded(payload: ExpandedImage) {
+  expandedImage.value = payload
+}
+
+function closeExpanded() {
+  expandedImage.value = null
+}
+
+function onKeydown(event: KeyboardEvent) {
+  if (event.key === 'Escape' && expandedImage.value) {
+    closeExpanded()
+    return
+  }
+  if (view.value !== 'trace' || expandedImage.value) return
+  const target = event.target as HTMLElement | null
+  if (target?.matches('input, select, textarea')) return
+  if (event.key === 'ArrowLeft') void selectTurn(selectedTurnIndex.value - 1)
+  if (event.key === 'ArrowRight') void selectTurn(selectedTurnIndex.value + 1)
+}
+
+onMounted(async () => {
+  window.addEventListener('keydown', onKeydown)
+  await nextTick()
+  await loadModels()
+})
+
+onBeforeUnmount(() => window.removeEventListener('keydown', onKeydown))
+</script>
+
+<template>
+  <div class="app-shell">
+    <header class="topbar">
+      <button class="brand" type="button" @click="showView('overview')">
+        <span class="brand-mark">A</span>
+        <span>
+          <strong>AutoCAD Bench</strong>
+          <small>Final results registry</small>
+        </span>
+      </button>
+      <div class="topbar-meta">
+        <span class="health"><i /> Direct S3 media</span>
+        <span>{{ suiteTotals.models }} models</span>
+        <span>{{ formatNumber(suiteTotals.tasks) }} finalized tasks</span>
+        <button class="icon-button" type="button" :disabled="loadingModels" @click="refreshModels">
+          {{ loadingModels ? 'Refreshing…' : 'Refresh' }}
+        </button>
+      </div>
+    </header>
+
+    <div v-if="loadingModels && !models.length" class="loading-screen">
+      <div class="loading-orbit"><span /></div>
+      <p>Reading finalized benchmark manifests…</p>
+    </div>
+
+    <main v-else class="workspace">
+      <aside class="model-rail">
+        <div class="rail-heading">
+          <span>Models</span>
+          <b>{{ models.length }}</b>
+        </div>
+        <button
+          v-for="model in models"
+          :key="model.slug"
+          type="button"
+          class="model-item"
+          :class="{ active: model.slug === selectedModelSlug }"
+          @click="selectModel(model.slug)"
+        >
+          <span class="model-avatar">{{ model.modelId.slice(0, 1).toUpperCase() }}</span>
+          <span class="model-copy">
+            <strong>{{ model.modelId }}</strong>
+            <small>{{ model.totals.included }}/{{ model.totals.expected }} tasks · {{ formatScore(model.scores.vision.mean) }} vision audit</small>
+          </span>
+          <span class="model-score">{{ formatScore(model.scores.deterministic.mean) }}</span>
+        </button>
+        <div class="rail-footnote">
+          <span>{{ formatNumber(suiteTotals.objects) }} objects</span>
+          <span>{{ formatBytes(suiteTotals.bytes) }}</span>
+          <small>Canonical artifacts only</small>
+        </div>
+      </aside>
+
+      <section v-if="selectedModel" class="content">
+        <div class="content-heading">
+          <div>
+            <div class="eyebrow">Final aggregate · {{ formatDate(selectedModel.createdAt) }}</div>
+            <h1>{{ selectedModel.modelId }}</h1>
+            <p>{{ selectedModel.aggregateId }}</p>
+          </div>
+          <div class="heading-actions">
+            <span class="registry-badge"><i /> Verified registry</span>
+            <button type="button" class="secondary-button" @click="showView('tasks')">Browse tasks</button>
+          </div>
+        </div>
+
+        <nav class="section-tabs" aria-label="Result sections">
+          <button type="button" :class="{ active: view === 'overview' }" @click="showView('overview')">Overview</button>
+          <button type="button" :class="{ active: view === 'tasks' }" @click="showView('tasks')">Tasks <span>{{ selectedModel.totals.included }}</span></button>
+          <button v-if="selectedTaskId" type="button" :class="{ active: view === 'trace' }" @click="showView('trace')">Trace</button>
+          <button v-if="selectedTaskId" type="button" :class="{ active: view === 'frames' }" @click="showView('frames')">All frames <span>{{ formatNumber(taskDetail?.frameCount) }}</span></button>
+        </nav>
+
+        <div v-if="error" class="error-banner">
+          <span>{{ error }}</span>
+          <button type="button" @click="error = ''">Dismiss</button>
+        </div>
+
+        <template v-if="view === 'overview'">
+          <section class="stat-grid">
+            <article class="stat-card hero-stat">
+              <span>Deterministic score</span>
+              <strong>{{ loadingMetrics ? '…' : formatScore(activeScores?.deterministic.mean) }}</strong>
+              <small>median {{ formatScore(activeScores?.deterministic.median) }} · {{ activeScores?.deterministic.count || 0 }} scored</small>
+              <div class="score-track"><i :style="{ width: scoreWidth(activeScores?.deterministic.mean) }" /></div>
+            </article>
+            <article class="stat-card">
+              <span>Vision audit</span>
+              <strong>{{ loadingMetrics ? '…' : formatScore(activeScores?.vision.mean) }}</strong>
+              <small>median {{ formatScore(activeScores?.vision.median) }}</small>
+            </article>
+            <article class="stat-card">
+              <span>Finalized</span>
+              <strong>{{ selectedModel.totals.included }}<em>/{{ selectedModel.totals.expected }}</em></strong>
+              <small>{{ selectedModel.totals.clean }} clean · {{ selectedModel.totals.budgetExhausted }} budget exhausted</small>
+            </article>
+            <article class="stat-card">
+              <span>Median actions</span>
+              <strong>{{ loadingMetrics ? '…' : formatNumber(metrics?.medians.acceptedActions) }}</strong>
+              <small>{{ loadingMetrics ? 'Loading trace totals' : `${formatNumber(metrics?.totals.screenshots)} screenshots total` }}</small>
+            </article>
+            <article class="stat-card">
+              <span>Runtime</span>
+              <strong>{{ loadingMetrics ? '…' : formatDuration(metrics?.totals.elapsedSeconds) }}</strong>
+              <small>{{ formatBytes(selectedModel.totals.bytes) }} retained</small>
+            </article>
+          </section>
+
+          <div class="overview-grid">
+            <section class="panel category-panel">
+              <div class="panel-heading">
+                <div>
+                  <span class="eyebrow">Performance map</span>
+                  <h2>Score by category</h2>
+                </div>
+                <div class="legend"><i class="deterministic" /> Deterministic <i class="vision" /> Vision audit</div>
+              </div>
+              <div class="category-list">
+                <div v-for="category in activeCategories" :key="category.category" class="category-row">
+                  <div class="category-name">
+                    <strong>{{ category.drawingType.toUpperCase() }} {{ category.level }}</strong>
+                    <small>{{ category.tasks }} tasks</small>
+                  </div>
+                  <div class="dual-bars">
+                    <div><i class="deterministic" :style="{ width: scoreWidth(category.deterministic.mean) }" /></div>
+                    <div><i class="vision" :style="{ width: scoreWidth(category.vision.mean) }" /></div>
+                  </div>
+                  <div class="category-values">
+                    <strong>{{ formatScore(category.deterministic.mean) }}</strong>
+                    <span>{{ formatScore(category.vision.mean) }}</span>
+                  </div>
+                </div>
+              </div>
+            </section>
+
+            <section class="panel distribution-panel">
+              <div class="panel-heading">
+                <div>
+                  <span class="eyebrow">Deterministic evaluator</span>
+                  <h2>Score distribution</h2>
+                </div>
+              </div>
+              <div class="histogram">
+                <div v-for="(count, index) in activeScores?.deterministicHistogram || []" :key="index" class="histogram-column">
+                  <span>{{ count || '' }}</span>
+                  <i :style="{ height: histogramHeight(count, activeScores?.deterministicHistogram || []) }" />
+                  <small>{{ index * 10 }}</small>
+                </div>
+              </div>
+              <div class="distribution-summary">
+                <div><span>Lowest</span><strong>{{ formatScore(activeScores?.deterministic.min) }}</strong></div>
+                <div><span>Median</span><strong>{{ formatScore(activeScores?.deterministic.median) }}</strong></div>
+                <div><span>Highest</span><strong>{{ formatScore(activeScores?.deterministic.max) }}</strong></div>
+              </div>
+            </section>
+          </div>
+
+          <section class="panel comparison-panel">
+            <div class="panel-heading">
+              <div>
+                <span class="eyebrow">Registry comparison</span>
+                <h2>All models</h2>
+              </div>
+              <span class="panel-note">Scores are shown independently; they are not blended.</span>
+            </div>
+            <div class="comparison-table table-scroll">
+              <table>
+                <thead><tr><th>Model</th><th>Finalized</th><th>Deterministic mean</th><th>Vision audit</th><th>Deterministic range</th><th>Artifacts</th></tr></thead>
+                <tbody>
+                  <tr v-for="model in models" :key="model.slug" :class="{ selected: model.slug === selectedModelSlug }" @click="selectModel(model.slug)">
+                    <td><strong>{{ model.modelId }}</strong><small>{{ model.aggregateId }}</small></td>
+                    <td>{{ model.totals.included }}/{{ model.totals.expected }}</td>
+                    <td><b>{{ formatScore(model.scores.deterministic.mean) }}</b></td>
+                    <td>{{ formatScore(model.scores.vision.mean) }}</td>
+                    <td>{{ formatScore(model.scores.deterministic.min) }}–{{ formatScore(model.scores.deterministic.max) }}</td>
+                    <td>{{ formatBytes(model.totals.bytes) }}</td>
+                  </tr>
+                </tbody>
+              </table>
+            </div>
+          </section>
+        </template>
+
+        <template v-else-if="view === 'tasks'">
+          <section class="task-toolbar">
+            <label class="search-field">
+              <span>Search</span>
+              <input v-model="taskSearch" type="search" placeholder="Find a task…" />
+            </label>
+            <label><span>Drawing</span><select v-model="taskDimension"><option value="all">All</option><option value="2d">2D</option><option value="3d">3D</option></select></label>
+            <label><span>Level</span><select v-model="taskLevel"><option value="all">All levels</option><option v-for="level in levels" :key="level" :value="level">{{ level }}</option></select></label>
+            <label><span>Status</span><select v-model="taskStatus"><option value="all">All statuses</option><option v-for="status in statuses" :key="status" :value="status">{{ readable(status) }}</option></select></label>
+            <label><span>Sort</span><select v-model="taskSort"><option value="task">Task ID</option><option value="deterministic">Deterministic score</option><option value="vision">Vision audit</option><option value="actions">Actions</option></select></label>
+            <div class="result-count">{{ filteredTasks.length }} results</div>
+          </section>
+          <section class="panel task-table-panel">
+            <div class="table-scroll">
+              <table class="task-table">
+                <thead><tr><th>Task</th><th>Type</th><th>Status</th><th>Deterministic</th><th>Vision audit</th><th>Verdict</th><th>Actions</th><th>Frames</th><th /></tr></thead>
+                <tbody>
+                  <tr v-for="task in filteredTasks" :key="task.taskId" tabindex="0" @click="openTask(task.taskId)" @keydown.enter="openTask(task.taskId)">
+                    <td><strong>{{ task.taskId }}</strong><small>{{ task.selectedAttempt }}</small></td>
+                    <td><span class="type-chip">{{ task.drawingType.toUpperCase() }}</span> {{ task.level }}</td>
+                    <td><span class="status-pill" :class="statusTone(task)"><i />{{ task.included ? readable(task.executionStatus) : 'excluded' }}</span></td>
+                    <td><strong>{{ formatScore(taskDeterministicScore(task)) }}</strong></td>
+                    <td>{{ formatScore(taskVisionScore(task)) }}</td>
+                    <td><span class="verdict" :class="verdictTone(taskDeterministicVerdict(task))">{{ readable(taskDeterministicVerdict(task)) }}</span></td>
+                    <td>{{ loadingMetrics ? '…' : formatNumber(metricByTask.get(task.taskId)?.acceptedActions) }}</td>
+                    <td>{{ loadingMetrics ? '…' : formatNumber(metricByTask.get(task.taskId)?.screenshots) }}</td>
+                    <td><button type="button" class="row-arrow" aria-label="Open task">→</button></td>
+                  </tr>
+                </tbody>
+              </table>
+            </div>
+          </section>
+        </template>
+
+        <template v-else-if="view === 'trace'">
+          <div v-if="loadingTask" class="task-loading"><div class="loading-orbit"><span /></div><p>Loading canonical trace…</p></div>
+          <template v-else-if="taskDetail && selectedTask">
+            <section class="task-titlebar">
+              <button type="button" class="back-button" @click="showView('tasks')">← Tasks</button>
+              <div><span class="eyebrow">{{ selectedTask.drawingType.toUpperCase() }} · {{ selectedTask.level }}</span><h2>{{ selectedTask.taskId }}</h2></div>
+              <div class="task-title-scores">
+                <span>Deterministic <strong>{{ formatScore(selectedDeterministicScore) }}</strong></span>
+                <span>Vision audit <strong>{{ formatScore(selectedVisionScore) }}</strong></span>
+                <span class="status-pill" :class="statusTone(selectedTask)"><i />{{ readable(selectedTask.executionStatus) }}</span>
+              </div>
+            </section>
+
+            <section class="artifact-strip">
+              <ReliableImage :src="mediaUrl(taskDetail.media.reference)" alt="Reference drawing" label="Reference" eager @expand="openExpanded" />
+              <ReliableImage :src="mediaUrl(taskDetail.media.final)" alt="Final model drawing" label="Model output" eager @expand="openExpanded" />
+              <ReliableImage :src="mediaUrl(taskDetail.media.diff)" alt="Evaluation difference" label="Difference" eager @expand="openExpanded" />
+              <div class="rubric-card">
+                <div class="rubric-score"><span>Evaluator</span><strong>{{ formatScore(selectedDeterministicScore) }}</strong></div>
+                <div v-for="([label, score]) in scoreBreakdown" :key="label" class="rubric-row">
+                  <span>{{ label }}</span><div><i :style="{ width: scoreWidth(score) }" /></div><b>{{ formatScore(score) }}</b>
+                </div>
+              </div>
+            </section>
+
+            <section class="trace-workbench">
+              <aside class="turn-list">
+                <div class="turn-list-heading">
+                  <div><span>Model trace</span><strong>{{ trace?.turns.length || 0 }} turns</strong></div>
+                  <small>{{ formatNumber(trace?.receiptCount) }} actions</small>
+                </div>
+                <button
+                  v-for="(turn, index) in trace?.turns || []"
+                  :key="turn.toolUseId || index"
+                  type="button"
+                  class="turn-item"
+                  :class="{ active: index === selectedTurnIndex }"
+                  @click="selectTurn(index)"
+                >
+                  <span class="turn-number">{{ String(turn.turn).padStart(2, '0') }}</span>
+                  <span class="turn-summary"><strong>{{ turn.actionCount }} action{{ turn.actionCount === 1 ? '' : 's' }}</strong><small>frames {{ turn.inputFrameSequence ?? '—' }} → {{ turn.outputFrameSequence ?? '—' }}</small></span>
+                  <span class="turn-latency">{{ formatLatency(turn.latencyMs) }}</span>
+                </button>
+              </aside>
+
+              <div v-if="selectedTurn" class="turn-stage">
+                <div class="turn-stage-heading">
+                  <div><span class="eyebrow">Turn {{ selectedTurn.turn }}</span><h3>{{ selectedTurn.actionCount }} recorded actions</h3></div>
+                  <div class="turn-controls">
+                    <button type="button" :disabled="selectedTurnIndex === 0" @click="selectTurn(selectedTurnIndex - 1)">←</button>
+                    <span>{{ selectedTurnIndex + 1 }} / {{ trace?.turns.length }}</span>
+                    <button type="button" :disabled="selectedTurnIndex + 1 >= (trace?.turns.length || 0)" @click="selectTurn(selectedTurnIndex + 1)">→</button>
+                  </div>
+                </div>
+                <div class="turn-images">
+                  <ReliableImage v-if="selectedTurn.inputFrameSequence != null" :src="frameUrl(selectedTurn.inputFrameSequence)" :alt="`Turn ${selectedTurn.turn} input frame`" :label="`Input · frame ${selectedTurn.inputFrameSequence}`" eager @expand="openExpanded" />
+                  <div v-else class="empty-frame">No input frame recorded</div>
+                  <ReliableImage v-if="selectedTurn.outputFrameSequence != null" :src="frameUrl(selectedTurn.outputFrameSequence)" :alt="`Turn ${selectedTurn.turn} output frame`" :label="`Output · frame ${selectedTurn.outputFrameSequence}`" eager @expand="openExpanded" />
+                  <div v-else class="empty-frame">No output frame recorded</div>
+                </div>
+                <div class="turn-facts">
+                  <span>Latency <strong>{{ formatLatency(selectedTurn.latencyMs) }}</strong></span>
+                  <span>Input tokens <strong>{{ formatNumber(selectedTurn.usage?.input_tokens) }}</strong></span>
+                  <span>Output tokens <strong>{{ formatNumber(selectedTurn.usage?.output_tokens) }}</strong></span>
+                  <span>Attempts <strong>{{ selectedTurn.requestAttempts ?? '—' }}</strong></span>
+                  <span>Validation retries <strong>{{ selectedTurn.validationRetries ?? '—' }}</strong></span>
+                </div>
+                <div class="trace-detail-grid">
+                  <section class="trace-card">
+                    <div class="trace-card-heading"><h4>Model response</h4><span>{{ selectedTurn.stopReason }}</span></div>
+                    <pre>{{ pretty(selectedTurn.text) }}</pre>
+                  </section>
+                  <section class="trace-card">
+                    <div class="trace-card-heading"><h4>Requested actions</h4><span>{{ selectedTurn.actions.length }}</span></div>
+                    <div v-if="selectedTurn.actions.length" class="action-list">
+                      <div v-for="(action, index) in selectedTurn.actions" :key="index" class="action-item"><span>{{ index + 1 }}</span><pre>{{ pretty(action) }}</pre></div>
+                    </div>
+                    <div v-else class="empty-copy">No valid action payload in this turn.</div>
+                  </section>
+                </div>
+                <section class="trace-card receipts-card">
+                  <div class="trace-card-heading"><h4>Execution receipts</h4><span>{{ loadingTurn ? 'Loading…' : `${turnDetail?.receipts.length || 0} receipts` }}</span></div>
+                  <div v-if="turnDetail?.receipts.length" class="receipt-list">
+                    <details v-for="receipt in turnDetail.receipts" :key="receipt.actionIndex || 0">
+                      <summary><span>#{{ receipt.actionIndex }}</span><strong>{{ String(receipt.action?.action || 'action') }}</strong><small>{{ receipt.receipt?.ok === false ? 'failed' : 'accepted' }}</small></summary>
+                      <pre>{{ pretty(receipt) }}</pre>
+                    </details>
+                  </div>
+                  <div v-else-if="!loadingTurn" class="empty-copy">No execution receipts matched this model turn.</div>
+                </section>
+                <details v-if="turnDetail?.turn" class="raw-turn">
+                  <summary>Raw model-turn record</summary>
+                  <pre>{{ pretty(turnDetail.turn) }}</pre>
+                </details>
+              </div>
+              <div v-else class="empty-trace">No model turns were recorded for this canonical task.</div>
+            </section>
+
+            <section class="panel downloads-panel">
+              <div class="panel-heading"><div><span class="eyebrow">Raw evidence</span><h2>Artifacts & trace files</h2></div><button type="button" class="secondary-button" @click="showView('frames')">Open all {{ formatNumber(taskDetail.frameCount) }} frames</button></div>
+              <div class="download-grid">
+                <a v-for="download in taskDetail.downloads" :key="download.path" :href="mediaUrl(download.path, true)"><span>{{ download.label }}</span><small>{{ download.path }}</small><b>↓</b></a>
+              </div>
+            </section>
+          </template>
+        </template>
+
+        <template v-else-if="view === 'frames'">
+          <section class="task-titlebar">
+            <button type="button" class="back-button" @click="showView('trace')">← Trace</button>
+            <div><span class="eyebrow">Complete screenshot sequence</span><h2>{{ selectedTaskId }}</h2></div>
+            <div class="frame-progress"><strong>{{ formatNumber(frames.length) }}</strong><span>of {{ formatNumber(frameTotal || taskDetail?.frameCount) }} loaded</span></div>
+          </section>
+          <div class="frame-gallery-note"><span><i /> Images load only as they approach the viewport</span><span>Direct, signed S3 delivery · automatic retry · immutable browser cache</span></div>
+          <section class="frame-gallery">
+            <button v-for="frame in frames" :key="frame.sequence" type="button" class="frame-tile" @click="openExpanded({ src: mediaUrl(frame.path), label: `${selectedTaskId} · frame ${frame.sequence}` })">
+              <ReliableImage :src="mediaUrl(frame.path)" :alt="`${selectedTaskId} frame ${frame.sequence}`" :label="`Frame ${frame.sequence}`" :expandable="false" />
+            </button>
+          </section>
+          <div class="load-more">
+            <button v-if="frameHasMore" type="button" class="primary-button" :disabled="loadingFrames" @click="loadFrames(false)">{{ loadingFrames ? 'Loading…' : `Load next ${Math.min(120, frameTotal - frames.length)} frames` }}</button>
+            <span v-else-if="frames.length">All {{ formatNumber(frameTotal) }} frames loaded</span>
+            <span v-else-if="loadingFrames">Loading frames…</span>
+          </div>
+        </template>
+      </section>
+
+      <section v-else class="empty-registry">
+        <h1>No result manifests found</h1>
+        <p>The configured bucket does not contain an aggregate manifest.</p>
+      </section>
+    </main>
+
+    <div v-if="expandedImage" class="lightbox" role="dialog" aria-modal="true" :aria-label="expandedImage.label" @click.self="closeExpanded">
+      <button type="button" class="lightbox-close" aria-label="Close image" @click="closeExpanded">×</button>
+      <div class="lightbox-content">
+        <img :src="expandedImage.src" :alt="expandedImage.label" />
+        <span>{{ expandedImage.label }}</span>
+      </div>
+    </div>
+  </div>
+</template>

apps/results-dashboard/src/components/ReliableImage.vue

@@ -0,0 +1,91 @@
+<script setup lang="ts">
+import { computed, onBeforeUnmount, ref, watch } from 'vue'
+
+const props = withDefaults(defineProps<{
+  src: string
+  alt: string
+  label?: string
+  eager?: boolean
+  expandable?: boolean
+}>(), {
+  label: '',
+  eager: false,
+  expandable: true,
+})
+
+const emit = defineEmits<{
+  expand: [payload: { src: string; label: string }]
+}>()
+
+const attempt = ref(0)
+const loaded = ref(false)
+const failed = ref(false)
+let retryTimer: number | undefined
+
+const resolvedSrc = computed(() => {
+  const separator = props.src.includes('?') ? '&' : '?'
+  return attempt.value ? `${props.src}${separator}retry=${attempt.value}` : props.src
+})
+
+function reset() {
+  if (retryTimer) window.clearTimeout(retryTimer)
+  attempt.value = 0
+  loaded.value = false
+  failed.value = false
+}
+
+function onLoad() {
+  loaded.value = true
+  failed.value = false
+}
+
+function onError() {
+  loaded.value = false
+  if (attempt.value >= 4) {
+    failed.value = true
+    return
+  }
+  const delay = 250 * 2 ** attempt.value
+  retryTimer = window.setTimeout(() => {
+    attempt.value += 1
+  }, delay)
+}
+
+function retry() {
+  attempt.value += 1
+  failed.value = false
+}
+
+function expand() {
+  if (loaded.value && props.expandable) {
+    emit('expand', { src: resolvedSrc.value, label: props.label || props.alt })
+  }
+}
+
+watch(() => props.src, reset)
+onBeforeUnmount(() => {
+  if (retryTimer) window.clearTimeout(retryTimer)
+})
+</script>
+
+<template>
+  <div class="reliable-image" :class="{ 'is-loaded': loaded, 'is-failed': failed }">
+    <div v-if="!loaded && !failed" class="image-skeleton" aria-hidden="true">
+      <span />
+    </div>
+    <img
+      :src="resolvedSrc"
+      :alt="alt"
+      :loading="eager ? 'eager' : 'lazy'"
+      :fetchpriority="eager ? 'high' : 'auto'"
+      decoding="async"
+      @load="onLoad"
+      @error="onError"
+      @click="expand"
+    />
+    <button v-if="failed" type="button" class="image-retry" @click="retry">
+      Image unavailable · retry
+    </button>
+    <div v-if="label" class="image-label">{{ label }}</div>
+  </div>
+</template>

apps/results-dashboard/src/env.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="vite/client" />
+
+declare module '*.vue' {
+  import type { DefineComponent } from 'vue'
+  const component: DefineComponent<object, object, unknown>
+  export default component
+}

apps/results-dashboard/src/main.ts

@@ -0,0 +1,5 @@
+import { createApp } from 'vue'
+import App from './App.vue'
+import './styles.css'
+
+createApp(App).mount('#app')

apps/results-dashboard/src/styles.css

@@ -0,0 +1,400 @@
+:root {
+  font-family: Inter, ui-sans-serif, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+  color: #e8edef;
+  background: #090c0e;
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  --bg: #090c0e;
+  --surface: #101518;
+  --surface-2: #151b1f;
+  --surface-3: #1b2328;
+  --line: #263037;
+  --line-soft: #1c252a;
+  --text: #e8edef;
+  --muted: #8b999f;
+  --quiet: #5d6b72;
+  --mint: #8fffc9;
+  --mint-strong: #43d891;
+  --cyan: #70d4ed;
+  --amber: #f0ba69;
+  --red: #ff8a80;
+  --radius: 14px;
+}
+
+* { box-sizing: border-box; }
+
+html { min-width: 320px; background: var(--bg); }
+body { margin: 0; min-width: 320px; min-height: 100vh; background: var(--bg); }
+button, input, select { font: inherit; }
+button, a { -webkit-tap-highlight-color: transparent; }
+button { color: inherit; }
+
+.app-shell { min-height: 100vh; }
+
+.topbar {
+  position: sticky;
+  z-index: 50;
+  top: 0;
+  display: flex;
+  height: 68px;
+  align-items: center;
+  justify-content: space-between;
+  padding: 0 24px;
+  border-bottom: 1px solid var(--line-soft);
+  background: rgba(9, 12, 14, .92);
+  backdrop-filter: blur(18px);
+}
+
+.brand {
+  display: flex;
+  align-items: center;
+  gap: 11px;
+  padding: 0;
+  border: 0;
+  background: none;
+  text-align: left;
+  cursor: pointer;
+}
+
+.brand-mark {
+  display: grid;
+  width: 34px;
+  height: 34px;
+  place-items: center;
+  border: 1px solid #487660;
+  border-radius: 9px;
+  color: var(--mint);
+  background: linear-gradient(145deg, #183426, #101b17);
+  font-weight: 800;
+  letter-spacing: -.04em;
+}
+
+.brand strong, .brand small { display: block; }
+.brand strong { font-size: 14px; letter-spacing: -.01em; }
+.brand small { margin-top: 2px; color: var(--muted); font-size: 10px; letter-spacing: .08em; text-transform: uppercase; }
+
+.topbar-meta { display: flex; align-items: center; gap: 22px; color: var(--muted); font-size: 12px; }
+.health, .registry-badge { display: inline-flex; align-items: center; gap: 7px; }
+.health i, .registry-badge i, .frame-gallery-note i {
+  display: block;
+  width: 7px;
+  height: 7px;
+  border-radius: 50%;
+  background: var(--mint-strong);
+  box-shadow: 0 0 0 4px rgba(67, 216, 145, .1);
+}
+
+.icon-button, .secondary-button, .primary-button, .back-button {
+  border: 1px solid var(--line);
+  border-radius: 8px;
+  background: var(--surface-2);
+  cursor: pointer;
+}
+.icon-button { padding: 7px 11px; color: var(--text); font-size: 11px; }
+.secondary-button { padding: 9px 13px; color: var(--text); font-size: 12px; font-weight: 650; }
+.primary-button { padding: 11px 18px; border-color: #4e8f70; color: #07110c; background: var(--mint); font-weight: 750; }
+.icon-button:hover, .secondary-button:hover, .back-button:hover { border-color: #41515a; background: var(--surface-3); }
+button:disabled { opacity: .42; cursor: not-allowed; }
+
+.workspace { display: grid; min-height: calc(100vh - 68px); grid-template-columns: 256px minmax(0, 1fr); }
+
+.model-rail {
+  position: sticky;
+  top: 68px;
+  display: flex;
+  height: calc(100vh - 68px);
+  flex-direction: column;
+  padding: 22px 14px;
+  border-right: 1px solid var(--line-soft);
+  background: #0b0f11;
+}
+
+.rail-heading { display: flex; align-items: center; justify-content: space-between; padding: 0 9px 12px; color: var(--muted); font-size: 11px; font-weight: 700; letter-spacing: .1em; text-transform: uppercase; }
+.rail-heading b { display: grid; min-width: 21px; height: 21px; place-items: center; border-radius: 6px; background: var(--surface-2); color: var(--text); font-size: 10px; }
+
+.model-item {
+  display: grid;
+  width: 100%;
+  grid-template-columns: 34px minmax(0, 1fr) auto;
+  align-items: center;
+  gap: 10px;
+  padding: 11px 9px;
+  border: 1px solid transparent;
+  border-radius: 10px;
+  color: var(--muted);
+  background: transparent;
+  text-align: left;
+  cursor: pointer;
+}
+.model-item + .model-item { margin-top: 3px; }
+.model-item:hover { background: rgba(255, 255, 255, .025); }
+.model-item.active { border-color: #284337; color: var(--text); background: linear-gradient(100deg, rgba(65, 180, 119, .12), rgba(65, 180, 119, .025)); }
+.model-avatar { display: grid; width: 34px; height: 34px; place-items: center; border: 1px solid var(--line); border-radius: 9px; color: var(--muted); background: var(--surface); font-size: 12px; font-weight: 750; }
+.model-item.active .model-avatar { border-color: #3c6a54; color: var(--mint); background: #12241b; }
+.model-copy { min-width: 0; }
+.model-copy strong, .model-copy small { display: block; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.model-copy strong { font-size: 12px; font-weight: 650; }
+.model-copy small { margin-top: 4px; color: var(--quiet); font-size: 9px; }
+.model-score { color: var(--text); font-size: 12px; font-variant-numeric: tabular-nums; }
+.rail-footnote { display: grid; grid-template-columns: 1fr 1fr; gap: 6px; margin-top: auto; padding: 14px 10px 0; border-top: 1px solid var(--line-soft); color: var(--muted); font-size: 10px; }
+.rail-footnote small { grid-column: 1 / -1; color: var(--quiet); }
+
+.content { min-width: 0; padding: 34px clamp(24px, 4vw, 62px) 80px; }
+.content-heading { display: flex; align-items: flex-end; justify-content: space-between; gap: 24px; }
+.eyebrow { color: var(--mint-strong); font-size: 10px; font-weight: 750; letter-spacing: .12em; text-transform: uppercase; }
+.content-heading h1 { margin: 9px 0 5px; font-size: clamp(28px, 3vw, 42px); font-weight: 680; letter-spacing: -.045em; }
+.content-heading p { margin: 0; color: var(--muted); font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 11px; }
+.heading-actions { display: flex; align-items: center; gap: 12px; }
+.registry-badge { padding: 8px 10px; border: 1px solid #264333; border-radius: 8px; color: #a7ddbe; background: rgba(38, 86, 57, .14); font-size: 10px; font-weight: 650; text-transform: uppercase; letter-spacing: .06em; }
+
+.section-tabs { display: flex; gap: 24px; margin: 27px 0 25px; border-bottom: 1px solid var(--line-soft); }
+.section-tabs button { position: relative; padding: 0 1px 12px; border: 0; color: var(--muted); background: none; font-size: 12px; font-weight: 650; cursor: pointer; }
+.section-tabs button span { margin-left: 4px; color: var(--quiet); }
+.section-tabs button.active { color: var(--text); }
+.section-tabs button.active::after { position: absolute; right: 0; bottom: -1px; left: 0; height: 2px; border-radius: 2px; background: var(--mint-strong); content: ""; }
+
+.error-banner { display: flex; align-items: center; justify-content: space-between; margin: 0 0 18px; padding: 10px 12px; border: 1px solid #5d3533; border-radius: 9px; color: #ffb2ab; background: #211311; font-size: 12px; }
+.error-banner button { border: 0; color: inherit; background: none; cursor: pointer; }
+
+.stat-grid { display: grid; grid-template-columns: 1.4fr repeat(4, minmax(0, 1fr)); gap: 10px; }
+.stat-card { min-width: 0; padding: 18px; border: 1px solid var(--line-soft); border-radius: var(--radius); background: linear-gradient(145deg, #12181b, #0f1417); }
+.stat-card > span { display: block; color: var(--muted); font-size: 10px; font-weight: 650; letter-spacing: .05em; text-transform: uppercase; }
+.stat-card > strong { display: block; margin: 16px 0 8px; font-size: 29px; font-weight: 600; line-height: 1; letter-spacing: -.04em; font-variant-numeric: tabular-nums; }
+.stat-card > strong em { color: var(--quiet); font-size: 15px; font-style: normal; font-weight: 500; }
+.stat-card > small { display: block; overflow: hidden; color: var(--quiet); font-size: 10px; text-overflow: ellipsis; white-space: nowrap; }
+.hero-stat { border-color: #284538; background: radial-gradient(circle at 15% 0, rgba(85, 223, 151, .12), transparent 55%), #111916; }
+.hero-stat > strong { color: var(--mint); }
+.score-track { height: 3px; margin-top: 13px; overflow: hidden; border-radius: 10px; background: #24302a; }
+.score-track i { display: block; height: 100%; border-radius: inherit; background: var(--mint-strong); }
+
+.overview-grid { display: grid; grid-template-columns: minmax(0, 1.55fr) minmax(300px, .8fr); gap: 12px; margin-top: 12px; }
+.panel { border: 1px solid var(--line-soft); border-radius: var(--radius); background: var(--surface); }
+.panel-heading { display: flex; align-items: center; justify-content: space-between; gap: 20px; padding: 20px 21px 17px; border-bottom: 1px solid var(--line-soft); }
+.panel-heading h2 { margin: 5px 0 0; font-size: 15px; font-weight: 650; letter-spacing: -.015em; }
+.panel-note { color: var(--quiet); font-size: 10px; }
+.legend { display: flex; align-items: center; gap: 6px; color: var(--muted); font-size: 9px; }
+.legend i { width: 7px; height: 7px; border-radius: 2px; }
+.legend i.deterministic { margin-left: 7px; }
+.vision { background: var(--mint-strong) !important; }
+.deterministic { background: var(--cyan) !important; }
+
+.category-list { padding: 9px 20px 16px; }
+.category-row { display: grid; grid-template-columns: 112px minmax(80px, 1fr) 76px; align-items: center; gap: 14px; padding: 10px 0; }
+.category-name strong, .category-name small { display: block; }
+.category-name strong { font-size: 10px; font-weight: 680; }
+.category-name small { margin-top: 3px; color: var(--quiet); font-size: 9px; }
+.dual-bars { display: grid; gap: 4px; }
+.dual-bars div { height: 5px; overflow: hidden; border-radius: 4px; background: #20292e; }
+.dual-bars i { display: block; height: 100%; border-radius: inherit; }
+.category-values { display: flex; justify-content: flex-end; gap: 10px; font-size: 10px; font-variant-numeric: tabular-nums; }
+.category-values strong { color: var(--mint); }
+.category-values span { color: var(--cyan); }
+
+.histogram { display: flex; height: 160px; align-items: flex-end; gap: 6px; padding: 26px 20px 20px; }
+.histogram-column { display: grid; height: 100%; flex: 1; grid-template-rows: 18px minmax(4px, 1fr) 14px; align-items: end; text-align: center; }
+.histogram-column span { align-self: start; color: var(--muted); font-size: 8px; }
+.histogram-column i { display: block; min-height: 3px; border-radius: 4px 4px 1px 1px; background: linear-gradient(#6be5a6, #2e9b67); }
+.histogram-column small { margin-top: 4px; color: var(--quiet); font-size: 8px; }
+.distribution-summary { display: grid; grid-template-columns: repeat(3, 1fr); border-top: 1px solid var(--line-soft); }
+.distribution-summary div { padding: 14px 16px; }
+.distribution-summary div + div { border-left: 1px solid var(--line-soft); }
+.distribution-summary span, .distribution-summary strong { display: block; }
+.distribution-summary span { color: var(--quiet); font-size: 8px; text-transform: uppercase; }
+.distribution-summary strong { margin-top: 6px; font-size: 14px; font-weight: 600; }
+
+.comparison-panel { margin-top: 12px; }
+.table-scroll { overflow-x: auto; }
+table { width: 100%; border-collapse: collapse; }
+th { padding: 11px 18px; color: var(--quiet); font-size: 8px; font-weight: 700; letter-spacing: .07em; text-align: left; text-transform: uppercase; white-space: nowrap; }
+td { padding: 14px 18px; border-top: 1px solid var(--line-soft); color: var(--muted); font-size: 11px; white-space: nowrap; }
+td strong, td small { display: block; }
+td strong { color: var(--text); font-weight: 620; }
+td small { max-width: 360px; margin-top: 4px; overflow: hidden; color: var(--quiet); font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 8px; text-overflow: ellipsis; }
+.comparison-table tbody tr { cursor: pointer; }
+.comparison-table tbody tr:hover, .comparison-table tbody tr.selected { background: rgba(86, 208, 143, .035); }
+
+.task-toolbar { display: grid; grid-template-columns: minmax(220px, 1.4fr) repeat(4, minmax(110px, .55fr)) auto; align-items: end; gap: 9px; margin-bottom: 12px; }
+.task-toolbar label { display: grid; gap: 6px; }
+.task-toolbar label > span { color: var(--quiet); font-size: 8px; font-weight: 700; letter-spacing: .08em; text-transform: uppercase; }
+.task-toolbar input, .task-toolbar select { width: 100%; height: 35px; padding: 0 10px; border: 1px solid var(--line); border-radius: 8px; outline: none; color: var(--text); background: var(--surface); font-size: 11px; }
+.task-toolbar input:focus, .task-toolbar select:focus { border-color: #47725e; box-shadow: 0 0 0 3px rgba(72, 176, 123, .08); }
+.result-count { padding: 0 4px 10px; color: var(--muted); font-size: 10px; white-space: nowrap; }
+.task-table-panel { overflow: hidden; }
+.task-table tbody tr { cursor: pointer; outline: none; }
+.task-table tbody tr:hover, .task-table tbody tr:focus { background: #141b1e; }
+.type-chip { display: inline-grid; min-width: 25px; height: 20px; margin-right: 6px; place-items: center; border: 1px solid var(--line); border-radius: 5px; color: var(--text); background: var(--surface-2); font-size: 8px; font-weight: 750; }
+.status-pill { display: inline-flex; align-items: center; gap: 6px; padding: 4px 7px; border: 1px solid var(--line); border-radius: 20px; font-size: 8px; font-weight: 700; letter-spacing: .03em; text-transform: uppercase; }
+.status-pill i { width: 5px; height: 5px; border-radius: 50%; background: currentColor; }
+.status-pill.positive { border-color: #2b543e; color: #75dba2; background: #102219; }
+.status-pill.warning { border-color: #5e4828; color: #f0ba69; background: #211a10; }
+.status-pill.negative { border-color: #5b302d; color: #ff8a80; background: #221210; }
+.status-pill.neutral { color: var(--muted); }
+.verdict { color: var(--muted); font-size: 9px; }
+.verdict.positive { color: var(--mint); }
+.verdict.good { color: #92d8e8; }
+.verdict.warning { color: var(--amber); }
+.verdict.negative { color: var(--red); }
+.row-arrow { border: 0; color: var(--quiet); background: none; cursor: pointer; }
+
+.task-titlebar { display: grid; grid-template-columns: auto 1fr auto; align-items: center; gap: 16px; margin-bottom: 15px; }
+.back-button { padding: 8px 10px; color: var(--muted); font-size: 10px; }
+.task-titlebar h2 { margin: 4px 0 0; font-size: 20px; letter-spacing: -.025em; }
+.task-title-scores { display: flex; align-items: center; gap: 16px; }
+.task-title-scores > span:not(.status-pill) { color: var(--muted); font-size: 9px; }
+.task-title-scores > span strong { margin-left: 4px; color: var(--text); font-size: 13px; }
+
+.artifact-strip { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)) minmax(240px, .78fr); gap: 9px; margin-bottom: 12px; }
+.artifact-strip .reliable-image { min-height: 180px; }
+.rubric-card { padding: 15px; border: 1px solid var(--line-soft); border-radius: var(--radius); background: var(--surface); }
+.rubric-score { display: flex; align-items: center; justify-content: space-between; margin-bottom: 15px; }
+.rubric-score span { color: var(--muted); font-size: 9px; text-transform: uppercase; }
+.rubric-score strong { color: var(--mint); font-size: 24px; font-weight: 600; }
+.rubric-row { display: grid; grid-template-columns: 67px 1fr 31px; align-items: center; gap: 7px; margin-top: 9px; color: var(--muted); font-size: 8px; }
+.rubric-row > div { height: 3px; overflow: hidden; border-radius: 4px; background: #263038; }
+.rubric-row i { display: block; height: 100%; background: var(--mint-strong); }
+.rubric-row b { color: var(--text); text-align: right; font-weight: 550; }
+
+.reliable-image { position: relative; overflow: hidden; min-height: 110px; border: 1px solid var(--line-soft); border-radius: 11px; background: #080b0d; }
+.reliable-image img { display: block; width: 100%; height: 100%; min-height: inherit; object-fit: contain; opacity: 0; transition: opacity .18s ease; cursor: zoom-in; }
+.reliable-image.is-loaded img { opacity: 1; }
+.image-label { position: absolute; right: 8px; bottom: 8px; padding: 5px 7px; border: 1px solid rgba(255,255,255,.1); border-radius: 6px; color: #dfe8e4; background: rgba(8, 12, 13, .78); backdrop-filter: blur(8px); font-size: 8px; font-weight: 650; text-transform: uppercase; letter-spacing: .06em; }
+.image-skeleton { position: absolute; inset: 0; overflow: hidden; background: #0d1214; }
+.image-skeleton span { position: absolute; inset: 0; transform: translateX(-100%); background: linear-gradient(90deg, transparent, rgba(255,255,255,.045), transparent); animation: shimmer 1.5s infinite; }
+.image-retry { position: absolute; inset: 0; width: 100%; border: 0; color: var(--red); background: #151011; font-size: 10px; cursor: pointer; }
+@keyframes shimmer { to { transform: translateX(100%); } }
+
+.trace-workbench { display: grid; min-height: 670px; grid-template-columns: 226px minmax(0, 1fr); overflow: hidden; border: 1px solid var(--line-soft); border-radius: var(--radius); background: var(--surface); }
+.turn-list { max-height: 760px; overflow-y: auto; border-right: 1px solid var(--line-soft); background: #0d1214; }
+.turn-list-heading { position: sticky; z-index: 2; top: 0; display: flex; align-items: flex-end; justify-content: space-between; padding: 15px 13px; border-bottom: 1px solid var(--line-soft); background: rgba(13, 18, 20, .96); backdrop-filter: blur(12px); }
+.turn-list-heading span, .turn-list-heading strong { display: block; }
+.turn-list-heading span { color: var(--quiet); font-size: 8px; text-transform: uppercase; }
+.turn-list-heading strong { margin-top: 4px; font-size: 11px; }
+.turn-list-heading small { color: var(--quiet); font-size: 8px; }
+.turn-item { display: grid; width: 100%; grid-template-columns: 27px 1fr auto; align-items: center; gap: 8px; padding: 10px 11px; border: 0; border-bottom: 1px solid #171e21; color: var(--muted); background: transparent; text-align: left; cursor: pointer; }
+.turn-item:hover { background: rgba(255,255,255,.02); }
+.turn-item.active { color: var(--text); background: linear-gradient(90deg, rgba(61, 186, 121, .15), transparent); box-shadow: inset 2px 0 var(--mint-strong); }
+.turn-number { color: var(--quiet); font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 9px; }
+.turn-summary strong, .turn-summary small { display: block; }
+.turn-summary strong { font-size: 9px; font-weight: 650; }
+.turn-summary small { margin-top: 3px; color: var(--quiet); font-size: 8px; }
+.turn-latency { color: var(--quiet); font-size: 8px; }
+
+.turn-stage { min-width: 0; padding: 18px; }
+.turn-stage-heading { display: flex; align-items: center; justify-content: space-between; margin-bottom: 14px; }
+.turn-stage-heading h3 { margin: 5px 0 0; font-size: 15px; }
+.turn-controls { display: flex; align-items: center; gap: 8px; color: var(--muted); font-size: 9px; }
+.turn-controls button { display: grid; width: 27px; height: 27px; place-items: center; border: 1px solid var(--line); border-radius: 7px; background: var(--surface-2); cursor: pointer; }
+.turn-images { display: grid; grid-template-columns: 1fr 1fr; gap: 9px; }
+.turn-images .reliable-image, .empty-frame { aspect-ratio: 16 / 9; }
+.empty-frame { display: grid; place-items: center; border: 1px dashed var(--line); border-radius: 11px; color: var(--quiet); font-size: 10px; }
+.turn-facts { display: flex; flex-wrap: wrap; gap: 19px; margin: 11px 0; padding: 9px 11px; border: 1px solid var(--line-soft); border-radius: 8px; background: #0e1315; color: var(--quiet); font-size: 8px; }
+.turn-facts strong { margin-left: 4px; color: var(--text); font-weight: 550; }
+.trace-detail-grid { display: grid; grid-template-columns: .85fr 1.15fr; gap: 9px; }
+.trace-card { min-width: 0; overflow: hidden; border: 1px solid var(--line-soft); border-radius: 10px; background: #0d1214; }
+.trace-card-heading { display: flex; align-items: center; justify-content: space-between; padding: 10px 12px; border-bottom: 1px solid var(--line-soft); }
+.trace-card-heading h4 { margin: 0; font-size: 10px; font-weight: 650; }
+.trace-card-heading span { color: var(--quiet); font-size: 8px; }
+.trace-card > pre, .action-item pre, details pre { max-height: 270px; margin: 0; overflow: auto; padding: 12px; color: #b7c3c7; font: 9px/1.55 ui-monospace, SFMono-Regular, Menlo, monospace; white-space: pre-wrap; word-break: break-word; }
+.action-list { max-height: 295px; overflow-y: auto; }
+.action-item { display: grid; grid-template-columns: 27px 1fr; }
+.action-item + .action-item { border-top: 1px solid var(--line-soft); }
+.action-item > span { padding: 13px 0 0 10px; color: var(--mint-strong); font: 8px ui-monospace, SFMono-Regular, Menlo, monospace; }
+.action-item pre { padding-left: 5px; }
+.receipts-card { margin-top: 9px; }
+.receipt-list { max-height: 310px; overflow-y: auto; }
+.receipt-list details + details { border-top: 1px solid var(--line-soft); }
+.receipt-list summary { display: grid; grid-template-columns: 48px 1fr auto; gap: 9px; padding: 10px 12px; color: var(--muted); font-size: 9px; cursor: pointer; list-style: none; }
+.receipt-list summary::-webkit-details-marker { display: none; }
+.receipt-list summary span { color: var(--quiet); font-family: ui-monospace, SFMono-Regular, Menlo, monospace; }
+.receipt-list summary strong { color: var(--text); }
+.receipt-list summary small { color: var(--mint-strong); }
+.empty-copy, .empty-trace { padding: 25px; color: var(--quiet); font-size: 10px; text-align: center; }
+.empty-trace { display: grid; place-items: center; }
+.raw-turn { margin-top: 9px; overflow: hidden; border: 1px solid var(--line-soft); border-radius: 9px; background: #0d1214; }
+.raw-turn summary { padding: 10px 12px; color: var(--muted); font-size: 9px; cursor: pointer; }
+.raw-turn pre { max-height: 420px; margin: 0; overflow: auto; padding: 12px; border-top: 1px solid var(--line-soft); color: #b7c3c7; font: 9px/1.55 ui-monospace, SFMono-Regular, Menlo, monospace; white-space: pre-wrap; word-break: break-word; }
+
+.downloads-panel { margin-top: 12px; }
+.download-grid { display: grid; grid-template-columns: repeat(5, minmax(0, 1fr)); gap: 1px; background: var(--line-soft); }
+.download-grid a { display: grid; min-width: 0; grid-template-columns: 1fr auto; padding: 13px 14px; color: var(--text); background: var(--surface); text-decoration: none; }
+.download-grid a:hover { background: var(--surface-2); }
+.download-grid span, .download-grid small { display: block; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.download-grid span { font-size: 9px; font-weight: 650; }
+.download-grid small { grid-column: 1; margin-top: 4px; color: var(--quiet); font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 7px; }
+.download-grid b { grid-row: 1 / 3; grid-column: 2; align-self: center; color: var(--mint-strong); font-size: 14px; }
+
+.frame-progress { text-align: right; }
+.frame-progress strong, .frame-progress span { display: block; }
+.frame-progress strong { font-size: 18px; }
+.frame-progress span { margin-top: 3px; color: var(--quiet); font-size: 9px; }
+.frame-gallery-note { display: flex; justify-content: space-between; margin-bottom: 12px; padding: 9px 11px; border: 1px solid var(--line-soft); border-radius: 8px; color: var(--quiet); background: var(--surface); font-size: 9px; }
+.frame-gallery-note span { display: flex; align-items: center; gap: 8px; }
+.frame-gallery { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 8px; }
+.frame-tile { padding: 0; overflow: hidden; border: 0; border-radius: 11px; background: none; cursor: zoom-in; }
+.frame-tile .reliable-image { aspect-ratio: 16 / 9; pointer-events: none; }
+.frame-tile:hover .reliable-image { border-color: #48725f; box-shadow: 0 0 0 2px rgba(67, 216, 145, .08); }
+.load-more { display: flex; justify-content: center; padding: 24px; color: var(--muted); font-size: 10px; }
+
+.lightbox { position: fixed; z-index: 100; inset: 0; display: grid; place-items: center; padding: 44px; background: rgba(2, 4, 5, .94); backdrop-filter: blur(12px); }
+.lightbox-close { position: absolute; top: 18px; right: 23px; width: 36px; height: 36px; border: 1px solid #344048; border-radius: 50%; color: var(--text); background: #101518; font-size: 23px; cursor: pointer; }
+.lightbox-content { display: grid; max-width: min(96vw, 1700px); max-height: 92vh; gap: 9px; justify-items: center; }
+.lightbox-content img { max-width: 100%; max-height: calc(92vh - 30px); border: 1px solid #29343a; border-radius: 9px; background: #000; object-fit: contain; }
+.lightbox-content span { color: var(--muted); font-size: 10px; }
+
+.loading-screen, .task-loading, .empty-registry { display: grid; min-height: 60vh; place-content: center; justify-items: center; color: var(--muted); font-size: 11px; }
+.task-loading { min-height: 420px; }
+.loading-orbit { position: relative; width: 34px; height: 34px; border: 1px solid #2a3932; border-radius: 50%; }
+.loading-orbit span { position: absolute; top: -2px; left: 15px; width: 4px; height: 4px; border-radius: 50%; background: var(--mint); animation: orbit 1s linear infinite; transform-origin: 2px 19px; }
+@keyframes orbit { to { transform: rotate(360deg); } }
+
+@media (max-width: 1180px) {
+  .stat-grid { grid-template-columns: repeat(3, 1fr); }
+  .hero-stat { grid-column: span 1; }
+  .overview-grid { grid-template-columns: 1fr; }
+  .artifact-strip { grid-template-columns: repeat(3, 1fr); }
+  .rubric-card { grid-column: 1 / -1; }
+  .download-grid { grid-template-columns: repeat(3, 1fr); }
+  .task-toolbar { grid-template-columns: repeat(3, 1fr); }
+  .search-field { grid-column: span 2; }
+  .frame-gallery { grid-template-columns: repeat(3, 1fr); }
+}
+
+@media (max-width: 850px) {
+  .topbar-meta > span:not(.health) { display: none; }
+  .workspace { grid-template-columns: 1fr; }
+  .model-rail { position: static; display: flex; width: 100%; height: auto; flex-direction: row; overflow-x: auto; padding: 10px 14px; border-right: 0; border-bottom: 1px solid var(--line-soft); }
+  .rail-heading, .rail-footnote { display: none; }
+  .model-item { min-width: 205px; }
+  .content { padding: 25px 16px 60px; }
+  .content-heading { align-items: flex-start; }
+  .registry-badge { display: none; }
+  .stat-grid { grid-template-columns: repeat(2, 1fr); }
+  .trace-workbench { grid-template-columns: 1fr; }
+  .turn-list { display: flex; max-height: none; overflow-x: auto; border-right: 0; border-bottom: 1px solid var(--line-soft); }
+  .turn-list-heading { min-width: 130px; }
+  .turn-item { min-width: 150px; border-right: 1px solid var(--line-soft); border-bottom: 0; }
+  .turn-images, .trace-detail-grid { grid-template-columns: 1fr; }
+  .download-grid { grid-template-columns: repeat(2, 1fr); }
+  .frame-gallery { grid-template-columns: repeat(2, 1fr); }
+  .task-title-scores { display: none; }
+}
+
+@media (max-width: 560px) {
+  .topbar { padding: 0 14px; }
+  .health { display: none; }
+  .content-heading h1 { font-size: 28px; }
+  .heading-actions .secondary-button { display: none; }
+  .section-tabs { gap: 15px; overflow-x: auto; }
+  .stat-grid { grid-template-columns: 1fr; }
+  .category-row { grid-template-columns: 92px 1fr 60px; }
+  .task-toolbar { grid-template-columns: 1fr 1fr; }
+  .search-field { grid-column: 1 / -1; }
+  .result-count { display: none; }
+  .artifact-strip { grid-template-columns: 1fr; }
+  .rubric-card { grid-column: auto; }
+  .turn-stage { padding: 12px; }
+  .download-grid { grid-template-columns: 1fr; }
+  .frame-gallery { grid-template-columns: 1fr; }
+  .frame-gallery-note { display: grid; gap: 6px; }
+  .lightbox { padding: 48px 8px 20px; }
+}

apps/results-dashboard/src/types.ts

@@ -0,0 +1,164 @@
+export type ScoreStats = {
+  count: number
+  mean: number | null
+  median: number | null
+  min: number | null
+  max: number | null
+}
+
+export type ResultTask = {
+  index: number
+  taskId: string
+  drawingType: '2d' | '3d'
+  level: string
+  category: string
+  included: boolean
+  executionStatus: string
+  evaluationStatus: string
+  selectedAttempt: string
+  selectedRunId: string
+  destinationPrefix: string
+  sourcePrefix: string
+  objectCount: number
+  bytes: number
+  deterministicScore: number | null
+  deterministicValid: boolean
+  visionScore: number | null
+  visionVerdict: string
+  evaluatorVersion: string
+  controllerClean: boolean
+  exclusionReason: string | null
+}
+
+export type CategorySummary = {
+  category: string
+  drawingType: '2d' | '3d'
+  level: string
+  tasks: number
+  deterministic: ScoreStats
+  vision: ScoreStats
+}
+
+export type ModelResult = {
+  slug: string
+  manifestKey: string
+  modelPrefix: string
+  modelId: string
+  aggregateId: string
+  createdAt: string | null
+  sourceBucket: string
+  destinationBucket: string
+  evaluatorVersion: string
+  tasks: ResultTask[]
+  categories: CategorySummary[]
+  totals: {
+    expected: number
+    included: number
+    excluded: number
+    clean: number
+    budgetExhausted: number
+    bytes: number
+    objects: number
+  }
+  scores: {
+    deterministic: ScoreStats
+    vision: ScoreStats
+    deterministicHistogram: number[]
+    visionHistogram: number[]
+  }
+  selectionPolicy: Record<string, unknown> | null
+  sourceRuns: Record<string, unknown>[]
+}
+
+export type TaskMetric = {
+  taskId: string
+  drawingType: '2d' | '3d'
+  level: string
+  acceptedActions: number | null
+  elapsedSeconds: number | null
+  rolloutSeconds: number | null
+  turns: number | null
+  screenshots: number | null
+  inputTokens: number | null
+  cachedInputTokens: number | null
+  cacheCreationTokens: number | null
+  outputTokens: number | null
+  reasoningTokens: number | null
+  totalTokens: number | null
+  artifactBytes: number | null
+  stopReason: string
+  deterministicScore: number | null
+  visionScore: number | null
+  visionVerdict: string
+}
+
+export type ModelMetrics = {
+  tasks: TaskMetric[]
+  totals: Record<string, number>
+  medians: Record<string, number | null>
+  scores: ModelResult['scores']
+  categories: CategorySummary[]
+}
+
+export type TaskDetail = {
+  model: { slug: string; modelId: string; aggregateId: string }
+  task: ResultTask
+  result: Record<string, unknown> | null
+  runState: Record<string, unknown> | null
+  evaluationScore: Record<string, unknown> | null
+  evaluationStatus: Record<string, unknown> | null
+  visionScore: Record<string, unknown> | null
+  frameCount: number
+  turnCount: number
+  media: Record<'reference' | 'final' | 'diff' | 'dwg', string>
+  downloads: Array<{ label: string; path: string }>
+}
+
+export type TraceTurn = {
+  index: number
+  turn: number
+  toolUseId: string
+  latencyMs: number | null
+  stopReason: string
+  requestAttempts: number | null
+  validationRetries: number | null
+  discardedToolUses: number | null
+  usage: Record<string, number> | null
+  text: unknown
+  actions: Record<string, unknown>[]
+  actionCount: number
+  inputFrameSequence: number | null
+  outputFrameSequence: number | null
+  firstActionIndex: number | null
+  lastActionIndex: number | null
+}
+
+export type TraceIndex = {
+  taskId: string
+  turns: TraceTurn[]
+  receiptCount: number
+}
+
+export type TurnDetail = {
+  turn: Record<string, unknown>
+  receipts: Array<{
+    actionIndex: number | null
+    batchIndex: number | null
+    batchSize: number | null
+    toolUseId: string | null
+    action: Record<string, unknown> | null
+    receipt: Record<string, unknown> | null
+    requestId: string | null
+    idempotentReplay: boolean
+  }>
+}
+
+export type Frame = { sequence: number; name: string; path: string }
+
+export type FramePage = {
+  offset: number
+  limit: number
+  total: number
+  hasMore: boolean
+  frames: Frame[]
+}

apps/results-dashboard/tests/results-api.test.mjs

@@ -0,0 +1,131 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { normalizeManifest, ResultsRepository } from '../results-api.mjs'
+
+const manifest = {
+  aggregate_id: 'aggregate-1',
+  model_id: 'gpt-5.6-terra',
+  created_at: '2026-07-22T00:00:00Z',
+  summary: { expected_tasks: 2 },
+  tasks: [
+    {
+      task_id: 'task-001',
+      included: true,
+      execution_status: 'completed',
+      destination_prefix: 'terra/artifacts//controller/run/task-001/',
+      object_count: 20,
+      bytes: 100,
+      deterministic_score: 0.4,
+      vision_score: 0.8,
+      vision_verdict: 'mostly_acquired',
+    },
+    {
+      task_id: 'task-049',
+      included: true,
+      execution_status: 'budget_exhausted',
+      controller_clean: false,
+      destination_prefix: 'terra/artifacts//controller/run/task-049/',
+      object_count: 30,
+      bytes: 200,
+      deterministic_score: 0.2,
+      vision_score: 0.6,
+      vision_verdict: 'partial',
+    },
+  ],
+}
+
+test('normalizes model and category statistics without blending evaluator scores', () => {
+  const result = normalizeManifest(manifest, { manifestKey: 'terra/aggregate/manifest.json' })
+  assert.equal(result.slug, 'terra')
+  assert.equal(result.totals.included, 2)
+  assert.equal(result.totals.budgetExhausted, 1)
+  assert.equal(result.totals.objects, 50)
+  assert.equal(result.scores.vision.mean, 0.7)
+  assert.equal(result.scores.deterministic.mean, 0.30000000000000004)
+  assert.deepEqual(result.categories.map((category) => category.category), ['2d-basic', '3d-project'])
+})
+
+test('normalizes the original aggregate manifest score and status field names', () => {
+  const result = normalizeManifest({
+    model_id: 'claude-fable-5',
+    summary: { expected_tasks: 1 },
+    tasks: [{
+      task_id: 'task-022',
+      included: true,
+      execution_state: 'budget_exhausted',
+      drawing_type: '3d',
+      level: 'basic',
+      score: 0.55,
+      outcome: 'partial',
+      score_source: 'vision_judge',
+      destination_prefix: 'fable/artifacts//run/task-022/',
+    }],
+  }, { manifestKey: 'fable/aggregate/manifest.json' })
+  assert.equal(result.tasks[0].executionStatus, 'budget_exhausted')
+  assert.equal(result.tasks[0].visionScore, 0.55)
+  assert.equal(result.tasks[0].visionVerdict, 'partial')
+  assert.equal(result.tasks[0].controllerClean, false)
+  assert.equal(result.scores.deterministic.count, 0)
+})
+
+test('preserves the aggregate bucket double slash in signed artifact keys', async () => {
+  let signedCommand = null
+  const repository = new ResultsRepository({
+    bucket: 'results',
+    s3: {
+      async send(command) {
+        if (command.constructor.name === 'ListObjectsV2Command') {
+          return { CommonPrefixes: [{ Prefix: 'terra/' }] }
+        }
+        const key = command.input.Key
+        if (key === 'terra/aggregate/manifest.json') {
+          return { Body: { transformToString: async () => JSON.stringify(manifest) } }
+        }
+        const error = new Error('missing')
+        error.name = 'NoSuchKey'
+        throw error
+      },
+    },
+    signUrl: async (command) => {
+      signedCommand = command
+      return 'https://signed.example/frame'
+    },
+  })
+  const url = await repository.mediaUrl('terra', 'task-001', 'frames/frame_0001.png')
+  assert.equal(url, 'https://signed.example/frame')
+  assert.equal(
+    signedCommand.input.Key,
+    'terra/artifacts//controller/run/task-001/frames/frame_0001.png',
+  )
+})
+
+test('derives a deterministic frame page from the finalized screenshot count', async () => {
+  const objects = new Map([
+    ['terra/aggregate/manifest.json', manifest],
+    ['terra/artifacts//controller/run/task-001/result.json', { screenshots: 4 }],
+    ['terra/artifacts//controller/run/task-001/run-state.json', { turn_count: 2 }],
+  ])
+  const repository = new ResultsRepository({
+    bucket: 'results',
+    signUrl: async () => 'signed',
+    s3: {
+      async send(command) {
+        if (command.constructor.name === 'ListObjectsV2Command') {
+          return { CommonPrefixes: [{ Prefix: 'terra/' }] }
+        }
+        const value = objects.get(command.input.Key)
+        if (value) return { Body: { transformToString: async () => JSON.stringify(value) } }
+        const error = new Error('missing')
+        error.name = 'NoSuchKey'
+        throw error
+      },
+    },
+  })
+  const page = await repository.framePage('terra', 'task-001', { offset: 1, limit: 2 })
+  assert.equal(page.total, 4)
+  assert.equal(page.hasMore, true)
+  assert.deepEqual(page.frames.map((frame) => frame.path), [
+    'frames/frame_0001.png',
+    'frames/frame_0002.png',
+  ])
+})

apps/results-dashboard/tsconfig.app.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "skipLibCheck": true,
+    "moduleResolution": "Bundler",
+    "allowImportingTsExtensions": true,
+    "noEmit": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "esModuleInterop": true,
+    "jsx": "preserve",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true
+  },
+  "include": ["src/**/*.ts", "src/**/*.tsx", "src/**/*.vue"]
+}

apps/results-dashboard/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "files": [],
+  "references": [
+    { "path": "./tsconfig.app.json" },
+    { "path": "./tsconfig.node.json" }
+  ]
+}

apps/results-dashboard/tsconfig.node.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+    "target": "ES2023",
+    "lib": ["ES2023"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "Bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "strict": true
+  },
+  "include": ["vite.config.ts"]
+}

apps/results-dashboard/vite.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from 'vite'
+import vue from '@vitejs/plugin-vue'
+
+export default defineConfig({
+  plugins: [vue()],
+  server: {
+    proxy: {
+      '/api': 'http://127.0.0.1:4274',
+    },
+  },
+  build: {
+    target: 'es2022',
+    sourcemap: true,
+  },
+})

artifacts/gold-cache/README.md

@@ -0,0 +1,31 @@
+# Gold cache
+
+This directory holds trusted, evaluator-versioned render and metadata artifacts:
+
+```text
+artifacts/gold-cache/<evaluator-version>/<task-id>/
+├── metadata.json
+└── render.png
+```
+
+Production entries are generated only by the pinned Windows/AutoCAD evaluator from the corresponding private gold DWG. Reference PNGs are never used to construct cache entries.
+
+Historical evaluator-version directories are generated artifacts and ignored by
+git. The public distribution includes the active
+`autocad-2019-r23.0.46-v4` cache so a checkout or exported bundle is
+evaluation-ready without using somebody else's infrastructure. It verifies all
+50 task source checksums and pins 3D rendering to `Layout1`.
+
+Portable bundle export checksum-binds the selected cache alongside the source
+corpus:
+
+```bash
+uv run autocad-bench bundle-export \
+  --output dist/autocad-bench-corpus-v1
+```
+
+```bash
+uv run autocad-bench verify-gold-cache \
+  --evaluator-version autocad-2019-r23.0.46-v4 \
+  --split all
+```