Trim

minimal server + web starter

README.md

@@ -1,86 +1,24 @@
-# RightCodes Architecture Scaffold
+# Minimal Server + Web Starter
 
-This repository is the starting scaffold for the code and standards migration assistant. The layout mirrors the planned AI-driven workflow (ingestion -> extraction -> mapping -> rewrite -> validation -> export) and keeps agent orchestration, backend services, and UI concerns separated.
+This repository is a stripped-down template with:
+- `server/` - FastAPI API with a single `/health` endpoint.
+- `frontend/` - Vite + React app that renders a black full-screen page.
 
-## Top-Level Directories
-
-- `frontend/` - React application for uploads, diff review, validation checklists, and export actions.
-- `server/` - FastAPI backend that manages sessions, orchestrates agents, and exposes REST/WebSocket APIs.
-- `agents/` - OpenAI agent wrappers plus prompt assets for each processing stage.
-- `workers/` - File ingestion, document parsing, and pipeline jobs executed off the main API thread.
-- `storage/` - Versioned document blobs, manifests, caches, and export artefacts.
-- `docs/` - Architecture notes, pipeline diagrams, agent specs, and UI flows.
-- `scripts/` - Developer utilities, operational scripts, and local tooling hooks.
-- `data/` - Sample inputs, canonical standards metadata, and fixture mappings.
-- `infra/` - DevOps assets (containers, CI pipelines, observability).
-- `common/` - Shared domain models, schemas, and event definitions.
-
-## Getting Started
-
-### Prerequisites
-
-- Python 3.8+ (3.11+ recommended)
-- Node.js 18+ and npm (ships with Node.js)
-- Internet connectivity on the first launch so pip/npm can download dependencies
-
-### Launcher Quick Start
-
-The repository ships with `start-rightcodes.ps1` (PowerShell) and `start-rightcodes.bat` (Command Prompt) which check for Python and Node.js, create the virtual environment, install dependencies, and open the launcher UI.  
+## Quick Start
 
+### Server
 ```powershell
-.\start-rightcodes.ps1
-```
-
-```bat
-start-rightcodes.bat
-```
-
-The scripts will guide you to the official Python and Node.js installers if either prerequisite is missing. After a successful first run, the cached `.venv/` and `frontend/node_modules/` folders allow the launcher to work offline.
-
-### Backend (FastAPI)
-
-```bash
-cd server
 python -m venv .venv
-.venv\Scripts\activate  # Windows
-pip install -r requirements.txt
-# copy the sample env and add your OpenAI key
-copy .env.example .env  # or use New-Item -Path .env -ItemType File
+.venv\Scripts\activate
+pip install -r server/requirements.txt
+uvicorn server.app.main:app --reload --port 8000
 ```
 
-Edit `.env` and set `RIGHTCODES_OPENAI_API_KEY=sk-your-key`.
-
-```bash
-uvicorn app.main:app --reload --port 8000
-```
-
-The API is available at `http://localhost:8000/api` and Swagger UI at `http://localhost:8000/api/docs`.
-
-### Frontend (Vite + React)
-
-```bash
+### Web
+```powershell
 cd frontend
 npm install
 npm run dev
 ```
 
-Navigate to `http://localhost:5173` to access the UI. Configure a custom API base URL by setting `VITE_API_BASE_URL` in `frontend/.env`.
-
-## Usage
-
-- Each conversion session requires the original report (`.docx`) plus one or more destination standards packs (`.pdf`). Upload all relevant standards PDFs so the AI pipeline can align existing references with the new context.
-- The web UI now shows live progress bars and an activity log so you can monitor each stage of the pipeline while it runs.
-- Backend agent calls expect an OpenAI API key in `RIGHTCODES_OPENAI_API_KEY`. On Windows PowerShell you can set it temporarily with `setx RIGHTCODES_OPENAI_API_KEY "sk-..."` (reopen your terminal afterward).
-- Optional: override the default OpenAI models by setting `RIGHTCODES_OPENAI_MODEL_EXTRACT`, `RIGHTCODES_OPENAI_MODEL_MAPPING`, `RIGHTCODES_OPENAI_MODEL_REWRITE`, `RIGHTCODES_OPENAI_MODEL_VALIDATE`, and `RIGHTCODES_OPENAI_MODEL_EMBED`. The pipeline stores standards embeddings under `storage/embeddings/`, enabling retrieval-augmented mapping, and the export stage now writes a converted DOCX to `storage/exports/` with a download button once the pipeline completes.
-
-## Offline Distribution Options
-
-- **Zip bundle:** Run `python tools/build_offline_package.py` after a successful online launch. The script creates `dist/rightcodes-offline.zip` containing the repository, the prepared `.venv/`, and `frontend/node_modules/`. Pass `--python-runtime` and `--node-runtime` to embed portable runtimes if you have them (for example, a locally extracted Python embeddable zip and Node.js binary folder). Extract the archive on another machine (same OS/architecture) and use the launcher scripts without needing internet access.
-- **Docker image:** Build a pre-baked container with `docker build -t rightcodes-launcher -f docker/Dockerfile .`. Supply `RIGHTCODES_OPENAI_API_KEY` (and optionally `RIGHTCODES_OPENAI_API_KEY_SOURCE`) at runtime: `docker run --rm -p 8765:8765 -p 8000:8000 -p 5173:5173 -e RIGHTCODES_OPENAI_API_KEY=sk-xxx rightcodes-launcher`.
-- **First-run reminder:** Even with these assets, the *initial* bundle build still requires internet so dependencies can be fetched once before packaging.
-
-## Next Steps
-
-1. Flesh out agent logic in `agents/` and integrate with orchestration hooks.
-2. Replace the in-memory session store with a durable persistence layer.
-3. Wire the worker queue (`workers/queue/`) to execute long-running stages asynchronously.
+Open `http://localhost:5173`.

agents/README.md

@@ -1,13 +0,0 @@
-# Agent Bundles
-
-Encapsulates prompts, tool definitions, and orchestration glue for each OpenAI Agent engaged in the pipeline.
-
-## Structure
-
-- `orchestrator/` - Coordinator agent spec, high-level playbooks, and session controller logic.
-- `extraction/` - Document clause extraction prompts, tool configs for parsers, and output schemas.
-- `standards_mapping/` - Normalization/mapping prompts, ontology helpers, and reference datasets.
-- `rewrite/` - Minimal-change rewrite prompts, safety rules, and diff formatting helpers.
-- `validation/` - Post-rewrite review prompts, calculation sanity checks, and reporting templates.
-- `export/` - Finalization prompts, merge instructions, and docx regeneration aids.
-- `shared/` - Common prompt fragments, JSON schema definitions, and evaluation heuristics.

agents/__init__.py

@@ -1,15 +0,0 @@
-from .orchestrator.agent import OrchestratorAgent
-from .extraction.agent import ExtractionAgent
-from .standards_mapping.agent import StandardsMappingAgent
-from .rewrite.agent import RewriteAgent
-from .validation.agent import ValidationAgent
-from .export.agent import ExportAgent
-
-__all__ = [
-    "OrchestratorAgent",
-    "ExtractionAgent",
-    "StandardsMappingAgent",
-    "RewriteAgent",
-    "ValidationAgent",
-    "ExportAgent",
-]

agents/export/__init__.py

@@ -1,3 +0,0 @@
-from .agent import ExportAgent
-
-__all__ = ["ExportAgent"]

agents/export/agent.py

@@ -1,112 +0,0 @@
-from __future__ import annotations
-
-from datetime import datetime
-from pathlib import Path
-from typing import Any, Dict, List
-
-from docx import Document
-
-from server.app.services.diagnostics_service import get_diagnostics_service
-
-from ..shared.base import AgentContext, BaseAgent
-
-
-def _apply_table_replacements(document: Document, replacements: List[Dict[str, Any]]) -> int:
-    tables = document.tables
-    applied = 0
-    for item in replacements:
-        index = item.get("table_index")
-        updated_rows = item.get("updated_rows")
-        if not isinstance(index, int) or index < 0 or index >= len(tables):
-            continue
-        if not isinstance(updated_rows, list):
-            continue
-        table = tables[index]
-        for row_idx, row_values in enumerate(updated_rows):
-            if row_idx < len(table.rows):
-                row = table.rows[row_idx]
-            else:
-                row = table.add_row()
-            for col_idx, value in enumerate(row_values):
-                if col_idx < len(row.cells):
-                    row.cells[col_idx].text = str(value) if value is not None else ""
-                else:
-                    break
-        applied += 1
-    return applied
-
-
-def _apply_replacements(document: Document, replacements: List[Dict[str, Any]]) -> int:
-    applied = 0
-    paragraphs = document.paragraphs
-    for item in replacements:
-        try:
-            index = int(item.get("paragraph_index"))
-        except (TypeError, ValueError):
-            continue
-        if index < 0 or index >= len(paragraphs):
-            continue
-        updated_text = item.get("updated_text")
-        if not isinstance(updated_text, str):
-            continue
-        paragraphs[index].text = updated_text
-        applied += 1
-    return applied
-
-
-class ExportAgent(BaseAgent):
-    name = "export-agent"
-
-    async def run(self, context: AgentContext) -> Dict[str, Any]:
-        await self.emit_debug("Exporting updated document to DOCX.")
-
-        rewrite_plan = context.payload.get("rewrite_plan") or {}
-        replacements = rewrite_plan.get("replacements") or []
-        table_replacements = rewrite_plan.get("table_replacements") or []
-        source_path = context.payload.get("original_path")
-        if not source_path or not Path(source_path).exists():
-            raise RuntimeError("Original document path not supplied to export agent.")
-
-        document = Document(source_path)
-        applied_paragraphs = _apply_replacements(document, replacements)
-        applied_tables = _apply_table_replacements(document, table_replacements)
-
-        storage_root = _resolve_storage_root()
-        export_dir = Path(storage_root) / "exports"
-        export_dir.mkdir(parents=True, exist_ok=True)
-        export_path = export_dir / f"{context.session_id}-converted.docx"
-        document.save(export_path)
-        diagnostics = get_diagnostics_service()
-        diagnostics.record_event(
-            node_id="exports",
-            event_type="export.generated",
-            message=f"Generated export for session `{context.session_id}`",
-            metadata={
-                "session_id": context.session_id,
-                "path": str(export_path),
-                "paragraph_replacements": applied_paragraphs,
-                "table_updates": applied_tables,
-            },
-        )
-
-        if applied_paragraphs or applied_tables:
-            note = "Converted document generated using rewrite plan."
-        else:
-            note = "Export completed, but no replacements were applied."
-
-        return {
-            "export_path": str(export_path),
-            "notes": note,
-            "replacement_count": applied_paragraphs,
-            "table_replacement_count": applied_tables,
-            "generated_at": datetime.utcnow().isoformat(),
-        }
-
-
-def _resolve_storage_root() -> Path:
-    try:
-        from server.app.core.config import get_settings  # local import avoids circular dependency
-
-        return get_settings().storage_dir
-    except Exception:  # noqa: BLE001
-        return (Path(__file__).resolve().parents[2] / "storage").resolve()

agents/extraction/__init__.py

@@ -1,3 +0,0 @@
-from .agent import ExtractionAgent
-
-__all__ = ["ExtractionAgent"]

agents/extraction/agent.py

@@ -1,239 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import asdict, is_dataclass
-import json
-from typing import Any, Dict, Iterable, List
-
-from ..shared.base import AgentContext, BaseAgent
-
-
-class ExtractionAgent(BaseAgent):
-    name = "extraction-agent"
-    paragraph_chunk_size = 40
-    table_chunk_size = 15
-    max_text_chars = 1500
-
-    async def run(self, context: AgentContext) -> Dict[str, Any]:
-        raw_paragraphs = context.payload.get("paragraphs", [])
-        raw_tables = context.payload.get("tables", [])
-        paragraphs = [_prepare_paragraph(item, self.max_text_chars) for item in _normalise_items(raw_paragraphs)]
-        tables = [_prepare_table(item, self.max_text_chars) for item in _normalise_items(raw_tables)]
-        metadata = context.payload.get("metadata", {})
-
-        if not paragraphs and not tables:
-            await self.emit_debug("No document content supplied to extraction agent.")
-            return {
-                "document_summary": "",
-                "sections": [],
-                "tables": [],
-                "references": [],
-                "notes": "Skipped: no document content provided.",
-            }
-
-        schema = {
-            "name": "ExtractionResult",
-            "schema": {
-                "type": "object",
-                "properties": {
-                    "document_summary": {"type": "string"},
-                    "sections": {
-                        "type": "array",
-                        "items": {
-                            "type": "object",
-                            "properties": {
-                                "paragraph_index": {"type": "integer"},
-                                "text": {"type": "string"},
-                                "references": {
-                                    "type": "array",
-                                    "items": {"type": "string"},
-                                    "default": [],
-                                },
-                            },
-                            "required": ["paragraph_index", "text"],
-                            "additionalProperties": False,
-                        },
-                        "default": [],
-                    },
-                    "tables": {
-                        "type": "array",
-                        "items": {
-                            "type": "object",
-                            "properties": {
-                                "table_index": {"type": "integer"},
-                                "summary": {"type": "string"},
-                                "references": {
-                                    "type": "array",
-                                    "items": {"type": "string"},
-                                    "default": [],
-                                },
-                            },
-                            "required": ["table_index", "summary"],
-                            "additionalProperties": False,
-                        },
-                        "default": [],
-                    },
-                    "references": {
-                        "type": "array",
-                        "items": {"type": "string"},
-                        "default": [],
-                    },
-                    "notes": {"type": "string"},
-                },
-                "required": ["document_summary", "sections", "tables", "references"],
-                "additionalProperties": False,
-            },
-        }
-
-        model = self.settings.openai_model_extract
-        aggregated_sections: List[Dict[str, Any]] = []
-        aggregated_tables: List[Dict[str, Any]] = []
-        aggregated_references: set[str] = set()
-        summaries: List[str] = []
-        notes: List[str] = []
-
-        for chunk in _chunk_list(paragraphs, self.paragraph_chunk_size):
-            batch = await self._process_batch(
-                context=context,
-                model=model,
-                schema=schema,
-                paragraphs=chunk,
-                tables=[],
-                metadata=metadata,
-            )
-            if batch:
-                summaries.append(batch.get("document_summary", ""))
-                aggregated_sections.extend(batch.get("sections", []))
-                aggregated_tables.extend(batch.get("tables", []))
-                aggregated_references.update(batch.get("references", []))
-                if batch.get("notes"):
-                    notes.append(batch["notes"])
-
-        for chunk in _chunk_list(tables, self.table_chunk_size):
-            batch = await self._process_batch(
-                context=context,
-                model=model,
-                schema=schema,
-                paragraphs=[],
-                tables=chunk,
-                metadata=metadata,
-            )
-            if batch:
-                aggregated_tables.extend(batch.get("tables", []))
-                aggregated_references.update(batch.get("references", []))
-                if batch.get("notes"):
-                    notes.append(batch["notes"])
-
-        summary = " ".join(filter(None, summaries)).strip()
-
-        for item in paragraphs:
-            aggregated_references.update(item.get("references", []))
-        for item in tables:
-            aggregated_references.update(item.get("references", []))
-
-        return {
-            "document_summary": summary,
-            "sections": aggregated_sections,
-            "tables": aggregated_tables,
-            "references": sorted(aggregated_references),
-            "notes": " ".join(notes).strip(),
-        }
-
-    async def _process_batch(
-        self,
-        *,
-        context: AgentContext,
-        model: str,
-        schema: Dict[str, Any],
-        paragraphs: List[Dict[str, Any]],
-        tables: List[Dict[str, Any]],
-        metadata: Dict[str, Any],
-    ) -> Dict[str, Any]:
-        if not paragraphs and not tables:
-            return {}
-
-        payload = {
-            "paragraphs": paragraphs,
-            "tables": tables,
-            "metadata": metadata,
-        }
-
-        messages = [
-            {
-                "role": "system",
-                "content": (
-                    "You are an engineering standards analyst. "
-                    "Analyse the supplied report content, identify normative references, "
-                    "and return structured data following the JSON schema."
-                ),
-            },
-            {
-                "role": "user",
-                "content": (
-                    f"Session ID: {context.session_id}\n"
-                    f"Payload: {json.dumps(payload, ensure_ascii=False)}"
-                ),
-            },
-        ]
-
-        try:
-            result = await self.call_openai_json(model=model, messages=messages, schema=schema)
-            return result
-        except Exception as exc:  # noqa: BLE001
-            await self.emit_debug(f"Extraction chunk failed: {exc}")
-            return {
-                "document_summary": "",
-                "sections": [],
-                "tables": [],
-                "references": [],
-                "notes": f"Chunk failed: {exc}",
-            }
-
-
-def _normalise_items(items: List[Any]) -> List[Dict[str, Any]]:
-    normalised: List[Dict[str, Any]] = []
-    for item in items:
-        if is_dataclass(item):
-            normalised.append(asdict(item))
-        elif isinstance(item, dict):
-            normalised.append(item)
-        else:
-            normalised.append({"value": str(item)})
-    return normalised
-
-
-def _prepare_paragraph(item: Dict[str, Any], max_chars: int) -> Dict[str, Any]:
-    text = item.get("text", "")
-    if len(text) > max_chars:
-        text = text[:max_chars] + "...(trimmed)"
-    return {
-        "index": item.get("index"),
-        "text": text,
-        "style": item.get("style"),
-        "heading_level": item.get("heading_level"),
-        "references": item.get("references", []),
-    }
-
-
-def _prepare_table(item: Dict[str, Any], max_chars: int) -> Dict[str, Any]:
-    rows = item.get("rows", [])
-    preview_rows = []
-    for row in rows:
-        preview_row = []
-        for cell in row:
-            cell_text = str(cell)
-            if len(cell_text) > max_chars:
-                cell_text = cell_text[:max_chars] + "...(trimmed)"
-            preview_row.append(cell_text)
-        preview_rows.append(preview_row)
-    return {
-        "index": item.get("index"),
-        "rows": preview_rows,
-        "references": item.get("references", []),
-    }
-
-
-def _chunk_list(items: List[Dict[str, Any]], size: int) -> Iterable[List[Dict[str, Any]]]:
-    if size <= 0:
-        size = len(items) or 1
-    for idx in range(0, len(items), size):
-        yield items[idx : idx + size]

agents/orchestrator/__init__.py

@@ -1,3 +0,0 @@
-from .agent import OrchestratorAgent
-
-__all__ = ["OrchestratorAgent"]

agents/orchestrator/agent.py

@@ -1,18 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Dict
-
-from ..shared.base import AgentContext, BaseAgent
-
-
-class OrchestratorAgent(BaseAgent):
-    name = "orchestrator-agent"
-
-    async def run(self, context: AgentContext) -> Dict[str, Any]:
-        await self.emit_debug(f"Received session {context.session_id}")
-        # In a future iteration this agent will orchestrate sub-agent calls.
-        return {
-            "next_stage": "ingest",
-            "notes": "Placeholder orchestrator response.",
-            "input_payload": context.payload,
-        }

agents/rewrite/__init__.py

@@ -1,3 +0,0 @@
-from .agent import RewriteAgent
-
-__all__ = ["RewriteAgent"]

agents/rewrite/agent.py

@@ -1,315 +0,0 @@
-from __future__ import annotations
-
-import json
-from typing import Any, Dict, Iterable, List, Sequence
-
-from ..shared.base import AgentContext, BaseAgent
-
-
-class RewriteAgent(BaseAgent):
-    name = "rewrite-agent"
-    paragraph_chunk_size = 20
-    max_paragraph_chars = 1600
-    max_table_chars = 1200
-
-    async def run(self, context: AgentContext) -> Dict[str, Any]:
-        mapping_result = context.payload.get("mapping_result") or {}
-        mappings: List[Dict[str, Any]] = mapping_result.get("mappings", [])
-        if not mappings:
-            await self.emit_debug("Rewrite skipped: no mappings provided.")
-            return {
-                "replacements": [],
-                "table_replacements": [],
-                "change_log": [],
-                "notes": "Rewrite skipped: no mappings provided.",
-            }
-
-        mapping_by_reference = _index_mappings(mappings)
-        doc_paragraphs = _normalise_paragraphs(
-            context.payload.get("document_paragraphs", []), self.max_paragraph_chars
-        )
-        doc_tables = _normalise_tables(
-            context.payload.get("document_tables", []), self.max_table_chars
-        )
-
-        paragraphs_to_rewrite = [
-            paragraph
-            for paragraph in doc_paragraphs
-            if any(ref in mapping_by_reference for ref in paragraph["references"])
-        ]
-        tables_to_rewrite = [
-            table
-            for table in doc_tables
-            if any(ref in mapping_by_reference for ref in table["references"])
-        ]
-
-        if not paragraphs_to_rewrite and not tables_to_rewrite:
-            await self.emit_debug("Rewrite skipped: no paragraphs or tables matched mapped references.")
-            return {
-                "replacements": [],
-                "table_replacements": [],
-                "change_log": [],
-                "notes": "Rewrite skipped: no references found in document.",
-            }
-
-        aggregated_replacements: List[Dict[str, Any]] = []
-        aggregated_table_replacements: List[Dict[str, Any]] = []
-        change_log_entries: List[Dict[str, Any]] = []
-        change_log_seen: set[tuple] = set()
-        notes: List[str] = []
-        target_voice = context.payload.get("target_voice", "Professional engineering tone")
-        constraints = context.payload.get("constraints", [])
-
-        pending_tables = {table["index"]: table for table in tables_to_rewrite}
-
-        for chunk in _chunk_list(paragraphs_to_rewrite, self.paragraph_chunk_size):
-            relevant_refs = sorted(
-                {
-                    reference
-                    for paragraph in chunk
-                    for reference in paragraph["references"]
-                    if reference in mapping_by_reference
-                }
-            )
-            if not relevant_refs:
-                continue
-
-            mapping_subset = _collect_mapping_subset(mapping_by_reference, relevant_refs)
-            associated_tables = _collect_tables_for_refs(pending_tables, relevant_refs)
-
-            payload = {
-                "instructions": {
-                    "target_voice": target_voice,
-                    "constraints": constraints,
-                    "guidance": [
-                        "Preserve numbering, bullet markers, and formatting cues.",
-                        "Do not alter calculations, quantities, or engineering values.",
-                        "Only update normative references and surrounding wording necessary for clarity.",
-                        "Maintain section titles and headings.",
-                    ],
-                },
-                "paragraphs": chunk,
-                "tables": associated_tables,
-                "mappings": mapping_subset,
-            }
-
-            schema = _rewrite_schema()
-            messages = [
-                {
-                    "role": "system",
-                    "content": (
-                        "You are an engineering editor updating a report so its references align with the target standards. "
-                        "Return JSON matching the schema. Maintain original structure and numbering while replacing each reference with the mapped target references."
-                    ),
-                },
-                {
-                    "role": "user",
-                    "content": (
-                        f"Session: {context.session_id}\n"
-                        f"Payload: {json.dumps(payload, ensure_ascii=False)}"
-                    ),
-                },
-            ]
-
-            try:
-                result = await self.call_openai_json(
-                    model=self.settings.openai_model_rewrite,
-                    messages=messages,
-                    schema=schema,
-                )
-                aggregated_replacements.extend(result.get("replacements", []))
-                aggregated_table_replacements.extend(result.get("table_replacements", []))
-                for entry in result.get("change_log", []):
-                    key = (
-                        entry.get("reference"),
-                        entry.get("target_reference"),
-                        tuple(entry.get("affected_paragraphs", [])),
-                    )
-                    if key not in change_log_seen:
-                        change_log_entries.append(entry)
-                        change_log_seen.add(key)
-                if result.get("notes"):
-                    notes.append(result["notes"])
-            except Exception as exc:  # noqa: BLE001
-                await self.emit_debug(f"Rewrite chunk failed: {exc}")
-                notes.append(f"Rewrite chunk failed: {exc}")
-
-        if not aggregated_replacements and not aggregated_table_replacements:
-            return {
-                "replacements": [],
-                "table_replacements": [],
-                "change_log": change_log_entries,
-                "notes": "Rewrite completed but no updates were suggested.",
-            }
-
-        return {
-            "replacements": aggregated_replacements,
-            "table_replacements": aggregated_table_replacements,
-            "change_log": change_log_entries,
-            "notes": " ".join(notes).strip(),
-        }
-
-
-def _index_mappings(mappings: Sequence[Dict[str, Any]]) -> Dict[str, List[Dict[str, Any]]]:
-    index: Dict[str, List[Dict[str, Any]]] = {}
-    for mapping in mappings:
-        ref = mapping.get("source_reference")
-        if not isinstance(ref, str):
-            continue
-        index.setdefault(ref, []).append(mapping)
-    return index
-
-
-def _collect_mapping_subset(
-    mapping_by_reference: Dict[str, List[Dict[str, Any]]],
-    references: Sequence[str],
-) -> List[Dict[str, Any]]:
-    subset: List[Dict[str, Any]] = []
-    for reference in references:
-        subset.extend(mapping_by_reference.get(reference, []))
-    return subset
-
-
-def _collect_tables_for_refs(
-    pending_tables: Dict[int, Dict[str, Any]],
-    references: Sequence[str],
-) -> List[Dict[str, Any]]:
-    matched: List[Dict[str, Any]] = []
-    for index in list(pending_tables.keys()):
-        table = pending_tables[index]
-        if any(ref in references for ref in table["references"]):
-            matched.append(table)
-            pending_tables.pop(index, None)
-    return matched
-
-
-def _normalise_paragraphs(items: Sequence[Dict[str, Any]], max_chars: int) -> List[Dict[str, Any]]:
-    paragraphs: List[Dict[str, Any]] = []
-    for item in items:
-        index = item.get("index")
-        if index is None:
-            continue
-        text = str(item.get("text", ""))
-        if len(text) > max_chars:
-            text = text[:max_chars] + "...(trimmed)"
-        paragraphs.append(
-            {
-                "index": index,
-                "text": text,
-                "style": item.get("style"),
-                "heading_level": item.get("heading_level"),
-                "references": item.get("references", []),
-            }
-        )
-    return paragraphs
-
-
-def _normalise_tables(items: Sequence[Dict[str, Any]], max_chars: int) -> List[Dict[str, Any]]:
-    tables: List[Dict[str, Any]] = []
-    for item in items:
-        index = item.get("index")
-        if index is None:
-            continue
-        rows = []
-        for row in item.get("rows", []):
-            preview_row = []
-            for cell in row:
-                cell_text = str(cell)
-                if len(cell_text) > max_chars:
-                    cell_text = cell_text[:max_chars] + "...(trimmed)"
-                preview_row.append(cell_text)
-            rows.append(preview_row)
-        tables.append(
-            {
-                "index": index,
-                "rows": rows,
-                "references": item.get("references", []),
-            }
-        )
-    return tables
-
-
-def _chunk_list(items: Sequence[Dict[str, Any]], size: int) -> Iterable[List[Dict[str, Any]]]:
-    if size <= 0:
-        size = len(items) or 1
-    for idx in range(0, len(items), size):
-        yield list(items[idx : idx + size])
-
-
-def _rewrite_schema() -> Dict[str, Any]:
-    return {
-        "name": "RewritePlanChunk",
-        "schema": {
-            "type": "object",
-            "properties": {
-                "replacements": {
-                    "type": "array",
-                    "items": {
-                        "type": "object",
-                        "properties": {
-                            "paragraph_index": {"type": "integer"},
-                            "original_text": {"type": "string"},
-                            "updated_text": {"type": "string"},
-                            "applied_mappings": {
-                                "type": "array",
-                                "items": {"type": "string"},
-                                "default": [],
-                            },
-                            "change_reason": {"type": "string"},
-                        },
-                        "required": ["paragraph_index", "updated_text"],
-                        "additionalProperties": False,
-                    },
-                    "default": [],
-                },
-                "table_replacements": {
-                    "type": "array",
-                    "items": {
-                        "type": "object",
-                        "properties": {
-                            "table_index": {"type": "integer"},
-                            "updated_rows": {
-                                "type": "array",
-                                "items": {
-                                    "type": "array",
-                                    "items": {"type": "string"},
-                                },
-                                "default": [],
-                            },
-                            "applied_mappings": {
-                                "type": "array",
-                                "items": {"type": "string"},
-                                "default": [],
-                            },
-                            "change_reason": {"type": "string"},
-                        },
-                        "required": ["table_index"],
-                        "additionalProperties": False,
-                    },
-                    "default": [],
-                },
-                "change_log": {
-                    "type": "array",
-                    "items": {
-                        "type": "object",
-                        "properties": {
-                            "reference": {"type": "string"},
-                            "target_reference": {"type": "string"},
-                            "affected_paragraphs": {
-                                "type": "array",
-                                "items": {"type": "integer"},
-                                "default": [],
-                            },
-                            "note": {"type": "string"},
-                        },
-                        "required": ["reference", "target_reference"],
-                        "additionalProperties": False,
-                    },
-                    "default": [],
-                },
-                "notes": {"type": "string"},
-            },
-            "required": ["replacements", "table_replacements", "change_log"],
-            "additionalProperties": False,
-        },
-    }

agents/shared/base.py

@@ -1,49 +0,0 @@
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from dataclasses import dataclass, field
-from typing import Any, Dict
-
-# We import config lazily to avoid circular imports during module initialisation.
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from server.app.core.config import Settings  # pragma: no cover
-
-
-@dataclass
-class AgentContext:
-    session_id: str
-    payload: Dict[str, Any] = field(default_factory=dict)
-
-
-class BaseAgent(ABC):
-    name: str
-
-    @abstractmethod
-    async def run(self, context: AgentContext) -> Dict[str, Any]:
-        """Execute agent logic and return structured output."""
-
-    async def emit_debug(self, message: str) -> None:
-        # Placeholder until logging/event bus is wired in.
-        print(f"[{self.name}] {message}")
-
-    @property
-    def settings(self):
-        from server.app.core.config import get_settings  # import here to avoid circular dependency
-
-        return get_settings()
-
-    async def call_openai_json(
-        self,
-        *,
-        model: str,
-        messages: list[Dict[str, Any]],
-        schema: Dict[str, Any],
-    ) -> Dict[str, Any]:
-        from .client import create_json_response  # import here to avoid circular dependency
-
-        if not self.settings.openai_api_key:
-            await self.emit_debug("OpenAI API key missing; returning empty response.")
-            raise RuntimeError("OpenAI API key missing")
-        return await create_json_response(model=model, messages=messages, schema=schema)

agents/shared/client.py

@@ -1,97 +0,0 @@
-from __future__ import annotations
-
-import json
-import logging
-from functools import lru_cache
-from typing import Any, Iterable
-
-from openai import AsyncOpenAI, OpenAIError
-
-try:
-    from server.app.core.config import get_settings
-    from server.app.services.diagnostics_service import get_diagnostics_service
-except ModuleNotFoundError as exc:  # pragma: no cover
-    raise RuntimeError(
-        "Failed to import server configuration. Ensure the project root is on PYTHONPATH."
-    ) from exc
-
-logger = logging.getLogger(__name__)
-
-
-@lru_cache
-def get_openai_client() -> AsyncOpenAI:
-    settings = get_settings()
-    if not settings.openai_api_key:
-        diagnostics = get_diagnostics_service()
-        diagnostics.record_event(
-            node_id="openai",
-            event_type="openai.missing_key",
-            message="OpenAI API key missing; requests will fail.",
-            metadata={},
-        )
-        raise RuntimeError(
-            "OpenAI API key is not configured. Set RIGHTCODES_OPENAI_API_KEY before invoking agents."
-        )
-    diagnostics = get_diagnostics_service()
-    diagnostics.record_event(
-        node_id="openai",
-        event_type="openai.client_ready",
-        message="OpenAI client initialised.",
-        metadata={},
-    )
-    return AsyncOpenAI(api_key=settings.openai_api_key, base_url=settings.openai_api_base)
-
-
-async def create_json_response(
-    *,
-    model: str,
-    messages: Iterable[dict[str, Any]],
-    schema: dict[str, Any],
-) -> dict[str, Any]:
-    """Invoke OpenAI with a JSON schema response format."""
-    client = get_openai_client()
-    diagnostics = get_diagnostics_service()
-    diagnostics.record_event(
-        node_id="openai",
-        event_type="openai.request",
-        message=f"Requesting model `{model}`",
-        metadata={"model": model},
-    )
-    try:
-        response = await client.chat.completions.create(
-            model=model,
-            messages=list(messages),
-            response_format={"type": "json_schema", "json_schema": schema},
-        )
-    except OpenAIError as exc:
-        logger.exception("OpenAI call failed: %s", exc)
-        diagnostics.record_event(
-            node_id="openai",
-            event_type="openai.error",
-            message="OpenAI request failed.",
-            metadata={"model": model, "error": str(exc)},
-        )
-        raise
-
-    try:
-        choice = response.choices[0]
-        content = choice.message.content if choice and choice.message else None
-        if not content:
-            raise RuntimeError("OpenAI response did not include message content.")
-        payload = json.loads(content)
-        diagnostics.record_event(
-            node_id="openai",
-            event_type="openai.response",
-            message="Received OpenAI response.",
-            metadata={"model": model},
-        )
-        return payload
-    except (AttributeError, json.JSONDecodeError) as exc:
-        logger.exception("Failed to decode OpenAI response: %s", exc)
-        diagnostics.record_event(
-            node_id="openai",
-            event_type="openai.error",
-            message="Failed to decode OpenAI response.",
-            metadata={"model": model, "error": str(exc)},
-        )
-        raise RuntimeError("OpenAI response was not valid JSON.") from exc

agents/shared/embeddings.py

@@ -1,19 +0,0 @@
-from __future__ import annotations
-
-from typing import Iterable, List, Sequence
-
-
-
-async def embed_texts(texts: Iterable[str]) -> List[List[float]]:
-    texts = [text if text else "" for text in texts]
-    if not texts:
-        return []
-    from ..shared.client import get_openai_client
-    client = get_openai_client()
-    from server.app.core.config import get_settings
-    settings = get_settings()
-    response = await client.embeddings.create(
-        model=settings.openai_model_embed,
-        input=list(texts),
-    )
-    return [item.embedding for item in response.data]

agents/standards_mapping/__init__.py

@@ -1,3 +0,0 @@
-from .agent import StandardsMappingAgent
-
-__all__ = ["StandardsMappingAgent"]

agents/standards_mapping/agent.py

@@ -1,293 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import asdict, is_dataclass
-import json
-from pathlib import Path
-from typing import Any, Dict, Iterable, List
-
-from ..shared.base import AgentContext, BaseAgent
-from ..shared.embeddings import embed_texts
-from common.embedding_store import EmbeddingStore, get_session_embedding_path
-
-
-class StandardsMappingAgent(BaseAgent):
-    name = "standards-mapping-agent"
-    reference_chunk_size = 20
-    max_excerpt_chars = 800
-
-    async def run(self, context: AgentContext) -> Dict[str, Any]:
-        extraction_result = context.payload.get("extraction_result") or {}
-        references: List[str] = extraction_result.get("references") or []
-        sections = extraction_result.get("sections") or []
-        tables = extraction_result.get("tables") or []
-        standards_chunks = _normalise_items(context.payload.get("standards_chunks", []))
-        target_metadata = context.payload.get("target_metadata", {})
-        store = EmbeddingStore(get_session_embedding_path(context.session_id))
-
-        if not references or not standards_chunks:
-            await self.emit_debug("Insufficient data for standards mapping.")
-            return {
-                "mappings": [],
-                "unmapped_references": references,
-                "notes": "Mapping skipped due to missing references or standards content.",
-            }
-
-        schema = {
-            "name": "StandardsMapping",
-            "schema": {
-                "type": "object",
-                "properties": {
-                    "mappings": {
-                        "type": "array",
-                        "items": {
-                            "type": "object",
-                            "properties": {
-                                "source_reference": {"type": "string"},
-                                "source_context": {"type": "string"},
-                                "target_reference": {"type": "string"},
-                                "target_clause": {"type": "string"},
-                                "target_summary": {"type": "string"},
-                                "confidence": {"type": "number"},
-                                "rationale": {"type": "string"},
-                            },
-                            "required": [
-                                "source_reference",
-                                "target_reference",
-                                "confidence",
-                            ],
-                            "additionalProperties": False,
-                        },
-                        "default": [],
-                    },
-                    "unmapped_references": {
-                        "type": "array",
-                        "items": {"type": "string"},
-                        "default": [],
-                    },
-                    "notes": {"type": "string"},
-                },
-                "required": ["mappings", "unmapped_references"],
-                "additionalProperties": False,
-            },
-        }
-
-        standards_overview = _build_standards_overview(standards_chunks, self.max_excerpt_chars)
-
-        model = self.settings.openai_model_mapping
-        aggregated_mappings: List[Dict[str, Any]] = []
-        aggregated_unmapped: set[str] = set()
-        notes: List[str] = []
-
-        for chunk in _chunk_list(references, self.reference_chunk_size):
-            reference_context = _build_reference_context(
-                chunk, sections, tables, self.max_excerpt_chars
-            )
-            retrieved_candidates = await _retrieve_candidates(
-                chunk, reference_context, store, target_metadata, self.max_excerpt_chars
-            )
-            payload = {
-                "references": chunk,
-                "reference_context": reference_context,
-                "retrieved_candidates": [
-                    {"reference": ref, "candidates": retrieved_candidates.get(ref, [])}
-                    for ref in chunk
-                ],
-                "standards_overview": standards_overview,
-                "target_metadata": target_metadata,
-            }
-
-            messages = [
-                {
-                    "role": "system",
-                    "content": (
-                        "You are an engineering standards migration specialist. "
-                        "Map each legacy reference to the best matching clause in the target standards. "
-                        "Use the provided context and standards overview to justify your mapping. "
-                        "Return JSON that conforms to the supplied schema."
-                    ),
-                },
-                {
-                    "role": "user",
-                    "content": (
-                        f"Session: {context.session_id}\n"
-                        f"Payload: {json.dumps(payload, ensure_ascii=False)}"
-                    ),
-                },
-            ]
-
-            try:
-                result = await self.call_openai_json(model=model, messages=messages, schema=schema)
-                aggregated_mappings.extend(result.get("mappings", []))
-                aggregated_unmapped.update(result.get("unmapped_references", []))
-                if result.get("notes"):
-                    notes.append(result["notes"])
-            except Exception as exc:  # noqa: BLE001
-                await self.emit_debug(f"Standards mapping chunk failed: {exc}")
-                aggregated_unmapped.update(chunk)
-                notes.append(f"Chunk failed: {exc}")
-
-        await self.emit_debug("Standards mapping completed via OpenAI.")
-        return {
-            "mappings": aggregated_mappings,
-            "unmapped_references": sorted(aggregated_unmapped),
-            "notes": " ".join(notes).strip(),
-        }
-
-
-def _normalise_items(items: List[Any]) -> List[Dict[str, Any]]:
-    normalised: List[Dict[str, Any]] = []
-    for item in items:
-        if is_dataclass(item):
-            normalised.append(asdict(item))
-        elif isinstance(item, dict):
-            normalised.append(item)
-        else:
-            normalised.append({"text": str(item)})
-    return normalised
-
-
-def _chunk_list(items: List[str], size: int) -> Iterable[List[str]]:
-    if size <= 0:
-        size = len(items) or 1
-    for idx in range(0, len(items), size):
-        yield items[idx : idx + size]
-
-
-def _build_reference_context(
-    references: List[str],
-    sections: List[Dict[str, Any]],
-    tables: List[Dict[str, Any]],
-    max_chars: int,
-) -> List[Dict[str, Any]]:
-    section_map: Dict[str, List[Dict[str, Any]]] = {}
-    for section in sections:
-        refs = section.get("references") or []
-        for ref in refs:
-            section_map.setdefault(ref, [])
-            if len(section_map[ref]) < 3:
-                text = section.get("text", "")
-                if len(text) > max_chars:
-                    text = text[:max_chars] + "...(trimmed)"
-                section_map[ref].append(
-                    {
-                        "paragraph_index": section.get("paragraph_index"),
-                        "text": text,
-                    }
-                )
-    table_map: Dict[str, List[Dict[str, Any]]] = {}
-    for table in tables:
-        refs = table.get("references") or []
-        for ref in refs:
-            table_map.setdefault(ref, [])
-            if len(table_map[ref]) < 2:
-                table_map[ref].append({"table_index": table.get("table_index"), "references": refs})
-
-    context = []
-    for ref in references:
-        context.append(
-            {
-                "reference": ref,
-                "paragraphs": section_map.get(ref, []),
-                "tables": table_map.get(ref, []),
-            }
-        )
-    return context
-
-
-def _build_standards_overview(
-    standards_chunks: List[Dict[str, Any]],
-    max_chars: int,
-) -> List[Dict[str, Any]]:
-    grouped: Dict[str, Dict[str, Any]] = {}
-    for chunk in standards_chunks:
-        path = chunk.get("path", "unknown")
-        heading = chunk.get("heading")
-        clauses = chunk.get("clause_numbers") or []
-        text = chunk.get("text", "")
-        if len(text) > max_chars:
-            text = text[:max_chars] + "...(trimmed)"
-
-        group = grouped.setdefault(
-            path,
-            {
-                "document": Path(path).name,
-                "headings": [],
-                "clauses": [],
-                "snippets": [],
-            },
-        )
-        if heading and heading not in group["headings"] and len(group["headings"]) < 120:
-            group["headings"].append(heading)
-        for clause in clauses:
-            if clause not in group["clauses"] and len(group["clauses"]) < 120:
-                group["clauses"].append(clause)
-        if text and len(group["snippets"]) < 30:
-            group["snippets"].append(text)
-
-    overview: List[Dict[str, Any]] = []
-    for data in grouped.values():
-        overview.append(
-            {
-                "document": data["document"],
-                "headings": data["headings"][:50],
-                "clauses": data["clauses"][:50],
-                "snippets": data["snippets"],
-            }
-        )
-    return overview[:30]
-
-
-async def _retrieve_candidates(
-    references: List[str],
-    reference_context: List[Dict[str, Any]],
-    store: EmbeddingStore,
-    target_metadata: Dict[str, Any],
-    max_chars: int,
-) -> Dict[str, List[Dict[str, Any]]]:
-    if not references:
-        return {}
-    if store.is_empty:
-        return {ref: [] for ref in references}
-
-    context_lookup = {entry["reference"]: entry for entry in reference_context}
-    embed_inputs = [
-        _compose_reference_embedding_input(
-            reference,
-            context_lookup.get(reference, {}),
-            target_metadata,
-            max_chars,
-        )
-        for reference in references
-    ]
-    vectors = await embed_texts(embed_inputs)
-    results: Dict[str, List[Dict[str, Any]]] = {}
-    for reference, vector in zip(references, vectors):
-        candidates = store.query(vector, top_k=8)
-        results[reference] = candidates
-    return results
-
-
-def _compose_reference_embedding_input(
-    reference: str,
-    context_entry: Dict[str, Any],
-    target_metadata: Dict[str, Any],
-    max_chars: int,
-) -> str:
-    lines = [reference]
-    target_standard = target_metadata.get("target_standard")
-    if target_standard:
-        lines.append(f"Target standard family: {target_standard}")
-    paragraphs = context_entry.get("paragraphs") or []
-    for paragraph in paragraphs[:2]:
-        text = paragraph.get("text")
-        if text:
-            lines.append(text)
-    tables = context_entry.get("tables") or []
-    if tables:
-        refs = tables[0].get("references") or []
-        if refs:
-            lines.append("Table references: " + ", ".join(refs))
-    text = "\n".join(filter(None, lines))
-    if len(text) > max_chars:
-        text = text[:max_chars] + "...(trimmed)"
-    return text

agents/validation/__init__.py

@@ -1,3 +0,0 @@
-from .agent import ValidationAgent
-
-__all__ = ["ValidationAgent"]

agents/validation/agent.py

@@ -1,96 +0,0 @@
-from __future__ import annotations
-
-import json
-from typing import Any, Dict, List
-
-from ..shared.base import AgentContext, BaseAgent
-
-
-class ValidationAgent(BaseAgent):
-    name = "validation-agent"
-
-    async def run(self, context: AgentContext) -> Dict[str, Any]:
-        await self.emit_debug("Running compliance checks.")
-
-        extraction = context.payload.get("extraction_result") or {}
-        mapping = context.payload.get("mapping_result") or {}
-        rewrite_plan = context.payload.get("rewrite_plan") or {}
-
-        if not mapping or not rewrite_plan:
-            return {
-                "issues": [],
-                "verdict": "pending",
-                "notes": "Validation skipped because mapping or rewrite data was unavailable.",
-            }
-
-        schema = {
-            "name": "ValidationReport",
-            "schema": {
-                "type": "object",
-                "properties": {
-                    "verdict": {
-                        "type": "string",
-                        "enum": ["approved", "changes_requested", "pending"],
-                    },
-                    "issues": {
-                        "type": "array",
-                        "items": {
-                            "type": "object",
-                            "properties": {
-                                "description": {"type": "string"},
-                                "severity": {
-                                    "type": "string",
-                                    "enum": ["info", "low", "medium", "high"],
-                                },
-                                "related_reference": {"type": "string"},
-                            },
-                            "required": ["description", "severity"],
-                            "additionalProperties": False,
-                        },
-                        "default": [],
-                    },
-                    "notes": {"type": "string"},
-                },
-                "required": ["verdict", "issues"],
-                "additionalProperties": False,
-            },
-        }
-
-        mapping_snippet = json.dumps(mapping.get("mappings", [])[:20], ensure_ascii=False)
-        rewrite_snippet = json.dumps(rewrite_plan.get("replacements", [])[:20], ensure_ascii=False)
-        references = extraction.get("references", [])
-
-        messages = [
-            {
-                "role": "system",
-                "content": (
-                    "You are a senior structural engineer reviewing a standards migration. "
-                    "Evaluate whether the proposed replacements maintain compliance and highlight any risks."
-                ),
-            },
-            {
-                "role": "user",
-                "content": (
-                    f"Session: {context.session_id}\n"
-                    f"Detected references: {references}\n"
-                    f"Mappings sample: {mapping_snippet}\n"
-                    f"Rewrite sample: {rewrite_snippet}"
-                ),
-            },
-        ]
-
-        model = self.settings.openai_model_mapping
-
-        try:
-            result = await self.call_openai_json(model=model, messages=messages, schema=schema)
-            await self.emit_debug("Validation agent completed via OpenAI.")
-            if not result.get("notes"):
-                result["notes"] = "Review generated by automated validation agent."
-            return result
-        except Exception as exc:  # noqa: BLE001
-            await self.emit_debug(f"Validation agent failed: {exc}")
-            return {
-                "issues": [],
-                "verdict": "pending",
-                "notes": f"Validation failed: {exc}",
-            }

common/README.md

@@ -1,10 +0,0 @@
-# Common Domain Assets
-
-Cross-cutting models, schemas, and events shared between backend services, agents, and workers.
-
-## Structure
-
-- `models/` - Core domain entities and DTOs reused across services.
-- `utils/` - Reusable helper functions (text normalization, ID generation).
-- `schemas/` - JSON schema definitions for agent input/output contracts.
-- `events/` - Event payload definitions for pipeline instrumentation.

common/embedding_store.py

@@ -1,98 +0,0 @@
-from __future__ import annotations
-
-import json
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any, List, Sequence, Tuple
-
-import numpy as np
-
-
-def _resolve_embedding_root() -> Path:
-    try:
-        from server.app.core.config import get_settings  # local import to avoid hard dependency at import time
-
-        storage_dir = get_settings().storage_dir
-    except Exception:  # noqa: BLE001
-        storage_dir = Path(__file__).resolve().parents[1] / "storage"
-    return Path(storage_dir) / "embeddings"
-
-
-def get_session_embedding_path(session_id: str) -> Path:
-    return _resolve_embedding_root() / f"{session_id}.json"
-
-
-@dataclass
-class EmbeddingRecord:
-    vector: List[float]
-    metadata: dict[str, Any]
-
-
-class EmbeddingStore:
-    def __init__(self, path: Path) -> None:
-        self.path = path
-        self._records: list[EmbeddingRecord] = []
-        self._matrix: np.ndarray | None = None
-        self._load()
-
-    def _load(self) -> None:
-        if not self.path.exists():
-            return
-        with self.path.open("r", encoding="utf-8") as fh:
-            data = json.load(fh)
-        self._records = [EmbeddingRecord(**item) for item in data]
-
-    def save(self) -> None:
-        self.path.parent.mkdir(parents=True, exist_ok=True)
-        with self.path.open("w", encoding="utf-8") as fh:
-            json.dump(
-                [{"vector": rec.vector, "metadata": rec.metadata} for rec in self._records],
-                fh,
-                ensure_ascii=False,
-                indent=2,
-            )
-
-    def clear(self) -> None:
-        self._records.clear()
-        self._matrix = None
-
-    def extend(self, vectors: Sequence[Sequence[float]], metadatas: Sequence[dict[str, Any]]) -> None:
-        for vector, metadata in zip(vectors, metadatas, strict=True):
-            self._records.append(EmbeddingRecord(list(vector), dict(metadata)))
-        self._matrix = None
-
-    @property
-    def is_empty(self) -> bool:
-        return not self._records
-
-    def _ensure_matrix(self) -> None:
-        if self._matrix is None and self._records:
-            self._matrix = np.array([rec.vector for rec in self._records], dtype=np.float32)
-
-    def query(self, vector: Sequence[float], top_k: int = 5) -> List[Tuple[dict[str, Any], float]]:
-        if self.is_empty:
-            return []
-        self._ensure_matrix()
-        assert self._matrix is not None
-        matrix = self._matrix
-        vec = np.array(vector, dtype=np.float32)
-        vec_norm = np.linalg.norm(vec)
-        if not np.isfinite(vec_norm) or vec_norm == 0:
-            return []
-        matrix_norms = np.linalg.norm(matrix, axis=1)
-        scores = matrix @ vec / (matrix_norms * vec_norm + 1e-12)
-        top_k = min(top_k, len(scores))
-        indices = np.argsort(scores)[::-1][:top_k]
-        results: List[Tuple[dict[str, Any], float]] = []
-        for idx in indices:
-            score = float(scores[idx])
-            metadata = self._records[int(idx)].metadata.copy()
-            metadata["score"] = score
-            results.append((metadata, score))
-        return results
-
-    def query_many(self, vectors: Sequence[Sequence[float]], top_k: int = 5) -> List[List[dict[str, Any]]]:
-        return [
-            [meta for meta, _ in self.query(vector, top_k=top_k)]
-            for vector in vectors
-        ]

docker/Dockerfile

@@ -1,20 +0,0 @@
-FROM node:20-bookworm
-
-RUN apt-get update \
-    && apt-get install -y --no-install-recommends python3 python3-venv python3-pip \
-    && rm -rf /var/lib/apt/lists/*
-
-WORKDIR /app
-
-COPY . /app
-
-RUN python3 -m venv /app/.venv \
-    && /app/.venv/bin/pip install --upgrade pip \
-    && /app/.venv/bin/pip install -r server/requirements.txt \
-    && npm install --prefix frontend
-
-ENV PATH="/app/.venv/bin:${PATH}"
-
-EXPOSE 8000 5173 8765
-
-CMD ["python3", "start-rightcodes.py", "--host", "0.0.0.0", "--port", "8765", "--no-browser"]

docs/README.md

@@ -1,12 +0,0 @@
-# Documentation Hub
-
-Authoritative documentation for architecture, pipelines, agents, and UI workflows.
-
-## Structure
-
-- `architecture/` - System diagrams, deployment topology, and context views.
-- `agents/` - Detailed specs of each agent, including prompt design and tool APIs.
-- `pipelines/` - Pypeflow diagrams, data contracts, and runbooks for each stage.
-- `standards/` - Reference material and taxonomy notes for supported codes and standards.
-- `ui/` - Wireframes, component inventories, and interaction design specs.
-- `specifications/` - Functional requirements, acceptance criteria, and use cases.

docs/agents/orchestrator.md

@@ -1,12 +0,0 @@
-# Orchestrator Agent (Draft)
-
-- **Goal:** Coordinate pipeline stages, persist state transitions, and request human intervention when confidence drops below threshold.
-- **Inputs:** `document_manifest.json`, latest stage outputs, user session preferences.
-- **Outputs:** `progress_state.json`, downstream agent invocation plans, notifications/events.
-- **Tool Hooks:** Worker queue enqueuer, storage manifest writer, validation reporter.
-
-Action items:
-
-1. Define structured prompt schema and guardrails.
-2. Enumerate tool signatures for queueing, status updates, and failure escalation.
-3. Align logging with `common/events/` payload definitions.

docs/architecture/system-context.md

@@ -1,11 +0,0 @@
-# System Context (Draft)
-
-- **Primary Actors:** Engineering consultant (user), Orchestrator Agent, Validation Agent, Export Agent.
-- **External Systems:** OpenAI APIs, Object storage (S3-compatible), Auth provider (to be determined).
-- **Key Data Stores:** Session manifest store, document blob storage, telemetry pipeline.
-
-Pending tasks:
-
-1. Complete C4 level 1 context diagram.
-2. Document trust boundaries (uploaded documents vs generated artefacts).
-3. Define audit/logging requirements tied to standards compliance.

docs/pipelines/pypeflow-overview.md

@@ -1,8 +0,0 @@
-# Pypeflow Overview
-
-> Placeholder: document the end-to-end job graph once the first pipeline prototype lands. Recommended sections:
->
-> 1. High-level mermaid diagram showing ingestion -> extraction -> mapping -> rewrite -> validation -> export.
-> 2. Stage-by-stage JSON artefact expectations (input/output schemas).
-> 3. Failure handling and retry strategy per stage.
-> 4. Hooks for agent overrides and manual approvals.

docs/ui/review-workflow.md

@@ -1,17 +0,0 @@
-# Review Workflow (Draft)
-
-Stages:
-
-1. Upload wizard captures Word report, one or more standards PDFs, and mapping intent.
-2. Diff workspace highlights replaced clauses with inline confidence tags.
-3. Validation dashboard lists outstanding checks, comments, and approval history.
-
-Open questions:
-
-- How should we present clause-level provenance (link back to PDF page)?
-- Do we surface agent rationales verbatim or summarised?
-- What accessibility requirements should inform colour coding and indicators?
-
-UI notes:
-
-- Show upload progress and pipeline activity log so users know when each processing stage completes.

frontend/README.md

@@ -1,17 +0,0 @@
-# Frontend Module
-
-React/TypeScript single-page app responsible for user interaction and review workflows.
-
-## Structure
-
-- `public/` - Static assets and HTML shell.
-- `src/components/` - Shared UI components (uploaders, diff panels, status widgets).
-- `src/pages/` - Route-level containers for upload, review, and export views.
-- `src/hooks/` - Reusable logic for API access, session state, and polling.
-- `src/layouts/` - Shell layouts (wizard, review workspace).
-- `src/state/` - Store configuration (React Query, Zustand, or Redux).
-- `src/services/` - API clients, WebSocket connectors, and agent progress handlers.
-- `src/utils/` - Formatting helpers, doc diff utilities, and schema transformers.
-- `src/types/` - Shared TypeScript declarations.
-- `tests/` - Component and integration tests with fixtures and mocks.
-- `config/` - Build-time configuration (Vite/Webpack, env samples).

frontend/index.html

@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>RightCodes</title>
+    <title>Starter</title>
   </head>
   <body>
     <div id="root"></div>

frontend/package-lock.json

@@ -1,2030 +0,0 @@
-{
-  "name": "rightcodes-frontend",
-  "version": "0.1.0",
-  "lockfileVersion": 3,
-  "requires": true,
-  "packages": {
-    "": {
-      "name": "rightcodes-frontend",
-      "version": "0.1.0",
-      "dependencies": {
-        "@tanstack/react-query": "^5.51.11",
-        "axios": "^1.7.7",
-        "react": "^18.3.1",
-        "react-dom": "^18.3.1",
-        "react-router-dom": "^6.26.0"
-      },
-      "devDependencies": {
-        "@types/react": "^18.3.3",
-        "@types/react-dom": "^18.3.3",
-        "@vitejs/plugin-react": "^4.3.1",
-        "typescript": "^5.4.5",
-        "vite": "^5.4.8"
-      }
-    },
-    "node_modules/@babel/code-frame": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.27.1.tgz",
-      "integrity": "sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/helper-validator-identifier": "^7.27.1",
-        "js-tokens": "^4.0.0",
-        "picocolors": "^1.1.1"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/compat-data": {
-      "version": "7.28.4",
-      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.28.4.tgz",
-      "integrity": "sha512-YsmSKC29MJwf0gF8Rjjrg5LQCmyh+j/nD8/eP7f+BeoQTKYqs9RoWbjGOdy0+1Ekr68RJZMUOPVQaQisnIo4Rw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/core": {
-      "version": "7.28.4",
-      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.28.4.tgz",
-      "integrity": "sha512-2BCOP7TN8M+gVDj7/ht3hsaO/B/n5oDbiAyyvnRlNOs+u1o+JWNYTQrmpuNp1/Wq2gcFrI01JAW+paEKDMx/CA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/code-frame": "^7.27.1",
-        "@babel/generator": "^7.28.3",
-        "@babel/helper-compilation-targets": "^7.27.2",
-        "@babel/helper-module-transforms": "^7.28.3",
-        "@babel/helpers": "^7.28.4",
-        "@babel/parser": "^7.28.4",
-        "@babel/template": "^7.27.2",
-        "@babel/traverse": "^7.28.4",
-        "@babel/types": "^7.28.4",
-        "@jridgewell/remapping": "^2.3.5",
-        "convert-source-map": "^2.0.0",
-        "debug": "^4.1.0",
-        "gensync": "^1.0.0-beta.2",
-        "json5": "^2.2.3",
-        "semver": "^6.3.1"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/babel"
-      }
-    },
-    "node_modules/@babel/generator": {
-      "version": "7.28.3",
-      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.28.3.tgz",
-      "integrity": "sha512-3lSpxGgvnmZznmBkCRnVREPUFJv2wrv9iAoFDvADJc0ypmdOxdUtcLeBgBJ6zE0PMeTKnxeQzyk0xTBq4Ep7zw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/parser": "^7.28.3",
-        "@babel/types": "^7.28.2",
-        "@jridgewell/gen-mapping": "^0.3.12",
-        "@jridgewell/trace-mapping": "^0.3.28",
-        "jsesc": "^3.0.2"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helper-compilation-targets": {
-      "version": "7.27.2",
-      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.27.2.tgz",
-      "integrity": "sha512-2+1thGUUWWjLTYTHZWK1n8Yga0ijBz1XAhUXcKy81rd5g6yh7hGqMp45v7cadSbEHc9G3OTv45SyneRN3ps4DQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/compat-data": "^7.27.2",
-        "@babel/helper-validator-option": "^7.27.1",
-        "browserslist": "^4.24.0",
-        "lru-cache": "^5.1.1",
-        "semver": "^6.3.1"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helper-globals": {
-      "version": "7.28.0",
-      "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.28.0.tgz",
-      "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helper-module-imports": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.27.1.tgz",
-      "integrity": "sha512-0gSFWUPNXNopqtIPQvlD5WgXYI5GY2kP2cCvoT8kczjbfcfuIljTbcWrulD1CIPIX2gt1wghbDy08yE1p+/r3w==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/traverse": "^7.27.1",
-        "@babel/types": "^7.27.1"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helper-module-transforms": {
-      "version": "7.28.3",
-      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.3.tgz",
-      "integrity": "sha512-gytXUbs8k2sXS9PnQptz5o0QnpLL51SwASIORY6XaBKF88nsOT0Zw9szLqlSGQDP/4TljBAD5y98p2U1fqkdsw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/helper-module-imports": "^7.27.1",
-        "@babel/helper-validator-identifier": "^7.27.1",
-        "@babel/traverse": "^7.28.3"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      },
-      "peerDependencies": {
-        "@babel/core": "^7.0.0"
-      }
-    },
-    "node_modules/@babel/helper-plugin-utils": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.27.1.tgz",
-      "integrity": "sha512-1gn1Up5YXka3YYAHGKpbideQ5Yjf1tDa9qYcgysz+cNCXukyLl6DjPXhD3VRwSb8c0J9tA4b2+rHEZtc6R0tlw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helper-string-parser": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
-      "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helper-validator-identifier": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.27.1.tgz",
-      "integrity": "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helper-validator-option": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz",
-      "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helpers": {
-      "version": "7.28.4",
-      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.28.4.tgz",
-      "integrity": "sha512-HFN59MmQXGHVyYadKLVumYsA9dBFun/ldYxipEjzA4196jpLZd8UjEEBLkbEkvfYreDqJhZxYAWFPtrfhNpj4w==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/template": "^7.27.2",
-        "@babel/types": "^7.28.4"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/parser": {
-      "version": "7.28.4",
-      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.28.4.tgz",
-      "integrity": "sha512-yZbBqeM6TkpP9du/I2pUZnJsRMGGvOuIrhjzC1AwHwW+6he4mni6Bp/m8ijn0iOuZuPI2BfkCoSRunpyjnrQKg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/types": "^7.28.4"
-      },
-      "bin": {
-        "parser": "bin/babel-parser.js"
-      },
-      "engines": {
-        "node": ">=6.0.0"
-      }
-    },
-    "node_modules/@babel/plugin-transform-react-jsx-self": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.27.1.tgz",
-      "integrity": "sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/helper-plugin-utils": "^7.27.1"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      },
-      "peerDependencies": {
-        "@babel/core": "^7.0.0-0"
-      }
-    },
-    "node_modules/@babel/plugin-transform-react-jsx-source": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.27.1.tgz",
-      "integrity": "sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/helper-plugin-utils": "^7.27.1"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      },
-      "peerDependencies": {
-        "@babel/core": "^7.0.0-0"
-      }
-    },
-    "node_modules/@babel/template": {
-      "version": "7.27.2",
-      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.27.2.tgz",
-      "integrity": "sha512-LPDZ85aEJyYSd18/DkjNh4/y1ntkE5KwUHWTiqgRxruuZL2F1yuHligVHLvcHY2vMHXttKFpJn6LwfI7cw7ODw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/code-frame": "^7.27.1",
-        "@babel/parser": "^7.27.2",
-        "@babel/types": "^7.27.1"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/traverse": {
-      "version": "7.28.4",
-      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.28.4.tgz",
-      "integrity": "sha512-YEzuboP2qvQavAcjgQNVgsvHIDv6ZpwXvcvjmyySP2DIMuByS/6ioU5G9pYrWHM6T2YDfc7xga9iNzYOs12CFQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/code-frame": "^7.27.1",
-        "@babel/generator": "^7.28.3",
-        "@babel/helper-globals": "^7.28.0",
-        "@babel/parser": "^7.28.4",
-        "@babel/template": "^7.27.2",
-        "@babel/types": "^7.28.4",
-        "debug": "^4.3.1"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/types": {
-      "version": "7.28.4",
-      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.28.4.tgz",
-      "integrity": "sha512-bkFqkLhh3pMBUQQkpVgWDWq/lqzc2678eUyDlTBhRqhCHFguYYGM0Efga7tYk4TogG/3x0EEl66/OQ+WGbWB/Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/helper-string-parser": "^7.27.1",
-        "@babel/helper-validator-identifier": "^7.27.1"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@esbuild/aix-ppc64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz",
-      "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==",
-      "cpu": [
-        "ppc64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "aix"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/android-arm": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz",
-      "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/android-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz",
-      "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/android-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz",
-      "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/darwin-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz",
-      "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/darwin-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz",
-      "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/freebsd-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz",
-      "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/freebsd-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz",
-      "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/linux-arm": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz",
-      "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/linux-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz",
-      "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/linux-ia32": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz",
-      "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/linux-loong64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz",
-      "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==",
-      "cpu": [
-        "loong64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/linux-mips64el": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz",
-      "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==",
-      "cpu": [
-        "mips64el"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/linux-ppc64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz",
-      "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==",
-      "cpu": [
-        "ppc64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/linux-riscv64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz",
-      "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==",
-      "cpu": [
-        "riscv64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/linux-s390x": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz",
-      "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==",
-      "cpu": [
-        "s390x"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/linux-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz",
-      "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/netbsd-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz",
-      "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "netbsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/openbsd-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz",
-      "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openbsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/sunos-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz",
-      "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "sunos"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/win32-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz",
-      "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/win32-ia32": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz",
-      "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@esbuild/win32-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz",
-      "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@jridgewell/gen-mapping": {
-      "version": "0.3.13",
-      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
-      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jridgewell/sourcemap-codec": "^1.5.0",
-        "@jridgewell/trace-mapping": "^0.3.24"
-      }
-    },
-    "node_modules/@jridgewell/remapping": {
-      "version": "2.3.5",
-      "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz",
-      "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jridgewell/gen-mapping": "^0.3.5",
-        "@jridgewell/trace-mapping": "^0.3.24"
-      }
-    },
-    "node_modules/@jridgewell/resolve-uri": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
-      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.0.0"
-      }
-    },
-    "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==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@jridgewell/trace-mapping": {
-      "version": "0.3.31",
-      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
-      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jridgewell/resolve-uri": "^3.1.0",
-        "@jridgewell/sourcemap-codec": "^1.4.14"
-      }
-    },
-    "node_modules/@remix-run/router": {
-      "version": "1.23.0",
-      "resolved": "https://registry.npmjs.org/@remix-run/router/-/router-1.23.0.tgz",
-      "integrity": "sha512-O3rHJzAQKamUz1fvE0Qaw0xSFqsA/yafi2iqeE0pvdFtCO1viYx8QL6f3Ln/aCCTLxs68SLf0KPM9eSeM8yBnA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=14.0.0"
-      }
-    },
-    "node_modules/@rolldown/pluginutils": {
-      "version": "1.0.0-beta.27",
-      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.27.tgz",
-      "integrity": "sha512-+d0F4MKMCbeVUJwG96uQ4SgAznZNSq93I3V+9NHA4OpvqG8mRCpGdKmK8l/dl02h2CCDHwW2FqilnTyDcAnqjA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@rollup/rollup-android-arm-eabi": {
-      "version": "4.52.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.52.4.tgz",
-      "integrity": "sha512-BTm2qKNnWIQ5auf4deoetINJm2JzvihvGb9R6K/ETwKLql/Bb3Eg2H1FBp1gUb4YGbydMA3jcmQTR73q7J+GAA==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ]
-    },
-    "node_modules/@rollup/rollup-android-arm64": {
-      "version": "4.52.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.52.4.tgz",
-      "integrity": "sha512-P9LDQiC5vpgGFgz7GSM6dKPCiqR3XYN1WwJKA4/BUVDjHpYsf3iBEmVz62uyq20NGYbiGPR5cNHI7T1HqxNs2w==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ]
-    },
-    "node_modules/@rollup/rollup-darwin-arm64": {
-      "version": "4.52.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.52.4.tgz",
-      "integrity": "sha512-QRWSW+bVccAvZF6cbNZBJwAehmvG9NwfWHwMy4GbWi/BQIA/laTIktebT2ipVjNncqE6GLPxOok5hsECgAxGZg==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ]
-    },
-    "node_modules/@rollup/rollup-darwin-x64": {
-      "version": "4.52.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.52.4.tgz",
-      "integrity": "sha512-hZgP05pResAkRJxL1b+7yxCnXPGsXU0fG9Yfd6dUaoGk+FhdPKCJ5L1Sumyxn8kvw8Qi5PvQ8ulenUbRjzeCTw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ]
-    },
-    "node_modules/@rollup/rollup-freebsd-arm64": {
-      "version": "4.52.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.52.4.tgz",
-      "integrity": "sha512-xmc30VshuBNUd58Xk4TKAEcRZHaXlV+tCxIXELiE9sQuK3kG8ZFgSPi57UBJt8/ogfhAF5Oz4ZSUBN77weM+mQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ]
-    },
-    "node_modules/@rollup/rollup-freebsd-x64": {
-      "version": "4.52.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.52.4.tgz",
-      "integrity": "sha512-WdSLpZFjOEqNZGmHflxyifolwAiZmDQzuOzIq9L27ButpCVpD7KzTRtEG1I0wMPFyiyUdOO+4t8GvrnBLQSwpw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
-      "version": "4.52.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.52.4.tgz",
-      "integrity": "sha512-xRiOu9Of1FZ4SxVbB0iEDXc4ddIcjCv2aj03dmW8UrZIW7aIQ9jVJdLBIhxBI+MaTnGAKyvMwPwQnoOEvP7FgQ==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
-      "version": "4.52.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.52.4.tgz",
-      "integrity": "sha512-FbhM2p9TJAmEIEhIgzR4soUcsW49e9veAQCziwbR+XWB2zqJ12b4i/+hel9yLiD8pLncDH4fKIPIbt5238341Q==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-arm64-gnu": {
-      "version": "4.52.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.52.4.tgz",
-      "integrity": "sha512-4n4gVwhPHR9q/g8lKCyz0yuaD0MvDf7dV4f9tHt0C73Mp8h38UCtSCSE6R9iBlTbXlmA8CjpsZoujhszefqueg==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-arm64-musl": {
-      "version": "4.52.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.52.4.tgz",
-      "integrity": "sha512-u0n17nGA0nvi/11gcZKsjkLj1QIpAuPFQbR48Subo7SmZJnGxDpspyw2kbpuoQnyK+9pwf3pAoEXerJs/8Mi9g==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-loong64-gnu": {
-      "version": "4.52.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.52.4.tgz",
-      "integrity": "sha512-0G2c2lpYtbTuXo8KEJkDkClE/+/2AFPdPAbmaHoE870foRFs4pBrDehilMcrSScrN/fB/1HTaWO4bqw+ewBzMQ==",
-      "cpu": [
-        "loong64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
-      "version": "4.52.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.52.4.tgz",
-      "integrity": "sha512-teSACug1GyZHmPDv14VNbvZFX779UqWTsd7KtTM9JIZRDI5NUwYSIS30kzI8m06gOPB//jtpqlhmraQ68b5X2g==",
-      "cpu": [
-        "ppc64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
-      "version": "4.52.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.52.4.tgz",
-      "integrity": "sha512-/MOEW3aHjjs1p4Pw1Xk4+3egRevx8Ji9N6HUIA1Ifh8Q+cg9dremvFCUbOX2Zebz80BwJIgCBUemjqhU5XI5Eg==",
-      "cpu": [
-        "riscv64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-riscv64-musl": {
-      "version": "4.52.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.52.4.tgz",
-      "integrity": "sha512-1HHmsRyh845QDpEWzOFtMCph5Ts+9+yllCrREuBR/vg2RogAQGGBRC8lDPrPOMnrdOJ+mt1WLMOC2Kao/UwcvA==",
-      "cpu": [
-        "riscv64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-s390x-gnu": {
-      "version": "4.52.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.52.4.tgz",
-      "integrity": "sha512-seoeZp4L/6D1MUyjWkOMRU6/iLmCU2EjbMTyAG4oIOs1/I82Y5lTeaxW0KBfkUdHAWN7j25bpkt0rjnOgAcQcA==",
-      "cpu": [
-        "s390x"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-x64-gnu": {
-      "version": "4.52.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.52.4.tgz",
-      "integrity": "sha512-Wi6AXf0k0L7E2gteNsNHUs7UMwCIhsCTs6+tqQ5GPwVRWMaflqGec4Sd8n6+FNFDw9vGcReqk2KzBDhCa1DLYg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-x64-musl": {
-      "version": "4.52.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.52.4.tgz",
-      "integrity": "sha512-dtBZYjDmCQ9hW+WgEkaffvRRCKm767wWhxsFW3Lw86VXz/uJRuD438/XvbZT//B96Vs8oTA8Q4A0AfHbrxP9zw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-openharmony-arm64": {
-      "version": "4.52.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.52.4.tgz",
-      "integrity": "sha512-1ox+GqgRWqaB1RnyZXL8PD6E5f7YyRUJYnCqKpNzxzP0TkaUh112NDrR9Tt+C8rJ4x5G9Mk8PQR3o7Ku2RKqKA==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openharmony"
-      ]
-    },
-    "node_modules/@rollup/rollup-win32-arm64-msvc": {
-      "version": "4.52.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.52.4.tgz",
-      "integrity": "sha512-8GKr640PdFNXwzIE0IrkMWUNUomILLkfeHjXBi/nUvFlpZP+FA8BKGKpacjW6OUUHaNI6sUURxR2U2g78FOHWQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ]
-    },
-    "node_modules/@rollup/rollup-win32-ia32-msvc": {
-      "version": "4.52.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.52.4.tgz",
-      "integrity": "sha512-AIy/jdJ7WtJ/F6EcfOb2GjR9UweO0n43jNObQMb6oGxkYTfLcnN7vYYpG+CN3lLxrQkzWnMOoNSHTW54pgbVxw==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ]
-    },
-    "node_modules/@rollup/rollup-win32-x64-gnu": {
-      "version": "4.52.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.52.4.tgz",
-      "integrity": "sha512-UF9KfsH9yEam0UjTwAgdK0anlQ7c8/pWPU2yVjyWcF1I1thABt6WXE47cI71pGiZ8wGvxohBoLnxM04L/wj8mQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ]
-    },
-    "node_modules/@rollup/rollup-win32-x64-msvc": {
-      "version": "4.52.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.52.4.tgz",
-      "integrity": "sha512-bf9PtUa0u8IXDVxzRToFQKsNCRz9qLYfR/MpECxl4mRoWYjAeFjgxj1XdZr2M/GNVpT05p+LgQOHopYDlUu6/w==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ]
-    },
-    "node_modules/@tanstack/query-core": {
-      "version": "5.90.3",
-      "resolved": "https://registry.npmjs.org/@tanstack/query-core/-/query-core-5.90.3.tgz",
-      "integrity": "sha512-HtPOnCwmx4dd35PfXU8jjkhwYrsHfuqgC8RCJIwWglmhIUIlzPP0ZcEkDAc+UtAWCiLm7T8rxeEfHZlz3hYMCA==",
-      "license": "MIT",
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/tannerlinsley"
-      }
-    },
-    "node_modules/@tanstack/react-query": {
-      "version": "5.90.3",
-      "resolved": "https://registry.npmjs.org/@tanstack/react-query/-/react-query-5.90.3.tgz",
-      "integrity": "sha512-i/LRL6DtuhG6bjGzavIMIVuKKPWx2AnEBIsBfuMm3YoHne0a20nWmsatOCBcVSaT0/8/5YFjNkebHAPLVUSi0Q==",
-      "license": "MIT",
-      "dependencies": {
-        "@tanstack/query-core": "5.90.3"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/tannerlinsley"
-      },
-      "peerDependencies": {
-        "react": "^18 || ^19"
-      }
-    },
-    "node_modules/@types/babel__core": {
-      "version": "7.20.5",
-      "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz",
-      "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/parser": "^7.20.7",
-        "@babel/types": "^7.20.7",
-        "@types/babel__generator": "*",
-        "@types/babel__template": "*",
-        "@types/babel__traverse": "*"
-      }
-    },
-    "node_modules/@types/babel__generator": {
-      "version": "7.27.0",
-      "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz",
-      "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/types": "^7.0.0"
-      }
-    },
-    "node_modules/@types/babel__template": {
-      "version": "7.4.4",
-      "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz",
-      "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/parser": "^7.1.0",
-        "@babel/types": "^7.0.0"
-      }
-    },
-    "node_modules/@types/babel__traverse": {
-      "version": "7.28.0",
-      "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz",
-      "integrity": "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/types": "^7.28.2"
-      }
-    },
-    "node_modules/@types/estree": {
-      "version": "1.0.8",
-      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
-      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/prop-types": {
-      "version": "15.7.15",
-      "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.15.tgz",
-      "integrity": "sha512-F6bEyamV9jKGAFBEmlQnesRPGOQqS2+Uwi0Em15xenOxHaf2hv6L8YCVn3rPdPJOiJfPiCnLIRyvwVaqMY3MIw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/react": {
-      "version": "18.3.26",
-      "resolved": "https://registry.npmjs.org/@types/react/-/react-18.3.26.tgz",
-      "integrity": "sha512-RFA/bURkcKzx/X9oumPG9Vp3D3JUgus/d0b67KB0t5S/raciymilkOa66olh78MUI92QLbEJevO7rvqU/kjwKA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/prop-types": "*",
-        "csstype": "^3.0.2"
-      }
-    },
-    "node_modules/@types/react-dom": {
-      "version": "18.3.7",
-      "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-18.3.7.tgz",
-      "integrity": "sha512-MEe3UeoENYVFXzoXEWsvcpg6ZvlrFNlOQ7EOsvhI3CfAXwzPfO8Qwuxd40nepsYKqyyVQnTdEfv68q91yLcKrQ==",
-      "dev": true,
-      "license": "MIT",
-      "peerDependencies": {
-        "@types/react": "^18.0.0"
-      }
-    },
-    "node_modules/@vitejs/plugin-react": {
-      "version": "4.7.0",
-      "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-4.7.0.tgz",
-      "integrity": "sha512-gUu9hwfWvvEDBBmgtAowQCojwZmJ5mcLn3aufeCsitijs3+f2NsrPtlAWIR6OPiqljl96GVCUbLe0HyqIpVaoA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/core": "^7.28.0",
-        "@babel/plugin-transform-react-jsx-self": "^7.27.1",
-        "@babel/plugin-transform-react-jsx-source": "^7.27.1",
-        "@rolldown/pluginutils": "1.0.0-beta.27",
-        "@types/babel__core": "^7.20.5",
-        "react-refresh": "^0.17.0"
-      },
-      "engines": {
-        "node": "^14.18.0 || >=16.0.0"
-      },
-      "peerDependencies": {
-        "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0"
-      }
-    },
-    "node_modules/asynckit": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
-      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
-      "license": "MIT"
-    },
-    "node_modules/axios": {
-      "version": "1.12.2",
-      "resolved": "https://registry.npmjs.org/axios/-/axios-1.12.2.tgz",
-      "integrity": "sha512-vMJzPewAlRyOgxV2dU0Cuz2O8zzzx9VYtbJOaBgXFeLc4IV/Eg50n4LowmehOOR61S8ZMpc2K5Sa7g6A4jfkUw==",
-      "license": "MIT",
-      "dependencies": {
-        "follow-redirects": "^1.15.6",
-        "form-data": "^4.0.4",
-        "proxy-from-env": "^1.1.0"
-      }
-    },
-    "node_modules/baseline-browser-mapping": {
-      "version": "2.8.16",
-      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.8.16.tgz",
-      "integrity": "sha512-OMu3BGQ4E7P1ErFsIPpbJh0qvDudM/UuJeHgkAvfWe+0HFJCXh+t/l8L6fVLR55RI/UbKrVLnAXZSVwd9ysWYw==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "bin": {
-        "baseline-browser-mapping": "dist/cli.js"
-      }
-    },
-    "node_modules/browserslist": {
-      "version": "4.26.3",
-      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.26.3.tgz",
-      "integrity": "sha512-lAUU+02RFBuCKQPj/P6NgjlbCnLBMp4UtgTx7vNHd3XSIJF87s9a5rA3aH2yw3GS9DqZAUbOtZdCCiZeVRqt0w==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/browserslist"
-        },
-        {
-          "type": "tidelift",
-          "url": "https://tidelift.com/funding/github/npm/browserslist"
-        },
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/ai"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "baseline-browser-mapping": "^2.8.9",
-        "caniuse-lite": "^1.0.30001746",
-        "electron-to-chromium": "^1.5.227",
-        "node-releases": "^2.0.21",
-        "update-browserslist-db": "^1.1.3"
-      },
-      "bin": {
-        "browserslist": "cli.js"
-      },
-      "engines": {
-        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
-      }
-    },
-    "node_modules/call-bind-apply-helpers": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
-      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "function-bind": "^1.1.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/caniuse-lite": {
-      "version": "1.0.30001750",
-      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001750.tgz",
-      "integrity": "sha512-cuom0g5sdX6rw00qOoLNSFCJ9/mYIsuSOA+yzpDw8eopiFqcVwQvZHqov0vmEighRxX++cfC0Vg1G+1Iy/mSpQ==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/browserslist"
-        },
-        {
-          "type": "tidelift",
-          "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
-        },
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/ai"
-        }
-      ],
-      "license": "CC-BY-4.0"
-    },
-    "node_modules/combined-stream": {
-      "version": "1.0.8",
-      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
-      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
-      "license": "MIT",
-      "dependencies": {
-        "delayed-stream": "~1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/convert-source-map": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
-      "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/csstype": {
-      "version": "3.1.3",
-      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz",
-      "integrity": "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/debug": {
-      "version": "4.4.3",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
-      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/delayed-stream": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
-      "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.4.0"
-      }
-    },
-    "node_modules/dunder-proto": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
-      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
-      "license": "MIT",
-      "dependencies": {
-        "call-bind-apply-helpers": "^1.0.1",
-        "es-errors": "^1.3.0",
-        "gopd": "^1.2.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/electron-to-chromium": {
-      "version": "1.5.237",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.237.tgz",
-      "integrity": "sha512-icUt1NvfhGLar5lSWH3tHNzablaA5js3HVHacQimfP8ViEBOQv+L7DKEuHdbTZ0SKCO1ogTJTIL1Gwk9S6Qvcg==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/es-define-property": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
-      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/es-errors": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
-      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/es-object-atoms": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
-      "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/es-set-tostringtag": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
-      "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "get-intrinsic": "^1.2.6",
-        "has-tostringtag": "^1.0.2",
-        "hasown": "^2.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/esbuild": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz",
-      "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",
-      "dev": true,
-      "hasInstallScript": true,
-      "license": "MIT",
-      "bin": {
-        "esbuild": "bin/esbuild"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "optionalDependencies": {
-        "@esbuild/aix-ppc64": "0.21.5",
-        "@esbuild/android-arm": "0.21.5",
-        "@esbuild/android-arm64": "0.21.5",
-        "@esbuild/android-x64": "0.21.5",
-        "@esbuild/darwin-arm64": "0.21.5",
-        "@esbuild/darwin-x64": "0.21.5",
-        "@esbuild/freebsd-arm64": "0.21.5",
-        "@esbuild/freebsd-x64": "0.21.5",
-        "@esbuild/linux-arm": "0.21.5",
-        "@esbuild/linux-arm64": "0.21.5",
-        "@esbuild/linux-ia32": "0.21.5",
-        "@esbuild/linux-loong64": "0.21.5",
-        "@esbuild/linux-mips64el": "0.21.5",
-        "@esbuild/linux-ppc64": "0.21.5",
-        "@esbuild/linux-riscv64": "0.21.5",
-        "@esbuild/linux-s390x": "0.21.5",
-        "@esbuild/linux-x64": "0.21.5",
-        "@esbuild/netbsd-x64": "0.21.5",
-        "@esbuild/openbsd-x64": "0.21.5",
-        "@esbuild/sunos-x64": "0.21.5",
-        "@esbuild/win32-arm64": "0.21.5",
-        "@esbuild/win32-ia32": "0.21.5",
-        "@esbuild/win32-x64": "0.21.5"
-      }
-    },
-    "node_modules/escalade": {
-      "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
-      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/follow-redirects": {
-      "version": "1.15.11",
-      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.11.tgz",
-      "integrity": "sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ==",
-      "funding": [
-        {
-          "type": "individual",
-          "url": "https://github.com/sponsors/RubenVerborgh"
-        }
-      ],
-      "license": "MIT",
-      "engines": {
-        "node": ">=4.0"
-      },
-      "peerDependenciesMeta": {
-        "debug": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/form-data": {
-      "version": "4.0.4",
-      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.4.tgz",
-      "integrity": "sha512-KrGhL9Q4zjj0kiUt5OO4Mr/A/jlI2jDYs5eHBpYHPcBEVSiipAvn2Ko2HnPe20rmcuuvMHNdZFp+4IlGTMF0Ow==",
-      "license": "MIT",
-      "dependencies": {
-        "asynckit": "^0.4.0",
-        "combined-stream": "^1.0.8",
-        "es-set-tostringtag": "^2.1.0",
-        "hasown": "^2.0.2",
-        "mime-types": "^2.1.12"
-      },
-      "engines": {
-        "node": ">= 6"
-      }
-    },
-    "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/function-bind": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
-      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/gensync": {
-      "version": "1.0.0-beta.2",
-      "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
-      "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/get-intrinsic": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
-      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
-      "license": "MIT",
-      "dependencies": {
-        "call-bind-apply-helpers": "^1.0.2",
-        "es-define-property": "^1.0.1",
-        "es-errors": "^1.3.0",
-        "es-object-atoms": "^1.1.1",
-        "function-bind": "^1.1.2",
-        "get-proto": "^1.0.1",
-        "gopd": "^1.2.0",
-        "has-symbols": "^1.1.0",
-        "hasown": "^2.0.2",
-        "math-intrinsics": "^1.1.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/get-proto": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
-      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
-      "license": "MIT",
-      "dependencies": {
-        "dunder-proto": "^1.0.1",
-        "es-object-atoms": "^1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/gopd": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
-      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/has-symbols": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
-      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/has-tostringtag": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
-      "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
-      "license": "MIT",
-      "dependencies": {
-        "has-symbols": "^1.0.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/hasown": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
-      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
-      "license": "MIT",
-      "dependencies": {
-        "function-bind": "^1.1.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/js-tokens": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
-      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
-      "license": "MIT"
-    },
-    "node_modules/jsesc": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
-      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "jsesc": "bin/jsesc"
-      },
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/json5": {
-      "version": "2.2.3",
-      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
-      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "json5": "lib/cli.js"
-      },
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/loose-envify": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
-      "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
-      "license": "MIT",
-      "dependencies": {
-        "js-tokens": "^3.0.0 || ^4.0.0"
-      },
-      "bin": {
-        "loose-envify": "cli.js"
-      }
-    },
-    "node_modules/lru-cache": {
-      "version": "5.1.1",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
-      "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "yallist": "^3.0.2"
-      }
-    },
-    "node_modules/math-intrinsics": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
-      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/mime-db": {
-      "version": "1.52.0",
-      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
-      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/mime-types": {
-      "version": "2.1.35",
-      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
-      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
-      "license": "MIT",
-      "dependencies": {
-        "mime-db": "1.52.0"
-      },
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/nanoid": {
-      "version": "3.3.11",
-      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
-      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
-      "dev": true,
-      "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/node-releases": {
-      "version": "2.0.23",
-      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.23.tgz",
-      "integrity": "sha512-cCmFDMSm26S6tQSDpBCg/NR8NENrVPhAJSf+XbxBG4rPFaaonlEoE9wHQmun+cls499TQGSb7ZyPBRlzgKfpeg==",
-      "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==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/postcss": {
-      "version": "8.5.6",
-      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz",
-      "integrity": "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==",
-      "dev": true,
-      "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.11",
-        "picocolors": "^1.1.1",
-        "source-map-js": "^1.2.1"
-      },
-      "engines": {
-        "node": "^10 || ^12 || >=14"
-      }
-    },
-    "node_modules/proxy-from-env": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
-      "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==",
-      "license": "MIT"
-    },
-    "node_modules/react": {
-      "version": "18.3.1",
-      "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz",
-      "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==",
-      "license": "MIT",
-      "dependencies": {
-        "loose-envify": "^1.1.0"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/react-dom": {
-      "version": "18.3.1",
-      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz",
-      "integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==",
-      "license": "MIT",
-      "dependencies": {
-        "loose-envify": "^1.1.0",
-        "scheduler": "^0.23.2"
-      },
-      "peerDependencies": {
-        "react": "^18.3.1"
-      }
-    },
-    "node_modules/react-refresh": {
-      "version": "0.17.0",
-      "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.17.0.tgz",
-      "integrity": "sha512-z6F7K9bV85EfseRCp2bzrpyQ0Gkw1uLoCel9XBVWPg/TjRj94SkJzUTGfOa4bs7iJvBWtQG0Wq7wnI0syw3EBQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/react-router": {
-      "version": "6.30.1",
-      "resolved": "https://registry.npmjs.org/react-router/-/react-router-6.30.1.tgz",
-      "integrity": "sha512-X1m21aEmxGXqENEPG3T6u0Th7g0aS4ZmoNynhbs+Cn+q+QGTLt+d5IQ2bHAXKzKcxGJjxACpVbnYQSCRcfxHlQ==",
-      "license": "MIT",
-      "dependencies": {
-        "@remix-run/router": "1.23.0"
-      },
-      "engines": {
-        "node": ">=14.0.0"
-      },
-      "peerDependencies": {
-        "react": ">=16.8"
-      }
-    },
-    "node_modules/react-router-dom": {
-      "version": "6.30.1",
-      "resolved": "https://registry.npmjs.org/react-router-dom/-/react-router-dom-6.30.1.tgz",
-      "integrity": "sha512-llKsgOkZdbPU1Eg3zK8lCn+sjD9wMRZZPuzmdWWX5SUs8OFkN5HnFVC0u5KMeMaC9aoancFI/KoLuKPqN+hxHw==",
-      "license": "MIT",
-      "dependencies": {
-        "@remix-run/router": "1.23.0",
-        "react-router": "6.30.1"
-      },
-      "engines": {
-        "node": ">=14.0.0"
-      },
-      "peerDependencies": {
-        "react": ">=16.8",
-        "react-dom": ">=16.8"
-      }
-    },
-    "node_modules/rollup": {
-      "version": "4.52.4",
-      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.52.4.tgz",
-      "integrity": "sha512-CLEVl+MnPAiKh5pl4dEWSyMTpuflgNQiLGhMv8ezD5W/qP8AKvmYpCOKRRNOh7oRKnauBZ4SyeYkMS+1VSyKwQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/estree": "1.0.8"
-      },
-      "bin": {
-        "rollup": "dist/bin/rollup"
-      },
-      "engines": {
-        "node": ">=18.0.0",
-        "npm": ">=8.0.0"
-      },
-      "optionalDependencies": {
-        "@rollup/rollup-android-arm-eabi": "4.52.4",
-        "@rollup/rollup-android-arm64": "4.52.4",
-        "@rollup/rollup-darwin-arm64": "4.52.4",
-        "@rollup/rollup-darwin-x64": "4.52.4",
-        "@rollup/rollup-freebsd-arm64": "4.52.4",
-        "@rollup/rollup-freebsd-x64": "4.52.4",
-        "@rollup/rollup-linux-arm-gnueabihf": "4.52.4",
-        "@rollup/rollup-linux-arm-musleabihf": "4.52.4",
-        "@rollup/rollup-linux-arm64-gnu": "4.52.4",
-        "@rollup/rollup-linux-arm64-musl": "4.52.4",
-        "@rollup/rollup-linux-loong64-gnu": "4.52.4",
-        "@rollup/rollup-linux-ppc64-gnu": "4.52.4",
-        "@rollup/rollup-linux-riscv64-gnu": "4.52.4",
-        "@rollup/rollup-linux-riscv64-musl": "4.52.4",
-        "@rollup/rollup-linux-s390x-gnu": "4.52.4",
-        "@rollup/rollup-linux-x64-gnu": "4.52.4",
-        "@rollup/rollup-linux-x64-musl": "4.52.4",
-        "@rollup/rollup-openharmony-arm64": "4.52.4",
-        "@rollup/rollup-win32-arm64-msvc": "4.52.4",
-        "@rollup/rollup-win32-ia32-msvc": "4.52.4",
-        "@rollup/rollup-win32-x64-gnu": "4.52.4",
-        "@rollup/rollup-win32-x64-msvc": "4.52.4",
-        "fsevents": "~2.3.2"
-      }
-    },
-    "node_modules/scheduler": {
-      "version": "0.23.2",
-      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz",
-      "integrity": "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==",
-      "license": "MIT",
-      "dependencies": {
-        "loose-envify": "^1.1.0"
-      }
-    },
-    "node_modules/semver": {
-      "version": "6.3.1",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
-      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
-      "dev": true,
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver.js"
-      }
-    },
-    "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==",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/typescript": {
-      "version": "5.9.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
-      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "bin": {
-        "tsc": "bin/tsc",
-        "tsserver": "bin/tsserver"
-      },
-      "engines": {
-        "node": ">=14.17"
-      }
-    },
-    "node_modules/update-browserslist-db": {
-      "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.3.tgz",
-      "integrity": "sha512-UxhIZQ+QInVdunkDAaiazvvT/+fXL5Osr0JZlJulepYu6Jd7qJtDZjlur0emRlT71EN3ScPoE7gvsuIKKNavKw==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/browserslist"
-        },
-        {
-          "type": "tidelift",
-          "url": "https://tidelift.com/funding/github/npm/browserslist"
-        },
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/ai"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "escalade": "^3.2.0",
-        "picocolors": "^1.1.1"
-      },
-      "bin": {
-        "update-browserslist-db": "cli.js"
-      },
-      "peerDependencies": {
-        "browserslist": ">= 4.21.0"
-      }
-    },
-    "node_modules/vite": {
-      "version": "5.4.20",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.20.tgz",
-      "integrity": "sha512-j3lYzGC3P+B5Yfy/pfKNgVEg4+UtcIJcVRt2cDjIOmhLourAqPqf8P7acgxeiSgUB7E3p2P8/3gNIgDLpwzs4g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "esbuild": "^0.21.3",
-        "postcss": "^8.4.43",
-        "rollup": "^4.20.0"
-      },
-      "bin": {
-        "vite": "bin/vite.js"
-      },
-      "engines": {
-        "node": "^18.0.0 || >=20.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",
-        "less": "*",
-        "lightningcss": "^1.21.0",
-        "sass": "*",
-        "sass-embedded": "*",
-        "stylus": "*",
-        "sugarss": "*",
-        "terser": "^5.4.0"
-      },
-      "peerDependenciesMeta": {
-        "@types/node": {
-          "optional": true
-        },
-        "less": {
-          "optional": true
-        },
-        "lightningcss": {
-          "optional": true
-        },
-        "sass": {
-          "optional": true
-        },
-        "sass-embedded": {
-          "optional": true
-        },
-        "stylus": {
-          "optional": true
-        },
-        "sugarss": {
-          "optional": true
-        },
-        "terser": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/yallist": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
-      "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==",
-      "dev": true,
-      "license": "ISC"
-    }
-  }
-}

frontend/package.json

@@ -9,11 +9,8 @@
     "preview": "vite preview"
   },
   "dependencies": {
-    "@tanstack/react-query": "^5.51.11",
-    "axios": "^1.7.7",
     "react": "^18.3.1",
-    "react-dom": "^18.3.1",
-    "react-router-dom": "^6.26.0"
+    "react-dom": "^18.3.1"
   },
   "devDependencies": {
     "@types/react": "^18.3.3",

frontend/public/index.html

@@ -1,13 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>RightCodes</title>
-  </head>
-  <body>
-    <div id="root"></div>
-    <script type="module" src="/src/main.tsx"></script>
-  </body>
-</html>

frontend/src/App.tsx

@@ -1,34 +1,3 @@
-import { BrowserRouter, NavLink, Route, Routes } from "react-router-dom";
-import SessionsPage from "./pages/SessionsPage";
-import PresetsPage from "./pages/PresetsPage";
-import PresetEditPage from "./pages/PresetEditPage";
-import ObservatoryPage from "./pages/ObservatoryPage";
-
 export default function App() {
-  return (
-    <BrowserRouter>
-      <div className="app-shell">
-        <header>
-          <h1>RightCodes Converter</h1>
-          <p>Upload reports, review AI-assisted updates, and export revised documents.</p>
-          <nav className="primary-nav">
-            <NavLink to="/" end>
-              Sessions
-            </NavLink>
-            <NavLink to="/presets">Presets</NavLink>
-            <NavLink to="/observatory">Observatory</NavLink>
-          </nav>
-        </header>
-        <main>
-          <Routes>
-            <Route path="/" element={<SessionsPage />} />
-            <Route path="/presets" element={<PresetsPage />} />
-            <Route path="/presets/:presetId/edit" element={<PresetEditPage />} />
-            <Route path="/observatory" element={<ObservatoryPage />} />
-          </Routes>
-        </main>
-        <footer>RightCodes {new Date().getFullYear()}</footer>
-      </div>
-    </BrowserRouter>
-  );
+  return <div className="black-screen" />;
 }

frontend/src/components/PresetManager.tsx

@@ -1,193 +0,0 @@
-import { useState } from "react";
-import { Link } from "react-router-dom";
-import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
-import { createPreset, deletePreset, fetchPresets } from "../services/api";
-import type { StandardsPreset } from "../types/session";
-
-export default function PresetManager() {
-  const queryClient = useQueryClient();
-  const { data: presets = [], isLoading, isError, error } = useQuery({
-    queryKey: ["presets"],
-    queryFn: fetchPresets,
-    refetchInterval: (currentPresets) =>
-      Array.isArray(currentPresets) &&
-      currentPresets.some((preset) => preset.status === "processing")
-        ? 2000
-        : false,
-  });
-
-  const [name, setName] = useState("");
-  const [description, setDescription] = useState("");
-  const [files, setFiles] = useState<File[]>([]);
-
-  const createPresetMutation = useMutation({
-    mutationFn: createPreset,
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["presets"] });
-      resetForm();
-    },
-    onError: (err: unknown) => {
-      alert(`Preset creation failed: ${(err as Error).message}`);
-    },
-  });
-
-  const deletePresetMutation = useMutation({
-    mutationFn: (id: string) => deletePreset(id),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["presets"] });
-    },
-    onError: (err: unknown) => {
-      alert(`Preset deletion failed: ${(err as Error).message}`);
-    },
-  });
-
-  const resetForm = () => {
-    setName("");
-    setDescription("");
-    setFiles([]);
-    const fileInput = document.getElementById("preset-standards-input") as HTMLInputElement | null;
-    if (fileInput) {
-      fileInput.value = "";
-    }
-  };
-
-  const handleSubmit = (event: React.FormEvent<HTMLFormElement>) => {
-    event.preventDefault();
-    if (!files.length) {
-      alert("Select at least one PDF to build a preset.");
-      return;
-    }
-    createPresetMutation.mutate({
-      name,
-      description: description || undefined,
-      files,
-    });
-  };
-
-  const handleDelete = (preset: StandardsPreset) => {
-    if (!window.confirm(`Delete preset "${preset.name}"? This cannot be undone.`)) {
-      return;
-    }
-    deletePresetMutation.mutate(preset.id);
-  };
-
-  return (
-    <section className="card">
-      <h2>Manage Standards Presets</h2>
-      <p className="muted">
-        Reuse commonly referenced standards without re-uploading them for every session.
-      </p>
-      <form className="stacked" onSubmit={handleSubmit}>
-        <label className="field">
-          <span>Preset Name</span>
-          <input value={name} onChange={(event) => setName(event.target.value)} required />
-        </label>
-        <label className="field">
-          <span>Description (optional)</span>
-          <input value={description} onChange={(event) => setDescription(event.target.value)} />
-        </label>
-        <label className="field">
-          <span>Preset Standards PDFs</span>
-          <input
-            id="preset-standards-input"
-            type="file"
-            accept=".pdf"
-            multiple
-            onChange={(event) => setFiles(Array.from(event.target.files ?? []))}
-          />
-          <small>
-            {files.length ? `${files.length} file(s) selected` : "Select one or more PDF references."}
-          </small>
-        </label>
-        <button type="submit" disabled={createPresetMutation.isPending}>
-          {createPresetMutation.isPending ? "Creating preset..." : "Save Preset"}
-        </button>
-        {createPresetMutation.isError && (
-          <p className="error">Preset creation failed: {(createPresetMutation.error as Error).message}</p>
-        )}
-        {createPresetMutation.isSuccess && (
-          <p className="success">
-            Preset queued for processing. Progress will appear below shortly.
-          </p>
-        )}
-      </form>
-
-      <div className="preset-list">
-        <h3>Saved Presets</h3>
-        {isLoading && <p className="muted">Loading presets...</p>}
-        {isError && <p className="error">Failed to load presets: {(error as Error).message}</p>}
-        {!isLoading && !presets.length && <p className="muted">No presets created yet.</p>}
-        {presets.length > 0 && (
-          <ul>
-            {presets.map((preset: StandardsPreset) => {
-              const totalDocs = preset.total_count || preset.document_count || 0;
-              const processed = Math.min(preset.processed_count || 0, totalDocs);
-              const progressPercent = totalDocs
-                ? Math.min(100, Math.round((processed / totalDocs) * 100))
-                : preset.status === "ready"
-                ? 100
-                : 0;
-              const nextDoc = Math.min(processed + 1, totalDocs);
-              return (
-                <li key={preset.id}>
-                  <div className="preset-header">
-                    <div>
-                      <strong>{preset.name}</strong>
-                      <p className="muted">
-                        {preset.document_count} file{preset.document_count === 1 ? "" : "s"} · Updated{" "}
-                        {new Date(preset.updated_at).toLocaleString()}
-                      </p>
-                      {preset.description && <p className="muted">{preset.description}</p>}
-                    </div>
-                    <div className="preset-status">
-                      {preset.status === "ready" && <span className="status-ready">Ready</span>}
-                      {preset.status === "processing" && (
-                        <span className="status-processing">
-                          Processing {processed}/{totalDocs}
-                        </span>
-                      )}
-                      {preset.status === "failed" && (
-                        <span className="status-failed">
-                          Failed{preset.last_error ? `: ${preset.last_error}` : ""}
-                        </span>
-                      )}
-                    </div>
-                  </div>
-                  {preset.status === "processing" && (
-                    <div className="progress-block">
-                      <div className="linear-progress">
-                        <div
-                          className="linear-progress-fill"
-                          style={{ width: `${progressPercent}%` }}
-                        />
-                      </div>
-                      <p className="muted">
-                        Currently processing document {nextDoc} of {totalDocs}.
-                      </p>
-                    </div>
-                  )}
-                  <div className="muted preset-docs">
-                    {preset.documents.map((doc) => doc.split(/[/\\]/).pop() ?? doc).join(", ")}
-                  </div>
-                  <div className="preset-actions">
-                    <Link className="ghost-button" to={`/presets/${preset.id}/edit`}>
-                      Edit
-                    </Link>
-                    <button
-                      type="button"
-                      className="ghost-button danger"
-                      onClick={() => handleDelete(preset)}
-                      disabled={deletePresetMutation.isPending || preset.status === "processing"}
-                    >
-                      Delete
-                    </button>
-                  </div>
-                </li>
-              );
-            })}
-          </ul>
-        )}
-      </div>
-    </section>
-  );
-}

frontend/src/components/SessionDetails.tsx

@@ -1,578 +0,0 @@
-import { useEffect, useState } from "react";
-import { useQuery } from "@tanstack/react-query";
-import { fetchSessionById } from "../services/api";
-import type { Session, SessionSummary } from "../types/session";
-
-interface DocParse {
-  path: string;
-  paragraphs: Array<{ index: number; text: string; style?: string | null; heading_level?: number | null; references?: string[] }>;
-  tables: Array<{ index: number; rows: string[][]; references?: string[] }>;
-  summary?: Record<string, unknown>;
-}
-
-interface StandardsParseEntry {
-  path: string;
-  summary?: Record<string, unknown>;
-  chunks?: Array<{
-    page_number: number;
-    chunk_index: number;
-    text: string;
-    heading?: string | null;
-    clause_numbers?: string[];
-    references?: string[];
-    is_ocr?: boolean;
-  }>;
-}
-
-interface ExtractionResult {
-  document_summary?: string;
-  sections?: Array<{ paragraph_index: number; text: string; references?: string[] }>;
-  tables?: Array<{ table_index: number; summary: string; references?: string[] }>;
-  references?: string[];
-  notes?: string;
-}
-
-interface MappingResult {
-  mappings?: Array<{
-    source_reference: string;
-    source_context?: string;
-    target_reference: string;
-    target_clause?: string;
-    target_summary?: string;
-    confidence?: number;
-    rationale?: string;
-  }>;
-  unmapped_references?: string[];
-  notes?: string;
-}
-
-interface RewritePlan {
-  replacements?: Array<{
-    paragraph_index: number;
-    original_text: string;
-    updated_text: string;
-    applied_mapping: string;
-    change_reason?: string;
-  }>;
-  notes?: string;
-}
-
-interface ValidationReport {
-  issues?: Array<{ description?: string; severity?: string }>;
-  verdict?: string;
-  notes?: string;
-}
-
-interface ExportManifest {
-  export_path?: string | null;
-  notes?: string;
-  replacement_count?: number;
-}
-
-interface SessionDetailsProps {
-  session: SessionSummary | null;
-}
-
-export default function SessionDetails({ session }: SessionDetailsProps) {
-  if (!session) {
-    return <div className="card">Select a session to inspect its progress.</div>;
-  }
-
-  const apiBaseUrl = import.meta.env.VITE_API_BASE_URL ?? "http://localhost:8000/api";
-  const partialSession = session as Partial<Session>;
-  const summaryStandards = Array.isArray(partialSession.standards_docs)
-    ? [...partialSession.standards_docs]
-    : [];
-  const summaryLogs = Array.isArray(partialSession.logs) ? [...partialSession.logs] : [];
-  const summaryMetadata =
-    partialSession.metadata && typeof partialSession.metadata === "object"
-      ? { ...(partialSession.metadata as Record<string, unknown>) }
-      : {};
-  const normalizedSummary: Session = {
-    ...session,
-    standards_docs: summaryStandards,
-    logs: summaryLogs,
-    metadata: summaryMetadata,
-  };
-  const sessionQuery = useQuery({
-    queryKey: ["session", session.id],
-    queryFn: () => fetchSessionById(session.id),
-    enabled: Boolean(session?.id),
-    refetchInterval: (data) =>
-      data && ["review", "completed", "failed"].includes(data.status) ? false : 2000,
-    placeholderData: () => normalizedSummary,
-  });
-
-  const latest = sessionQuery.data ?? normalizedSummary;
-  const standardsDocs = Array.isArray(latest.standards_docs) ? latest.standards_docs : [];
-  const standardNames = standardsDocs.map((path) => path.split(/[/\\]/).pop() ?? path);
-  const activityLogs = Array.isArray(latest.logs) ? latest.logs : [];
-  const inFlight = !["review", "completed", "failed"].includes(latest.status);
-
-  useEffect(() => {
-    if (sessionQuery.data) {
-      console.log(`[Session ${sessionQuery.data.id}] status: ${sessionQuery.data.status}`);
-    }
-  }, [sessionQuery.data?.id, sessionQuery.data?.status]);
-
-  const metadata = (latest.metadata ?? {}) as Record<string, unknown>;
-  const docParse = metadata.doc_parse as DocParse | undefined;
-  const standardsParse = metadata.standards_parse as StandardsParseEntry[] | undefined;
-  const extractionResult = metadata.extraction_result as ExtractionResult | undefined;
-  const mappingResult = metadata.mapping_result as MappingResult | undefined;
-  const rewritePlan = metadata.rewrite_plan as RewritePlan | undefined;
-  const validationReport = metadata.validation_report as ValidationReport | undefined;
-  const exportManifest = metadata.export_manifest as ExportManifest | undefined;
-  const exportDownloadUrl =
-    exportManifest?.export_path !== undefined
-      ? `${apiBaseUrl}/sessions/${latest.id}/export`
-      : null;
-
-  const docSummary = docParse?.summary as
-    | { paragraph_count?: number; table_count?: number; reference_count?: number }
-    | undefined;
-
-  const standardsProgress = metadata.standards_ingest_progress as
-    | {
-        total?: number;
-        processed?: number;
-        current_file?: string;
-        cached_count?: number;
-        parsed_count?: number;
-        completed?: boolean;
-      }
-    | undefined;
-  const standardsProgressFile =
-    standardsProgress?.current_file?.split(/[/\\]/).pop() ?? undefined;
-  const standardsProgressTotal =
-    typeof standardsProgress?.total === "number" ? standardsProgress.total : undefined;
-  const standardsProgressProcessed =
-    standardsProgressTotal !== undefined
-      ? Math.min(
-          typeof standardsProgress?.processed === "number" ? standardsProgress.processed : 0,
-          standardsProgressTotal
-        )
-      : undefined;
-  const standardsCachedCount =
-    typeof standardsProgress?.cached_count === "number" ? standardsProgress.cached_count : undefined;
-  const standardsParsedCount =
-    typeof standardsProgress?.parsed_count === "number" ? standardsProgress.parsed_count : undefined;
-  const pipelineProgress = metadata.pipeline_progress as
-    | {
-        total?: number;
-        current_index?: number;
-        stage?: string | null;
-        status?: string;
-      }
-    | undefined;
-  const pipelineStageLabel = pipelineProgress?.stage
-    ? pipelineProgress.stage
-        .split("_")
-        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-        .join(" ")
-    : undefined;
-  const pipelineStageStatus = pipelineProgress?.status
-    ? pipelineProgress.status.charAt(0).toUpperCase() + pipelineProgress.status.slice(1)
-    : undefined;
-  const presetMetadata = Array.isArray(metadata.presets)
-    ? (metadata.presets as Array<{ id?: string; name?: string | null; documents?: string[] }>)
-    : [];
-  const presetNames = presetMetadata
-    .map((item) => item?.name || item?.id || "")
-    .filter((value) => Boolean(value)) as string[];
-  const presetDocTotal = presetMetadata.reduce(
-    (acc, item) => acc + (Array.isArray(item?.documents) ? item.documents.length : 0),
-    0
-  );
-
-  const [showAllMappings, setShowAllMappings] = useState(false);
-  const [showAllReplacements, setShowAllReplacements] = useState(false);
-
-  const sections = extractionResult?.sections ?? [];
-  const sectionsPreview = sections.slice(0, 6);
-
-  const mappingLimit = 6;
-  const mappings = mappingResult?.mappings ?? [];
-  const mappingsToDisplay = showAllMappings ? mappings : mappings.slice(0, mappingLimit);
-
-  const replacementLimit = 6;
-  const replacements = rewritePlan?.replacements ?? [];
-  const replacementsToDisplay = showAllReplacements ? replacements : replacements.slice(0, replacementLimit);
-
-  const tableReplacements = rewritePlan?.table_replacements ?? [];
-  const changeLog = rewritePlan?.change_log ?? [];
-
-  return (
-    <div className="card">
-      <div className="card-header">
-        <h2>Session Overview</h2>
-        <div className="header-actions">
-          {sessionQuery.isFetching && <span className="muted text-small">Updating...</span>}
-          <button
-            type="button"
-            className="ghost-button"
-            onClick={() => sessionQuery.refetch()}
-            disabled={sessionQuery.isFetching}
-          >
-            {sessionQuery.isFetching ? "Refreshing..." : "Refresh now"}
-          </button>
-        </div>
-      </div>
-      {inFlight && (
-        <div className="progress-block">
-          <div className="progress-bar">
-            <div className="progress-bar-fill" />
-          </div>
-          <p className="muted">Processing pipeline... refreshing every 2s.</p>
-          {pipelineProgress?.total ? (
-            <p className="muted">
-              Pipeline stages:{" "}
-              {Math.min(pipelineProgress.current_index ?? 0, pipelineProgress.total)} /{" "}
-              {pipelineProgress.total}
-              {pipelineStageLabel ? ` — ${pipelineStageLabel}` : ""}
-              {pipelineStageStatus ? ` (${pipelineStageStatus})` : ""}
-            </p>
-          ) : null}
-          {standardsProgressTotal !== undefined ? (
-            <p className="muted">
-              Standards PDFs: {standardsProgressProcessed ?? 0} / {standardsProgressTotal}
-              {standardsProgressFile ? ` — ${standardsProgressFile}` : ""}
-              {standardsCachedCount !== undefined || standardsParsedCount !== undefined ? (
-                <>
-                  {" "}(cached {standardsCachedCount ?? 0}, parsed {standardsParsedCount ?? 0})
-                </>
-              ) : null}
-            </p>
-          ) : null}
-        </div>
-      )}
-      <dl className="details-grid">
-        <div>
-          <dt>Status</dt>
-          <dd>{latest.status}</dd>
-        </div>
-        <div>
-          <dt>Created</dt>
-          <dd>{new Date(latest.created_at).toLocaleString()}</dd>
-        </div>
-        <div>
-          <dt>Updated</dt>
-          <dd>{new Date(latest.updated_at).toLocaleString()}</dd>
-        </div>
-        <div>
-          <dt>Origin</dt>
-          <dd>{latest.target_standard}</dd>
-        </div>
-        <div>
-          <dt>Destination</dt>
-          <dd>{latest.destination_standard}</dd>
-        </div>
-        {standardNames.length > 0 && (
-          <div>
-            <dt>Standards PDFs</dt>
-            <dd>{standardNames.join(", ")}</dd>
-          </div>
-        )}
-        {presetNames.length ? (
-          <div>
-            <dt>Preset</dt>
-            <dd>
-              {presetNames.join(", ")}
-              {presetDocTotal ? ` (${presetDocTotal} file${presetDocTotal === 1 ? "" : "s"})` : ""}
-            </dd>
-          </div>
-        ) : null}
-      </dl>
-      {latest.status === "review" && (
-        <div className="notice success">
-          Pipeline completed. Review the AI change set and validation notes next.
-        </div>
-      )}
-      {latest.last_error && (
-        <p className="error">
-          <strong>Last error:</strong> {latest.last_error}
-        </p>
-      )}
-      <div className="log-panel">
-        <h3>Activity Log</h3>
-        {activityLogs.length ? (
-          <ul>
-            {activityLogs.map((entry, index) => (
-              <li key={`${entry}-${index}`}>{entry}</li>
-            ))}
-          </ul>
-        ) : (
-          <p className="muted">No activity recorded yet.</p>
-        )}
-      </div>
-
-      {docParse && (
-        <div className="section-card">
-          <h3>Document Parsing</h3>
-          <p className="muted">
-            Analysed {docSummary?.paragraph_count ?? docParse.paragraphs.length} paragraphs and{" "}
-            {docSummary?.table_count ?? docParse.tables.length} tables.
-          </p>
-          <ul className="section-list">
-            {docParse.paragraphs.slice(0, 5).map((paragraph) => (
-              <li key={paragraph.index}>
-                <strong>Paragraph {paragraph.index}:</strong> {paragraph.text}
-                {paragraph.references?.length ? (
-                  <span className="muted"> — refs: {paragraph.references.join(", ")}</span>
-                ) : null}
-              </li>
-            ))}
-          </ul>
-        </div>
-      )}
-
-      {standardsParse && standardsParse.length > 0 && (
-        <div className="section-card">
-          <h3>Standards Corpus</h3>
-          <ul className="section-list">
-            {standardsParse.slice(0, 4).map((entry) => {
-              const name = entry.path.split(/[/\\]/).pop() ?? entry.path;
-              const summary = entry.summary as
-                | { chunk_count?: number; reference_count?: number; ocr_chunk_count?: number }
-                | undefined;
-              const chunkCount = summary?.chunk_count ?? entry.chunks?.length ?? 0;
-              const ocrChunkCount =
-                summary?.ocr_chunk_count ?? entry.chunks?.filter((chunk) => chunk.is_ocr)?.length ?? 0;
-              return (
-                <li key={entry.path}>
-                  <strong>{name}</strong> - {chunkCount} chunks analysed
-                  {ocrChunkCount ? (
-                    <span className="muted">
-                      {" "}
-                      ({ocrChunkCount} OCR supplement{ocrChunkCount === 1 ? "" : "s"})
-                    </span>
-                  ) : null}
-                </li>
-              );
-            })}
-          </ul>
-        </div>
-      )}
-
-      {extractionResult && (
-        <div className="section-card">
-          <h3>Extraction Summary</h3>
-          {extractionResult.document_summary && (
-            <p>{extractionResult.document_summary}</p>
-          )}
-          {extractionResult.references && extractionResult.references.length ? (
-            <p className="muted">
-              References detected: {extractionResult.references.slice(0, 20).join(", ")}
-              {extractionResult.references.length > 20 ? "..." : ""}
-            </p>
-          ) : null}
-          {sectionsPreview.length ? (
-            <ul className="section-list">
-              {sectionsPreview.map((section) => (
-                <li key={section.paragraph_index}>
-                  <strong>Paragraph {section.paragraph_index}:</strong> {section.text}
-                </li>
-              ))}
-            </ul>
-          ) : null}
-          {extractionResult.notes && <p className="muted">{extractionResult.notes}</p>}
-        </div>
-      )}
-
-      {mappingResult && (
-        <div className="section-card">
-          <h3>Reference Mapping</h3>
-          {mappings.length ? (
-            <>
-              <p className="muted">
-                Showing {mappingsToDisplay.length} of {mappings.length} mappings.
-              </p>
-              <ul className="section-list">
-                {mappingsToDisplay.map((mapping, idx) => {
-                  const cappedConfidence =
-                    typeof mapping.confidence === "number"
-                      ? Math.round(Math.min(Math.max(mapping.confidence, 0), 1) * 100)
-                      : null;
-                  return (
-                    <li key={`${mapping.source_reference}-${idx}`}>
-                      <strong>{mapping.source_reference}</strong>{" -> "}{mapping.target_reference}
-                      {cappedConfidence !== null && (
-                        <span className="muted"> (confidence {cappedConfidence}%)</span>
-                      )}
-                      {mapping.target_clause && (
-                        <div className="muted">Clause: {mapping.target_clause}</div>
-                      )}
-                      {mapping.rationale && (
-                        <div className="muted">Reason: {mapping.rationale}</div>
-                      )}
-                    </li>
-                  );
-                })}
-              </ul>
-              {mappings.length > mappingLimit && (
-                <button
-                  type="button"
-                  className="ghost-button"
-                  onClick={() => setShowAllMappings((prev) => !prev)}
-                >
-                  {showAllMappings ? "Show fewer" : `Show all ${mappings.length}`}
-                </button>
-              )}
-            </>
-          ) : (
-            <p className="muted">
-              {mappingResult.notes ?? "No mapping actions recorded."}
-            </p>
-          )}
-        </div>
-      )}
-
-      {rewritePlan && (
-        <div className="section-card">
-          <h3>Rewrite Plan</h3>
-          {replacements.length ? (
-            <>
-              <p className="muted">
-                Showing {replacementsToDisplay.length} of {replacements.length} replacements.
-              </p>
-              <ul className="section-list">
-                {replacementsToDisplay.map((replacement, idx) => {
-                  const appliedMappings =
-                    Array.isArray(replacement.applied_mappings) && replacement.applied_mappings.length
-                      ? replacement.applied_mappings
-                      : replacement.applied_mapping
-                      ? [replacement.applied_mapping]
-                      : [];
-                  return (
-                    <li key={`${replacement.paragraph_index}-${idx}`}>
-                      <strong>Paragraph {replacement.paragraph_index}</strong>
-                      <div className="diff-block">
-                        <div>
-                          <span className="muted">Original:</span> {replacement.original_text}
-                        </div>
-                        <div>
-                          <span className="muted">Updated:</span> {replacement.updated_text}
-                        </div>
-                        {appliedMappings.length ? (
-                          <div className="muted">Mapping: {appliedMappings.join(", ")}</div>
-                        ) : null}
-                        {replacement.change_reason && (
-                          <div className="muted">Reason: {replacement.change_reason}</div>
-                        )}
-                      </div>
-                    </li>
-                  );
-                })}
-              </ul>
-              {replacements.length > replacementLimit && (
-                <button
-                  type="button"
-                  className="ghost-button"
-                  onClick={() => setShowAllReplacements((prev) => !prev)}
-                >
-                  {showAllReplacements ? "Show fewer" : `Show all ${replacements.length}`}
-                </button>
-              )}
-            </>
-          ) : (
-            <p className="muted">{rewritePlan.notes ?? "No rewrite actions required."}</p>
-          )}
-          {tableReplacements.length ? (
-            <div className="subsection">
-              <h4>Table Updates</h4>
-              <ul className="section-list">
-                {tableReplacements.map((table, idx) => {
-                  const appliedMappings =
-                    Array.isArray(table.applied_mappings) && table.applied_mappings.length
-                      ? table.applied_mappings
-                      : table.applied_mapping
-                      ? [table.applied_mapping]
-                      : [];
-                  return (
-                    <li key={`${table.table_index}-${idx}`}>
-                      <strong>Table {table.table_index}</strong>
-                      {appliedMappings.length ? (
-                        <div className="muted">Mapping: {appliedMappings.join(", ")}</div>
-                      ) : null}
-                      {table.change_reason && <div className="muted">{table.change_reason}</div>}
-                      {Array.isArray(table.updated_rows) && table.updated_rows.length ? (
-                        <div className="muted">Updated rows: {table.updated_rows.length}</div>
-                      ) : null}
-                    </li>
-                  );
-                })}
-              </ul>
-            </div>
-          ) : null}
-          {changeLog.length ? (
-            <div className="subsection">
-              <h4>Change Log</h4>
-              <ul className="section-list">
-                {changeLog.map((entry, idx) => (
-                  <li key={`${entry.reference}-${idx}`}>
-                    <strong>{entry.reference}</strong>{" -> "}{entry.target_reference}
-                    {entry.affected_paragraphs && entry.affected_paragraphs.length ? (
-                      <span className="muted">{" "}(paragraphs {entry.affected_paragraphs.join(", ")})</span>
-                    ) : null}
-                    {entry.note && <div className="muted">{entry.note}</div>}
-                  </li>
-                ))}
-              </ul>
-            </div>
-          ) : null}
-          {rewritePlan.notes && replacements.length ? (
-            <p className="muted">{rewritePlan.notes}</p>
-          ) : null}
-        </div>
-      )}
-
-      {validationReport && (
-        <div className="section-card">
-          <h3>Validation</h3>
-          {validationReport.verdict && (
-            <p>
-              Verdict: <strong>{validationReport.verdict}</strong>
-            </p>
-          )}
-          {validationReport.issues?.length ? (
-            <ul className="section-list">
-              {validationReport.issues.map((issue, idx) => (
-                <li key={idx}>
-                  {issue.description ?? "Issue reported"}
-                  {issue.severity && <span className="muted"> ({issue.severity})</span>}
-                </li>
-              ))}
-            </ul>
-          ) : (
-            <p className="muted">No validation issues reported.</p>
-          )}
-          {validationReport.notes && <p className="muted">{validationReport.notes}</p>}
-        </div>
-      )}
-
-      {exportManifest && (
-        <div className="section-card">
-          <h3>Export</h3>
-          {exportDownloadUrl ? (
-            <>
-              <p className="muted">
-                {exportManifest.notes ?? "Converted document generated using rewrite plan."}
-              </p>
-              {typeof exportManifest.replacement_count === "number" && (
-                <p className="muted">
-                  {exportManifest.replacement_count} paragraph replacements applied.
-                </p>
-              )}
-              <a className="ghost-button" href={exportDownloadUrl} download>
-                Download DOCX
-              </a>
-            </>
-          ) : (
-            <p className="muted">{exportManifest.notes ?? "Export not yet generated."}</p>
-          )}
-        </div>
-      )}
-    </div>
-  );
-}
-

frontend/src/components/SessionList.tsx

@@ -1,59 +0,0 @@
-import { useQuery } from "@tanstack/react-query";
-import { fetchSessions } from "../services/api";
-import type { SessionSummary } from "../types/session";
-
-interface SessionListProps {
-  selectedId?: string | null;
-  onSelect?: (session: SessionSummary) => void;
-}
-
-export default function SessionList({ selectedId, onSelect }: SessionListProps) {
-  const { data, isLoading, isError, error } = useQuery({
-    queryKey: ["sessions"],
-    queryFn: fetchSessions,
-    refetchInterval: 5000,
-  });
-  const dateFormatter = new Intl.DateTimeFormat(undefined, {
-    dateStyle: "medium",
-    timeStyle: "short",
-  });
-
-  if (isLoading) {
-    return <div className="card">Loading sessions...</div>;
-  }
-  if (isError) {
-    return <div className="card error">Failed to load sessions: {(error as Error).message}</div>;
-  }
-
-  if (!data?.length) {
-    return <div className="card">No sessions yet. Upload a report to get started.</div>;
-  }
-
-  return (
-    <div className="card">
-      <h2>Recent Sessions</h2>
-      <p className="muted">Auto-refreshing every 5s.</p>
-      <ul className="session-list">
-        {data.map((session) => (
-          <li
-            key={session.id}
-            className={session.id === selectedId ? "selected" : ""}
-            onClick={() => onSelect?.(session)}
-          >
-            <div>
-              <strong>{session.name}</strong>
-              <p>
-                {session.target_standard} {"->"} {session.destination_standard}
-              </p>
-              <p className="muted" title={session.source_doc}>
-                {dateFormatter.format(new Date(session.created_at))} {" · "}
-                {session.source_doc.split(/[/\\]/).pop() ?? session.source_doc}
-              </p>
-            </div>
-            <span className={`status status-${session.status}`}>{session.status}</span>
-          </li>
-        ))}
-      </ul>
-    </div>
-  );
-}

frontend/src/components/UploadForm.tsx

@@ -1,189 +0,0 @@
-import { useState } from "react";
-import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
-import { fetchPresets, uploadSession } from "../services/api";
-import type { Session, StandardsPreset } from "../types/session";
-
-interface UploadFormProps {
-  onSuccess?: (session: Session) => void;
-}
-
-export default function UploadForm({ onSuccess }: UploadFormProps) {
-  const queryClient = useQueryClient();
-  const [name, setName] = useState("");
-  const [targetStandard, setTargetStandard] = useState("");
-  const [destinationStandard, setDestinationStandard] = useState("");
-  const [file, setFile] = useState<File | null>(null);
-  const [standardsFiles, setStandardsFiles] = useState<File[]>([]);
-  const [selectedPresetId, setSelectedPresetId] = useState<string>("");
-
-  const { data: presets = [], isLoading: presetsLoading, isError: presetsError } = useQuery({
-    queryKey: ["presets"],
-    queryFn: fetchPresets,
-    refetchInterval: (currentPresets) =>
-      Array.isArray(currentPresets) &&
-      currentPresets.some((preset) => preset.status === "processing")
-        ? 2000
-        : false,
-  });
-  const selectedPreset = presets.find((preset) => preset.id === selectedPresetId);
-
-  const mutation = useMutation({
-    mutationFn: uploadSession,
-    onSuccess: (session) => {
-      console.log("Session created:", session);
-      queryClient.invalidateQueries({ queryKey: ["sessions"] });
-      onSuccess?.(session);
-      resetForm();
-    },
-    onError: (error: unknown) => {
-      console.error("Session creation failed:", error);
-    },
-  });
-
-  function resetForm() {
-    setName("");
-    setTargetStandard("");
-    setDestinationStandard("");
-    setFile(null);
-    setStandardsFiles([]);
-    setSelectedPresetId("");
-    const reportInput = document.getElementById("source-doc-input") as HTMLInputElement | null;
-    if (reportInput) {
-      reportInput.value = "";
-    }
-    const standardsInput = document.getElementById("standards-doc-input") as HTMLInputElement | null;
-    if (standardsInput) {
-      standardsInput.value = "";
-    }
-  }
-
-  const handleSubmit = (event: React.FormEvent<HTMLFormElement>) => {
-    event.preventDefault();
-    if (!file) {
-      alert("Please select a report to upload.");
-      return;
-    }
-    if (!standardsFiles.length && !selectedPresetId) {
-      alert("Upload at least one standards PDF or choose a preset bundle.");
-      return;
-    }
-    if (selectedPresetId && selectedPreset && selectedPreset.status !== "ready") {
-      alert("The selected preset is still processing. Please wait until it is ready.");
-      return;
-    }
-    mutation.mutate({
-      name,
-      target_standard: targetStandard,
-      destination_standard: destinationStandard,
-      metadata: {},
-      sourceFile: file,
-      standardsFiles,
-      standardsPresetId: selectedPresetId || undefined,
-    });
-  };
-
-  return (
-    <form className="card" onSubmit={handleSubmit}>
-      <h2>Create Conversion Session</h2>
-      <label className="field">
-        <span>Session Name</span>
-        <input value={name} onChange={(event) => setName(event.target.value)} required />
-      </label>
-      <label className="field">
-        <span>Current Standard</span>
-        <input
-          value={targetStandard}
-          onChange={(event) => setTargetStandard(event.target.value)}
-          required
-        />
-      </label>
-      <label className="field">
-        <span>Target Standard</span>
-        <input
-          value={destinationStandard}
-          onChange={(event) => setDestinationStandard(event.target.value)}
-          required
-        />
-      </label>
-      <label className="field">
-        <span>Word Report</span>
-        <input
-          id="source-doc-input"
-          type="file"
-          accept=".docx"
-          onChange={(event) => setFile(event.target.files?.[0] ?? null)}
-          required
-        />
-      </label>
-      <label className="field">
-        <span>New Standards PDFs</span>
-        <input
-          id="standards-doc-input"
-          type="file"
-          accept=".pdf"
-          multiple
-          onChange={(event) => setStandardsFiles(Array.from(event.target.files ?? []))}
-        />
-        <small>
-          {standardsFiles.length
-            ? `${standardsFiles.length} file(s) selected`
-            : "Select one or more PDF references."}
-        </small>
-      </label>
-      <label className="field">
-        <span>Saved Standards Preset (optional)</span>
-        <select
-          value={selectedPresetId}
-          onChange={(event) => setSelectedPresetId(event.target.value)}
-          disabled={presetsLoading || !presets.length}
-        >
-          <option value="">Select a preset...</option>
-          {presets.map((preset: StandardsPreset) => (
-            <option
-              key={preset.id}
-              value={preset.id}
-              disabled={preset.status !== "ready"}
-            >
-              {preset.name} ({preset.document_count} file{preset.document_count === 1 ? "" : "s"})
-              {preset.status === "processing"
-                ? ` — processing ${preset.processed_count}/${preset.total_count || preset.document_count}`
-                : preset.status === "failed"
-                ? " — failed"
-                : ""}
-            </option>
-          ))}
-        </select>
-        <small>
-          {presetsLoading
-            ? "Loading saved presets..."
-            : presetsError
-            ? "Failed to load presets."
-            : presets.length
-            ? selectedPreset
-              ? selectedPreset.status === "processing"
-                ? `Processing preset ${selectedPreset.processed_count}/${selectedPreset.total_count || selectedPreset.document_count}.`
-                : selectedPreset.status === "failed"
-                ? `Preset failed${selectedPreset.last_error ? `: ${selectedPreset.last_error}` : ""}`
-                : "Optionally reuse a previously parsed standards bundle."
-              : "Optionally reuse a previously parsed standards bundle."
-            : "No presets yet. Create one below."}
-        </small>
-      </label>
-      <button type="submit" disabled={mutation.isPending}>
-        {mutation.isPending ? "Uploading..." : "Start Conversion"}
-      </button>
-      {mutation.isPending && (
-        <div className="progress-block">
-          <div className="progress-bar">
-            <div className="progress-bar-fill" />
-          </div>
-          <p className="muted">Uploading files and starting pipeline...</p>
-        </div>
-      )}
-      {mutation.isError && (
-        <p className="error">Upload failed: {(mutation.error as Error).message}</p>
-      )}
-      {mutation.isSuccess && <p className="success">Session created successfully.</p>}
-    </form>
-  );
-}

frontend/src/main.tsx

@@ -1,15 +1,10 @@
 import React from "react";
 import ReactDOM from "react-dom/client";
-import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
 import App from "./App";
 import "./styles.css";
 
-const queryClient = new QueryClient();
-
 ReactDOM.createRoot(document.getElementById("root") as HTMLElement).render(
   <React.StrictMode>
-    <QueryClientProvider client={queryClient}>
-      <App />
-    </QueryClientProvider>
+    <App />
   </React.StrictMode>,
 );

frontend/src/pages/ObservatoryPage.tsx

@@ -1,179 +0,0 @@
-import { useEffect, useMemo, useState } from "react";
-import { useQuery } from "@tanstack/react-query";
-import { fetchDiagnosticsEvents, fetchDiagnosticsTopology } from "../services/api";
-import type { DiagnosticsEvent, DiagnosticsNode, DiagnosticsTopology } from "../types/diagnostics";
-
-const EVENT_PULSE_WINDOW_MS = 5000;
-const EVENTS_LIMIT = 60;
-
-function buildNodeMap(topology?: DiagnosticsTopology): Map<string, DiagnosticsNode> {
-  if (!topology) {
-    return new Map();
-  }
-  return new Map(topology.nodes.map((node) => [node.id, node]));
-}
-
-function useActiveNodes(events: DiagnosticsEvent[] | undefined, tick: number): Set<string> {
-  return useMemo(() => {
-    const active = new Set<string>();
-    if (!events) {
-      return active;
-    }
-    const now = Date.now();
-    for (const event of events) {
-      if (!event.node_id) {
-        continue;
-      }
-      const timestamp = Date.parse(event.timestamp);
-      if (Number.isNaN(timestamp)) {
-        continue;
-      }
-      if (now - timestamp <= EVENT_PULSE_WINDOW_MS) {
-        active.add(event.node_id);
-      }
-    }
-    return active;
-  }, [events, tick]);
-}
-
-const timeFormatter = new Intl.DateTimeFormat(undefined, {
-  hour: "2-digit",
-  minute: "2-digit",
-  second: "2-digit",
-});
-
-export default function ObservatoryPage() {
-  const [timeTick, setTimeTick] = useState(Date.now());
-  useEffect(() => {
-    const id = window.setInterval(() => setTimeTick(Date.now()), 1000);
-    return () => window.clearInterval(id);
-  }, []);
-
-  const {
-    data: topology,
-    isLoading: topologyLoading,
-    isError: topologyError,
-    error: topologyErrorDetails,
-  } = useQuery({
-    queryKey: ["diagnostics", "topology"],
-    queryFn: fetchDiagnosticsTopology,
-    refetchInterval: 15000,
-  });
-
-  const {
-    data: eventsData,
-    isLoading: eventsLoading,
-    isError: eventsError,
-    error: eventsErrorDetails,
-  } = useQuery({
-    queryKey: ["diagnostics", "events"],
-    queryFn: () => fetchDiagnosticsEvents(EVENTS_LIMIT),
-    refetchInterval: 2000,
-  });
-
-  const nodeMap = buildNodeMap(topology);
-  const activeNodes = useActiveNodes(eventsData, timeTick);
-
-  const edges = useMemo(() => {
-    if (!topology) {
-      return [];
-    }
-    return topology.edges
-      .map((edge) => {
-        const source = nodeMap.get(edge.source);
-        const target = nodeMap.get(edge.target);
-        if (!source || !target) {
-          return null;
-        }
-        return (
-          <line
-            key={edge.id}
-            x1={source.position.x}
-            y1={source.position.y}
-            x2={target.position.x}
-            y2={target.position.y}
-            className="observatory-edge"
-          />
-        );
-      })
-      .filter(Boolean) as JSX.Element[];
-  }, [nodeMap, topology]);
-
-  const nodes = useMemo(() => {
-    if (!topology) {
-      return [];
-    }
-    return topology.nodes.map((node) => {
-      const isActive = activeNodes.has(node.id);
-      return (
-        <g key={node.id} className={`observatory-node group-${node.group}`}>
-          <circle
-            cx={node.position.x}
-            cy={node.position.y}
-            r={isActive ? 6 : 4}
-            className={isActive ? "pulse" : undefined}
-          />
-          <text x={node.position.x} y={node.position.y - 9} textAnchor="middle">
-            {node.label}
-          </text>
-        </g>
-      );
-    });
-  }, [activeNodes, topology]);
-
-  return (
-    <div className="observatory-page">
-      <div className="observatory-header">
-        <h2>System Observatory</h2>
-        <p>
-          Visual map of key storage locations, services, and external dependencies. Nodes pulse when recent activity
-          is detected.
-        </p>
-      </div>
-      <div className="observatory-content">
-        <section className="observatory-graph-card">
-          <h3>Topology</h3>
-          {topologyLoading ? (
-            <p className="muted">Loading topology...</p>
-          ) : topologyError ? (
-            <p className="error">Failed to load topology: {(topologyErrorDetails as Error).message}</p>
-          ) : (
-            <svg className="observatory-canvas" viewBox="0 0 100 60" preserveAspectRatio="xMidYMid meet">
-              {edges}
-              {nodes}
-            </svg>
-          )}
-        </section>
-        <aside className="observatory-feed-card">
-          <h3>Activity Feed</h3>
-          {eventsLoading ? (
-            <p className="muted">Monitoring events...</p>
-          ) : eventsError ? (
-            <p className="error">Failed to load events: {(eventsErrorDetails as Error).message}</p>
-          ) : eventsData && eventsData.length ? (
-            <ul className="observatory-feed">
-              {eventsData.map((event) => {
-                const timestamp = Date.parse(event.timestamp);
-                const timeString = Number.isNaN(timestamp)
-                  ? event.timestamp
-                  : timeFormatter.format(new Date(timestamp));
-                const node = event.node_id ? nodeMap.get(event.node_id) : undefined;
-                return (
-                  <li key={event.id}>
-                    <div className="feed-row">
-                      <strong>{node?.label ?? event.node_id ?? "System"}</strong>
-                      <span className="muted">{timeString}</span>
-                    </div>
-                    <div>{event.message}</div>
-                  </li>
-                );
-              })}
-            </ul>
-          ) : (
-            <p className="muted">No activity detected yet.</p>
-          )}
-        </aside>
-      </div>
-    </div>
-  );
-}

frontend/src/pages/PresetEditPage.tsx

@@ -1,202 +0,0 @@
-import { useEffect, useState } from "react";
-import { Link, Navigate, useParams } from "react-router-dom";
-import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
-import {
-  addPresetDocuments,
-  fetchPresetById,
-  removePresetDocument,
-  updatePreset,
-} from "../services/api";
-import type { StandardsPreset } from "../types/session";
-
-export default function PresetEditPage() {
-  const { presetId } = useParams<{ presetId: string }>();
-  const queryClient = useQueryClient();
-
-  const {
-    data: preset,
-    isLoading,
-    isError,
-    error,
-  } = useQuery({
-    queryKey: ["preset", presetId],
-    queryFn: () => fetchPresetById(presetId ?? ""),
-    enabled: Boolean(presetId),
-    refetchInterval: (currentPreset) =>
-      currentPreset?.status === "processing" ? 2000 : false,
-  });
-
-  const [name, setName] = useState("");
-  const [description, setDescription] = useState("");
-
-  useEffect(() => {
-    if (preset) {
-      setName(preset.name);
-      setDescription(preset.description ?? "");
-    }
-  }, [preset?.id, preset?.name, preset?.description]);
-
-  const updateMutation = useMutation({
-    mutationFn: (payload: { name?: string; description?: string | null }) =>
-      updatePreset(presetId ?? "", payload),
-    onSuccess: (updated) => {
-      queryClient.setQueryData(["preset", presetId], updated);
-      queryClient.invalidateQueries({ queryKey: ["presets"] });
-    },
-    onError: (err: unknown) => {
-      alert(`Failed to update preset: ${(err as Error).message}`);
-    },
-  });
-
-  const addDocumentsMutation = useMutation({
-    mutationFn: (files: File[]) => addPresetDocuments(presetId ?? "", files),
-    onSuccess: (updated) => {
-      queryClient.setQueryData(["preset", presetId], updated);
-      queryClient.invalidateQueries({ queryKey: ["presets"] });
-    },
-    onError: (err: unknown) => {
-      alert(`Failed to add documents: ${(err as Error).message}`);
-    },
-  });
-
-  const removeDocumentMutation = useMutation({
-    mutationFn: (documentPath: string) => removePresetDocument(presetId ?? "", documentPath),
-    onSuccess: (updated) => {
-      queryClient.setQueryData(["preset", presetId], updated);
-      queryClient.invalidateQueries({ queryKey: ["presets"] });
-    },
-    onError: (err: unknown) => {
-      alert(`Failed to remove document: ${(err as Error).message}`);
-    },
-  });
-
-  if (!presetId) {
-    return <Navigate to="/presets" replace />;
-  }
-
-  const totalDocs = preset?.total_count ?? preset?.document_count ?? 0;
-  const processedDocs = Math.min(preset?.processed_count ?? 0, totalDocs);
-  const progressPercent = totalDocs
-    ? Math.min(100, Math.round((processedDocs / totalDocs) * 100))
-    : preset?.status === "ready"
-    ? 100
-    : 0;
-  const nextDoc = Math.min(processedDocs + 1, totalDocs);
-
-  const handleSave = (event: React.FormEvent<HTMLFormElement>) => {
-    event.preventDefault();
-    const trimmedName = name.trim();
-    if (!trimmedName) {
-      alert("Preset name cannot be empty.");
-      return;
-    }
-    updateMutation.mutate({
-      name: trimmedName,
-      description: description.trim() || "",
-    });
-  };
-
-  const handleAddFiles = (event: React.ChangeEvent<HTMLInputElement>) => {
-    const files = Array.from(event.target.files ?? []);
-    if (!files.length) {
-      return;
-    }
-    addDocumentsMutation.mutate(files);
-    event.target.value = "";
-  };
-
-  const handleRemoveDocument = (documentPath: string) => {
-    if (!window.confirm("Remove this document from the preset?")) {
-      return;
-    }
-    removeDocumentMutation.mutate(documentPath);
-  };
-
-  return (
-    <div className="page-stack">
-      <div className="card">
-        <div className="edit-header">
-          <div>
-            <h2>Edit Preset</h2>
-            <p className="muted">Update preset metadata and manage the associated PDF files.</p>
-          </div>
-          <Link className="ghost-button" to="/presets">
-            ← Back to Presets
-          </Link>
-        </div>
-
-        {isLoading && <p className="muted">Loading preset details...</p>}
-        {isError && <p className="error">Failed to load preset: {(error as Error).message}</p>}
-        {preset && (
-          <>
-            <form className="stacked" onSubmit={handleSave}>
-              <label className="field">
-                <span>Preset Name</span>
-                <input value={name} onChange={(event) => setName(event.target.value)} required />
-              </label>
-              <label className="field">
-                <span>Description</span>
-                <input value={description} onChange={(event) => setDescription(event.target.value)} />
-              </label>
-              <button type="submit" disabled={updateMutation.isPending}>
-                {updateMutation.isPending ? "Saving..." : "Save Changes"}
-              </button>
-            </form>
-
-            <div className="preset-status-card">
-              <p className="muted">
-                Status: <strong>{preset.status}</strong>
-                {preset.status === "processing" && (
-                  <>
-                    {" "}
-                    · {processedDocs}/{totalDocs} processed
-                  </>
-                )}
-              </p>
-              {preset.last_error && <p className="error">Last error: {preset.last_error}</p>}
-            </div>
-            {preset.status === "processing" && totalDocs > 0 && (
-              <div className="progress-block">
-                <div className="linear-progress">
-                  <div className="linear-progress-fill" style={{ width: `${progressPercent}%` }} />
-                </div>
-                <p className="muted">
-                  Currently parsing document {nextDoc} of {totalDocs}.
-                </p>
-              </div>
-            )}
-
-            <div className="card subsection">
-              <h3>Documents</h3>
-              {preset.documents.length ? (
-                <ul className="document-list">
-                  {preset.documents.map((doc) => (
-                    <li key={doc} className="document-item">
-                      <span>{doc.split(/[/\\]/).pop() ?? doc}</span>
-                      <button
-                        type="button"
-                        className="ghost-button danger"
-                        onClick={() => handleRemoveDocument(doc)}
-                        disabled={removeDocumentMutation.isPending || preset.status === "processing"}
-                      >
-                        Remove
-                      </button>
-                    </li>
-                  ))}
-                </ul>
-              ) : (
-                <p className="muted">No documents attached yet.</p>
-              )}
-              <label className="field">
-                <span>Add Additional PDFs</span>
-                <input type="file" accept=".pdf" multiple onChange={handleAddFiles} />
-                {addDocumentsMutation.isPending && <p className="muted">Uploading and parsing...</p>}
-              </label>
-            </div>
-          </>
-        )}
-      </div>
-    </div>
-  );
-}
-

frontend/src/pages/PresetsPage.tsx

@@ -1,9 +0,0 @@
-import PresetManager from "../components/PresetManager";
-
-export default function PresetsPage() {
-  return (
-    <div className="page-stack">
-      <PresetManager />
-    </div>
-  );
-}

frontend/src/pages/SessionsPage.tsx

@@ -1,19 +0,0 @@
-import { useState } from "react";
-import UploadForm from "../components/UploadForm";
-import SessionDetails from "../components/SessionDetails";
-import SessionList from "../components/SessionList";
-import type { Session, SessionSummary } from "../types/session";
-
-export default function SessionsPage() {
-  const [selectedSession, setSelectedSession] = useState<Session | SessionSummary | null>(null);
-
-  return (
-    <div className="grid">
-      <div>
-        <UploadForm onSuccess={setSelectedSession} />
-        <SessionDetails session={selectedSession} />
-      </div>
-      <SessionList selectedId={selectedSession?.id ?? null} onSelect={setSelectedSession} />
-    </div>
-  );
-}

frontend/src/services/api.ts

@@ -1,113 +0,0 @@
-import axios from "axios";
-import type {
-  CreatePresetPayload,
-  CreateSessionPayload,
-  Session,
-  SessionStatusResponse,
-  SessionSummary,
-  StandardsPreset,
-  UpdatePresetPayload,
-} from "../types/session";
-import type { DiagnosticsEvent, DiagnosticsTopology } from "../types/diagnostics";
-
-const API_BASE_URL = import.meta.env.VITE_API_BASE_URL ?? "http://localhost:8000/api";
-
-export async function uploadSession(payload: CreateSessionPayload): Promise<Session> {
-  const formData = new FormData();
-  formData.append("name", payload.name);
-  formData.append("target_standard", payload.target_standard);
-  formData.append("destination_standard", payload.destination_standard);
-  formData.append("source_doc", payload.sourceFile);
-  (payload.standardsFiles ?? []).forEach((file) => {
-    formData.append("standards_pdfs", file);
-  });
-  if (payload.standardsPresetId) {
-    formData.append("standards_preset_id", payload.standardsPresetId);
-  }
-  if (payload.metadata) {
-    formData.append("metadata", JSON.stringify(payload.metadata));
-  }
-
-  const response = await axios.post<Session>(`${API_BASE_URL}/sessions`, formData, {
-    headers: { "Content-Type": "multipart/form-data" },
-  });
-  return response.data;
-}
-
-export async function fetchSessions(): Promise<SessionSummary[]> {
-  const response = await axios.get<SessionSummary[]>(`${API_BASE_URL}/sessions`);
-  return response.data;
-}
-
-export async function fetchSessionById(id: string): Promise<Session> {
-  const response = await axios.get<Session>(`${API_BASE_URL}/sessions/${id}`);
-  return response.data;
-}
-
-export async function fetchSessionStatus(id: string): Promise<SessionStatusResponse> {
-  const response = await axios.get<SessionStatusResponse>(`${API_BASE_URL}/sessions/${id}/status`);
-  return response.data;
-}
-
-export async function fetchPresets(): Promise<StandardsPreset[]> {
-  const response = await axios.get<StandardsPreset[]>(`${API_BASE_URL}/presets`);
-  return response.data;
-}
-
-export async function fetchPresetById(id: string): Promise<StandardsPreset> {
-  const response = await axios.get<StandardsPreset>(`${API_BASE_URL}/presets/${id}`);
-  return response.data;
-}
-
-export async function createPreset(payload: CreatePresetPayload): Promise<StandardsPreset> {
-  const formData = new FormData();
-  formData.append("name", payload.name);
-  if (payload.description) {
-    formData.append("description", payload.description);
-  }
-  payload.files.forEach((file) => {
-    formData.append("standards_pdfs", file);
-  });
-
-  const response = await axios.post<StandardsPreset>(`${API_BASE_URL}/presets`, formData, {
-    headers: { "Content-Type": "multipart/form-data" },
-  });
-  return response.data;
-}
-
-export async function addPresetDocuments(id: string, files: File[]): Promise<StandardsPreset> {
-  const formData = new FormData();
-  files.forEach((file) => formData.append("standards_pdfs", file));
-  const response = await axios.post<StandardsPreset>(`${API_BASE_URL}/presets/${id}/documents`, formData, {
-    headers: { "Content-Type": "multipart/form-data" },
-  });
-  return response.data;
-}
-
-export async function updatePreset(id: string, payload: UpdatePresetPayload): Promise<StandardsPreset> {
-  const response = await axios.patch<StandardsPreset>(`${API_BASE_URL}/presets/${id}`, payload);
-  return response.data;
-}
-
-export async function deletePreset(id: string): Promise<void> {
-  await axios.delete(`${API_BASE_URL}/presets/${id}`);
-}
-
-export async function removePresetDocument(id: string, documentPath: string): Promise<StandardsPreset> {
-  const response = await axios.delete<StandardsPreset>(`${API_BASE_URL}/presets/${id}/documents`, {
-    params: { document: documentPath },
-  });
-  return response.data;
-}
-
-export async function fetchDiagnosticsTopology(): Promise<DiagnosticsTopology> {
-  const response = await axios.get<DiagnosticsTopology>(`${API_BASE_URL}/diagnostics/topology`);
-  return response.data;
-}
-
-export async function fetchDiagnosticsEvents(limit = 50): Promise<DiagnosticsEvent[]> {
-  const response = await axios.get<{ events: DiagnosticsEvent[] }>(`${API_BASE_URL}/diagnostics/events`, {
-    params: { limit },
-  });
-  return response.data.events;
-}

frontend/src/styles.css

@@ -1,643 +1,15 @@
-:root {
-  color-scheme: light;
-  font-family: "Inter", system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
-  line-height: 1.5;
-  font-weight: 400;
-  color: #0f172a;
-  background-color: #f8fafc;
-}
-
 * {
   box-sizing: border-box;
 }
 
 body {
   margin: 0;
+  background: #000000;
 }
 
-a {
-  color: inherit;
-}
-
-button {
-  font: inherit;
-}
-
-.app-shell {
-  min-height: 100vh;
-  display: flex;
-  flex-direction: column;
-  padding: 1.5rem;
-  gap: 1.5rem;
-}
-
-header {
-  display: flex;
-  flex-direction: column;
-  gap: 0.5rem;
-}
-
-.primary-nav {
-  display: flex;
-  gap: 0.75rem;
-  margin-top: 0.5rem;
-}
-
-.primary-nav a {
-  color: #1d4ed8;
-  padding: 0.4rem 0.75rem;
-  border-radius: 999px;
-  border: 1px solid transparent;
-  text-decoration: none;
-  transition: background 0.2s, color 0.2s, border-color 0.2s;
-  font-weight: 600;
-  font-size: 0.9rem;
-}
-
-.primary-nav a:hover {
-  border-color: #bfdbfe;
-  background: #e0f2fe;
-}
-
-.primary-nav a.active {
-  background: #1d4ed8;
-  color: #ffffff;
-}
-
-main {
-  flex: 1;
-}
-
-.grid {
-  display: grid;
-  grid-template-columns: minmax(0, 1.2fr) minmax(0, 1fr);
-  gap: 1.5rem;
-}
-
-.card {
-  background: #ffffff;
-  padding: 1.25rem;
-  border-radius: 12px;
-  box-shadow: 0 2px 8px rgba(15, 23, 42, 0.08);
-  display: flex;
-  flex-direction: column;
-  gap: 0.75rem;
-}
-
-.field {
-  display: flex;
-  flex-direction: column;
-  gap: 0.25rem;
-  font-weight: 600;
-  color: #0f172a;
-}
-
-.field input {
-  padding: 0.5rem 0.75rem;
-  border-radius: 8px;
-  border: 1px solid #cbd5f5;
-  font: inherit;
-}
-
-.field select {
-  padding: 0.5rem 0.75rem;
-  border-radius: 8px;
-  border: 1px solid #cbd5f5;
-  font: inherit;
-  background: #ffffff;
-}
-
-button[type="submit"] {
-  background: #1d4ed8;
-  color: #ffffff;
-  border: none;
-  padding: 0.6rem 1rem;
-  border-radius: 8px;
-  cursor: pointer;
-  transition: background 0.2s;
-}
-
-button[type="submit"]:disabled {
-  background: #93c5fd;
-  cursor: not-allowed;
-}
-
-.error {
-  color: #b91c1c;
-}
-
-.success {
-  color: #047857;
-}
-
-.muted {
-  color: #64748b;
-  font-size: 0.875rem;
-}
-
-.progress-block {
-  display: flex;
-  flex-direction: column;
-  gap: 0.5rem;
-}
-
-.progress-bar {
-  position: relative;
-  width: 100%;
-  height: 6px;
-  background: #dbeafe;
-  border-radius: 999px;
-  overflow: hidden;
-}
-
-.progress-bar-fill {
-  position: absolute;
-  inset: 0;
-  background: linear-gradient(90deg, #1d4ed8, #38bdf8);
-  animation: progress-pulse 1.2s linear infinite;
-}
-
-@keyframes progress-pulse {
-  0% {
-    transform: translateX(-50%);
-  }
-  50% {
-    transform: translateX(0%);
-  }
-  100% {
-    transform: translateX(100%);
-  }
-}
-
-.notice {
-  padding: 0.75rem;
-  border-radius: 8px;
-  border: 1px solid transparent;
-}
-
-.notice.success {
-  background: #ecfdf5;
-  border-color: #bbf7d0;
-  color: #036949;
-}
-
-.log-panel {
-  display: flex;
-  flex-direction: column;
-  gap: 0.5rem;
+#root,
+.black-screen {
+  width: 100vw;
+  height: 100vh;
+  background: #000000;
 }
-
-.log-panel ul {
-  margin: 0;
-  padding-left: 1rem;
-  display: flex;
-  flex-direction: column;
-  gap: 0.35rem;
-}
-
-.log-panel li {
-  font-size: 0.9rem;
-  color: #0f172a;
-}
-
-.section-card {
-  margin-top: 1.25rem;
-  padding-top: 1rem;
-  border-top: 1px solid #e2e8f0;
-  display: flex;
-  flex-direction: column;
-  gap: 0.6rem;
-}
-
-.section-card h3 {
-  margin: 0;
-  font-size: 1rem;
-  color: #1e293b;
-}
-
-.section-list {
-  list-style: disc;
-  margin: 0;
-  padding-left: 1.25rem;
-  display: flex;
-  flex-direction: column;
-  gap: 0.5rem;
-}
-
-.section-list li {
-  color: #0f172a;
-}
-
-.diff-block {
-  display: flex;
-  flex-direction: column;
-  gap: 0.35rem;
-  margin-top: 0.35rem;
-  padding-left: 0.5rem;
-  border-left: 2px solid #cbd5f5;
-}
-
-.field small {
-  font-weight: 400;
-  color: #64748b;
-}
-
-.session-list {
-  list-style: none;
-  margin: 0;
-  padding: 0;
-  display: flex;
-  flex-direction: column;
-  gap: 0.75rem;
-}
-
-.session-list li {
-  display: flex;
-  justify-content: space-between;
-  align-items: center;
-  padding: 0.75rem;
-  border-radius: 10px;
-  border: 1px solid transparent;
-  cursor: pointer;
-  transition: border-color 0.2s, background 0.2s;
-}
-
-.session-list li:hover {
-  border-color: #bfdbfe;
-}
-
-.session-list li.selected {
-  border-color: #1d4ed8;
-  background: #eff6ff;
-}
-
-.status {
-  text-transform: uppercase;
-  font-weight: 600;
-  font-size: 0.75rem;
-}
-
-.status-created,
-.status-processing {
-  color: #1d4ed8;
-}
-
-.status-review {
-  color: #0f766e;
-}
-
-.status-completed {
-  color: #16a34a;
-}
-
-.status-failed {
-  color: #b91c1c;
-}
-
-.details-grid {
-  display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(160px, 1fr));
-  gap: 0.75rem;
-}
-
-.details-grid dt {
-  font-size: 0.75rem;
-  text-transform: uppercase;
-  color: #475569;
-}
-
-.details-grid dd {
-  margin: 0;
-  font-weight: 600;
-}
-
-footer {
-  text-align: center;
-  color: #64748b;
-  font-size: 0.875rem;
-}
-
-@media (max-width: 960px) {
-  .grid {
-    grid-template-columns: 1fr;
-  }
-}
-.actions-row {
-  display: flex;
-  justify-content: flex-end;
-}
-
-.card-header {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  gap: 1rem;
-  margin-bottom: 1rem;
-}
-
-.card-header h2 {
-  margin: 0;
-}
-
-.header-actions {
-  display: flex;
-  align-items: center;
-  gap: 0.75rem;
-}
-
-.text-small {
-  font-size: 0.875rem;
-}
-
-.ghost-button {
-  background: transparent;
-  border: 1px solid #cbd5f5;
-  color: #1d4ed8;
-  padding: 0.4rem 0.8rem;
-  border-radius: 8px;
-  cursor: pointer;
-  transition: background 0.2s, color 0.2s;
-}
-
-.ghost-button:hover:not(:disabled) {
-  background: #e0f2fe;
-}
-
-.ghost-button:disabled {
-  color: #94a3b8;
-  cursor: not-allowed;
-}
-
-.subsection {
-  margin-top: 0.75rem;
-  display: flex;
-  flex-direction: column;
-  gap: 0.5rem;
-}
-
-.stacked {
-  display: flex;
-  flex-direction: column;
-  gap: 0.75rem;
-}
-
-.preset-list ul {
-  list-style: none;
-  padding: 0;
-  margin: 0;
-  display: flex;
-  flex-direction: column;
-  gap: 0.75rem;
-}
-
-.preset-list li {
-  border: 1px solid #e2e8f0;
-  border-radius: 10px;
-  padding: 0.75rem;
-  display: flex;
-  flex-direction: column;
-  gap: 0.35rem;
-}
-
-.preset-docs {
-  font-size: 0.8rem;
-}
-
-.preset-actions {
-  display: flex;
-  gap: 0.5rem;
-  margin-top: 0.5rem;
-}
-
-.ghost-button.danger {
-  border-color: #fca5a5;
-  color: #b91c1c;
-}
-
-.ghost-button.danger:hover:not(:disabled) {
-  background: #fee2e2;
-}
-
-.ghost-button.danger:disabled {
-  color: #fca5a5;
-  border-color: #fca5a5;
-}
-
-.edit-header {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  gap: 1rem;
-  flex-wrap: wrap;
-}
-
-.document-list {
-  list-style: none;
-  padding: 0;
-  margin: 0;
-  display: flex;
-  flex-direction: column;
-  gap: 0.5rem;
-}
-
-.document-item {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  gap: 0.75rem;
-  padding: 0.6rem 0.75rem;
-  border: 1px solid #e2e8f0;
-  border-radius: 8px;
-}
-
-.preset-status-card {
-  margin-top: 1rem;
-  padding: 0.75rem;
-  border: 1px solid #e2e8f0;
-  border-radius: 10px;
-  background: #f8fafc;
-}
-
-
-.page-stack {
-  display: flex;
-  flex-direction: column;
-  gap: 1.5rem;
-}
-
-.preset-header {
-  display: flex;
-  justify-content: space-between;
-  gap: 1rem;
-}
-
-.preset-status {
-  display: flex;
-  align-items: center;
-  gap: 0.5rem;
-  font-size: 0.85rem;
-}
-
-.status-ready {
-  color: #16a34a;
-  font-weight: 600;
-}
-
-.status-processing {
-  color: #1d4ed8;
-  font-weight: 600;
-}
-
-.status-failed {
-  color: #b91c1c;
-  font-weight: 600;
-}
-
-.linear-progress {
-  width: 100%;
-  height: 6px;
-  border-radius: 999px;
-  background: #dbeafe;
-  overflow: hidden;
-}
-
-.linear-progress-fill {
-  height: 100%;
-  background: linear-gradient(90deg, #1d4ed8, #38bdf8);
-  transition: width 0.3s ease;
-}
-
-
-/* Observatory */
-.observatory-page {
-  display: flex;
-  flex-direction: column;
-  gap: 1.5rem;
-}
-
-.observatory-header h2 {
-  margin: 0;
-}
-
-.observatory-header p {
-  margin: 0.25rem 0 0;
-  color: #475569;
-}
-
-.observatory-content {
-  display: flex;
-  flex-wrap: wrap;
-  gap: 1.5rem;
-}
-
-.observatory-graph-card,
-.observatory-feed-card {
-  background: #ffffff;
-  border-radius: 12px;
-  padding: 1.25rem;
-  box-shadow: 0 10px 25px rgba(15, 23, 42, 0.08);
-  flex: 1 1 320px;
-  min-height: 320px;
-}
-
-.observatory-graph-card {
-  flex: 2 1 520px;
-  display: flex;
-  flex-direction: column;
-}
-
-.observatory-canvas {
-  margin-top: 1rem;
-  width: 100%;
-  height: 100%;
-  min-height: 320px;
-  border-radius: 12px;
-  background: radial-gradient(circle at center, #dbeafe, #e2e8f0 70%);
-  padding: 1rem;
-}
-
-.observatory-edge {
-  stroke: rgba(30, 64, 175, 0.35);
-  stroke-width: 0.8;
-  stroke-linecap: round;
-}
-
-.observatory-node circle {
-  transform-origin: center;
-  transform-box: fill-box;
-  fill: #1d4ed8;
-  opacity: 0.7;
-  transition: r 0.2s ease, opacity 0.2s ease;
-}
-
-.observatory-node text {
-  font-size: 3px;
-  fill: #0f172a;
-  pointer-events: none;
-}
-
-.observatory-node.group-storage circle {
-  fill: #0ea5e9;
-}
-
-.observatory-node.group-service circle {
-  fill: #16a34a;
-}
-
-.observatory-node.group-external circle {
-  fill: #f97316;
-}
-
-.observatory-node circle.pulse {
-  animation: observatory-pulse 1.2s ease-in-out infinite;
-  opacity: 0.95;
-}
-
-@keyframes observatory-pulse {
-  0%, 100% {
-    transform: scale(1);
-    opacity: 0.95;
-  }
-  50% {
-    transform: scale(1.3);
-    opacity: 0.6;
-  }
-}
-
-.observatory-feed-card {
-  display: flex;
-  flex-direction: column;
-}
-
-.observatory-feed {
-  list-style: none;
-  padding: 0;
-  margin: 1rem 0 0;
-  display: flex;
-  flex-direction: column;
-  gap: 0.75rem;
-  max-height: 360px;
-  overflow-y: auto;
-}
-
-.observatory-feed li {
-  padding: 0.75rem;
-  border-radius: 10px;
-  background: #f8fafc;
-  border: 1px solid #e2e8f0;
-}
-
-.observatory-feed .feed-row {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  margin-bottom: 0.35rem;
-}
-
-.observatory-feed .feed-row strong {
-  color: #0f172a;
-}
-
-.observatory-feed .feed-row .muted {
-  font-size: 0.85rem;
-}

frontend/src/types/diagnostics.ts

@@ -1,27 +0,0 @@
-export interface DiagnosticsNode {
-  id: string;
-  label: string;
-  group: "storage" | "service" | "external" | string;
-  position: { x: number; y: number };
-  last_event_at?: string | null;
-}
-
-export interface DiagnosticsEdge {
-  id: string;
-  source: string;
-  target: string;
-}
-
-export interface DiagnosticsTopology {
-  nodes: DiagnosticsNode[];
-  edges: DiagnosticsEdge[];
-}
-
-export interface DiagnosticsEvent {
-  id: string;
-  timestamp: string;
-  event_type: string;
-  message: string;
-  node_id?: string | null;
-  metadata?: Record<string, unknown>;
-}

frontend/src/types/session.ts

@@ -1,59 +0,0 @@
-export interface SessionSummary {
-  id: string;
-  name: string;
-  status: string;
-  created_at: string;
-  updated_at: string;
-  source_doc: string;
-  target_standard: string;
-  destination_standard: string;
-  standards_count: number;
-  last_error?: string | null;
-}
-
-export interface Session extends SessionSummary {
-  standards_docs: string[];
-  logs: string[];
-  metadata: Record<string, unknown>;
-}
-
-export interface CreateSessionPayload {
-  name: string;
-  target_standard: string;
-  destination_standard: string;
-  metadata?: Record<string, unknown>;
-  sourceFile: File;
-  standardsFiles?: File[];
-  standardsPresetId?: string | null;
-}
-
-export interface SessionStatusResponse {
-  id: string;
-  status: string;
-  updated_at: string;
-}
-
-export interface StandardsPreset {
-  id: string;
-  name: string;
-  description?: string | null;
-  documents: string[];
-  document_count: number;
-  status: string;
-  processed_count: number;
-  total_count: number;
-  last_error?: string | null;
-  created_at: string;
-  updated_at: string;
-}
-
-export interface CreatePresetPayload {
-  name: string;
-  description?: string;
-  files: File[];
-}
-
-export interface UpdatePresetPayload {
-  name?: string;
-  description?: string | null;
-}

infra/README.md

@@ -1,10 +0,0 @@
-# Infrastructure Assets
-
-Deployment and operational tooling for local, staging, and production environments.
-
-## Structure
-
-- `docker/` - Container definitions, compose files, and local runtime configs.
-- `configs/` - Shared configuration overlays (env templates, secrets examples).
-- `observability/` - Logging, metrics, and tracing configuration.
-- `ci/` - Continuous integration workflows and automation manifests.

scripts/README.md

@@ -1,9 +0,0 @@
-# Scripts
-
-Automation helpers for development, QA, and operations.
-
-## Structure
-
-- `dev/` - Local environment bootstrap, data loaders, and convenience tasks.
-- `tools/` - Linting, formatting, and code generation utilities.
-- `ops/` - Deployment, monitoring, and maintenance scripts.

server/.env.example

@@ -1,12 +0,0 @@
-RIGHTCODES_APP_NAME=RightCodes Server
-RIGHTCODES_DEBUG=true
-RIGHTCODES_API_PREFIX=/api
-RIGHTCODES_CORS_ORIGINS=["http://localhost:5173"]
-RIGHTCODES_STORAGE_DIR=./storage
-RIGHTCODES_OPENAI_API_KEY=sk-your-openai-key
-RIGHTCODES_OPENAI_API_BASE=https://api.openai.com/v1
-RIGHTCODES_OPENAI_MODEL_EXTRACT=gpt-4.1-mini
-RIGHTCODES_OPENAI_MODEL_MAPPING=gpt-4.1-mini
-RIGHTCODES_OPENAI_MODEL_REWRITE=gpt-4o-mini
-RIGHTCODES_OPENAI_MODEL_VALIDATE=gpt-4.1-mini
-RIGHTCODES_OPENAI_MODEL_EMBED=text-embedding-3-large