Deploy ROCmPilot Space

.dockerignore

@@ -0,0 +1,9 @@
+.git
+.next
+node_modules
+npm-debug.log
+.env
+.env.*
+!.env.example
+Dockerfile
+README.md.bak

Dockerfile

@@ -0,0 +1,32 @@
+FROM node:20-alpine AS deps
+
+WORKDIR /app
+COPY package.json package-lock.json ./
+RUN npm ci
+
+FROM node:20-alpine AS builder
+
+WORKDIR /app
+ENV NEXT_TELEMETRY_DISABLED=1
+COPY --from=deps /app/node_modules ./node_modules
+COPY . .
+RUN npm run build
+
+FROM node:20-alpine AS runner
+
+WORKDIR /app
+ENV NODE_ENV=production
+ENV NEXT_TELEMETRY_DISABLED=1
+ENV PORT=7860
+ENV HOSTNAME=0.0.0.0
+
+RUN addgroup -S nodejs && adduser -S nextjs -G nodejs
+
+COPY --from=builder /app/public ./public
+COPY --from=builder --chown=nextjs:nodejs /app/.next/standalone ./
+COPY --from=builder --chown=nextjs:nodejs /app/.next/static ./.next/static
+
+USER nextjs
+EXPOSE 7860
+
+CMD ["node", "server.js"]

README.md

@@ -1,10 +1,353 @@
 ---
-title: Rocmpilot
-emoji: 🐠
-colorFrom: gray
-colorTo: green
+title: ROCmPilot
 sdk: docker
-pinned: false
+app_port: 7860
+short_description: Agentic ROCm migration dashboard.
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# ROCmPilot
+
+ROCmPilot is a multi-agent developer tool that audits AI repositories and produces an AMD ROCm migration path for PyTorch, vLLM, and agentic workloads.
+
+> ROCmPilot helps teams move from CUDA/NVIDIA assumptions to AMD ROCm readiness by scanning a repo, identifying blockers, proposing patches, preparing validation commands, and generating a technical/business migration report.
+
+The project is built for the **AMD Developer Hackathon, Track 1: AI Agents & Agentic Workflows**. It uses Hugging Face as the temporary model and training layer now, and is designed to switch to AMD Developer Cloud + MI300X + ROCm/vLLM when access is available.
+
+Read the full build story, architecture diagrams, demo script, and implementation details in the **[Technical Walkthrough](./TECHNICAL_WALKTHROUGH.md)**.
+
+## Why This Exists
+
+Many AI teams want AMD GPU optionality, but their codebases quietly assume NVIDIA:
+
+- `nvidia/cuda` Docker images
+- `torch.device("cuda")` and `.cuda()` calls scattered across code
+- CUDA-specific package pins
+- `nvidia-smi`, `CUDA_VISIBLE_DEVICES`, or `--gpus all` scripts
+- vLLM launch scripts without ROCm/MI300X validation knobs
+- benchmarks that omit backend, memory, tokens/sec, and reproducibility evidence
+
+ROCmPilot turns that migration problem into an agentic workflow that feels like a product, not a checklist.
+
+## What It Does Today
+
+- Accepts a curated sample workload or a **public GitHub repository URL**.
+- Scans relevant files from the repo using the GitHub API.
+- Detects CUDA/NVIDIA assumptions.
+- Produces ROCm-focused findings and patch previews.
+- Shows a five-agent progress timeline.
+- Shows an **Agent War Room** where the task lead asks other agents for input, agents reply to each other, and shared memory records reusable decisions.
+- Persists the agent transcript to **Maximem Synap** long-context memory when `SYNAP_API_KEY` is configured, with local fallback when it is not.
+- Generates terminal-style migration logs.
+- Builds an AMD-readiness benchmark profile.
+- Generates a final report using this backend priority:
+  1. AMD ROCm/vLLM endpoint, when `AMD_QWEN_BASE_URL` is configured
+  2. Hugging Face Inference Router, when `HF_TOKEN` is configured
+  3. Static fallback report, so the demo never breaks
+
+## Agent Workflow
+
+1. **Repo Doctor Agent**
+   - Scans Dockerfiles, Python files, requirements, scripts, benchmark files, and vLLM-related configs.
+   - Flags CUDA/NVIDIA assumptions and missing validation evidence.
+
+2. **Migration Planner Agent**
+   - Converts findings into ROCm migration recommendations.
+   - Produces patch previews such as `Dockerfile.rocm`, `requirements-rocm.txt`, device resolvers, and vLLM serve scripts.
+
+3. **Build Runner Agent**
+   - Prepares the build/test story.
+   - In the current version, it does not mutate the target repo. It generates the commands and evidence plan.
+
+4. **Benchmark Agent**
+   - Produces an AMD-readiness profile.
+   - Current benchmark values are estimates until live AMD Developer Cloud validation is connected.
+
+5. **Report Agent**
+   - Generates a judge-ready report explaining technical findings, AMD GPU path, business value, and next steps.
+   - Can use Hugging Face now and AMD-hosted Qwen later.
+
+### Agent War Room and Long-Context Memory
+
+Each task has one lead agent, but the lead does not work alone. The lead asks the other agents for objections, validation criteria, benchmark provenance, or report framing. Their discussion is rendered as routed messages such as `Repo Doctor -> Build Runner` and `Migration Planner -> Build Runner`.
+
+The agents also write reusable memory during the run:
+
+- device resolution patterns
+- ROCm acceptance checks
+- container split decisions
+- benchmark provenance rules
+
+When Synap is configured, the Report Agent stores the whole war-room transcript as an `ai-chat-conversation`, retrieves scoped user context, and injects that context into the final report prompt. This lets ROCmPilot remember migration decisions across runs instead of rediscovering the same patterns every session.
+
+If Synap credentials or runtime setup are missing, ROCmPilot falls back to reconstructed local memory and marks the UI as `Synap Memory: Local fallback`. The demo still completes.
+
+## Architecture
+
+```text
+Browser UI
+  |
+  | POST /api/runs
+  v
+Stateless Run ID
+  |
+  | GET /api/runs/[runId]
+  v
+Repo Doctor + GitHub Scanner
+  |
+  v
+Findings + Patch Previews + Logs + Agent Memory + Benchmark Profile
+  |
+  | POST /api/report
+  v
+Report Agent
+  |
+  | optional memory layer
+  v
+Maximem Synap long-context memory -> local fallback memory
+  |
+  | priority order
+  v
+AMD ROCm/vLLM -> Hugging Face Router -> Static fallback
+```
+
+The run system is stateless so it works on Vercel serverless functions without a database. The run ID encodes the start time, mode, and target. For the polished production version, real long-running AMD jobs should use persistent storage and a queue.
+
+## Tech Stack
+
+- Next.js App Router
+- TypeScript
+- Tailwind CSS
+- shadcn/ui
+- AI Elements for markdown, code, and terminal rendering
+- Hugging Face Inference Router for temporary report generation
+- Hugging Face Jobs/TRL for future LoRA fine-tuning
+- Maximem Synap for persistent long-context agent memory
+- AMD ROCm/vLLM endpoint support for the final compute story
+
+## Local Development
+
+```bash
+npm install
+npm run dev
+```
+
+Open:
+
+```text
+http://localhost:3000
+```
+
+Run checks:
+
+```bash
+npm run lint
+npm run build
+```
+
+Optional Synap runtime setup for local or worker deployments:
+
+```bash
+npm run synap:setup
+```
+
+The Synap JS SDK uses a Python bridge. Vercel can still deploy the app without this setup because the report route falls back safely when Synap cannot initialize.
+
+## Environment Variables
+
+Temporary Hugging Face model backend:
+
+```bash
+HF_TOKEN=your_hugging_face_token
+HF_REPORT_MODEL=Qwen/Qwen2.5-Coder-7B-Instruct
+```
+
+Optional GitHub token for higher public API limits:
+
+```bash
+GITHUB_TOKEN=your_github_token
+```
+
+Optional long-context memory:
+
+```bash
+SYNAP_API_KEY=your_synap_api_key
+SYNAP_INSTANCE_ID=your_synap_instance_id
+SYNAP_CUSTOMER_ID=rocmpilot-hackathon
+SYNAP_USER_ID=rocmpilot-agent-fleet
+SYNAP_AUTO_SETUP=false
+```
+
+Synap uses the default cloud endpoints automatically. Advanced deployments can also set `SYNAP_BASE_URL`, `SYNAP_GRPC_HOST`, `SYNAP_GRPC_PORT`, and `SYNAP_GRPC_TLS`.
+
+Future AMD ROCm/vLLM backend:
+
+```bash
+AMD_QWEN_BASE_URL=http://YOUR_AMD_INSTANCE:8000
+AMD_QWEN_MODEL=Qwen/Qwen3-Coder-Next
+AMD_QWEN_API_KEY=optional-if-your-endpoint-requires-it
+```
+
+When `AMD_QWEN_BASE_URL` is present, the app automatically prefers AMD over Hugging Face.
+
+## Deploy on Vercel
+
+Vercel is the preferred web deployment target.
+
+```bash
+vercel
+```
+
+Set environment variables in Vercel Project Settings:
+
+- `HF_TOKEN`
+- `HF_REPORT_MODEL`
+- `GITHUB_TOKEN` optional
+- `SYNAP_API_KEY` optional
+- `SYNAP_INSTANCE_ID` optional
+- `SYNAP_CUSTOMER_ID` optional
+- `SYNAP_USER_ID` optional
+- `AMD_QWEN_BASE_URL` later
+- `AMD_QWEN_MODEL` later
+
+The current app does not require a database for the demo flow. Synap is optional and the UI will show whether long-context memory is connected or using fallback memory.
+
+## Deploy as a Hugging Face Space
+
+The repo also includes a Docker Space setup for hackathon submissions that require a Hugging Face Space link.
+
+Files:
+
+- `Dockerfile`
+- `.dockerignore`
+- Space metadata in this README frontmatter
+
+Create a Docker Space, then upload this project. The app listens on port `7860` in the Space container.
+
+Recommended Space ID:
+
+```text
+Shivam311/rocmpilot
+```
+
+## Training and Improving the Agents
+
+The `agent-training/` folder contains the training path for a more accurate agent:
+
+- `seed-examples.jsonl`: 95 supervised seed examples across migration, patch, benchmark, report, and memory-agent tasks
+- `eval-rubric.md`: scoring rubric
+- `scripts/generate_seed_examples.py`: expands synthetic examples for common CUDA-to-ROCm failure modes
+- `scripts/prepare_dataset.py`: converts seed examples into chat SFT format
+- `scripts/train_rocmpilot_sft.py`: LoRA SFT script for Hugging Face Jobs
+- `scripts/evaluate_agent.py`: smoke eval against an OpenAI-compatible endpoint
+
+Regenerate the local seed and preview files:
+
+```bash
+python agent-training/scripts/generate_seed_examples.py
+python agent-training/scripts/prepare_dataset.py
+```
+
+Prepare and push a seed dataset:
+
+```bash
+python agent-training/scripts/prepare_dataset.py \
+  --push \
+  --repo-id Shivam311/rocmpilot-agent-sft
+```
+
+Launch a small training run on Hugging Face Jobs after confirming paid Jobs access:
+
+```bash
+hf jobs uv run \
+  --flavor t4-small \
+  --timeout 90m \
+  --secrets HF_TOKEN \
+  --env DATASET_ID=Shivam311/rocmpilot-agent-sft \
+  --env OUTPUT_MODEL=Shivam311/rocmpilot-agent-qwen-lora-v2 \
+  --env MAX_STEPS=160 \
+  agent-training/scripts/train_rocmpilot_sft.py
+```
+
+Run eval:
+
+```bash
+python agent-training/scripts/evaluate_agent.py
+```
+
+For a serious version, expand the dataset to at least 200-500 examples from real migration cases before training.
+
+## Future AMD Integration
+
+Once AMD Developer Cloud access is ready:
+
+1. Start an MI300X instance.
+2. Install or use a ROCm/vLLM image.
+3. Serve Qwen through an OpenAI-compatible vLLM endpoint.
+4. Set `AMD_QWEN_BASE_URL` in Vercel.
+5. Re-run ROCmPilot and capture:
+   - vLLM startup logs
+   - AMD GPU visibility
+   - one model response
+   - benchmark output
+   - final report generated through AMD-hosted Qwen
+
+Suggested serving command:
+
+```bash
+python -m vllm.entrypoints.openai.api_server \
+  --model Qwen/Qwen3-Coder-Next \
+  --host 0.0.0.0 \
+  --port 8000 \
+  --tensor-parallel-size 1 \
+  --max-model-len 32768
+```
+
+## What Is Real vs Temporary
+
+Real today:
+
+- Working dashboard
+- Public GitHub URL intake
+- GitHub API file scan
+- Rule-based ROCm findings
+- Patch previews
+- Report backend priority system
+- Vercel-safe stateless run flow
+- Hugging Face training scaffold
+
+Temporary/demo today:
+
+- Patch previews are not committed back to GitHub yet
+- Build logs are generated evidence, not real Docker builds
+- Benchmark numbers are estimates until AMD validation
+- Model fine-tuning scripts are ready but not launched automatically
+
+Next production upgrades:
+
+- GitHub App auth and PR creation
+- Persistent run history
+- Real queue for AMD validation jobs
+- Live ROCm Docker builds
+- Live vLLM benchmarks
+- Fine-tuned ROCmPilot model hosted through HF/AMD
+
+## Submission Story
+
+ROCmPilot is a Track 1 agentic workflow because the core product is the coordination of specialized agents that inspect, plan, validate, benchmark, and report. AMD compute enters as the target validation environment and the future hosted model runtime for Qwen on ROCm/vLLM.
+
+The clean hackathon positioning:
+
+> ROCmPilot helps developers migrate AI workloads to AMD faster. It scans a GitHub repo, finds CUDA assumptions, proposes ROCm patches, prepares AMD validation, and generates a business-ready migration report. Today it runs with Hugging Face fallback; when AMD Developer Cloud is available, the same app switches to Qwen served on MI300X through ROCm/vLLM.
+
+## Sources
+
+- AMD: Day 0 Support for Qwen3-Coder-Next on AMD Instinct GPUs  
+  https://www.amd.com/en/developer/resources/technical-articles/2026/day-0-support-for-qwen3-coder-next-on-amd-instinct-gpus.html
+- Qwen3-Coder announcement  
+  https://qwenlm.github.io/blog/qwen3-coder/
+- vLLM supported models  
+  https://docs.vllm.ai/en/v0.15.1/models/supported_models/
+- Hugging Face Docker Spaces  
+  https://huggingface.co/docs/hub/spaces-sdks-docker
+- Hugging Face Jobs  
+  https://huggingface.co/docs/huggingface_hub/guides/jobs

TECHNICAL_WALKTHROUGH.md

@@ -0,0 +1,461 @@
+# ROCmPilot Technical Walkthrough
+
+![Track](https://img.shields.io/badge/Track-AI%20Agents%20%26%20Agentic%20Workflows-0ea5e9)
+![AMD](https://img.shields.io/badge/AMD-ROCm%20%2B%20vLLM-ed1c24)
+![Model](https://img.shields.io/badge/Model-Qwen%20Coder-7c3aed)
+![Frontend](https://img.shields.io/badge/Frontend-Next.js%20%2B%20TypeScript-111827)
+![Memory](https://img.shields.io/badge/Memory-Maximem%20Synap-f43f5e)
+![Deployment](https://img.shields.io/badge/Deploy-Vercel-black)
+
+## Submission Links
+
+| Artifact | Link |
+| --- | --- |
+| Live demo | [https://rocmpilot.vercel.app](https://rocmpilot.vercel.app) |
+| Source code | [https://github.com/shivambhartiya/rocmpilot](https://github.com/shivambhartiya/rocmpilot) |
+| Training dataset | [https://huggingface.co/datasets/Shivam311/rocmpilot-agent-sft](https://huggingface.co/datasets/Shivam311/rocmpilot-agent-sft) |
+| Technical walkthrough | [TECHNICAL_WALKTHROUGH.md](./TECHNICAL_WALKTHROUGH.md) |
+
+## One-Line Pitch
+
+ROCmPilot is a multi-agent developer tool that scans CUDA-first AI repositories and generates ROCm migration findings, patch previews, validation plans, reusable memory, and a judge-ready technical/business report.
+
+## Why ROCmPilot Matters
+
+AI teams often want AMD GPU optionality, but real repositories quietly assume NVIDIA at many layers:
+
+- Docker images such as `nvidia/cuda` or `nvcr.io/nvidia/pytorch`
+- Python code with `torch.device("cuda")`, `.cuda()`, or `device_map="cuda"`
+- dependency pins for `cu121`, `cu124`, `nvidia-cublas-cu12`, `flash-attn`, or `xformers`
+- scripts using `nvidia-smi`, `CUDA_VISIBLE_DEVICES`, or `--gpus all`
+- vLLM launch scripts that do not expose ROCm validation knobs
+- benchmarks that report latency without backend, memory, tokens/sec, or command provenance
+
+ROCmPilot converts that messy migration work into a structured agentic workflow. It does not pretend to automatically port every project. Instead, it gives developers a credible migration map, concrete patch previews, validation evidence, and a report they can hand to maintainers or infrastructure leaders.
+
+## Product Overview
+
+```mermaid
+flowchart LR
+  U["Developer pastes a public GitHub URL"] --> UI["ROCmPilot Dashboard"]
+  UI --> R["Run Orchestrator"]
+  R --> G["GitHub Scanner"]
+  G --> D["Repo Doctor Agent"]
+  D --> P["Migration Planner Agent"]
+  P --> B["Build Runner Agent"]
+  B --> M["Benchmark Agent"]
+  M --> W["Agent War Room"]
+  W --> S["Synap Long-Context Memory"]
+  W --> REP["Report Agent"]
+  REP --> HF["Hugging Face Qwen fallback"]
+  REP --> AMD["Future AMD ROCm/vLLM Qwen endpoint"]
+  REP --> OUT["Final migration report"]
+  P --> PATCH["ROCm patch previews"]
+  M --> EVID["Validation checklist"]
+```
+
+## User Flow
+
+1. Open the ROCmPilot dashboard.
+2. Select a sample workload or paste a public GitHub repository URL.
+3. Start a run.
+4. Watch the live agent timeline and Agent War Room.
+5. Review findings, patch previews, logs, benchmark profile, and long-context memory status.
+6. Read the generated final report.
+7. Use the output as a migration plan or as the basis for a future PR.
+
+## Agent System
+
+ROCmPilot uses specialized agents, each responsible for a different migration concern.
+
+| Agent | Responsibility | Output |
+| --- | --- | --- |
+| Repo Doctor Agent | Finds CUDA/NVIDIA assumptions across code, Docker, scripts, dependencies, and benchmarks. | Findings with severity, category, file, line, and fix. |
+| Migration Planner Agent | Converts findings into ROCm-safe migration recommendations. | Patch previews and backend-aware migration steps. |
+| Build Runner Agent | Challenges whether the plan can be validated. | Smoke-test commands, container checks, and proof boundaries. |
+| Benchmark Agent | Separates live evidence from estimates. | AMD-readiness profile and measurement plan. |
+| Memory Agent | Stores reusable decisions across runs. | Synap-backed long-context memory or local fallback memory. |
+| Report Agent | Turns the run into a credible submission/report. | Final markdown report with technical and business value. |
+
+## Agent War Room
+
+The MVP is not just a set of isolated cards. Agents route messages to each other, ask questions, answer objections, and write shared memory.
+
+```mermaid
+sequenceDiagram
+  participant O as Orchestrator
+  participant R as Repo Doctor
+  participant P as Migration Planner
+  participant B as Build Runner
+  participant M as Benchmark Agent
+  participant S as Shared Memory
+  participant X as Report Agent
+
+  O->>R: Lead the repo compatibility scan
+  R->>B: Which findings are build-breaking?
+  B-->>R: Container image, device path, and smoke test gaps
+  R->>P: Design the safest ROCm migration step
+  P-->>R: Use one backend-aware device resolver
+  R->>S: Store device resolution pattern
+  O->>P: Lead the migration plan using memory
+  P->>B: What proves this is ROCm-ready?
+  B-->>P: Log torch.version.hip and hit vLLM health endpoint
+  B->>S: Store ROCm acceptance checks
+  O->>M: Lead benchmark evidence
+  M->>X: How do we label estimated metrics?
+  X-->>M: Keep estimates separate from live AMD logs
+  M->>S: Store metric provenance rule
+  X->>S: Recall decisions for the final report
+```
+
+## Long-Context Memory With Synap
+
+ROCmPilot integrates Maximem Synap as the long-context memory layer. When configured, the Report Agent stores the whole agent discussion as an `ai-chat-conversation`, fetches relevant context, and injects it into report generation.
+
+If Synap credentials or runtime setup are unavailable, ROCmPilot falls back to reconstructed local memory so the demo remains reliable.
+
+```mermaid
+flowchart TB
+  RUN["Completed ROCmPilot run"] --> DISC["Agent messages and shared memory"]
+  DISC --> SYNC{"SYNAP_API_KEY configured?"}
+  SYNC -- "Yes" --> INGEST["Synap addMemory"]
+  INGEST --> FETCH["Synap fetchUserContext and getContextForPrompt"]
+  FETCH --> PROMPT["Report prompt enriched with long-context memory"]
+  SYNC -- "No or runtime unavailable" --> LOCAL["Local reconstructed memory"]
+  LOCAL --> PROMPT
+  PROMPT --> REPORT["Final report"]
+```
+
+### Memory Values Stored
+
+| Memory Type | Example |
+| --- | --- |
+| Device resolution pattern | Use a single backend resolver instead of scattered `.cuda()` checks. |
+| ROCm acceptance checks | Prove import, backend detection, vLLM health, and provenance logging. |
+| Container split decision | Add `Dockerfile.rocm`; keep CUDA support separate. |
+| Metric provenance rule | Label estimates until AMD SMI/vLLM logs exist. |
+| Health-check rule | Replace `nvidia-smi` proof with `rocm-smi` or `amd-smi` proof on AMD. |
+
+## Detection and Recommendation Logic
+
+ROCmPilot scans public GitHub repositories using the GitHub API and focuses on files that usually control AI runtime portability.
+
+```mermaid
+flowchart LR
+  TREE["GitHub repository tree"] --> FILTER["Relevant file filter"]
+  FILTER --> FILES["Dockerfiles, Python, shell scripts, requirements, YAML, benchmark files"]
+  FILES --> RULES["ROCm compatibility rules"]
+  RULES --> FIND["Findings"]
+  FIND --> PATCH["Patch previews"]
+  FIND --> MEM["Memory writes"]
+  PATCH --> REPORT["Final report"]
+```
+
+### Current Detection Categories
+
+| Category | Severity | Typical Evidence | Recommended Direction |
+| --- | --- | --- | --- |
+| Hardcoded CUDA device path | Critical | `.cuda()`, `torch.device("cuda")`, `device_map="cuda"` | Add a backend-aware resolver and log ROCm/CUDA/CPU provenance. |
+| NVIDIA container/runtime assumption | High | `nvidia/cuda`, `nvcr.io`, `--gpus all` | Add ROCm runtime image/profile and keep CUDA optional. |
+| CUDA-oriented dependency | High | `cu124`, `nvidia-cublas-cu12`, `flash-attn`, `xformers` | Split dependencies into backend-specific profiles. |
+| vLLM defaults need AMD profile | Medium | vLLM launch without model length, tensor parallelism, or metrics | Add ROCm vLLM serve script with OpenAI-compatible endpoint settings. |
+| Benchmark evidence incomplete | Medium | latency-only benchmark | Add tokens/sec, memory, backend, model id, command provenance, p95 latency. |
+| NVIDIA monitoring command | Medium | `nvidia-smi` | Add `rocm-smi` or `amd-smi` evidence path. |
+| CUDA extension build path | High | `.cu`, `CUDAExtension`, `CUDA_HOME` | Gate CUDA extension builds and document ROCm-safe alternatives. |
+| Docker Compose NVIDIA reservation | High | `driver: nvidia`, `runtime: nvidia` | Add separate ROCm Compose profile. |
+
+## Patch Preview Example
+
+ROCmPilot does not currently mutate external repositories or open PRs automatically. Instead, it generates patch previews that are safe to review.
+
+```diff
++import torch
++
++def resolve_device() -> tuple[str, str]:
++    if torch.cuda.is_available():
++        backend = "rocm" if getattr(torch.version, "hip", None) else "cuda"
++        return "cuda", backend
++    return "cpu", "cpu"
++
++DEVICE, GPU_BACKEND = resolve_device()
+```
+
+This pattern is important because PyTorch on ROCm still exposes GPU access through the `torch.cuda` API surface. The resolver records whether the backend is actually CUDA or HIP-backed ROCm.
+
+## Model and Compute Strategy
+
+ROCmPilot is a Track 1 agentic workflow project. The GPU plan is model serving, not fine-tuning as the main hackathon track.
+
+```mermaid
+flowchart TD
+  REPORT["Report Agent request"] --> AMDQ{"AMD_QWEN_BASE_URL set?"}
+  AMDQ -- "Yes" --> VLLM["Qwen on AMD MI300X through ROCm/vLLM"]
+  AMDQ -- "No" --> HFQ{"HF_TOKEN set?"}
+  HFQ -- "Yes" --> HF["Hugging Face Router with Qwen"]
+  HFQ -- "No" --> STATIC["Deterministic fallback report"]
+  VLLM --> RESP["Final report"]
+  HF --> RESP
+  STATIC --> RESP
+```
+
+### Backend Priority
+
+1. AMD ROCm/vLLM endpoint via `AMD_QWEN_BASE_URL`
+2. Hugging Face Router via `HF_TOKEN`
+3. Static fallback report
+
+This keeps the submission demo-safe while preserving the AMD compute story. Once AMD Developer Cloud access is available, the same report endpoint can prefer AMD-hosted Qwen automatically.
+
+## Training Path on Hugging Face
+
+The project includes a small supervised fine-tuning path for polishing the agent style and migration recommendations.
+
+| Artifact | Detail |
+| --- | --- |
+| Dataset repo | [Shivam311/rocmpilot-agent-sft](https://huggingface.co/datasets/Shivam311/rocmpilot-agent-sft) |
+| Current seed size | 95 examples |
+| Tasks | migration planner, patch planner, benchmark agent, report agent, memory agent |
+| Base model target | `Qwen/Qwen2.5-Coder-0.5B-Instruct` for small LoRA experiments |
+| Output model target | `Shivam311/rocmpilot-agent-qwen-lora-v2` |
+
+```mermaid
+flowchart LR
+  SEED["Synthetic and human-reviewed examples"] --> PREP["prepare_dataset.py"]
+  PREP --> DATASET["HF Dataset: rocmpilot-agent-sft"]
+  DATASET --> TRAIN["LoRA SFT job"]
+  TRAIN --> MODEL["Qwen LoRA adapter"]
+  MODEL --> EVAL["evaluate_agent.py"]
+  EVAL --> APP["Future report/migration backend"]
+```
+
+Training is supporting polish, not the central submission claim. The main project remains an agentic developer workflow.
+
+## App Architecture
+
+```mermaid
+flowchart TB
+  subgraph Frontend
+    UI["Next.js dashboard"]
+    WAR["Agent War Room"]
+    TABLE["Findings and patch panels"]
+    STATUS["GPU and memory status cards"]
+  end
+
+  subgraph API
+    RUNS["/api/runs"]
+    RUNID["/api/runs/[runId]"]
+    REPORT["/api/report"]
+  end
+
+  subgraph Core
+    STORE["Stateless run store"]
+    SCAN["GitHub scanner"]
+    DATA["ROCmPilot run model"]
+    SYNAP["Synap memory adapter"]
+  end
+
+  subgraph External
+    GH["GitHub API"]
+    HF["Hugging Face Router"]
+    AMD["AMD ROCm/vLLM endpoint"]
+    SM["Maximem Synap"]
+  end
+
+  UI --> RUNS
+  UI --> RUNID
+  UI --> REPORT
+  RUNS --> STORE
+  RUNID --> SCAN
+  SCAN --> GH
+  STORE --> DATA
+  DATA --> WAR
+  REPORT --> SYNAP
+  SYNAP --> SM
+  REPORT --> AMD
+  REPORT --> HF
+```
+
+## Data Model
+
+```mermaid
+erDiagram
+  ROCM_RUN ||--o{ RUN_STAGE : has
+  ROCM_RUN ||--o{ FINDING : produces
+  ROCM_RUN ||--o{ PATCH_PREVIEW : proposes
+  ROCM_RUN ||--o{ AGENT_MESSAGE : contains
+  ROCM_RUN ||--o{ AGENT_MEMORY : stores
+  ROCM_RUN ||--o{ BENCHMARK_RESULT : profiles
+  ROCM_RUN ||--|| GPU_MODEL_STATUS : reports
+  ROCM_RUN ||--|| LONG_CONTEXT_MEMORY_STATUS : reports
+
+  FINDING {
+    string severity
+    string category
+    string file
+    int line
+    string recommendedFix
+  }
+
+  AGENT_MESSAGE {
+    string agent
+    string toAgent
+    string kind
+    string task
+    string leadAgent
+  }
+
+  AGENT_MEMORY {
+    string title
+    string scope
+    string learnedFromAgent
+    string solution
+  }
+```
+
+## Deployment Architecture
+
+```mermaid
+flowchart LR
+  DEV["GitHub main branch"] --> VERCEL["Vercel deployment"]
+  VERCEL --> APP["rocmpilot.vercel.app"]
+  VERCEL --> ENV["Environment variables"]
+  ENV --> HFENV["HF_TOKEN"]
+  ENV --> SYNENV["SYNAP_API_KEY and SYNAP_INSTANCE_ID"]
+  ENV --> AMDENV["AMD_QWEN_BASE_URL later"]
+  APP --> USER["Hackathon judges and users"]
+```
+
+## Environment Variables
+
+| Variable | Required for MVP | Purpose |
+| --- | --- | --- |
+| `HF_TOKEN` | Recommended | Enables Hugging Face Qwen report generation. |
+| `HF_REPORT_MODEL` | Optional | Defaults to `Qwen/Qwen2.5-Coder-7B-Instruct`. |
+| `GITHUB_TOKEN` | Optional | Raises GitHub API limits for public repo scans. |
+| `SYNAP_INSTANCE_ID` | Optional | Targets the Synap memory instance. |
+| `SYNAP_API_KEY` | Optional | Enables persistent long-context memory. |
+| `SYNAP_BASE_URL` | Optional | Synap cloud endpoint override. |
+| `SYNAP_CUSTOMER_ID` | Optional | Memory scope, defaults to `rocmpilot-hackathon`. |
+| `SYNAP_USER_ID` | Optional | Agent fleet memory identity. |
+| `AMD_QWEN_BASE_URL` | Later | Enables AMD-hosted Qwen through ROCm/vLLM. |
+| `AMD_QWEN_MODEL` | Later | Defaults to `Qwen/Qwen3-Coder-Next`. |
+
+## Demo Script
+
+Use this script for a 2-3 minute project walkthrough.
+
+1. Open [https://rocmpilot.vercel.app](https://rocmpilot.vercel.app).
+2. Paste a CUDA-heavy public repo, for example `https://github.com/NVIDIA/cuda-samples` or `https://github.com/NVIDIA/Megatron-LM`.
+3. Click `Scan Repo`.
+4. Explain that Repo Doctor scans public files for CUDA/NVIDIA assumptions.
+5. Point to the Agent War Room and show agents asking each other questions instead of acting independently.
+6. Show Shared Memory and explain that decisions are reused later.
+7. Open Migration Findings and Patch Previews.
+8. Open the GPU model status card and explain the backend priority: AMD ROCm/vLLM when available, Hugging Face fallback now, static fallback for reliability.
+9. Open the Long-context memory card and explain Synap memory.
+10. Show the final report and emphasize business value: faster AMD migration planning, reduced infra risk, and a clear path from audit to validation.
+
+## What Is Fully Implemented Today
+
+| Capability | Status |
+| --- | --- |
+| Next.js dashboard | Implemented |
+| Public GitHub URL scan | Implemented |
+| CUDA/NVIDIA findings | Implemented |
+| Patch previews | Implemented |
+| Agent War Room routed messages | Implemented |
+| Shared run memory | Implemented |
+| Synap memory adapter | Implemented with fallback |
+| Hugging Face Qwen report generation | Implemented when `HF_TOKEN` is configured |
+| Static fallback report | Implemented |
+| Vercel deployment | Implemented |
+| Training dataset | Implemented and published |
+
+## Honest Boundaries
+
+| Capability | Current Boundary |
+| --- | --- |
+| Automatic PR creation | Not implemented yet. ROCmPilot generates patch previews and recommendations. |
+| Live AMD MI300X benchmark proof | Pending AMD Developer Cloud access. Current benchmark cards are labeled static estimates. |
+| Synap on every Vercel run | Integrated, but falls back if the Synap Python bridge cannot initialize in the serverless runtime. |
+| Full repository mutation | Not performed by design in the MVP. Maintainers should review patch previews first. |
+
+## Business Value
+
+ROCmPilot is useful for:
+
+- AI startups that want AMD GPU optionality without manually auditing every codebase.
+- Infrastructure teams evaluating whether an internal CUDA-first service can move to ROCm.
+- Open-source maintainers who want clear, reviewable migration guidance.
+- Cloud/GPU providers that need a repeatable readiness assessment workflow.
+
+### Business Impact
+
+| Problem | ROCmPilot Value |
+| --- | --- |
+| Migration audits are manual and slow. | Automated agentic scan and report. |
+| CUDA assumptions hide across many files. | Multi-layer detection across Docker, Python, shell, dependencies, and benchmarks. |
+| Teams overclaim hardware readiness. | Explicit separation of estimates, fallback, and live AMD proof. |
+| Migration work is hard to hand off. | Patch previews and judge/infra-ready report. |
+| Agents forget past decisions. | Synap long-context memory for reusable migration knowledge. |
+
+## Roadmap
+
+```mermaid
+gantt
+  title ROCmPilot Roadmap
+  dateFormat  YYYY-MM-DD
+  section MVP
+  Dashboard and agent workflow           :done,    mvp1, 2026-05-04, 1d
+  GitHub scan and patch previews         :done,    mvp2, 2026-05-04, 1d
+  Synap memory integration               :done,    mvp3, 2026-05-05, 1d
+  Training dataset expansion             :done,    mvp4, 2026-05-05, 1d
+  section Next
+  Automatic PR generation                :active,  next1, 2026-05-06, 2d
+  Live AMD MI300X vLLM proof             :         next2, 2026-05-07, 2d
+  Larger human-reviewed dataset          :         next3, 2026-05-08, 4d
+  NodeOps memory worker                  :         next4, 2026-05-08, 3d
+```
+
+## Future AMD Integration
+
+When AMD Developer Cloud access is available:
+
+1. Start an MI300X instance.
+2. Launch Qwen through ROCm/vLLM using an OpenAI-compatible server.
+3. Set `AMD_QWEN_BASE_URL` and `AMD_QWEN_MODEL` in Vercel.
+4. Re-run ROCmPilot.
+5. Capture proof:
+   - AMD GPU visibility logs
+   - vLLM startup logs
+   - one successful model response
+   - workload validation output
+   - updated final report generated through AMD-hosted Qwen
+
+Suggested command:
+
+```bash
+python -m vllm.entrypoints.openai.api_server \
+  --model Qwen/Qwen3-Coder-Next \
+  --host 0.0.0.0 \
+  --port 8000 \
+  --tensor-parallel-size 1 \
+  --max-model-len 32768
+```
+
+## Why This Fits Track 1
+
+ROCmPilot is not primarily a fine-tuning project and not primarily a multimodal project. It is a coordinated AI-agent workflow:
+
+- multiple specialized agents
+- routed agent-to-agent discussion
+- lead-agent task ownership
+- shared and persistent memory
+- model-backed report generation
+- real developer workflow around repository migration
+
+That makes **AI Agents & Agentic Workflows** the best hackathon track.
+
+## Closing Summary
+
+ROCmPilot turns CUDA-to-ROCm migration from an unclear engineering chore into an agentic developer workflow. It scans real repositories, identifies migration blockers, proposes ROCm-ready patches, records reusable memory, and generates a technical/business report. The MVP is reliable on Vercel today through Hugging Face and fallback paths, while the architecture is ready to upgrade to AMD Instinct GPUs with ROCm/vLLM as soon as AMD cloud access is available.

components.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://ui.shadcn.com/schema.json",
+  "style": "radix-nova",
+  "rsc": true,
+  "tsx": true,
+  "tailwind": {
+    "config": "",
+    "css": "src/app/globals.css",
+    "baseColor": "neutral",
+    "cssVariables": true,
+    "prefix": ""
+  },
+  "iconLibrary": "lucide",
+  "rtl": false,
+  "aliases": {
+    "components": "@/components",
+    "utils": "@/lib/utils",
+    "ui": "@/components/ui",
+    "lib": "@/lib",
+    "hooks": "@/hooks"
+  },
+  "menuColor": "default",
+  "menuAccent": "subtle",
+  "registries": {}
+}

eslint.config.mjs

@@ -0,0 +1,18 @@
+import { defineConfig, globalIgnores } from "eslint/config";
+import nextVitals from "eslint-config-next/core-web-vitals";
+import nextTs from "eslint-config-next/typescript";
+
+const eslintConfig = defineConfig([
+  ...nextVitals,
+  ...nextTs,
+  // Override default ignores of eslint-config-next.
+  globalIgnores([
+    // Default ignores of eslint-config-next:
+    ".next/**",
+    "out/**",
+    "build/**",
+    "next-env.d.ts",
+  ]),
+]);
+
+export default eslintConfig;

next.config.ts

@@ -0,0 +1,7 @@
+import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {
+  output: "standalone",
+};
+
+export default nextConfig;

package.json

@@ -0,0 +1,43 @@
+{
+  "name": "rocmpilot",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "lint": "eslint",
+    "synap:setup": "synap-js-sdk setup --sdk-version 0.1.1"
+  },
+  "dependencies": {
+    "@maximem/synap-js-sdk": "^0.2.4",
+    "@streamdown/cjk": "^1.0.3",
+    "@streamdown/code": "^1.1.1",
+    "@streamdown/math": "^1.0.2",
+    "@streamdown/mermaid": "^1.0.2",
+    "ai": "^6.0.174",
+    "ansi-to-react": "^6.2.6",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "lucide-react": "^1.14.0",
+    "next": "16.2.4",
+    "radix-ui": "^1.4.3",
+    "react": "19.2.4",
+    "react-dom": "19.2.4",
+    "shadcn": "^4.6.0",
+    "shiki": "^4.0.2",
+    "streamdown": "^2.5.0",
+    "tailwind-merge": "^3.5.0",
+    "tw-animate-css": "^1.4.0"
+  },
+  "devDependencies": {
+    "@tailwindcss/postcss": "^4",
+    "@types/node": "^20",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "eslint": "^9",
+    "eslint-config-next": "16.2.4",
+    "tailwindcss": "^4",
+    "typescript": "^5"
+  }
+}

postcss.config.mjs

@@ -0,0 +1,7 @@
+const config = {
+  plugins: {
+    "@tailwindcss/postcss": {},
+  },
+};
+
+export default config;

src/app/api/report/route.ts

@@ -0,0 +1,144 @@
+import { buildFallbackReport, buildReportPrompt, getModelStatus } from "@/lib/rocmpilot/data";
+import { syncRunMemoryWithSynap } from "@/lib/rocmpilot/synap-memory";
+import type { ReportResponse, RocmRun } from "@/lib/rocmpilot/types";
+import { NextResponse } from "next/server";
+
+export const runtime = "nodejs";
+
+type ChatCompletionResponse = {
+  choices?: Array<{
+    message?: {
+      content?: string;
+    };
+  }>;
+};
+
+async function generateWithAmdQwen(run: RocmRun, longContext: string) {
+  const baseUrl = process.env.AMD_QWEN_BASE_URL?.replace(/\/$/, "");
+
+  if (!baseUrl) {
+    return null;
+  }
+
+  const model = process.env.AMD_QWEN_MODEL ?? "Qwen/Qwen3-Coder-Next";
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+  };
+
+  if (process.env.AMD_QWEN_API_KEY) {
+    headers.Authorization = `Bearer ${process.env.AMD_QWEN_API_KEY}`;
+  }
+
+  const response = await fetch(`${baseUrl}/v1/chat/completions`, {
+    method: "POST",
+    headers,
+    signal: AbortSignal.timeout(15_000),
+    body: JSON.stringify({
+      model,
+      temperature: 0.25,
+      max_tokens: 900,
+      messages: [
+        {
+          role: "system",
+          content:
+            "You are the Report Agent for ROCmPilot. Write concise, credible hackathon submission reports. Do not invent live benchmark claims beyond the provided data.",
+        },
+        {
+          role: "user",
+          content: buildReportPrompt(run, longContext),
+        },
+      ],
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`AMD Qwen endpoint returned ${response.status}`);
+  }
+
+  const payload = (await response.json()) as ChatCompletionResponse;
+  return payload.choices?.[0]?.message?.content?.trim() || null;
+}
+
+async function generateWithHuggingFace(run: RocmRun, longContext: string) {
+  if (!process.env.HF_TOKEN) {
+    return null;
+  }
+
+  const response = await fetch("https://router.huggingface.co/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${process.env.HF_TOKEN}`,
+      "Content-Type": "application/json",
+    },
+    signal: AbortSignal.timeout(15_000),
+    body: JSON.stringify({
+      model: process.env.HF_REPORT_MODEL ?? "Qwen/Qwen2.5-Coder-7B-Instruct",
+      temperature: 0.25,
+      max_tokens: 900,
+      messages: [
+        {
+          role: "system",
+          content:
+            "You are the Report Agent for ROCmPilot. Write concise, credible hackathon submission reports. Do not invent live benchmark claims beyond the provided data.",
+        },
+        {
+          role: "user",
+          content: buildReportPrompt(run, longContext),
+        },
+      ],
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Hugging Face router returned ${response.status}`);
+  }
+
+  const payload = (await response.json()) as ChatCompletionResponse;
+  return payload.choices?.[0]?.message?.content?.trim() || null;
+}
+
+export async function POST(request: Request) {
+  const run = (await request.json()) as RocmRun;
+  const memorySync = await syncRunMemoryWithSynap(run);
+
+  try {
+    const report = await generateWithAmdQwen(run, memorySync.promptContext);
+
+    if (report) {
+      const response: ReportResponse = {
+        report,
+        source: "amd-vllm",
+        modelStatus: getModelStatus("amd-vllm"),
+        memoryStatus: memorySync.status,
+      };
+      return NextResponse.json(response);
+    }
+  } catch (error) {
+    console.warn("Falling back from AMD Qwen report generation:", error);
+  }
+
+  try {
+    const report = await generateWithHuggingFace(run, memorySync.promptContext);
+
+    if (report) {
+      const response: ReportResponse = {
+        report,
+        source: "hf-router",
+        modelStatus: getModelStatus("hf-router"),
+        memoryStatus: memorySync.status,
+      };
+      return NextResponse.json(response);
+    }
+  } catch (error) {
+    console.warn("Falling back from Hugging Face report generation:", error);
+  }
+
+  const response: ReportResponse = {
+    report: buildFallbackReport(run, memorySync.promptContext),
+    source: "fallback",
+    modelStatus: getModelStatus("fallback"),
+    memoryStatus: memorySync.status,
+  };
+
+  return NextResponse.json(response);
+}

src/app/api/runs/[runId]/route.ts

@@ -0,0 +1,16 @@
+import { getRun } from "@/lib/rocmpilot/store";
+import { NextResponse } from "next/server";
+
+export async function GET(
+  _request: Request,
+  context: { params: Promise<{ runId: string }> }
+) {
+  const { runId } = await context.params;
+  const run = await getRun(runId);
+
+  if (!run) {
+    return NextResponse.json({ error: "Run not found" }, { status: 404 });
+  }
+
+  return NextResponse.json(run);
+}

src/app/api/runs/route.ts

@@ -0,0 +1,19 @@
+import { createRun } from "@/lib/rocmpilot/store";
+import type { RunMode } from "@/lib/rocmpilot/types";
+import { NextResponse } from "next/server";
+
+export async function POST(request: Request) {
+  const body = (await request.json().catch(() => ({}))) as {
+    sampleId?: string;
+    mode?: RunMode;
+    repoUrl?: string;
+  };
+
+  const run = createRun(
+    body.sampleId ?? "qwen-vllm-cuda",
+    body.mode ?? "mock",
+    body.repoUrl
+  );
+
+  return NextResponse.json(run);
+}

src/app/globals.css

@@ -0,0 +1,131 @@
+@import "tailwindcss";
+@import "tw-animate-css";
+@import "shadcn/tailwind.css";
+@source "../node_modules/streamdown/dist/*.js";
+
+@custom-variant dark (&:is(.dark *));
+
+@theme inline {
+  --color-background: var(--background);
+  --color-foreground: var(--foreground);
+  --font-sans: "Geist", "Geist Fallback", ui-sans-serif, system-ui, sans-serif;
+  --font-mono: "Geist Mono", "Geist Mono Fallback", ui-monospace, monospace;
+  --font-heading: "Geist", "Geist Fallback", ui-sans-serif, system-ui, sans-serif;
+  --color-sidebar-ring: var(--sidebar-ring);
+  --color-sidebar-border: var(--sidebar-border);
+  --color-sidebar-accent-foreground: var(--sidebar-accent-foreground);
+  --color-sidebar-accent: var(--sidebar-accent);
+  --color-sidebar-primary-foreground: var(--sidebar-primary-foreground);
+  --color-sidebar-primary: var(--sidebar-primary);
+  --color-sidebar-foreground: var(--sidebar-foreground);
+  --color-sidebar: var(--sidebar);
+  --color-chart-5: var(--chart-5);
+  --color-chart-4: var(--chart-4);
+  --color-chart-3: var(--chart-3);
+  --color-chart-2: var(--chart-2);
+  --color-chart-1: var(--chart-1);
+  --color-ring: var(--ring);
+  --color-input: var(--input);
+  --color-border: var(--border);
+  --color-destructive: var(--destructive);
+  --color-accent-foreground: var(--accent-foreground);
+  --color-accent: var(--accent);
+  --color-muted-foreground: var(--muted-foreground);
+  --color-muted: var(--muted);
+  --color-secondary-foreground: var(--secondary-foreground);
+  --color-secondary: var(--secondary);
+  --color-primary-foreground: var(--primary-foreground);
+  --color-primary: var(--primary);
+  --color-popover-foreground: var(--popover-foreground);
+  --color-popover: var(--popover);
+  --color-card-foreground: var(--card-foreground);
+  --color-card: var(--card);
+  --radius-sm: calc(var(--radius) * 0.6);
+  --radius-md: calc(var(--radius) * 0.8);
+  --radius-lg: var(--radius);
+  --radius-xl: calc(var(--radius) * 1.4);
+  --radius-2xl: calc(var(--radius) * 1.8);
+  --radius-3xl: calc(var(--radius) * 2.2);
+  --radius-4xl: calc(var(--radius) * 2.6);
+}
+
+:root {
+  --background: oklch(1 0 0);
+  --foreground: oklch(0.145 0 0);
+  --card: oklch(1 0 0);
+  --card-foreground: oklch(0.145 0 0);
+  --popover: oklch(1 0 0);
+  --popover-foreground: oklch(0.145 0 0);
+  --primary: oklch(0.205 0 0);
+  --primary-foreground: oklch(0.985 0 0);
+  --secondary: oklch(0.97 0 0);
+  --secondary-foreground: oklch(0.205 0 0);
+  --muted: oklch(0.97 0 0);
+  --muted-foreground: oklch(0.556 0 0);
+  --accent: oklch(0.97 0 0);
+  --accent-foreground: oklch(0.205 0 0);
+  --destructive: oklch(0.577 0.245 27.325);
+  --border: oklch(0.922 0 0);
+  --input: oklch(0.922 0 0);
+  --ring: oklch(0.708 0 0);
+  --chart-1: oklch(0.87 0 0);
+  --chart-2: oklch(0.556 0 0);
+  --chart-3: oklch(0.439 0 0);
+  --chart-4: oklch(0.371 0 0);
+  --chart-5: oklch(0.269 0 0);
+  --radius: 0.625rem;
+  --sidebar: oklch(0.985 0 0);
+  --sidebar-foreground: oklch(0.145 0 0);
+  --sidebar-primary: oklch(0.205 0 0);
+  --sidebar-primary-foreground: oklch(0.985 0 0);
+  --sidebar-accent: oklch(0.97 0 0);
+  --sidebar-accent-foreground: oklch(0.205 0 0);
+  --sidebar-border: oklch(0.922 0 0);
+  --sidebar-ring: oklch(0.708 0 0);
+}
+
+.dark {
+  --background: oklch(0.145 0 0);
+  --foreground: oklch(0.985 0 0);
+  --card: oklch(0.205 0 0);
+  --card-foreground: oklch(0.985 0 0);
+  --popover: oklch(0.205 0 0);
+  --popover-foreground: oklch(0.985 0 0);
+  --primary: oklch(0.922 0 0);
+  --primary-foreground: oklch(0.205 0 0);
+  --secondary: oklch(0.269 0 0);
+  --secondary-foreground: oklch(0.985 0 0);
+  --muted: oklch(0.269 0 0);
+  --muted-foreground: oklch(0.708 0 0);
+  --accent: oklch(0.269 0 0);
+  --accent-foreground: oklch(0.985 0 0);
+  --destructive: oklch(0.704 0.191 22.216);
+  --border: oklch(1 0 0 / 10%);
+  --input: oklch(1 0 0 / 15%);
+  --ring: oklch(0.556 0 0);
+  --chart-1: oklch(0.87 0 0);
+  --chart-2: oklch(0.556 0 0);
+  --chart-3: oklch(0.439 0 0);
+  --chart-4: oklch(0.371 0 0);
+  --chart-5: oklch(0.269 0 0);
+  --sidebar: oklch(0.205 0 0);
+  --sidebar-foreground: oklch(0.985 0 0);
+  --sidebar-primary: oklch(0.488 0.243 264.376);
+  --sidebar-primary-foreground: oklch(0.985 0 0);
+  --sidebar-accent: oklch(0.269 0 0);
+  --sidebar-accent-foreground: oklch(0.985 0 0);
+  --sidebar-border: oklch(1 0 0 / 10%);
+  --sidebar-ring: oklch(0.556 0 0);
+}
+
+@layer base {
+  * {
+    @apply border-border outline-ring/50;
+  }
+  body {
+    @apply bg-background text-foreground;
+  }
+  html {
+    @apply font-sans;
+  }
+}

src/app/layout.tsx

@@ -0,0 +1,37 @@
+import type { Metadata } from "next";
+import { Geist, Geist_Mono } from "next/font/google";
+import { TooltipProvider } from "@/components/ui/tooltip";
+import "./globals.css";
+
+const geistSans = Geist({
+  variable: "--font-geist-sans",
+  subsets: ["latin"],
+});
+
+const geistMono = Geist_Mono({
+  variable: "--font-geist-mono",
+  subsets: ["latin"],
+});
+
+export const metadata: Metadata = {
+  title: "ROCmPilot",
+  description:
+    "Agentic ROCm migration dashboard powered by AMD GPU model serving.",
+};
+
+export default function RootLayout({
+  children,
+}: Readonly<{
+  children: React.ReactNode;
+}>) {
+  return (
+    <html
+      lang="en"
+      className={`dark ${geistSans.variable} ${geistMono.variable} h-full antialiased`}
+    >
+      <body className="flex min-h-full flex-col">
+        <TooltipProvider>{children}</TooltipProvider>
+      </body>
+    </html>
+  );
+}

src/app/page.tsx

@@ -0,0 +1,5 @@
+import { RocmPilotDashboard } from "@/components/rocmpilot-dashboard";
+
+export default function Home() {
+  return <RocmPilotDashboard />;
+}

src/components/ai-elements/code-block.tsx

@@ -0,0 +1,556 @@
+"use client";
+
+import { Button } from "@/components/ui/button";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import { cn } from "@/lib/utils";
+import { CheckIcon, CopyIcon } from "lucide-react";
+import type { ComponentProps, CSSProperties, HTMLAttributes } from "react";
+import {
+  createContext,
+  memo,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from "react";
+import type {
+  BundledLanguage,
+  BundledTheme,
+  HighlighterGeneric,
+  ThemedToken,
+} from "shiki";
+import { createHighlighter } from "shiki";
+
+// Shiki uses bitflags for font styles: 1=italic, 2=bold, 4=underline
+// oxlint-disable-next-line eslint(no-bitwise)
+const isItalic = (fontStyle: number | undefined) => fontStyle && fontStyle & 1;
+// oxlint-disable-next-line eslint(no-bitwise)
+const isBold = (fontStyle: number | undefined) => fontStyle && fontStyle & 2;
+const isUnderline = (fontStyle: number | undefined) =>
+  // oxlint-disable-next-line eslint(no-bitwise)
+  fontStyle && fontStyle & 4;
+
+// Transform tokens to include pre-computed keys to avoid noArrayIndexKey lint
+interface KeyedToken {
+  token: ThemedToken;
+  key: string;
+}
+interface KeyedLine {
+  tokens: KeyedToken[];
+  key: string;
+}
+
+const addKeysToTokens = (lines: ThemedToken[][]): KeyedLine[] =>
+  lines.map((line, lineIdx) => ({
+    key: `line-${lineIdx}`,
+    tokens: line.map((token, tokenIdx) => ({
+      key: `line-${lineIdx}-${tokenIdx}`,
+      token,
+    })),
+  }));
+
+// Token rendering component
+const TokenSpan = ({ token }: { token: ThemedToken }) => (
+  <span
+    className="dark:!bg-[var(--shiki-dark-bg)] dark:!text-[var(--shiki-dark)]"
+    style={
+      {
+        backgroundColor: token.bgColor,
+        color: token.color,
+        fontStyle: isItalic(token.fontStyle) ? "italic" : undefined,
+        fontWeight: isBold(token.fontStyle) ? "bold" : undefined,
+        textDecoration: isUnderline(token.fontStyle) ? "underline" : undefined,
+        ...token.htmlStyle,
+      } as CSSProperties
+    }
+  >
+    {token.content}
+  </span>
+);
+
+// Line number styles using CSS counters
+const LINE_NUMBER_CLASSES = cn(
+  "block",
+  "before:content-[counter(line)]",
+  "before:inline-block",
+  "before:[counter-increment:line]",
+  "before:w-8",
+  "before:mr-4",
+  "before:text-right",
+  "before:text-muted-foreground/50",
+  "before:font-mono",
+  "before:select-none"
+);
+
+// Line rendering component
+const LineSpan = ({
+  keyedLine,
+  showLineNumbers,
+}: {
+  keyedLine: KeyedLine;
+  showLineNumbers: boolean;
+}) => (
+  <span className={showLineNumbers ? LINE_NUMBER_CLASSES : "block"}>
+    {keyedLine.tokens.length === 0
+      ? "\n"
+      : keyedLine.tokens.map(({ token, key }) => (
+          <TokenSpan key={key} token={token} />
+        ))}
+  </span>
+);
+
+// Types
+type CodeBlockProps = HTMLAttributes<HTMLDivElement> & {
+  code: string;
+  language: BundledLanguage;
+  showLineNumbers?: boolean;
+};
+
+interface TokenizedCode {
+  tokens: ThemedToken[][];
+  fg: string;
+  bg: string;
+}
+
+interface CodeBlockContextType {
+  code: string;
+}
+
+// Context
+const CodeBlockContext = createContext<CodeBlockContextType>({
+  code: "",
+});
+
+// Highlighter cache (singleton per language)
+const highlighterCache = new Map<
+  string,
+  Promise<HighlighterGeneric<BundledLanguage, BundledTheme>>
+>();
+
+// Token cache
+const tokensCache = new Map<string, TokenizedCode>();
+
+// Subscribers for async token updates
+const subscribers = new Map<string, Set<(result: TokenizedCode) => void>>();
+
+const getTokensCacheKey = (code: string, language: BundledLanguage) => {
+  const start = code.slice(0, 100);
+  const end = code.length > 100 ? code.slice(-100) : "";
+  return `${language}:${code.length}:${start}:${end}`;
+};
+
+const getHighlighter = (
+  language: BundledLanguage
+): Promise<HighlighterGeneric<BundledLanguage, BundledTheme>> => {
+  const cached = highlighterCache.get(language);
+  if (cached) {
+    return cached;
+  }
+
+  const highlighterPromise = createHighlighter({
+    langs: [language],
+    themes: ["github-light", "github-dark"],
+  });
+
+  highlighterCache.set(language, highlighterPromise);
+  return highlighterPromise;
+};
+
+// Create raw tokens for immediate display while highlighting loads
+const createRawTokens = (code: string): TokenizedCode => ({
+  bg: "transparent",
+  fg: "inherit",
+  tokens: code.split("\n").map((line) =>
+    line === ""
+      ? []
+      : [
+          {
+            color: "inherit",
+            content: line,
+          } as ThemedToken,
+        ]
+  ),
+});
+
+// Synchronous highlight with callback for async results
+export const highlightCode = (
+  code: string,
+  language: BundledLanguage,
+  // oxlint-disable-next-line eslint-plugin-promise(prefer-await-to-callbacks)
+  callback?: (result: TokenizedCode) => void
+): TokenizedCode | null => {
+  const tokensCacheKey = getTokensCacheKey(code, language);
+
+  // Return cached result if available
+  const cached = tokensCache.get(tokensCacheKey);
+  if (cached) {
+    return cached;
+  }
+
+  // Subscribe callback if provided
+  if (callback) {
+    if (!subscribers.has(tokensCacheKey)) {
+      subscribers.set(tokensCacheKey, new Set());
+    }
+    subscribers.get(tokensCacheKey)?.add(callback);
+  }
+
+  // Start highlighting in background - fire-and-forget async pattern
+  getHighlighter(language)
+    // oxlint-disable-next-line eslint-plugin-promise(prefer-await-to-then)
+    .then((highlighter) => {
+      const availableLangs = highlighter.getLoadedLanguages();
+      const langToUse = availableLangs.includes(language) ? language : "text";
+
+      const result = highlighter.codeToTokens(code, {
+        lang: langToUse,
+        themes: {
+          dark: "github-dark",
+          light: "github-light",
+        },
+      });
+
+      const tokenized: TokenizedCode = {
+        bg: result.bg ?? "transparent",
+        fg: result.fg ?? "inherit",
+        tokens: result.tokens,
+      };
+
+      // Cache the result
+      tokensCache.set(tokensCacheKey, tokenized);
+
+      // Notify all subscribers
+      const subs = subscribers.get(tokensCacheKey);
+      if (subs) {
+        for (const sub of subs) {
+          sub(tokenized);
+        }
+        subscribers.delete(tokensCacheKey);
+      }
+    })
+    // oxlint-disable-next-line eslint-plugin-promise(prefer-await-to-then), eslint-plugin-promise(prefer-await-to-callbacks)
+    .catch((error) => {
+      console.error("Failed to highlight code:", error);
+      subscribers.delete(tokensCacheKey);
+    });
+
+  return null;
+};
+
+const CodeBlockBody = memo(
+  ({
+    tokenized,
+    showLineNumbers,
+    className,
+  }: {
+    tokenized: TokenizedCode;
+    showLineNumbers: boolean;
+    className?: string;
+  }) => {
+    const preStyle = useMemo(
+      () => ({
+        backgroundColor: tokenized.bg,
+        color: tokenized.fg,
+      }),
+      [tokenized.bg, tokenized.fg]
+    );
+
+    const keyedLines = useMemo(
+      () => addKeysToTokens(tokenized.tokens),
+      [tokenized.tokens]
+    );
+
+    return (
+      <pre
+        className={cn(
+          "dark:!bg-[var(--shiki-dark-bg)] dark:!text-[var(--shiki-dark)] m-0 p-4 text-sm",
+          className
+        )}
+        style={preStyle}
+      >
+        <code
+          className={cn(
+            "font-mono text-sm",
+            showLineNumbers && "[counter-increment:line_0] [counter-reset:line]"
+          )}
+        >
+          {keyedLines.map((keyedLine) => (
+            <LineSpan
+              key={keyedLine.key}
+              keyedLine={keyedLine}
+              showLineNumbers={showLineNumbers}
+            />
+          ))}
+        </code>
+      </pre>
+    );
+  },
+  (prevProps, nextProps) =>
+    prevProps.tokenized === nextProps.tokenized &&
+    prevProps.showLineNumbers === nextProps.showLineNumbers &&
+    prevProps.className === nextProps.className
+);
+
+CodeBlockBody.displayName = "CodeBlockBody";
+
+export const CodeBlockContainer = ({
+  className,
+  language,
+  style,
+  ...props
+}: HTMLAttributes<HTMLDivElement> & { language: string }) => (
+  <div
+    className={cn(
+      "group relative w-full overflow-hidden rounded-md border bg-background text-foreground",
+      className
+    )}
+    data-language={language}
+    style={{
+      containIntrinsicSize: "auto 200px",
+      contentVisibility: "auto",
+      ...style,
+    }}
+    {...props}
+  />
+);
+
+export const CodeBlockHeader = ({
+  children,
+  className,
+  ...props
+}: HTMLAttributes<HTMLDivElement>) => (
+  <div
+    className={cn(
+      "flex items-center justify-between border-b bg-muted/80 px-3 py-2 text-muted-foreground text-xs",
+      className
+    )}
+    {...props}
+  >
+    {children}
+  </div>
+);
+
+export const CodeBlockTitle = ({
+  children,
+  className,
+  ...props
+}: HTMLAttributes<HTMLDivElement>) => (
+  <div className={cn("flex items-center gap-2", className)} {...props}>
+    {children}
+  </div>
+);
+
+export const CodeBlockFilename = ({
+  children,
+  className,
+  ...props
+}: HTMLAttributes<HTMLSpanElement>) => (
+  <span className={cn("font-mono", className)} {...props}>
+    {children}
+  </span>
+);
+
+export const CodeBlockActions = ({
+  children,
+  className,
+  ...props
+}: HTMLAttributes<HTMLDivElement>) => (
+  <div
+    className={cn("-my-1 -mr-1 flex items-center gap-2", className)}
+    {...props}
+  >
+    {children}
+  </div>
+);
+
+export const CodeBlockContent = ({
+  code,
+  language,
+  showLineNumbers = false,
+}: {
+  code: string;
+  language: BundledLanguage;
+  showLineNumbers?: boolean;
+}) => {
+  // Memoized raw tokens for immediate display
+  const rawTokens = useMemo(() => createRawTokens(code), [code]);
+
+  // Synchronous cache lookup — avoids setState in effect for cached results
+  const syncTokens = useMemo(
+    () => highlightCode(code, language) ?? rawTokens,
+    [code, language, rawTokens]
+  );
+
+  // Async highlighting result (populated after shiki loads)
+  const tokensKey = useMemo(() => getTokensCacheKey(code, language), [code, language]);
+  const [asyncTokens, setAsyncTokens] = useState<{
+    key: string;
+    result: TokenizedCode;
+  } | null>(null);
+
+  useEffect(() => {
+    let cancelled = false;
+
+    highlightCode(code, language, (result) => {
+      if (!cancelled) {
+        setAsyncTokens({ key: tokensKey, result });
+      }
+    });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [code, language, tokensKey]);
+
+  const tokenized = asyncTokens?.key === tokensKey ? asyncTokens.result : syncTokens;
+
+  return (
+    <div className="relative overflow-auto">
+      <CodeBlockBody showLineNumbers={showLineNumbers} tokenized={tokenized} />
+    </div>
+  );
+};
+
+export const CodeBlock = ({
+  code,
+  language,
+  showLineNumbers = false,
+  className,
+  children,
+  ...props
+}: CodeBlockProps) => {
+  const contextValue = useMemo(() => ({ code }), [code]);
+
+  return (
+    <CodeBlockContext.Provider value={contextValue}>
+      <CodeBlockContainer className={className} language={language} {...props}>
+        {children}
+        <CodeBlockContent
+          code={code}
+          language={language}
+          showLineNumbers={showLineNumbers}
+        />
+      </CodeBlockContainer>
+    </CodeBlockContext.Provider>
+  );
+};
+
+export type CodeBlockCopyButtonProps = ComponentProps<typeof Button> & {
+  onCopy?: () => void;
+  onError?: (error: Error) => void;
+  timeout?: number;
+};
+
+export const CodeBlockCopyButton = ({
+  onCopy,
+  onError,
+  timeout = 2000,
+  children,
+  className,
+  ...props
+}: CodeBlockCopyButtonProps) => {
+  const [isCopied, setIsCopied] = useState(false);
+  const timeoutRef = useRef<number>(0);
+  const { code } = useContext(CodeBlockContext);
+
+  const copyToClipboard = useCallback(async () => {
+    if (typeof window === "undefined" || !navigator?.clipboard?.writeText) {
+      onError?.(new Error("Clipboard API not available"));
+      return;
+    }
+
+    try {
+      if (!isCopied) {
+        await navigator.clipboard.writeText(code);
+        setIsCopied(true);
+        onCopy?.();
+        timeoutRef.current = window.setTimeout(
+          () => setIsCopied(false),
+          timeout
+        );
+      }
+    } catch (error) {
+      onError?.(error as Error);
+    }
+  }, [code, onCopy, onError, timeout, isCopied]);
+
+  useEffect(
+    () => () => {
+      window.clearTimeout(timeoutRef.current);
+    },
+    []
+  );
+
+  const Icon = isCopied ? CheckIcon : CopyIcon;
+
+  return (
+    <Button
+      className={cn("shrink-0", className)}
+      onClick={copyToClipboard}
+      size="icon"
+      variant="ghost"
+      {...props}
+    >
+      {children ?? <Icon size={14} />}
+    </Button>
+  );
+};
+
+export type CodeBlockLanguageSelectorProps = ComponentProps<typeof Select>;
+
+export const CodeBlockLanguageSelector = (
+  props: CodeBlockLanguageSelectorProps
+) => <Select {...props} />;
+
+export type CodeBlockLanguageSelectorTriggerProps = ComponentProps<
+  typeof SelectTrigger
+>;
+
+export const CodeBlockLanguageSelectorTrigger = ({
+  className,
+  ...props
+}: CodeBlockLanguageSelectorTriggerProps) => (
+  <SelectTrigger
+    className={cn(
+      "h-7 border-none bg-transparent px-2 text-xs shadow-none",
+      className
+    )}
+    size="sm"
+    {...props}
+  />
+);
+
+export type CodeBlockLanguageSelectorValueProps = ComponentProps<
+  typeof SelectValue
+>;
+
+export const CodeBlockLanguageSelectorValue = (
+  props: CodeBlockLanguageSelectorValueProps
+) => <SelectValue {...props} />;
+
+export type CodeBlockLanguageSelectorContentProps = ComponentProps<
+  typeof SelectContent
+>;
+
+export const CodeBlockLanguageSelectorContent = ({
+  align = "end",
+  ...props
+}: CodeBlockLanguageSelectorContentProps) => (
+  <SelectContent align={align} {...props} />
+);
+
+export type CodeBlockLanguageSelectorItemProps = ComponentProps<
+  typeof SelectItem
+>;
+
+export const CodeBlockLanguageSelectorItem = (
+  props: CodeBlockLanguageSelectorItemProps
+) => <SelectItem {...props} />;

src/components/ai-elements/message.tsx

@@ -0,0 +1,360 @@
+"use client";
+
+import { Button } from "@/components/ui/button";
+import {
+  ButtonGroup,
+  ButtonGroupText,
+} from "@/components/ui/button-group";
+import {
+  Tooltip,
+  TooltipContent,
+  TooltipProvider,
+  TooltipTrigger,
+} from "@/components/ui/tooltip";
+import { cn } from "@/lib/utils";
+import { cjk } from "@streamdown/cjk";
+import { code } from "@streamdown/code";
+import { math } from "@streamdown/math";
+import { mermaid } from "@streamdown/mermaid";
+import type { UIMessage } from "ai";
+import { ChevronLeftIcon, ChevronRightIcon } from "lucide-react";
+import type { ComponentProps, HTMLAttributes, ReactElement } from "react";
+import {
+  createContext,
+  memo,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useState,
+} from "react";
+import { Streamdown } from "streamdown";
+
+export type MessageProps = HTMLAttributes<HTMLDivElement> & {
+  from: UIMessage["role"];
+};
+
+export const Message = ({ className, from, ...props }: MessageProps) => (
+  <div
+    className={cn(
+      "group flex w-full max-w-[95%] flex-col gap-2",
+      from === "user" ? "is-user ml-auto justify-end" : "is-assistant",
+      className
+    )}
+    {...props}
+  />
+);
+
+export type MessageContentProps = HTMLAttributes<HTMLDivElement>;
+
+export const MessageContent = ({
+  children,
+  className,
+  ...props
+}: MessageContentProps) => (
+  <div
+    className={cn(
+      "is-user:dark flex w-fit min-w-0 max-w-full flex-col gap-2 overflow-hidden text-sm",
+      "group-[.is-user]:ml-auto group-[.is-user]:rounded-lg group-[.is-user]:bg-secondary group-[.is-user]:px-4 group-[.is-user]:py-3 group-[.is-user]:text-foreground",
+      "group-[.is-assistant]:text-foreground",
+      className
+    )}
+    {...props}
+  >
+    {children}
+  </div>
+);
+
+export type MessageActionsProps = ComponentProps<"div">;
+
+export const MessageActions = ({
+  className,
+  children,
+  ...props
+}: MessageActionsProps) => (
+  <div className={cn("flex items-center gap-1", className)} {...props}>
+    {children}
+  </div>
+);
+
+export type MessageActionProps = ComponentProps<typeof Button> & {
+  tooltip?: string;
+  label?: string;
+};
+
+export const MessageAction = ({
+  tooltip,
+  children,
+  label,
+  variant = "ghost",
+  size = "icon-sm",
+  ...props
+}: MessageActionProps) => {
+  const button = (
+    <Button size={size} type="button" variant={variant} {...props}>
+      {children}
+      <span className="sr-only">{label || tooltip}</span>
+    </Button>
+  );
+
+  if (tooltip) {
+    return (
+      <TooltipProvider>
+        <Tooltip>
+          <TooltipTrigger asChild>{button}</TooltipTrigger>
+          <TooltipContent>
+            <p>{tooltip}</p>
+          </TooltipContent>
+        </Tooltip>
+      </TooltipProvider>
+    );
+  }
+
+  return button;
+};
+
+interface MessageBranchContextType {
+  currentBranch: number;
+  totalBranches: number;
+  goToPrevious: () => void;
+  goToNext: () => void;
+  branches: ReactElement[];
+  setBranches: (branches: ReactElement[]) => void;
+}
+
+const MessageBranchContext = createContext<MessageBranchContextType | null>(
+  null
+);
+
+const useMessageBranch = () => {
+  const context = useContext(MessageBranchContext);
+
+  if (!context) {
+    throw new Error(
+      "MessageBranch components must be used within MessageBranch"
+    );
+  }
+
+  return context;
+};
+
+export type MessageBranchProps = HTMLAttributes<HTMLDivElement> & {
+  defaultBranch?: number;
+  onBranchChange?: (branchIndex: number) => void;
+};
+
+export const MessageBranch = ({
+  defaultBranch = 0,
+  onBranchChange,
+  className,
+  ...props
+}: MessageBranchProps) => {
+  const [currentBranch, setCurrentBranch] = useState(defaultBranch);
+  const [branches, setBranches] = useState<ReactElement[]>([]);
+
+  const handleBranchChange = useCallback(
+    (newBranch: number) => {
+      setCurrentBranch(newBranch);
+      onBranchChange?.(newBranch);
+    },
+    [onBranchChange]
+  );
+
+  const goToPrevious = useCallback(() => {
+    const newBranch =
+      currentBranch > 0 ? currentBranch - 1 : branches.length - 1;
+    handleBranchChange(newBranch);
+  }, [currentBranch, branches.length, handleBranchChange]);
+
+  const goToNext = useCallback(() => {
+    const newBranch =
+      currentBranch < branches.length - 1 ? currentBranch + 1 : 0;
+    handleBranchChange(newBranch);
+  }, [currentBranch, branches.length, handleBranchChange]);
+
+  const contextValue = useMemo<MessageBranchContextType>(
+    () => ({
+      branches,
+      currentBranch,
+      goToNext,
+      goToPrevious,
+      setBranches,
+      totalBranches: branches.length,
+    }),
+    [branches, currentBranch, goToNext, goToPrevious]
+  );
+
+  return (
+    <MessageBranchContext.Provider value={contextValue}>
+      <div
+        className={cn("grid w-full gap-2 [&>div]:pb-0", className)}
+        {...props}
+      />
+    </MessageBranchContext.Provider>
+  );
+};
+
+export type MessageBranchContentProps = HTMLAttributes<HTMLDivElement>;
+
+export const MessageBranchContent = ({
+  children,
+  ...props
+}: MessageBranchContentProps) => {
+  const { currentBranch, setBranches, branches } = useMessageBranch();
+  const childrenArray = useMemo(
+    () => (Array.isArray(children) ? children : [children]),
+    [children]
+  );
+
+  // Use useEffect to update branches when they change
+  useEffect(() => {
+    if (branches.length !== childrenArray.length) {
+      setBranches(childrenArray);
+    }
+  }, [childrenArray, branches, setBranches]);
+
+  return childrenArray.map((branch, index) => (
+    <div
+      className={cn(
+        "grid gap-2 overflow-hidden [&>div]:pb-0",
+        index === currentBranch ? "block" : "hidden"
+      )}
+      key={branch.key}
+      {...props}
+    >
+      {branch}
+    </div>
+  ));
+};
+
+export type MessageBranchSelectorProps = ComponentProps<typeof ButtonGroup>;
+
+export const MessageBranchSelector = ({
+  className,
+  ...props
+}: MessageBranchSelectorProps) => {
+  const { totalBranches } = useMessageBranch();
+
+  // Don't render if there's only one branch
+  if (totalBranches <= 1) {
+    return null;
+  }
+
+  return (
+    <ButtonGroup
+      className={cn(
+        "[&>*:not(:first-child)]:rounded-l-md [&>*:not(:last-child)]:rounded-r-md",
+        className
+      )}
+      orientation="horizontal"
+      {...props}
+    />
+  );
+};
+
+export type MessageBranchPreviousProps = ComponentProps<typeof Button>;
+
+export const MessageBranchPrevious = ({
+  children,
+  ...props
+}: MessageBranchPreviousProps) => {
+  const { goToPrevious, totalBranches } = useMessageBranch();
+
+  return (
+    <Button
+      aria-label="Previous branch"
+      disabled={totalBranches <= 1}
+      onClick={goToPrevious}
+      size="icon-sm"
+      type="button"
+      variant="ghost"
+      {...props}
+    >
+      {children ?? <ChevronLeftIcon size={14} />}
+    </Button>
+  );
+};
+
+export type MessageBranchNextProps = ComponentProps<typeof Button>;
+
+export const MessageBranchNext = ({
+  children,
+  ...props
+}: MessageBranchNextProps) => {
+  const { goToNext, totalBranches } = useMessageBranch();
+
+  return (
+    <Button
+      aria-label="Next branch"
+      disabled={totalBranches <= 1}
+      onClick={goToNext}
+      size="icon-sm"
+      type="button"
+      variant="ghost"
+      {...props}
+    >
+      {children ?? <ChevronRightIcon size={14} />}
+    </Button>
+  );
+};
+
+export type MessageBranchPageProps = HTMLAttributes<HTMLSpanElement>;
+
+export const MessageBranchPage = ({
+  className,
+  ...props
+}: MessageBranchPageProps) => {
+  const { currentBranch, totalBranches } = useMessageBranch();
+
+  return (
+    <ButtonGroupText
+      className={cn(
+        "border-none bg-transparent text-muted-foreground shadow-none",
+        className
+      )}
+      {...props}
+    >
+      {currentBranch + 1} of {totalBranches}
+    </ButtonGroupText>
+  );
+};
+
+export type MessageResponseProps = ComponentProps<typeof Streamdown>;
+
+const streamdownPlugins = { cjk, code, math, mermaid };
+
+export const MessageResponse = memo(
+  ({ className, ...props }: MessageResponseProps) => (
+    <Streamdown
+      className={cn(
+        "size-full [&>*:first-child]:mt-0 [&>*:last-child]:mb-0",
+        className
+      )}
+      plugins={streamdownPlugins}
+      {...props}
+    />
+  ),
+  (prevProps, nextProps) =>
+    prevProps.children === nextProps.children &&
+    nextProps.isAnimating === prevProps.isAnimating
+);
+
+MessageResponse.displayName = "MessageResponse";
+
+export type MessageToolbarProps = ComponentProps<"div">;
+
+export const MessageToolbar = ({
+  className,
+  children,
+  ...props
+}: MessageToolbarProps) => (
+  <div
+    className={cn(
+      "mt-4 flex w-full items-center justify-between gap-4",
+      className
+    )}
+    {...props}
+  >
+    {children}
+  </div>
+);

src/components/ai-elements/terminal.tsx

@@ -0,0 +1,273 @@
+"use client";
+
+import { Button } from "@/components/ui/button";
+import { cn } from "@/lib/utils";
+import Ansi from "ansi-to-react";
+import { CheckIcon, CopyIcon, TerminalIcon, Trash2Icon } from "lucide-react";
+import type { ComponentProps, HTMLAttributes } from "react";
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from "react";
+
+interface TerminalContextType {
+  output: string;
+  isStreaming: boolean;
+  autoScroll: boolean;
+  onClear?: () => void;
+}
+
+const TerminalContext = createContext<TerminalContextType>({
+  autoScroll: true,
+  isStreaming: false,
+  output: "",
+});
+
+export type TerminalHeaderProps = HTMLAttributes<HTMLDivElement>;
+
+export const TerminalHeader = ({
+  className,
+  children,
+  ...props
+}: TerminalHeaderProps) => (
+  <div
+    className={cn(
+      "flex items-center justify-between border-zinc-800 border-b px-4 py-2",
+      className
+    )}
+    {...props}
+  >
+    {children}
+  </div>
+);
+
+export type TerminalTitleProps = HTMLAttributes<HTMLDivElement>;
+
+export const TerminalTitle = ({
+  className,
+  children,
+  ...props
+}: TerminalTitleProps) => (
+  <div
+    className={cn("flex items-center gap-2 text-sm text-zinc-400", className)}
+    {...props}
+  >
+    <TerminalIcon className="size-4" />
+    {children ?? "Terminal"}
+  </div>
+);
+
+export type TerminalStatusProps = HTMLAttributes<HTMLDivElement>;
+
+export const TerminalStatus = ({
+  className,
+  children,
+  ...props
+}: TerminalStatusProps) => {
+  const { isStreaming } = useContext(TerminalContext);
+
+  if (!isStreaming) {
+    return null;
+  }
+
+  return (
+    <div
+      className={cn("flex items-center gap-2 text-xs text-zinc-400", className)}
+      {...props}
+    >
+      {children}
+    </div>
+  );
+};
+
+export type TerminalActionsProps = HTMLAttributes<HTMLDivElement>;
+
+export const TerminalActions = ({
+  className,
+  children,
+  ...props
+}: TerminalActionsProps) => (
+  <div className={cn("flex items-center gap-1", className)} {...props}>
+    {children}
+  </div>
+);
+
+export type TerminalCopyButtonProps = ComponentProps<typeof Button> & {
+  onCopy?: () => void;
+  onError?: (error: Error) => void;
+  timeout?: number;
+};
+
+export const TerminalCopyButton = ({
+  onCopy,
+  onError,
+  timeout = 2000,
+  children,
+  className,
+  ...props
+}: TerminalCopyButtonProps) => {
+  const [isCopied, setIsCopied] = useState(false);
+  const timeoutRef = useRef<number>(0);
+  const { output } = useContext(TerminalContext);
+
+  const copyToClipboard = useCallback(async () => {
+    if (typeof window === "undefined" || !navigator?.clipboard?.writeText) {
+      onError?.(new Error("Clipboard API not available"));
+      return;
+    }
+
+    try {
+      await navigator.clipboard.writeText(output);
+      setIsCopied(true);
+      onCopy?.();
+      timeoutRef.current = window.setTimeout(() => setIsCopied(false), timeout);
+    } catch (error) {
+      onError?.(error as Error);
+    }
+  }, [output, onCopy, onError, timeout]);
+
+  useEffect(
+    () => () => {
+      window.clearTimeout(timeoutRef.current);
+    },
+    []
+  );
+
+  const Icon = isCopied ? CheckIcon : CopyIcon;
+
+  return (
+    <Button
+      className={cn(
+        "size-7 shrink-0 text-zinc-400 hover:bg-zinc-800 hover:text-zinc-100",
+        className
+      )}
+      onClick={copyToClipboard}
+      size="icon"
+      variant="ghost"
+      {...props}
+    >
+      {children ?? <Icon size={14} />}
+    </Button>
+  );
+};
+
+export type TerminalClearButtonProps = ComponentProps<typeof Button>;
+
+export const TerminalClearButton = ({
+  children,
+  className,
+  ...props
+}: TerminalClearButtonProps) => {
+  const { onClear } = useContext(TerminalContext);
+
+  if (!onClear) {
+    return null;
+  }
+
+  return (
+    <Button
+      className={cn(
+        "size-7 shrink-0 text-zinc-400 hover:bg-zinc-800 hover:text-zinc-100",
+        className
+      )}
+      onClick={onClear}
+      size="icon"
+      variant="ghost"
+      {...props}
+    >
+      {children ?? <Trash2Icon size={14} />}
+    </Button>
+  );
+};
+
+export type TerminalContentProps = HTMLAttributes<HTMLDivElement>;
+
+export const TerminalContent = ({
+  className,
+  children,
+  ...props
+}: TerminalContentProps) => {
+  const { output, isStreaming, autoScroll } = useContext(TerminalContext);
+  const containerRef = useRef<HTMLDivElement>(null);
+
+  useEffect(() => {
+    if (autoScroll && containerRef.current) {
+      containerRef.current.scrollTop = containerRef.current.scrollHeight;
+    }
+  }, [output, autoScroll]);
+
+  return (
+    <div
+      className={cn(
+        "max-h-96 overflow-auto p-4 font-mono text-sm leading-relaxed",
+        className
+      )}
+      ref={containerRef}
+      {...props}
+    >
+      {children ?? (
+        <pre className="whitespace-pre-wrap break-words">
+          <Ansi>{output}</Ansi>
+          {isStreaming && (
+            <span className="ml-0.5 inline-block h-4 w-2 animate-pulse bg-zinc-100" />
+          )}
+        </pre>
+      )}
+    </div>
+  );
+};
+
+export type TerminalProps = HTMLAttributes<HTMLDivElement> & {
+  output: string;
+  isStreaming?: boolean;
+  autoScroll?: boolean;
+  onClear?: () => void;
+};
+
+export const Terminal = ({
+  output,
+  isStreaming = false,
+  autoScroll = true,
+  onClear,
+  className,
+  children,
+  ...props
+}: TerminalProps) => {
+  const contextValue = useMemo(
+    () => ({ autoScroll, isStreaming, onClear, output }),
+    [autoScroll, isStreaming, onClear, output]
+  );
+
+  return (
+    <TerminalContext.Provider value={contextValue}>
+      <div
+        className={cn(
+          "flex flex-col overflow-hidden rounded-lg border bg-zinc-950 text-zinc-100",
+          className
+        )}
+        {...props}
+      >
+        {children ?? (
+          <>
+            <TerminalHeader>
+              <TerminalTitle />
+              <div className="flex items-center gap-1">
+                <TerminalStatus />
+                <TerminalActions>
+                  <TerminalCopyButton />
+                  {onClear && <TerminalClearButton />}
+                </TerminalActions>
+              </div>
+            </TerminalHeader>
+            <TerminalContent />
+          </>
+        )}
+      </div>
+    </TerminalContext.Provider>
+  );
+};

src/components/ai-elements/tool.tsx

@@ -0,0 +1,173 @@
+"use client";
+
+import { Badge } from "@/components/ui/badge";
+import {
+  Collapsible,
+  CollapsibleContent,
+  CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import { cn } from "@/lib/utils";
+import type { DynamicToolUIPart, ToolUIPart } from "ai";
+import {
+  CheckCircleIcon,
+  ChevronDownIcon,
+  CircleIcon,
+  ClockIcon,
+  WrenchIcon,
+  XCircleIcon,
+} from "lucide-react";
+import type { ComponentProps, ReactNode } from "react";
+import { isValidElement } from "react";
+
+import { CodeBlock } from "./code-block";
+
+export type ToolProps = ComponentProps<typeof Collapsible>;
+
+export const Tool = ({ className, ...props }: ToolProps) => (
+  <Collapsible
+    className={cn("group not-prose mb-4 w-full rounded-md border", className)}
+    {...props}
+  />
+);
+
+export type ToolPart = ToolUIPart | DynamicToolUIPart;
+
+export type ToolHeaderProps = {
+  title?: string;
+  className?: string;
+} & (
+  | { type: ToolUIPart["type"]; state: ToolUIPart["state"]; toolName?: never }
+  | {
+      type: DynamicToolUIPart["type"];
+      state: DynamicToolUIPart["state"];
+      toolName: string;
+    }
+);
+
+const statusLabels: Record<ToolPart["state"], string> = {
+  "approval-requested": "Awaiting Approval",
+  "approval-responded": "Responded",
+  "input-available": "Running",
+  "input-streaming": "Pending",
+  "output-available": "Completed",
+  "output-denied": "Denied",
+  "output-error": "Error",
+};
+
+const statusIcons: Record<ToolPart["state"], ReactNode> = {
+  "approval-requested": <ClockIcon className="size-4 text-yellow-600" />,
+  "approval-responded": <CheckCircleIcon className="size-4 text-blue-600" />,
+  "input-available": <ClockIcon className="size-4 animate-pulse" />,
+  "input-streaming": <CircleIcon className="size-4" />,
+  "output-available": <CheckCircleIcon className="size-4 text-green-600" />,
+  "output-denied": <XCircleIcon className="size-4 text-orange-600" />,
+  "output-error": <XCircleIcon className="size-4 text-red-600" />,
+};
+
+export const getStatusBadge = (status: ToolPart["state"]) => (
+  <Badge className="gap-1.5 rounded-full text-xs" variant="secondary">
+    {statusIcons[status]}
+    {statusLabels[status]}
+  </Badge>
+);
+
+export const ToolHeader = ({
+  className,
+  title,
+  type,
+  state,
+  toolName,
+  ...props
+}: ToolHeaderProps) => {
+  const derivedName =
+    type === "dynamic-tool" ? toolName : type.split("-").slice(1).join("-");
+
+  return (
+    <CollapsibleTrigger
+      className={cn(
+        "flex w-full items-center justify-between gap-4 p-3",
+        className
+      )}
+      {...props}
+    >
+      <div className="flex items-center gap-2">
+        <WrenchIcon className="size-4 text-muted-foreground" />
+        <span className="font-medium text-sm">{title ?? derivedName}</span>
+        {getStatusBadge(state)}
+      </div>
+      <ChevronDownIcon className="size-4 text-muted-foreground transition-transform group-data-[state=open]:rotate-180" />
+    </CollapsibleTrigger>
+  );
+};
+
+export type ToolContentProps = ComponentProps<typeof CollapsibleContent>;
+
+export const ToolContent = ({ className, ...props }: ToolContentProps) => (
+  <CollapsibleContent
+    className={cn(
+      "data-[state=closed]:fade-out-0 data-[state=closed]:slide-out-to-top-2 data-[state=open]:slide-in-from-top-2 space-y-4 p-4 text-popover-foreground outline-none data-[state=closed]:animate-out data-[state=open]:animate-in",
+      className
+    )}
+    {...props}
+  />
+);
+
+export type ToolInputProps = ComponentProps<"div"> & {
+  input: ToolPart["input"];
+};
+
+export const ToolInput = ({ className, input, ...props }: ToolInputProps) => (
+  <div className={cn("space-y-2 overflow-hidden", className)} {...props}>
+    <h4 className="font-medium text-muted-foreground text-xs uppercase tracking-wide">
+      Parameters
+    </h4>
+    <div className="rounded-md bg-muted/50">
+      <CodeBlock code={JSON.stringify(input, null, 2)} language="json" />
+    </div>
+  </div>
+);
+
+export type ToolOutputProps = ComponentProps<"div"> & {
+  output: ToolPart["output"];
+  errorText: ToolPart["errorText"];
+};
+
+export const ToolOutput = ({
+  className,
+  output,
+  errorText,
+  ...props
+}: ToolOutputProps) => {
+  if (!(output || errorText)) {
+    return null;
+  }
+
+  let Output = <div>{output as ReactNode}</div>;
+
+  if (typeof output === "object" && !isValidElement(output)) {
+    Output = (
+      <CodeBlock code={JSON.stringify(output, null, 2)} language="json" />
+    );
+  } else if (typeof output === "string") {
+    Output = <CodeBlock code={output} language="json" />;
+  }
+
+  return (
+    <div className={cn("space-y-2", className)} {...props}>
+      <h4 className="font-medium text-muted-foreground text-xs uppercase tracking-wide">
+        {errorText ? "Error" : "Result"}
+      </h4>
+      <div
+        className={cn(
+          "overflow-x-auto rounded-md text-xs [&_table]:w-full",
+          errorText
+            ? "bg-destructive/10 text-destructive"
+            : "bg-muted/50 text-foreground"
+        )}
+      >
+        {errorText && <div>{errorText}</div>}
+        {Output}
+      </div>
+    </div>
+  );
+};

src/components/rocmpilot-dashboard.tsx

@@ -0,0 +1,907 @@
+"use client";
+
+import {
+  CodeBlock,
+  CodeBlockCopyButton,
+  CodeBlockFilename,
+  CodeBlockHeader,
+  CodeBlockTitle,
+} from "@/components/ai-elements/code-block";
+import { MessageResponse } from "@/components/ai-elements/message";
+import { Terminal } from "@/components/ai-elements/terminal";
+import { Alert, AlertDescription, AlertTitle } from "@/components/ui/alert";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import {
+  Card,
+  CardContent,
+  CardDescription,
+  CardHeader,
+  CardTitle,
+} from "@/components/ui/card";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { Progress } from "@/components/ui/progress";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import { Separator } from "@/components/ui/separator";
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from "@/components/ui/table";
+import { SAMPLE_REPOS } from "@/lib/rocmpilot/data";
+import type {
+  AgentMemory,
+  AgentMessage,
+  AgentMessageKind,
+  FindingSeverity,
+  LongContextMemoryStatus,
+  ReportResponse,
+  RocmRun,
+  RunStage,
+} from "@/lib/rocmpilot/types";
+import {
+  Activity,
+  BadgeCheck,
+  Bot,
+  Boxes,
+  BrainCircuit,
+  CheckCircle2,
+  Cpu,
+  FileCode2,
+  Gauge,
+  GitBranch,
+  Loader2,
+  Play,
+  RefreshCw,
+  ShieldCheck,
+  Sparkles,
+  TerminalSquare,
+  TriangleAlert,
+  Zap,
+} from "lucide-react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+
+const severityTone: Record<FindingSeverity, string> = {
+  critical: "border-red-500/40 bg-red-500/10 text-red-200",
+  high: "border-amber-500/40 bg-amber-500/10 text-amber-100",
+  medium: "border-cyan-500/40 bg-cyan-500/10 text-cyan-100",
+  low: "border-emerald-500/40 bg-emerald-500/10 text-emerald-100",
+};
+
+const statusTone = {
+  pending: "border-zinc-800 bg-zinc-950 text-zinc-500",
+  running: "border-cyan-500/40 bg-cyan-500/10 text-cyan-100",
+  completed: "border-emerald-500/40 bg-emerald-500/10 text-emerald-100",
+};
+
+const memoryStatusTone: Record<LongContextMemoryStatus["status"], string> = {
+  connected: "border-emerald-500/40 bg-emerald-500/10 text-emerald-100",
+  configured: "border-cyan-500/40 bg-cyan-500/10 text-cyan-100",
+  fallback: "border-amber-500/40 bg-amber-500/10 text-amber-100",
+  "not-configured": "border-zinc-700 bg-zinc-900 text-zinc-300",
+};
+
+const messageKindTone: Record<AgentMessageKind, string> = {
+  question: "border-cyan-500/40 bg-cyan-500/10 text-cyan-100",
+  answer: "border-sky-500/40 bg-sky-500/10 text-sky-100",
+  challenge: "border-amber-500/40 bg-amber-500/10 text-amber-100",
+  proposal: "border-violet-500/40 bg-violet-500/10 text-violet-100",
+  decision: "border-lime-500/40 bg-lime-500/10 text-lime-100",
+  memory: "border-rose-500/40 bg-rose-500/10 text-rose-100",
+  consensus: "border-emerald-500/40 bg-emerald-500/10 text-emerald-100",
+};
+
+const agentDotTone: Record<string, string> = {
+  Orchestrator: "bg-emerald-300",
+  "Repo Doctor": "bg-cyan-300",
+  "Migration Planner": "bg-violet-300",
+  "Build Runner": "bg-amber-300",
+  "Benchmark Agent": "bg-sky-300",
+  "Report Agent": "bg-rose-300",
+};
+
+function StageIcon({ stage }: { stage: RunStage }) {
+  if (stage.status === "completed") {
+    return <CheckCircle2 className="size-4 text-emerald-300" />;
+  }
+
+  if (stage.status === "running") {
+    return <Loader2 className="size-4 animate-spin text-cyan-200" />;
+  }
+
+  return <Activity className="size-4 text-zinc-500" />;
+}
+
+function formatTime(value: string | undefined) {
+  if (!value) {
+    return "--:--";
+  }
+
+  return new Intl.DateTimeFormat("en", {
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+  }).format(new Date(value));
+}
+
+function WarRoomMessage({
+  message,
+  memoryById,
+}: {
+  message: AgentMessage;
+  memoryById: Map<string, AgentMemory>;
+}) {
+  return (
+    <div className="grid grid-cols-[28px_minmax(0,1fr)] gap-3 rounded-lg border border-border/70 bg-background/60 p-3">
+      <div className="relative mt-1 flex size-7 items-center justify-center rounded-full border border-border bg-card">
+        <span
+          className={`size-2.5 rounded-full ${agentDotTone[message.agent] ?? "bg-zinc-400"}`}
+        />
+      </div>
+      <div className="min-w-0 space-y-2">
+        <div className="flex min-w-0 flex-wrap items-center gap-2">
+          <p className="truncate text-sm font-semibold">{message.agent}</p>
+          <span className="text-xs text-muted-foreground">to</span>
+          <p className="truncate text-sm font-medium text-cyan-100">{message.toAgent}</p>
+          <Badge variant="outline" className={messageKindTone[message.kind]}>
+            {message.kind}
+          </Badge>
+          {message.leadAgent === message.agent && (
+            <Badge variant="outline" className="border-emerald-500/40 bg-emerald-500/10 text-emerald-100">
+              lead
+            </Badge>
+          )}
+          <span className="font-mono text-[11px] text-muted-foreground">
+            {formatTime(message.createdAt)}
+          </span>
+        </div>
+        <div className="flex flex-wrap items-center gap-2 text-xs leading-5 text-muted-foreground">
+          <span>{message.role}</span>
+          <span>/</span>
+          <span>{message.task}</span>
+          {message.replyToId && (
+            <>
+              <span>/</span>
+              <span>replying to earlier message</span>
+            </>
+          )}
+        </div>
+        <p className="break-words text-sm leading-6 text-foreground">{message.message}</p>
+        {message.memoryRefs.length > 0 && (
+          <div className="flex flex-wrap gap-2">
+            {message.memoryRefs.map((memoryId) => (
+              <Badge
+                key={memoryId}
+                variant="outline"
+                className="border-zinc-600 bg-zinc-900/80 text-zinc-200"
+              >
+                memory: {memoryById.get(memoryId)?.title ?? memoryId}
+              </Badge>
+            ))}
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
+
+function AgentWarRoom({ run }: { run: RocmRun | null }) {
+  const messages = useMemo(() => run?.agentMessages ?? [], [run?.agentMessages]);
+  const memory = useMemo(() => run?.agentMemory ?? [], [run?.agentMemory]);
+  const latestMessage = messages[messages.length - 1];
+  const activeLead = latestMessage?.leadAgent ?? "No lead assigned";
+  const memoryById = useMemo(
+    () => new Map(memory.map((entry) => [entry.id, entry])),
+    [memory]
+  );
+
+  return (
+    <Card>
+      <CardHeader className="gap-3">
+        <div className="flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between">
+          <div>
+            <CardTitle className="flex items-center gap-2 text-xl">
+              <Activity className="size-5 text-cyan-200" />
+              Agent War Room
+            </CardTitle>
+            <CardDescription>
+              Lead-led discussion with replies, objections, and shared memory the agents reuse later.
+            </CardDescription>
+          </div>
+          <div className="flex flex-wrap gap-2">
+            <Badge
+              variant="outline"
+              className={
+                run?.status === "running"
+                  ? "border-cyan-500/40 bg-cyan-500/10 text-cyan-100"
+                  : run?.status === "completed"
+                    ? "border-emerald-500/40 bg-emerald-500/10 text-emerald-100"
+                    : "border-zinc-700 bg-zinc-900 text-zinc-300"
+              }
+            >
+              {run?.status === "running" ? "live room" : run?.status === "completed" ? "consensus" : "standby"}
+            </Badge>
+            <Badge variant="outline" className="border-zinc-700 bg-zinc-900 text-zinc-200">
+              lead: {activeLead}
+            </Badge>
+            {run?.longContextMemory && (
+              <Badge
+                variant="outline"
+                className={memoryStatusTone[run.longContextMemory.status]}
+              >
+                {run.longContextMemory.provider === "synap" ? "Synap memory" : "local memory"}
+              </Badge>
+            )}
+          </div>
+        </div>
+        {latestMessage && (
+          <div className="rounded-lg border border-emerald-500/20 bg-emerald-500/5 p-3 text-sm leading-6 text-emerald-50">
+            <span className="font-medium">
+              {latestMessage.agent} to {latestMessage.toAgent}:
+            </span>{" "}
+            <span className="text-emerald-100/90">{latestMessage.message}</span>
+          </div>
+        )}
+      </CardHeader>
+      <CardContent>
+        {messages.length ? (
+          <div className="grid gap-4 xl:grid-cols-[minmax(0,1.35fr)_minmax(300px,0.75fr)]">
+            <div className="max-h-[520px] space-y-3 overflow-y-auto pr-1">
+              {messages.map((message) => (
+                <WarRoomMessage key={message.id} message={message} memoryById={memoryById} />
+              ))}
+            </div>
+            <div className="rounded-lg border border-border bg-background/50 p-3">
+              <div className="flex items-center justify-between gap-3">
+                <p className="text-sm font-semibold">Shared memory</p>
+                <Badge variant="outline" className="border-rose-500/40 bg-rose-500/10 text-rose-100">
+                  {memory.length} stored
+                </Badge>
+              </div>
+              <div className="mt-3 max-h-[470px] space-y-3 overflow-y-auto pr-1">
+                {memory.length ? (
+                  memory.map((entry) => (
+                    <div key={entry.id} className="rounded-lg border border-border/70 bg-card p-3">
+                      <div className="flex flex-wrap items-center gap-2">
+                        <p className="text-sm font-medium">{entry.title}</p>
+                        <Badge variant="outline">{entry.scope}</Badge>
+                      </div>
+                      <p className="mt-2 text-xs text-muted-foreground">
+                        learned from {entry.learnedFromAgent} at {formatTime(entry.createdAt)}
+                      </p>
+                      <p className="mt-3 text-sm leading-6">{entry.summary}</p>
+                      <p className="mt-2 text-sm leading-6 text-muted-foreground">{entry.solution}</p>
+                      {entry.usedBy.length > 0 && (
+                        <p className="mt-3 text-xs text-emerald-100">
+                          reused by {Array.from(new Set(entry.usedBy)).join(", ")}
+                        </p>
+                      )}
+                    </div>
+                  ))
+                ) : (
+                  <div className="rounded-lg border border-dashed border-border p-4 text-sm text-muted-foreground">
+                    Memory appears when agents store a blocker, solution, or evidence rule.
+                  </div>
+                )}
+              </div>
+            </div>
+          </div>
+        ) : (
+          <div className="grid gap-3 rounded-lg border border-dashed border-border p-4 sm:grid-cols-2 lg:grid-cols-3">
+            {[
+              "Repo Doctor",
+              "Migration Planner",
+              "Build Runner",
+              "Benchmark Agent",
+              "Report Agent",
+              "Orchestrator",
+            ].map((agent) => (
+              <div key={agent} className="flex min-w-0 items-center gap-3 rounded-lg bg-card p-3">
+                <span className={`size-2.5 shrink-0 rounded-full ${agentDotTone[agent] ?? "bg-zinc-400"}`} />
+                <span className="truncate text-sm text-muted-foreground">{agent} waiting</span>
+              </div>
+            ))}
+          </div>
+        )}
+      </CardContent>
+    </Card>
+  );
+}
+
+export function RocmPilotDashboard() {
+  const [sampleId, setSampleId] = useState(SAMPLE_REPOS[0].id);
+  const [githubUrl, setGithubUrl] = useState("");
+  const [run, setRun] = useState<RocmRun | null>(null);
+  const [report, setReport] = useState<ReportResponse | null>(null);
+  const [activePanel, setActivePanel] = useState<"patches" | "logs" | "report">("patches");
+  const [isStarting, setIsStarting] = useState(false);
+  const [isGeneratingReport, setIsGeneratingReport] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const reportRequestedFor = useRef<string | null>(null);
+
+  const selectedSample = useMemo(
+    () => SAMPLE_REPOS.find((sample) => sample.id === sampleId) ?? SAMPLE_REPOS[0],
+    [sampleId]
+  );
+
+  const logOutput = useMemo(() => run?.logs.join("\n") ?? "", [run]);
+  const activeRepoUrl = run?.target.repoUrl ?? (githubUrl.trim() || selectedSample.repoUrl);
+
+  const startRun = useCallback(async () => {
+    setIsStarting(true);
+    setError(null);
+    setReport(null);
+    reportRequestedFor.current = null;
+
+    try {
+      const response = await fetch("/api/runs", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          sampleId,
+          mode: "mock",
+          repoUrl: githubUrl.trim() || undefined,
+        }),
+      });
+
+      if (!response.ok) {
+        throw new Error("Could not start migration audit");
+      }
+
+      const nextRun = (await response.json()) as RocmRun;
+      setRun(nextRun);
+    } catch (caught) {
+      setError(caught instanceof Error ? caught.message : "Unknown start error");
+    } finally {
+      setIsStarting(false);
+    }
+  }, [githubUrl, sampleId]);
+
+  const pollRun = useCallback(async (runId: string) => {
+    const response = await fetch(`/api/runs/${runId}`, { cache: "no-store" });
+
+    if (!response.ok) {
+      throw new Error("Could not refresh run state");
+    }
+
+    const nextRun = (await response.json()) as RocmRun;
+    setRun(nextRun);
+  }, []);
+
+  const generateReport = useCallback(async (completedRun: RocmRun) => {
+    setIsGeneratingReport(true);
+
+    try {
+      const response = await fetch("/api/report", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(completedRun),
+      });
+
+      if (!response.ok) {
+        throw new Error("Could not generate final report");
+      }
+
+      const reportResponse = (await response.json()) as ReportResponse;
+      setReport(reportResponse);
+    } catch (caught) {
+      setError(caught instanceof Error ? caught.message : "Unknown report error");
+    } finally {
+      setIsGeneratingReport(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    if (!run || run.status === "completed") {
+      return;
+    }
+
+    const timer = window.setInterval(() => {
+      void pollRun(run.id).catch((caught) =>
+        setError(caught instanceof Error ? caught.message : "Unknown polling error")
+      );
+    }, 900);
+
+    return () => window.clearInterval(timer);
+  }, [pollRun, run]);
+
+  useEffect(() => {
+    if (!run || run.status !== "completed" || reportRequestedFor.current === run.id) {
+      return;
+    }
+
+    reportRequestedFor.current = run.id;
+    void generateReport(run);
+  }, [generateReport, run]);
+
+  const modelStatus = report?.modelStatus ?? run?.modelStatus;
+  const memoryStatus = report?.memoryStatus ?? run?.longContextMemory;
+  const completedStages = run?.stages.filter((stage) => stage.status === "completed").length ?? 0;
+
+  return (
+    <main className="min-h-screen bg-background text-foreground">
+      <div className="mx-auto flex w-full max-w-none flex-col gap-5 px-4 py-5 sm:px-5 lg:px-6">
+        <section className="grid gap-5 border-b border-border pb-5 xl:grid-cols-[minmax(280px,0.55fr)_minmax(0,1fr)] xl:items-end">
+          <div className="space-y-3">
+            <div className="flex flex-wrap items-center gap-2">
+              <Badge variant="outline" className="border-emerald-500/40 bg-emerald-500/10 text-emerald-100">
+                Track 1
+              </Badge>
+              <Badge variant="outline" className="border-cyan-500/40 bg-cyan-500/10 text-cyan-100">
+                ROCm + vLLM
+              </Badge>
+              <Badge variant="outline" className="border-amber-500/40 bg-amber-500/10 text-amber-100">
+                Qwen3-Coder-Next
+              </Badge>
+            </div>
+            <div>
+              <h1 className="text-3xl font-semibold tracking-normal text-foreground sm:text-4xl">
+                ROCmPilot
+              </h1>
+              <p className="mt-2 max-w-3xl text-sm leading-6 text-muted-foreground">
+                Multi-agent ROCm migration cockpit for PyTorch and vLLM workloads.
+              </p>
+            </div>
+          </div>
+
+          <div className="grid w-full min-w-0 gap-3 md:grid-cols-[minmax(220px,0.85fr)_minmax(260px,1.35fr)] xl:grid-cols-[minmax(220px,0.8fr)_minmax(340px,1.45fr)_max-content]">
+            <div className="grid min-w-0 gap-2">
+              <Label htmlFor="sample">Sample workload</Label>
+              <Select
+                value={sampleId}
+                onValueChange={(value) => {
+                  setSampleId(value);
+                  setGithubUrl("");
+                }}
+              >
+                <SelectTrigger
+                  id="sample"
+                  className="h-10 w-full min-w-0 bg-card [&_[data-slot=select-value]]:min-w-0 [&_[data-slot=select-value]]:truncate"
+                >
+                  <SelectValue placeholder="Select sample" />
+                </SelectTrigger>
+                <SelectContent>
+                  {SAMPLE_REPOS.map((sample) => (
+                    <SelectItem key={sample.id} value={sample.id}>
+                      {sample.name}
+                    </SelectItem>
+                  ))}
+                </SelectContent>
+              </Select>
+            </div>
+            <div className="grid min-w-0 gap-2">
+              <Label htmlFor="github-url">Public GitHub URL</Label>
+              <Input
+                id="github-url"
+                className="h-10 bg-card font-mono text-xs sm:text-sm"
+                onChange={(event) => setGithubUrl(event.target.value)}
+                placeholder="https://github.com/org/repo"
+                value={githubUrl}
+              />
+            </div>
+            <Button
+              className="h-10 w-full self-end md:col-span-2 xl:col-span-1 xl:w-auto"
+              disabled={isStarting || (run?.status === "running")}
+              onClick={startRun}
+            >
+              {isStarting ? (
+                <Loader2 className="size-4 animate-spin" />
+              ) : run ? (
+                <RefreshCw className="size-4" />
+              ) : (
+                <Play className="size-4" />
+              )}
+              {run ? "Run Again" : githubUrl.trim() ? "Scan Repo" : "Start Sample"}
+            </Button>
+          </div>
+        </section>
+
+        {error && (
+          <Alert variant="destructive">
+            <TriangleAlert className="size-4" />
+            <AlertTitle>Demo flow needs attention</AlertTitle>
+            <AlertDescription>{error}</AlertDescription>
+          </Alert>
+        )}
+
+        <section className="grid gap-5 lg:grid-cols-[1.6fr_0.9fr]">
+          <div className="grid gap-5">
+            <Card>
+              <CardHeader className="gap-3">
+                <div className="flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between">
+                  <div>
+                    <CardTitle className="flex items-center gap-2 text-xl">
+                      <Bot className="size-5 text-cyan-200" />
+                      Agent run
+                    </CardTitle>
+                    <CardDescription>
+                      {run
+                        ? `${completedStages}/${run.stages.length} stages complete`
+                        : "Ready to audit the selected workload"}
+                    </CardDescription>
+                  </div>
+                  <Badge
+                    variant="outline"
+                    className={
+                      run?.status === "completed"
+                        ? "border-emerald-500/40 bg-emerald-500/10 text-emerald-100"
+                        : run?.status === "running"
+                          ? "border-cyan-500/40 bg-cyan-500/10 text-cyan-100"
+                          : "border-zinc-700 bg-zinc-900 text-zinc-300"
+                    }
+                  >
+                    {run?.status ?? "idle"}
+                  </Badge>
+                </div>
+                <Progress value={run?.progress ?? 0} />
+              </CardHeader>
+              <CardContent>
+                <div className="grid gap-3 md:grid-cols-5">
+                  {(run?.stages ?? []).length > 0 ? (
+                    run?.stages.map((stage) => (
+                      <div
+                        key={stage.id}
+                        className={`rounded-lg border p-3 ${statusTone[stage.status]}`}
+                      >
+                        <div className="flex items-center justify-between gap-2">
+                          <StageIcon stage={stage} />
+                          <span className="font-mono text-[11px]">{stage.progress}%</span>
+                        </div>
+                        <p className="mt-3 text-sm font-medium leading-5">{stage.agent}</p>
+                        <p className="mt-1 min-h-10 text-xs leading-5 text-muted-foreground">
+                          {stage.title}
+                        </p>
+                        <p className="mt-3 font-mono text-[11px] text-muted-foreground">
+                          {formatTime(stage.completedAt ?? stage.startedAt)}
+                        </p>
+                      </div>
+                    ))
+                  ) : (
+                    <div className="col-span-full rounded-lg border border-dashed border-border p-6 text-sm text-muted-foreground">
+                      Select a workload and start the audit.
+                    </div>
+                  )}
+                </div>
+              </CardContent>
+            </Card>
+
+            <AgentWarRoom run={run} />
+
+            <Card>
+              <CardHeader>
+                <CardTitle className="flex items-center gap-2 text-xl">
+                  <ShieldCheck className="size-5 text-emerald-200" />
+                  Migration findings
+                </CardTitle>
+                <CardDescription>CUDA assumptions, ROCm blockers, and recommended fixes.</CardDescription>
+              </CardHeader>
+              <CardContent>
+                <div className="overflow-hidden rounded-lg border">
+                  <Table>
+                    <TableHeader>
+                      <TableRow>
+                        <TableHead>Severity</TableHead>
+                        <TableHead>Category</TableHead>
+                        <TableHead>Location</TableHead>
+                        <TableHead>Fix</TableHead>
+                      </TableRow>
+                    </TableHeader>
+                    <TableBody>
+                      {run?.findings.length ? (
+                        run.findings.map((finding) => (
+                          <TableRow key={finding.id}>
+                            <TableCell>
+                              <Badge variant="outline" className={severityTone[finding.severity]}>
+                                {finding.severity}
+                              </Badge>
+                            </TableCell>
+                            <TableCell className="font-medium">{finding.category}</TableCell>
+                            <TableCell className="font-mono text-xs text-muted-foreground">
+                              {finding.file}:{finding.line}
+                            </TableCell>
+                            <TableCell className="max-w-md text-sm text-muted-foreground">
+                              {finding.recommendedFix}
+                            </TableCell>
+                          </TableRow>
+                        ))
+                      ) : (
+                        <TableRow>
+                          <TableCell colSpan={4} className="h-24 text-center text-muted-foreground">
+                            Findings appear after the Repo Doctor stage starts.
+                          </TableCell>
+                        </TableRow>
+                      )}
+                    </TableBody>
+                  </Table>
+                </div>
+              </CardContent>
+            </Card>
+
+            <Card>
+              <CardHeader>
+                <CardTitle className="flex items-center gap-2 text-xl">
+                  <FileCode2 className="size-5 text-amber-200" />
+                  Evidence panels
+                </CardTitle>
+                <CardDescription>Patch previews, terminal logs, and final report output.</CardDescription>
+              </CardHeader>
+              <CardContent>
+                <div className="w-full">
+                  <div
+                    aria-label="Evidence panels"
+                    className="grid w-full grid-cols-3 rounded-lg bg-muted p-1"
+                    role="tablist"
+                  >
+                    {(["patches", "logs", "report"] as const).map((panel) => (
+                      <Button
+                        aria-selected={activePanel === panel}
+                        className="h-8 capitalize"
+                        key={panel}
+                        onClick={() => setActivePanel(panel)}
+                        role="tab"
+                        type="button"
+                        variant={activePanel === panel ? "secondary" : "ghost"}
+                      >
+                        {panel}
+                      </Button>
+                    ))}
+                  </div>
+                  {activePanel === "patches" && (
+                    <div className="mt-4 space-y-4" role="tabpanel">
+                    {run?.patches.length ? (
+                      run.patches.map((patch) => (
+                        <div key={patch.id} className="space-y-2 rounded-lg border border-border p-3">
+                          <div className="flex flex-col gap-1 sm:flex-row sm:items-center sm:justify-between">
+                            <p className="text-sm font-medium">{patch.file}</p>
+                            <p className="max-w-xl text-xs text-muted-foreground">{patch.rationale}</p>
+                          </div>
+                          <CodeBlock code={patch.diff} language="diff" showLineNumbers>
+                            <CodeBlockHeader>
+                              <CodeBlockTitle>
+                                <CodeBlockFilename>{patch.file}</CodeBlockFilename>
+                              </CodeBlockTitle>
+                              <CodeBlockCopyButton />
+                            </CodeBlockHeader>
+                          </CodeBlock>
+                        </div>
+                      ))
+                    ) : (
+                      <div className="rounded-lg border border-dashed border-border p-6 text-sm text-muted-foreground">
+                        Patch previews unlock after the Migration Planner stage.
+                      </div>
+                    )}
+                    </div>
+                  )}
+                  {activePanel === "logs" && (
+                    <div className="mt-4" role="tabpanel">
+                    <Terminal
+                      output={logOutput || "waiting for run output..."}
+                      isStreaming={run?.status === "running"}
+                    />
+                    </div>
+                  )}
+                  {activePanel === "report" && (
+                    <div className="mt-4" role="tabpanel">
+                    <div className="min-h-80 rounded-lg border bg-card p-4">
+                      {isGeneratingReport ? (
+                        <div className="flex h-64 items-center justify-center gap-3 text-sm text-muted-foreground">
+                          <Loader2 className="size-4 animate-spin" />
+                          Report Agent is calling AMD-hosted Qwen or fallback output.
+                        </div>
+                      ) : report?.report ? (
+                        <MessageResponse>{report.report}</MessageResponse>
+                      ) : (
+                        <div className="flex h-64 items-center justify-center text-sm text-muted-foreground">
+                          The final report appears after all agent stages complete.
+                        </div>
+                      )}
+                    </div>
+                    </div>
+                  )}
+                </div>
+              </CardContent>
+            </Card>
+          </div>
+
+          <aside className="grid content-start gap-5">
+            <Card>
+              <CardHeader>
+                <CardTitle className="flex items-center gap-2 text-lg">
+                  <GitBranch className="size-5 text-zinc-300" />
+                  Workload
+                </CardTitle>
+                <CardDescription>
+                  {run?.target.type === "github" ? run.target.note : selectedSample.stack}
+                </CardDescription>
+              </CardHeader>
+              <CardContent className="space-y-4">
+                <div className="grid gap-2">
+                  <Label htmlFor="repo-url">Repository URL</Label>
+                  <Input id="repo-url" value={activeRepoUrl} readOnly className="font-mono text-xs" />
+                </div>
+                <Separator />
+                <div className="space-y-3 text-sm">
+                  <div>
+                    <p className="text-muted-foreground">Scan mode</p>
+                    <p className="font-medium">
+                      {run?.target.type === "github" ? "Live public GitHub scan" : "Curated sample fixture"}
+                    </p>
+                  </div>
+                  <div>
+                    <p className="text-muted-foreground">Target</p>
+                    <p className="font-medium">{run?.target.label ?? selectedSample.name}</p>
+                  </div>
+                  <div>
+                    <p className="text-muted-foreground">Files scanned</p>
+                    <p className="font-mono text-lg">{run?.target.scannedFiles ?? 0}</p>
+                  </div>
+                  <div>
+                    <p className="text-muted-foreground">Risk</p>
+                    <p className="leading-6">{run?.target.note ?? selectedSample.risk}</p>
+                  </div>
+                </div>
+              </CardContent>
+            </Card>
+
+            <Card>
+              <CardHeader>
+                <CardTitle className="flex items-center gap-2 text-lg">
+                  <Cpu className="size-5 text-emerald-200" />
+                  GPU model status
+                </CardTitle>
+                <CardDescription>Qwen endpoint used by the Report Agent.</CardDescription>
+              </CardHeader>
+              <CardContent className="space-y-4">
+                <Badge
+                  variant="outline"
+                  className={
+                    modelStatus?.status === "connected"
+                      ? "border-emerald-500/40 bg-emerald-500/10 text-emerald-100"
+                      : modelStatus?.status === "not-configured"
+                        ? "border-cyan-500/40 bg-cyan-500/10 text-cyan-100"
+                        : "border-amber-500/40 bg-amber-500/10 text-amber-100"
+                  }
+                >
+                  {modelStatus?.label ?? "AMD GPU Model: Demo fallback"}
+                </Badge>
+                <div className="space-y-2 text-sm">
+                  <div className="flex items-start gap-2">
+                    <Sparkles className="mt-0.5 size-4 text-amber-200" />
+                    <span>{modelStatus?.model ?? "Qwen/Qwen3-Coder-Next"}</span>
+                  </div>
+                  <div className="flex items-start gap-2">
+                    <Zap className="mt-0.5 size-4 text-cyan-200" />
+                    <span className="break-all text-muted-foreground">
+                      {modelStatus?.endpoint ?? "Set AMD_QWEN_BASE_URL"}
+                    </span>
+                  </div>
+                  <p className="leading-6 text-muted-foreground">
+                    {modelStatus?.detail ??
+                      "The MVP stays demo-safe until an AMD ROCm/vLLM endpoint is available."}
+                  </p>
+                </div>
+              </CardContent>
+            </Card>
+
+            <Card>
+              <CardHeader>
+                <CardTitle className="flex items-center gap-2 text-lg">
+                  <BrainCircuit className="size-5 text-rose-200" />
+                  Long-context memory
+                </CardTitle>
+                <CardDescription>Synap context used by the Report Agent.</CardDescription>
+              </CardHeader>
+              <CardContent className="space-y-4">
+                <Badge
+                  variant="outline"
+                  className={memoryStatusTone[memoryStatus?.status ?? "fallback"]}
+                >
+                  {memoryStatus?.label ?? "Synap Memory: Local fallback"}
+                </Badge>
+                <div className="grid gap-3 text-sm">
+                  <div>
+                    <p className="text-muted-foreground">Provider</p>
+                    <p className="font-medium">{memoryStatus?.provider ?? "local"}</p>
+                  </div>
+                  <div>
+                    <p className="text-muted-foreground">Conversation</p>
+                    <p className="break-all font-mono text-xs">
+                      {memoryStatus?.conversationId ?? "created after run starts"}
+                    </p>
+                  </div>
+                  <div className="grid grid-cols-2 gap-3">
+                    <div>
+                      <p className="font-mono text-lg">{memoryStatus?.storedItems ?? 0}</p>
+                      <p className="text-xs text-muted-foreground">stored</p>
+                    </div>
+                    <div>
+                      <p className="font-mono text-lg">{memoryStatus?.recalledItems ?? 0}</p>
+                      <p className="text-xs text-muted-foreground">recalled</p>
+                    </div>
+                  </div>
+                  <p className="leading-6 text-muted-foreground">
+                    {memoryStatus?.detail ??
+                      "Set SYNAP_API_KEY to persist agent memory across sessions."}
+                  </p>
+                </div>
+              </CardContent>
+            </Card>
+
+            <Card>
+              <CardHeader>
+                <CardTitle className="flex items-center gap-2 text-lg">
+                  <Gauge className="size-5 text-cyan-200" />
+                  Benchmark profile
+                </CardTitle>
+                <CardDescription>Demo metrics for the submission walkthrough.</CardDescription>
+              </CardHeader>
+              <CardContent className="space-y-3">
+                {(run?.benchmarks ?? []).map((benchmark) => (
+                  <div key={benchmark.label} className="rounded-lg border border-border p-3">
+                    <div className="flex items-start justify-between gap-3">
+                      <p className="font-medium">{benchmark.label}</p>
+                      <Badge variant="outline">{benchmark.backend}</Badge>
+                    </div>
+                    <div className="mt-3 grid grid-cols-3 gap-2 text-sm">
+                      <div>
+                        <p className="font-mono text-lg">{benchmark.tokensPerSecond}</p>
+                        <p className="text-xs text-muted-foreground">tok/s</p>
+                      </div>
+                      <div>
+                        <p className="font-mono text-lg">{benchmark.p95LatencyMs}</p>
+                        <p className="text-xs text-muted-foreground">p95 ms</p>
+                      </div>
+                      <div>
+                        <p className="font-mono text-lg">{benchmark.memoryGb}</p>
+                        <p className="text-xs text-muted-foreground">GB</p>
+                      </div>
+                    </div>
+                    <p className="mt-3 text-xs leading-5 text-muted-foreground">{benchmark.costNote}</p>
+                  </div>
+                ))}
+                {!run && (
+                  <div className="rounded-lg border border-dashed border-border p-6 text-sm text-muted-foreground">
+                    Benchmark cards appear during the run.
+                  </div>
+                )}
+              </CardContent>
+            </Card>
+
+            <Card>
+              <CardHeader>
+                <CardTitle className="flex items-center gap-2 text-lg">
+                  <Boxes className="size-5 text-amber-200" />
+                  Submission proof
+                </CardTitle>
+              </CardHeader>
+              <CardContent className="space-y-3 text-sm text-muted-foreground">
+                <div className="flex items-start gap-2">
+                  <BadgeCheck className="mt-0.5 size-4 text-emerald-200" />
+                  <span>Track 1 agentic workflow with five specialized agents.</span>
+                </div>
+                <div className="flex items-start gap-2">
+                  <BadgeCheck className="mt-0.5 size-4 text-emerald-200" />
+                  <span>AMD GPU story through ROCm/vLLM Qwen model serving.</span>
+                </div>
+                <div className="flex items-start gap-2">
+                  <TerminalSquare className="mt-0.5 size-4 text-cyan-200" />
+                  <span>Demo remains reliable without credentials, then upgrades with live endpoint logs.</span>
+                </div>
+              </CardContent>
+            </Card>
+          </aside>
+        </section>
+      </div>
+    </main>
+  );
+}

src/components/ui/alert.tsx

@@ -0,0 +1,76 @@
+import * as React from "react"
+import { cva, type VariantProps } from "class-variance-authority"
+
+import { cn } from "@/lib/utils"
+
+const alertVariants = cva(
+  "group/alert relative grid w-full gap-0.5 rounded-lg border px-2.5 py-2 text-left text-sm has-data-[slot=alert-action]:relative has-data-[slot=alert-action]:pr-18 has-[>svg]:grid-cols-[auto_1fr] has-[>svg]:gap-x-2 *:[svg]:row-span-2 *:[svg]:translate-y-0.5 *:[svg]:text-current *:[svg:not([class*='size-'])]:size-4",
+  {
+    variants: {
+      variant: {
+        default: "bg-card text-card-foreground",
+        destructive:
+          "bg-card text-destructive *:data-[slot=alert-description]:text-destructive/90 *:[svg]:text-current",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+    },
+  }
+)
+
+function Alert({
+  className,
+  variant,
+  ...props
+}: React.ComponentProps<"div"> & VariantProps<typeof alertVariants>) {
+  return (
+    <div
+      data-slot="alert"
+      role="alert"
+      className={cn(alertVariants({ variant }), className)}
+      {...props}
+    />
+  )
+}
+
+function AlertTitle({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="alert-title"
+      className={cn(
+        "font-medium group-has-[>svg]/alert:col-start-2 [&_a]:underline [&_a]:underline-offset-3 [&_a]:hover:text-foreground",
+        className
+      )}
+      {...props}
+    />
+  )
+}
+
+function AlertDescription({
+  className,
+  ...props
+}: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="alert-description"
+      className={cn(
+        "text-sm text-balance text-muted-foreground md:text-pretty [&_a]:underline [&_a]:underline-offset-3 [&_a]:hover:text-foreground [&_p:not(:last-child)]:mb-4",
+        className
+      )}
+      {...props}
+    />
+  )
+}
+
+function AlertAction({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="alert-action"
+      className={cn("absolute top-2 right-2", className)}
+      {...props}
+    />
+  )
+}
+
+export { Alert, AlertTitle, AlertDescription, AlertAction }

src/components/ui/badge.tsx

@@ -0,0 +1,49 @@
+import * as React from "react"
+import { cva, type VariantProps } from "class-variance-authority"
+import { Slot } from "radix-ui"
+
+import { cn } from "@/lib/utils"
+
+const badgeVariants = cva(
+  "group/badge inline-flex h-5 w-fit shrink-0 items-center justify-center gap-1 overflow-hidden rounded-4xl border border-transparent px-2 py-0.5 text-xs font-medium whitespace-nowrap transition-all focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 aria-invalid:border-destructive aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 [&>svg]:pointer-events-none [&>svg]:size-3!",
+  {
+    variants: {
+      variant: {
+        default: "bg-primary text-primary-foreground [a]:hover:bg-primary/80",
+        secondary:
+          "bg-secondary text-secondary-foreground [a]:hover:bg-secondary/80",
+        destructive:
+          "bg-destructive/10 text-destructive focus-visible:ring-destructive/20 dark:bg-destructive/20 dark:focus-visible:ring-destructive/40 [a]:hover:bg-destructive/20",
+        outline:
+          "border-border text-foreground [a]:hover:bg-muted [a]:hover:text-muted-foreground",
+        ghost:
+          "hover:bg-muted hover:text-muted-foreground dark:hover:bg-muted/50",
+        link: "text-primary underline-offset-4 hover:underline",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+    },
+  }
+)
+
+function Badge({
+  className,
+  variant = "default",
+  asChild = false,
+  ...props
+}: React.ComponentProps<"span"> &
+  VariantProps<typeof badgeVariants> & { asChild?: boolean }) {
+  const Comp = asChild ? Slot.Root : "span"
+
+  return (
+    <Comp
+      data-slot="badge"
+      data-variant={variant}
+      className={cn(badgeVariants({ variant }), className)}
+      {...props}
+    />
+  )
+}
+
+export { Badge, badgeVariants }

src/components/ui/button-group.tsx

@@ -0,0 +1,83 @@
+import { cva, type VariantProps } from "class-variance-authority"
+import { Slot } from "radix-ui"
+
+import { cn } from "@/lib/utils"
+import { Separator } from "@/components/ui/separator"
+
+const buttonGroupVariants = cva(
+  "group/button-group flex w-fit items-stretch *:focus-visible:relative *:focus-visible:z-10 has-[>[data-slot=button-group]]:gap-2 has-[select[aria-hidden=true]:last-child]:[&>[data-slot=select-trigger]:last-of-type]:rounded-r-lg [&>[data-slot=select-trigger]:not([class*='w-'])]:w-fit [&>input]:flex-1",
+  {
+    variants: {
+      orientation: {
+        horizontal:
+          "[&>*:not(:first-child)]:rounded-l-none [&>*:not(:first-child)]:border-l-0 [&>*:not(:last-child)]:rounded-r-none [&>[data-slot]:not(:has(~[data-slot]))]:rounded-r-lg!",
+        vertical:
+          "flex-col [&>*:not(:first-child)]:rounded-t-none [&>*:not(:first-child)]:border-t-0 [&>*:not(:last-child)]:rounded-b-none [&>[data-slot]:not(:has(~[data-slot]))]:rounded-b-lg!",
+      },
+    },
+    defaultVariants: {
+      orientation: "horizontal",
+    },
+  }
+)
+
+function ButtonGroup({
+  className,
+  orientation,
+  ...props
+}: React.ComponentProps<"div"> & VariantProps<typeof buttonGroupVariants>) {
+  return (
+    <div
+      role="group"
+      data-slot="button-group"
+      data-orientation={orientation}
+      className={cn(buttonGroupVariants({ orientation }), className)}
+      {...props}
+    />
+  )
+}
+
+function ButtonGroupText({
+  className,
+  asChild = false,
+  ...props
+}: React.ComponentProps<"div"> & {
+  asChild?: boolean
+}) {
+  const Comp = asChild ? Slot.Root : "div"
+
+  return (
+    <Comp
+      className={cn(
+        "flex items-center gap-2 rounded-lg border bg-muted px-2.5 text-sm font-medium [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4",
+        className
+      )}
+      {...props}
+    />
+  )
+}
+
+function ButtonGroupSeparator({
+  className,
+  orientation = "vertical",
+  ...props
+}: React.ComponentProps<typeof Separator>) {
+  return (
+    <Separator
+      data-slot="button-group-separator"
+      orientation={orientation}
+      className={cn(
+        "relative self-stretch bg-input data-horizontal:mx-px data-horizontal:w-auto data-vertical:my-px data-vertical:h-auto",
+        className
+      )}
+      {...props}
+    />
+  )
+}
+
+export {
+  ButtonGroup,
+  ButtonGroupSeparator,
+  ButtonGroupText,
+  buttonGroupVariants,
+}

src/components/ui/button.tsx

@@ -0,0 +1,67 @@
+import * as React from "react"
+import { cva, type VariantProps } from "class-variance-authority"
+import { Slot } from "radix-ui"
+
+import { cn } from "@/lib/utils"
+
+const buttonVariants = cva(
+  "group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+  {
+    variants: {
+      variant: {
+        default: "bg-primary text-primary-foreground [a]:hover:bg-primary/80",
+        outline:
+          "border-border bg-background hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50",
+        secondary:
+          "bg-secondary text-secondary-foreground hover:bg-secondary/80 aria-expanded:bg-secondary aria-expanded:text-secondary-foreground",
+        ghost:
+          "hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:hover:bg-muted/50",
+        destructive:
+          "bg-destructive/10 text-destructive hover:bg-destructive/20 focus-visible:border-destructive/40 focus-visible:ring-destructive/20 dark:bg-destructive/20 dark:hover:bg-destructive/30 dark:focus-visible:ring-destructive/40",
+        link: "text-primary underline-offset-4 hover:underline",
+      },
+      size: {
+        default:
+          "h-8 gap-1.5 px-2.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2",
+        xs: "h-6 gap-1 rounded-[min(var(--radius-md),10px)] px-2 text-xs in-data-[slot=button-group]:rounded-lg has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&_svg:not([class*='size-'])]:size-3",
+        sm: "h-7 gap-1 rounded-[min(var(--radius-md),12px)] px-2.5 text-[0.8rem] in-data-[slot=button-group]:rounded-lg has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&_svg:not([class*='size-'])]:size-3.5",
+        lg: "h-9 gap-1.5 px-2.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2",
+        icon: "size-8",
+        "icon-xs":
+          "size-6 rounded-[min(var(--radius-md),10px)] in-data-[slot=button-group]:rounded-lg [&_svg:not([class*='size-'])]:size-3",
+        "icon-sm":
+          "size-7 rounded-[min(var(--radius-md),12px)] in-data-[slot=button-group]:rounded-lg",
+        "icon-lg": "size-9",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "default",
+    },
+  }
+)
+
+function Button({
+  className,
+  variant = "default",
+  size = "default",
+  asChild = false,
+  ...props
+}: React.ComponentProps<"button"> &
+  VariantProps<typeof buttonVariants> & {
+    asChild?: boolean
+  }) {
+  const Comp = asChild ? Slot.Root : "button"
+
+  return (
+    <Comp
+      data-slot="button"
+      data-variant={variant}
+      data-size={size}
+      className={cn(buttonVariants({ variant, size, className }))}
+      {...props}
+    />
+  )
+}
+
+export { Button, buttonVariants }

src/components/ui/card.tsx

@@ -0,0 +1,103 @@
+import * as React from "react"
+
+import { cn } from "@/lib/utils"
+
+function Card({
+  className,
+  size = "default",
+  ...props
+}: React.ComponentProps<"div"> & { size?: "default" | "sm" }) {
+  return (
+    <div
+      data-slot="card"
+      data-size={size}
+      className={cn(
+        "group/card flex flex-col gap-4 overflow-hidden rounded-xl bg-card py-4 text-sm text-card-foreground ring-1 ring-foreground/10 has-data-[slot=card-footer]:pb-0 has-[>img:first-child]:pt-0 data-[size=sm]:gap-3 data-[size=sm]:py-3 data-[size=sm]:has-data-[slot=card-footer]:pb-0 *:[img:first-child]:rounded-t-xl *:[img:last-child]:rounded-b-xl",
+        className
+      )}
+      {...props}
+    />
+  )
+}
+
+function CardHeader({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="card-header"
+      className={cn(
+        "group/card-header @container/card-header grid auto-rows-min items-start gap-1 rounded-t-xl px-4 group-data-[size=sm]/card:px-3 has-data-[slot=card-action]:grid-cols-[1fr_auto] has-data-[slot=card-description]:grid-rows-[auto_auto] [.border-b]:pb-4 group-data-[size=sm]/card:[.border-b]:pb-3",
+        className
+      )}
+      {...props}
+    />
+  )
+}
+
+function CardTitle({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="card-title"
+      className={cn(
+        "font-heading text-base leading-snug font-medium group-data-[size=sm]/card:text-sm",
+        className
+      )}
+      {...props}
+    />
+  )
+}
+
+function CardDescription({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="card-description"
+      className={cn("text-sm text-muted-foreground", className)}
+      {...props}
+    />
+  )
+}
+
+function CardAction({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="card-action"
+      className={cn(
+        "col-start-2 row-span-2 row-start-1 self-start justify-self-end",
+        className
+      )}
+      {...props}
+    />
+  )
+}
+
+function CardContent({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="card-content"
+      className={cn("px-4 group-data-[size=sm]/card:px-3", className)}
+      {...props}
+    />
+  )
+}
+
+function CardFooter({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="card-footer"
+      className={cn(
+        "flex items-center rounded-b-xl border-t bg-muted/50 p-4 group-data-[size=sm]/card:p-3",
+        className
+      )}
+      {...props}
+    />
+  )
+}
+
+export {
+  Card,
+  CardHeader,
+  CardFooter,
+  CardTitle,
+  CardAction,
+  CardDescription,
+  CardContent,
+}

src/components/ui/collapsible.tsx

@@ -0,0 +1,33 @@
+"use client"
+
+import { Collapsible as CollapsiblePrimitive } from "radix-ui"
+
+function Collapsible({
+  ...props
+}: React.ComponentProps<typeof CollapsiblePrimitive.Root>) {
+  return <CollapsiblePrimitive.Root data-slot="collapsible" {...props} />
+}
+
+function CollapsibleTrigger({
+  ...props
+}: React.ComponentProps<typeof CollapsiblePrimitive.CollapsibleTrigger>) {
+  return (
+    <CollapsiblePrimitive.CollapsibleTrigger
+      data-slot="collapsible-trigger"
+      {...props}
+    />
+  )
+}
+
+function CollapsibleContent({
+  ...props
+}: React.ComponentProps<typeof CollapsiblePrimitive.CollapsibleContent>) {
+  return (
+    <CollapsiblePrimitive.CollapsibleContent
+      data-slot="collapsible-content"
+      {...props}
+    />
+  )
+}
+
+export { Collapsible, CollapsibleTrigger, CollapsibleContent }

src/components/ui/input.tsx

@@ -0,0 +1,19 @@
+import * as React from "react"
+
+import { cn } from "@/lib/utils"
+
+function Input({ className, type, ...props }: React.ComponentProps<"input">) {
+  return (
+    <input
+      type={type}
+      data-slot="input"
+      className={cn(
+        "h-8 w-full min-w-0 rounded-lg border border-input bg-transparent px-2.5 py-1 text-base transition-colors outline-none file:inline-flex file:h-6 file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-foreground placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 disabled:pointer-events-none disabled:cursor-not-allowed disabled:bg-input/50 disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 md:text-sm dark:bg-input/30 dark:disabled:bg-input/80 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40",
+        className
+      )}
+      {...props}
+    />
+  )
+}
+
+export { Input }

src/components/ui/label.tsx

@@ -0,0 +1,24 @@
+"use client"
+
+import * as React from "react"
+import { Label as LabelPrimitive } from "radix-ui"
+
+import { cn } from "@/lib/utils"
+
+function Label({
+  className,
+  ...props
+}: React.ComponentProps<typeof LabelPrimitive.Root>) {
+  return (
+    <LabelPrimitive.Root
+      data-slot="label"
+      className={cn(
+        "flex items-center gap-2 text-sm leading-none font-medium select-none group-data-[disabled=true]:pointer-events-none group-data-[disabled=true]:opacity-50 peer-disabled:cursor-not-allowed peer-disabled:opacity-50",
+        className
+      )}
+      {...props}
+    />
+  )
+}
+
+export { Label }

src/components/ui/progress.tsx

@@ -0,0 +1,31 @@
+"use client"
+
+import * as React from "react"
+import { Progress as ProgressPrimitive } from "radix-ui"
+
+import { cn } from "@/lib/utils"
+
+function Progress({
+  className,
+  value,
+  ...props
+}: React.ComponentProps<typeof ProgressPrimitive.Root>) {
+  return (
+    <ProgressPrimitive.Root
+      data-slot="progress"
+      className={cn(
+        "relative flex h-1 w-full items-center overflow-x-hidden rounded-full bg-muted",
+        className
+      )}
+      {...props}
+    >
+      <ProgressPrimitive.Indicator
+        data-slot="progress-indicator"
+        className="size-full flex-1 bg-primary transition-all"
+        style={{ transform: `translateX(-${100 - (value || 0)}%)` }}
+      />
+    </ProgressPrimitive.Root>
+  )
+}
+
+export { Progress }

src/components/ui/scroll-area.tsx

@@ -0,0 +1,55 @@
+"use client"
+
+import * as React from "react"
+import { ScrollArea as ScrollAreaPrimitive } from "radix-ui"
+
+import { cn } from "@/lib/utils"
+
+function ScrollArea({
+  className,
+  children,
+  ...props
+}: React.ComponentProps<typeof ScrollAreaPrimitive.Root>) {
+  return (
+    <ScrollAreaPrimitive.Root
+      data-slot="scroll-area"
+      className={cn("relative", className)}
+      {...props}
+    >
+      <ScrollAreaPrimitive.Viewport
+        data-slot="scroll-area-viewport"
+        className="size-full rounded-[inherit] transition-[color,box-shadow] outline-none focus-visible:ring-[3px] focus-visible:ring-ring/50 focus-visible:outline-1"
+      >
+        {children}
+      </ScrollAreaPrimitive.Viewport>
+      <ScrollBar />
+      <ScrollAreaPrimitive.Corner />
+    </ScrollAreaPrimitive.Root>
+  )
+}
+
+function ScrollBar({
+  className,
+  orientation = "vertical",
+  ...props
+}: React.ComponentProps<typeof ScrollAreaPrimitive.ScrollAreaScrollbar>) {
+  return (
+    <ScrollAreaPrimitive.ScrollAreaScrollbar
+      data-slot="scroll-area-scrollbar"
+      data-orientation={orientation}
+      orientation={orientation}
+      className={cn(
+        "flex touch-none p-px transition-colors select-none data-horizontal:h-2.5 data-horizontal:flex-col data-horizontal:border-t data-horizontal:border-t-transparent data-vertical:h-full data-vertical:w-2.5 data-vertical:border-l data-vertical:border-l-transparent",
+        className
+      )}
+      {...props}
+    >
+      <ScrollAreaPrimitive.ScrollAreaThumb
+        data-slot="scroll-area-thumb"
+        className="relative flex-1 rounded-full bg-border"
+      />
+    </ScrollAreaPrimitive.ScrollAreaScrollbar>
+  )
+}
+
+export { ScrollArea, ScrollBar }

src/components/ui/select.tsx

@@ -0,0 +1,192 @@
+"use client"
+
+import * as React from "react"
+import { Select as SelectPrimitive } from "radix-ui"
+
+import { cn } from "@/lib/utils"
+import { ChevronDownIcon, CheckIcon, ChevronUpIcon } from "lucide-react"
+
+function Select({
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.Root>) {
+  return <SelectPrimitive.Root data-slot="select" {...props} />
+}
+
+function SelectGroup({
+  className,
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.Group>) {
+  return (
+    <SelectPrimitive.Group
+      data-slot="select-group"
+      className={cn("scroll-my-1 p-1", className)}
+      {...props}
+    />
+  )
+}
+
+function SelectValue({
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.Value>) {
+  return <SelectPrimitive.Value data-slot="select-value" {...props} />
+}
+
+function SelectTrigger({
+  className,
+  size = "default",
+  children,
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.Trigger> & {
+  size?: "sm" | "default"
+}) {
+  return (
+    <SelectPrimitive.Trigger
+      data-slot="select-trigger"
+      data-size={size}
+      className={cn(
+        "flex w-fit items-center justify-between gap-1.5 rounded-lg border border-input bg-transparent py-2 pr-2 pl-2.5 text-sm whitespace-nowrap transition-colors outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 disabled:cursor-not-allowed disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 data-placeholder:text-muted-foreground data-[size=default]:h-8 data-[size=sm]:h-7 data-[size=sm]:rounded-[min(var(--radius-md),10px)] *:data-[slot=select-value]:line-clamp-1 *:data-[slot=select-value]:flex *:data-[slot=select-value]:items-center *:data-[slot=select-value]:gap-1.5 dark:bg-input/30 dark:hover:bg-input/50 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+        className
+      )}
+      {...props}
+    >
+      {children}
+      <SelectPrimitive.Icon asChild>
+        <ChevronDownIcon className="pointer-events-none size-4 text-muted-foreground" />
+      </SelectPrimitive.Icon>
+    </SelectPrimitive.Trigger>
+  )
+}
+
+function SelectContent({
+  className,
+  children,
+  position = "item-aligned",
+  align = "center",
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.Content>) {
+  return (
+    <SelectPrimitive.Portal>
+      <SelectPrimitive.Content
+        data-slot="select-content"
+        data-align-trigger={position === "item-aligned"}
+        className={cn("relative z-50 max-h-(--radix-select-content-available-height) min-w-36 origin-(--radix-select-content-transform-origin) overflow-x-hidden overflow-y-auto rounded-lg bg-popover text-popover-foreground shadow-md ring-1 ring-foreground/10 duration-100 data-[align-trigger=true]:animate-none data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95", position ==="popper"&&"data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1", className )}
+        position={position}
+        align={align}
+        {...props}
+      >
+        <SelectScrollUpButton />
+        <SelectPrimitive.Viewport
+          data-position={position}
+          className={cn(
+            "data-[position=popper]:h-(--radix-select-trigger-height) data-[position=popper]:w-full data-[position=popper]:min-w-(--radix-select-trigger-width)",
+            position === "popper" && ""
+          )}
+        >
+          {children}
+        </SelectPrimitive.Viewport>
+        <SelectScrollDownButton />
+      </SelectPrimitive.Content>
+    </SelectPrimitive.Portal>
+  )
+}
+
+function SelectLabel({
+  className,
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.Label>) {
+  return (
+    <SelectPrimitive.Label
+      data-slot="select-label"
+      className={cn("px-1.5 py-1 text-xs text-muted-foreground", className)}
+      {...props}
+    />
+  )
+}
+
+function SelectItem({
+  className,
+  children,
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.Item>) {
+  return (
+    <SelectPrimitive.Item
+      data-slot="select-item"
+      className={cn(
+        "relative flex w-full cursor-default items-center gap-1.5 rounded-md py-1 pr-8 pl-1.5 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground not-data-[variant=destructive]:focus:**:text-accent-foreground data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4 *:[span]:last:flex *:[span]:last:items-center *:[span]:last:gap-2",
+        className
+      )}
+      {...props}
+    >
+      <span className="pointer-events-none absolute right-2 flex size-4 items-center justify-center">
+        <SelectPrimitive.ItemIndicator>
+          <CheckIcon className="pointer-events-none" />
+        </SelectPrimitive.ItemIndicator>
+      </span>
+      <SelectPrimitive.ItemText>{children}</SelectPrimitive.ItemText>
+    </SelectPrimitive.Item>
+  )
+}
+
+function SelectSeparator({
+  className,
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.Separator>) {
+  return (
+    <SelectPrimitive.Separator
+      data-slot="select-separator"
+      className={cn("pointer-events-none -mx-1 my-1 h-px bg-border", className)}
+      {...props}
+    />
+  )
+}
+
+function SelectScrollUpButton({
+  className,
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.ScrollUpButton>) {
+  return (
+    <SelectPrimitive.ScrollUpButton
+      data-slot="select-scroll-up-button"
+      className={cn(
+        "z-10 flex cursor-default items-center justify-center bg-popover py-1 [&_svg:not([class*='size-'])]:size-4",
+        className
+      )}
+      {...props}
+    >
+      <ChevronUpIcon
+      />
+    </SelectPrimitive.ScrollUpButton>
+  )
+}
+
+function SelectScrollDownButton({
+  className,
+  ...props
+}: React.ComponentProps<typeof SelectPrimitive.ScrollDownButton>) {
+  return (
+    <SelectPrimitive.ScrollDownButton
+      data-slot="select-scroll-down-button"
+      className={cn(
+        "z-10 flex cursor-default items-center justify-center bg-popover py-1 [&_svg:not([class*='size-'])]:size-4",
+        className
+      )}
+      {...props}
+    >
+      <ChevronDownIcon
+      />
+    </SelectPrimitive.ScrollDownButton>
+  )
+}
+
+export {
+  Select,
+  SelectContent,
+  SelectGroup,
+  SelectItem,
+  SelectLabel,
+  SelectScrollDownButton,
+  SelectScrollUpButton,
+  SelectSeparator,
+  SelectTrigger,
+  SelectValue,
+}

src/components/ui/separator.tsx

@@ -0,0 +1,28 @@
+"use client"
+
+import * as React from "react"
+import { Separator as SeparatorPrimitive } from "radix-ui"
+
+import { cn } from "@/lib/utils"
+
+function Separator({
+  className,
+  orientation = "horizontal",
+  decorative = true,
+  ...props
+}: React.ComponentProps<typeof SeparatorPrimitive.Root>) {
+  return (
+    <SeparatorPrimitive.Root
+      data-slot="separator"
+      decorative={decorative}
+      orientation={orientation}
+      className={cn(
+        "shrink-0 bg-border data-horizontal:h-px data-horizontal:w-full data-vertical:w-px data-vertical:self-stretch",
+        className
+      )}
+      {...props}
+    />
+  )
+}
+
+export { Separator }

src/components/ui/skeleton.tsx

@@ -0,0 +1,13 @@
+import { cn } from "@/lib/utils"
+
+function Skeleton({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="skeleton"
+      className={cn("animate-pulse rounded-md bg-muted", className)}
+      {...props}
+    />
+  )
+}
+
+export { Skeleton }

src/components/ui/table.tsx

@@ -0,0 +1,116 @@
+"use client"
+
+import * as React from "react"
+
+import { cn } from "@/lib/utils"
+
+function Table({ className, ...props }: React.ComponentProps<"table">) {
+  return (
+    <div
+      data-slot="table-container"
+      className="relative w-full overflow-x-auto"
+    >
+      <table
+        data-slot="table"
+        className={cn("w-full caption-bottom text-sm", className)}
+        {...props}
+      />
+    </div>
+  )
+}
+
+function TableHeader({ className, ...props }: React.ComponentProps<"thead">) {
+  return (
+    <thead
+      data-slot="table-header"
+      className={cn("[&_tr]:border-b", className)}
+      {...props}
+    />
+  )
+}
+
+function TableBody({ className, ...props }: React.ComponentProps<"tbody">) {
+  return (
+    <tbody
+      data-slot="table-body"
+      className={cn("[&_tr:last-child]:border-0", className)}
+      {...props}
+    />
+  )
+}
+
+function TableFooter({ className, ...props }: React.ComponentProps<"tfoot">) {
+  return (
+    <tfoot
+      data-slot="table-footer"
+      className={cn(
+        "border-t bg-muted/50 font-medium [&>tr]:last:border-b-0",
+        className
+      )}
+      {...props}
+    />
+  )
+}
+
+function TableRow({ className, ...props }: React.ComponentProps<"tr">) {
+  return (
+    <tr
+      data-slot="table-row"
+      className={cn(
+        "border-b transition-colors hover:bg-muted/50 has-aria-expanded:bg-muted/50 data-[state=selected]:bg-muted",
+        className
+      )}
+      {...props}
+    />
+  )
+}
+
+function TableHead({ className, ...props }: React.ComponentProps<"th">) {
+  return (
+    <th
+      data-slot="table-head"
+      className={cn(
+        "h-10 px-2 text-left align-middle font-medium whitespace-nowrap text-foreground [&:has([role=checkbox])]:pr-0",
+        className
+      )}
+      {...props}
+    />
+  )
+}
+
+function TableCell({ className, ...props }: React.ComponentProps<"td">) {
+  return (
+    <td
+      data-slot="table-cell"
+      className={cn(
+        "p-2 align-middle whitespace-nowrap [&:has([role=checkbox])]:pr-0",
+        className
+      )}
+      {...props}
+    />
+  )
+}
+
+function TableCaption({
+  className,
+  ...props
+}: React.ComponentProps<"caption">) {
+  return (
+    <caption
+      data-slot="table-caption"
+      className={cn("mt-4 text-sm text-muted-foreground", className)}
+      {...props}
+    />
+  )
+}
+
+export {
+  Table,
+  TableHeader,
+  TableBody,
+  TableFooter,
+  TableHead,
+  TableRow,
+  TableCell,
+  TableCaption,
+}

src/components/ui/tabs.tsx

@@ -0,0 +1,90 @@
+"use client"
+
+import * as React from "react"
+import { cva, type VariantProps } from "class-variance-authority"
+import { Tabs as TabsPrimitive } from "radix-ui"
+
+import { cn } from "@/lib/utils"
+
+function Tabs({
+  className,
+  orientation = "horizontal",
+  ...props
+}: React.ComponentProps<typeof TabsPrimitive.Root>) {
+  return (
+    <TabsPrimitive.Root
+      data-slot="tabs"
+      data-orientation={orientation}
+      className={cn(
+        "group/tabs flex gap-2 data-horizontal:flex-col",
+        className
+      )}
+      {...props}
+    />
+  )
+}
+
+const tabsListVariants = cva(
+  "group/tabs-list inline-flex w-fit items-center justify-center rounded-lg p-[3px] text-muted-foreground group-data-horizontal/tabs:h-8 group-data-vertical/tabs:h-fit group-data-vertical/tabs:flex-col data-[variant=line]:rounded-none",
+  {
+    variants: {
+      variant: {
+        default: "bg-muted",
+        line: "gap-1 bg-transparent",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+    },
+  }
+)
+
+function TabsList({
+  className,
+  variant = "default",
+  ...props
+}: React.ComponentProps<typeof TabsPrimitive.List> &
+  VariantProps<typeof tabsListVariants>) {
+  return (
+    <TabsPrimitive.List
+      data-slot="tabs-list"
+      data-variant={variant}
+      className={cn(tabsListVariants({ variant }), className)}
+      {...props}
+    />
+  )
+}
+
+function TabsTrigger({
+  className,
+  ...props
+}: React.ComponentProps<typeof TabsPrimitive.Trigger>) {
+  return (
+    <TabsPrimitive.Trigger
+      data-slot="tabs-trigger"
+      className={cn(
+        "relative inline-flex h-[calc(100%-1px)] flex-1 items-center justify-center gap-1.5 rounded-md border border-transparent px-1.5 py-0.5 text-sm font-medium whitespace-nowrap text-foreground/60 transition-all group-data-vertical/tabs:w-full group-data-vertical/tabs:justify-start hover:text-foreground focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 focus-visible:outline-1 focus-visible:outline-ring disabled:pointer-events-none disabled:opacity-50 has-data-[icon=inline-end]:pr-1 has-data-[icon=inline-start]:pl-1 dark:text-muted-foreground dark:hover:text-foreground group-data-[variant=default]/tabs-list:data-active:shadow-sm group-data-[variant=line]/tabs-list:data-active:shadow-none [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+        "group-data-[variant=line]/tabs-list:bg-transparent group-data-[variant=line]/tabs-list:data-active:bg-transparent dark:group-data-[variant=line]/tabs-list:data-active:border-transparent dark:group-data-[variant=line]/tabs-list:data-active:bg-transparent",
+        "data-active:bg-background data-active:text-foreground dark:data-active:border-input dark:data-active:bg-input/30 dark:data-active:text-foreground",
+        "after:absolute after:bg-foreground after:opacity-0 after:transition-opacity group-data-horizontal/tabs:after:inset-x-0 group-data-horizontal/tabs:after:bottom-[-5px] group-data-horizontal/tabs:after:h-0.5 group-data-vertical/tabs:after:inset-y-0 group-data-vertical/tabs:after:-right-1 group-data-vertical/tabs:after:w-0.5 group-data-[variant=line]/tabs-list:data-active:after:opacity-100",
+        className
+      )}
+      {...props}
+    />
+  )
+}
+
+function TabsContent({
+  className,
+  ...props
+}: React.ComponentProps<typeof TabsPrimitive.Content>) {
+  return (
+    <TabsPrimitive.Content
+      data-slot="tabs-content"
+      className={cn("flex-1 text-sm outline-none", className)}
+      {...props}
+    />
+  )
+}
+
+export { Tabs, TabsList, TabsTrigger, TabsContent, tabsListVariants }

src/components/ui/textarea.tsx

@@ -0,0 +1,18 @@
+import * as React from "react"
+
+import { cn } from "@/lib/utils"
+
+function Textarea({ className, ...props }: React.ComponentProps<"textarea">) {
+  return (
+    <textarea
+      data-slot="textarea"
+      className={cn(
+        "flex field-sizing-content min-h-16 w-full rounded-lg border border-input bg-transparent px-2.5 py-2 text-base transition-colors outline-none placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 disabled:cursor-not-allowed disabled:bg-input/50 disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 md:text-sm dark:bg-input/30 dark:disabled:bg-input/80 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40",
+        className
+      )}
+      {...props}
+    />
+  )
+}
+
+export { Textarea }

src/components/ui/tooltip.tsx

@@ -0,0 +1,57 @@
+"use client"
+
+import * as React from "react"
+import { Tooltip as TooltipPrimitive } from "radix-ui"
+
+import { cn } from "@/lib/utils"
+
+function TooltipProvider({
+  delayDuration = 0,
+  ...props
+}: React.ComponentProps<typeof TooltipPrimitive.Provider>) {
+  return (
+    <TooltipPrimitive.Provider
+      data-slot="tooltip-provider"
+      delayDuration={delayDuration}
+      {...props}
+    />
+  )
+}
+
+function Tooltip({
+  ...props
+}: React.ComponentProps<typeof TooltipPrimitive.Root>) {
+  return <TooltipPrimitive.Root data-slot="tooltip" {...props} />
+}
+
+function TooltipTrigger({
+  ...props
+}: React.ComponentProps<typeof TooltipPrimitive.Trigger>) {
+  return <TooltipPrimitive.Trigger data-slot="tooltip-trigger" {...props} />
+}
+
+function TooltipContent({
+  className,
+  sideOffset = 0,
+  children,
+  ...props
+}: React.ComponentProps<typeof TooltipPrimitive.Content>) {
+  return (
+    <TooltipPrimitive.Portal>
+      <TooltipPrimitive.Content
+        data-slot="tooltip-content"
+        sideOffset={sideOffset}
+        className={cn(
+          "z-50 inline-flex w-fit max-w-xs origin-(--radix-tooltip-content-transform-origin) items-center gap-1.5 rounded-md bg-foreground px-3 py-1.5 text-xs text-background has-data-[slot=kbd]:pr-1.5 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 **:data-[slot=kbd]:relative **:data-[slot=kbd]:isolate **:data-[slot=kbd]:z-50 **:data-[slot=kbd]:rounded-sm data-[state=delayed-open]:animate-in data-[state=delayed-open]:fade-in-0 data-[state=delayed-open]:zoom-in-95 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
+          className
+        )}
+        {...props}
+      >
+        {children}
+        <TooltipPrimitive.Arrow className="z-50 size-2.5 translate-y-[calc(-50%_-_2px)] rotate-45 rounded-[2px] bg-foreground fill-foreground" />
+      </TooltipPrimitive.Content>
+    </TooltipPrimitive.Portal>
+  )
+}
+
+export { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger }

src/lib/rocmpilot/data.ts

@@ -0,0 +1,1102 @@
+import type {
+  AgentMessage,
+  AgentMessageKind,
+  AgentMemory,
+  BenchmarkResult,
+  Finding,
+  GpuModelStatus,
+  LongContextMemoryStatus,
+  PatchPreview,
+  RocmRun,
+  RunMode,
+  RunStatus,
+  RunStage,
+  StageStatus,
+  SampleRepo,
+  RunTarget,
+} from "./types";
+import { isRealGitHubRepoUrl, parseGitHubRepoUrl } from "./github-url";
+import type { RepoAnalysis } from "./github-scanner";
+import {
+  buildMemoryConversationId,
+  DEFAULT_MEMORY_CUSTOMER_ID,
+  DEFAULT_MEMORY_USER_ID,
+} from "./memory-ids";
+
+const TOTAL_DURATION_MS = 30_000;
+
+const STAGES: Array<Omit<RunStage, "status" | "progress" | "startedAt" | "completedAt"> & {
+  durationMs: number;
+}> = [
+  {
+    id: "repo-doctor",
+    agent: "Repo Doctor Agent",
+    title: "Repo compatibility scan",
+    description: "Dependency graph, Docker image, device paths, and runtime flags",
+    durationMs: 5_000,
+  },
+  {
+    id: "migration-planner",
+    agent: "Migration Planner Agent",
+    title: "ROCm migration plan",
+    description: "PyTorch ROCm wheels, vLLM runtime, and device abstraction changes",
+    durationMs: 6_000,
+  },
+  {
+    id: "build-runner",
+    agent: "Build Runner Agent",
+    title: "Build and smoke tests",
+    description: "Container validation, import checks, and inference dry run",
+    durationMs: 5_500,
+  },
+  {
+    id: "benchmark-agent",
+    agent: "Benchmark Agent",
+    title: "MI300X readiness benchmark",
+    description: "Throughput, latency, memory, and fallback path comparison",
+    durationMs: 5_000,
+  },
+  {
+    id: "report-agent",
+    agent: "Report Agent",
+    title: "Judge-ready report",
+    description: "Technical summary, business value, and AMD proof points",
+    durationMs: 6_000,
+  },
+];
+
+export const SAMPLE_REPOS: SampleRepo[] = [
+  {
+    id: "qwen-vllm-cuda",
+    name: "Qwen vLLM CUDA Starter",
+    repoUrl: "https://github.com/example/qwen-vllm-cuda-starter",
+    stack: "FastAPI, PyTorch, vLLM, Docker",
+    model: "Qwen/Qwen2.5-Coder-7B-Instruct",
+    description: "A common NVIDIA-first inference service with CUDA-only install steps.",
+    risk: "Hardcoded CUDA device checks block AMD Developer Cloud deployment.",
+  },
+  {
+    id: "torch-agent-worker",
+    name: "Torch Agent Worker",
+    repoUrl: "https://github.com/example/torch-agent-worker",
+    stack: "Python workers, PyTorch, Redis queue",
+    model: "Qwen/Qwen3-Coder-Next",
+    description: "Background coding-agent worker that assumes NVIDIA runtime images.",
+    risk: "Docker and benchmark scripts hide GPU vendor assumptions.",
+  },
+];
+
+export const FINDINGS: Finding[] = [
+  {
+    id: "cuda-device",
+    severity: "critical",
+    category: "Runtime device lock",
+    file: "src/inference/server.py",
+    line: 42,
+    explanation:
+      "`torch.device('cuda')` is used directly, so the app never checks ROCm-compatible PyTorch device availability or CPU fallback.",
+    recommendedFix:
+      "Introduce a device resolver that accepts HIP-backed PyTorch as CUDA-compatible and records the detected backend.",
+  },
+  {
+    id: "docker-image",
+    severity: "high",
+    category: "Container image",
+    file: "Dockerfile",
+    line: 1,
+    explanation:
+      "The base image is `nvidia/cuda`, which prevents a clean ROCm/vLLM deployment on AMD Developer Cloud.",
+    recommendedFix:
+      "Use the ROCm vLLM image for AMD runs and keep CUDA images only as an optional backend.",
+  },
+  {
+    id: "vllm-flags",
+    severity: "high",
+    category: "Serving configuration",
+    file: "scripts/serve.sh",
+    line: 9,
+    explanation:
+      "The vLLM launch script omits ROCm-oriented environment flags and does not expose tensor-parallel settings.",
+    recommendedFix:
+      "Add backend-aware vLLM launch arguments and document MI300X model-serving defaults.",
+  },
+  {
+    id: "metrics",
+    severity: "medium",
+    category: "Benchmark visibility",
+    file: "benchmarks/run_latency.py",
+    line: 18,
+    explanation:
+      "The benchmark reports request latency only and misses GPU memory, tokens/sec, and backend provenance.",
+    recommendedFix:
+      "Add AMD SMI/vLLM metrics capture so submission evidence includes GPU model, memory, and throughput.",
+  },
+];
+
+export const PATCHES: PatchPreview[] = [
+  {
+    id: "device-resolver",
+    file: "src/inference/device.py",
+    rationale:
+      "Centralizes device selection so ROCm-backed PyTorch can run without scattering vendor checks across the service.",
+    diff: `+import torch
++
++def resolve_device() -> tuple[str, str]:
++    if torch.cuda.is_available():
++        backend = "rocm" if getattr(torch.version, "hip", None) else "cuda"
++        return "cuda", backend
++    return "cpu", "cpu"
++
++DEVICE, GPU_BACKEND = resolve_device()
+`,
+  },
+  {
+    id: "rocm-docker",
+    file: "Dockerfile.rocm",
+    rationale:
+      "Adds an AMD-specific runtime image while preserving the original CUDA path for teams that need dual-vendor support.",
+    diff: `+FROM rocm/vllm:latest
++
++WORKDIR /workspace
++COPY requirements-rocm.txt .
++RUN pip install --no-cache-dir -r requirements-rocm.txt
++COPY . .
++
++ENV HIP_VISIBLE_DEVICES=0
++ENV VLLM_USE_ROCM=1
++CMD ["bash", "scripts/serve-rocm.sh"]
+`,
+  },
+  {
+    id: "serve-rocm",
+    file: "scripts/serve-rocm.sh",
+    rationale:
+      "Launches an OpenAI-compatible vLLM endpoint for the migration/report agents on AMD Instinct GPUs.",
+    diff: `+#!/usr/bin/env bash
++set -euo pipefail
++
++MODEL="\${MODEL:-Qwen/Qwen3-Coder-Next}"
++PORT="\${PORT:-8000}"
++
++python -m vllm.entrypoints.openai.api_server \\
++  --model "$MODEL" \\
++  --host 0.0.0.0 \\
++  --port "$PORT" \\
++  --tensor-parallel-size "\${TENSOR_PARALLEL_SIZE:-1}" \\
++  --max-model-len "\${MAX_MODEL_LEN:-32768}"
+`,
+  },
+];
+
+export const BENCHMARKS: BenchmarkResult[] = [
+  {
+    label: "Before migration",
+    backend: "CUDA-only config",
+    tokensPerSecond: 0,
+    p95LatencyMs: 0,
+    memoryGb: 0,
+    costNote: "Does not boot on AMD ROCm image.",
+  },
+  {
+    label: "ROCm-ready target",
+    backend: "ROCm + vLLM on MI300X",
+    tokensPerSecond: 182,
+    p95LatencyMs: 730,
+    memoryGb: 92,
+    costNote: "Estimated from demo profile; replace with live AMD run evidence.",
+  },
+  {
+    label: "Agent report model",
+    backend: "Qwen3-Coder-Next via OpenAI-compatible endpoint",
+    tokensPerSecond: 64,
+    p95LatencyMs: 1180,
+    memoryGb: 46,
+    costNote: "Runs as the Report Agent when AMD_QWEN_BASE_URL is configured.",
+  },
+];
+
+const LOGS = [
+  "queued run qwen-vllm-cuda-starter in mock-safe mode",
+  "repo-doctor: scanning pyproject.toml, Dockerfile, scripts, and src/inference",
+  "repo-doctor: found nvidia/cuda base image in Dockerfile",
+  "repo-doctor: found direct torch.device('cuda') usage in src/inference/server.py:42",
+  "migration-planner: generated ROCm runtime image proposal",
+  "migration-planner: created backend-aware device resolver",
+  "build-runner: docker build -f Dockerfile.rocm .",
+  "build-runner: import torch; torch.version.hip detected when ROCm wheel is present",
+  "build-runner: vLLM OpenAI endpoint smoke test passed in demo mode",
+  "benchmark-agent: captured target profile for MI300X/vLLM serving",
+  "report-agent: preparing technical and business summary",
+  "completed run with fallback-safe report path",
+];
+
+type MessageBlueprint = {
+  offsetMs: number;
+  agent: string;
+  toAgent: string;
+  role: string;
+  task: string;
+  leadAgent: string;
+  kind: AgentMessageKind;
+  replyToOffsetMs?: number;
+  memoryRefs?: string[];
+  message: (context: {
+    target: RunTarget;
+    sample: SampleRepo;
+    findings: Finding[];
+    patches: PatchPreview[];
+  }) => string;
+};
+
+const WAR_ROOM_MESSAGES: MessageBlueprint[] = [
+  {
+    offsetMs: 1_200,
+    agent: "Orchestrator",
+    toAgent: "Repo Doctor",
+    role: "Run coordinator",
+    task: "Repo compatibility scan",
+    leadAgent: "Repo Doctor",
+    kind: "question",
+    message: ({ target }) =>
+      `You are lead for the first task on ${target.label}. Ask the other agents what evidence they need before you mark any blocker as real.`,
+  },
+  {
+    offsetMs: 2_600,
+    agent: "Repo Doctor",
+    toAgent: "Build Runner",
+    role: "Compatibility scout",
+    task: "Repo compatibility scan",
+    leadAgent: "Repo Doctor",
+    kind: "question",
+    replyToOffsetMs: 1_200,
+    message: ({ target }) =>
+      target.type === "github"
+        ? `I am scanning ${target.scannedFiles || "the selected"} files. Which findings should I flag as build-breaking instead of just advisory?`
+        : "I am scanning Docker, vLLM scripts, PyTorch device paths, and benchmarks. Which findings should I flag as build-breaking instead of advisory?",
+  },
+  {
+    offsetMs: 3_700,
+    agent: "Build Runner",
+    toAgent: "Repo Doctor",
+    role: "Skeptical validator",
+    task: "Repo compatibility scan",
+    leadAgent: "Repo Doctor",
+    kind: "answer",
+    replyToOffsetMs: 2_600,
+    message:
+      () =>
+        "Treat container base images, hardcoded device selection, and missing smoke commands as build-breaking. Those decide whether the workload even starts on ROCm.",
+  },
+  {
+    offsetMs: 5_200,
+    agent: "Repo Doctor",
+    toAgent: "Migration Planner",
+    role: "Compatibility scout",
+    task: "Repo compatibility scan",
+    leadAgent: "Repo Doctor",
+    kind: "question",
+    replyToOffsetMs: 3_700,
+    message: ({ findings }) =>
+      findings[0]
+        ? `I found ${findings[0].category} in ${findings[0].file}:${findings[0].line}. Can you design the safest migration step for this first?`
+        : "I have no hard blocker yet. Can you prepare a safe migration pattern for hidden GPU vendor assumptions?",
+  },
+  {
+    offsetMs: 6_700,
+    agent: "Migration Planner",
+    toAgent: "Repo Doctor",
+    role: "Patch strategist",
+    task: "Repo compatibility scan",
+    leadAgent: "Repo Doctor",
+    kind: "proposal",
+    replyToOffsetMs: 5_200,
+    message: ({ findings }) =>
+      findings[0]
+        ? `Yes. First migration step: ${findings[0].recommendedFix} I will store that as the device-resolution pattern for later stages.`
+        : "Yes. I will store a pattern that keeps CUDA and ROCm paths explicit instead of hidden in environment assumptions.",
+  },
+  {
+    offsetMs: 8_200,
+    agent: "Repo Doctor",
+    toAgent: "Shared Memory",
+    role: "Compatibility scout",
+    task: "Repo compatibility scan",
+    leadAgent: "Repo Doctor",
+    kind: "memory",
+    replyToOffsetMs: 6_700,
+    memoryRefs: ["mem-device-resolution"],
+    message:
+      () =>
+        "Memory write: hardcoded device selection must be solved with one backend resolver, not scattered if/else checks.",
+  },
+  {
+    offsetMs: 9_600,
+    agent: "Orchestrator",
+    toAgent: "Migration Planner",
+    role: "Run coordinator",
+    task: "ROCm migration plan",
+    leadAgent: "Migration Planner",
+    kind: "question",
+    memoryRefs: ["mem-device-resolution"],
+    message:
+      () =>
+        "You are lead now. Use the device-resolution memory and ask Build Runner what would make the patch testable.",
+  },
+  {
+    offsetMs: 10_800,
+    agent: "Migration Planner",
+    toAgent: "Build Runner",
+    role: "Patch strategist",
+    task: "ROCm migration plan",
+    leadAgent: "Migration Planner",
+    kind: "question",
+    replyToOffsetMs: 9_600,
+    memoryRefs: ["mem-device-resolution"],
+    message:
+      () =>
+        "I can patch the resolver, but what acceptance check should prove this is ROCm-ready and not just cleaner code?",
+  },
+  {
+    offsetMs: 12_100,
+    agent: "Build Runner",
+    toAgent: "Migration Planner",
+    role: "Skeptical validator",
+    task: "ROCm migration plan",
+    leadAgent: "Migration Planner",
+    kind: "answer",
+    replyToOffsetMs: 10_800,
+    memoryRefs: ["mem-device-resolution"],
+    message:
+      () =>
+        "Acceptance check: import torch, report torch.version.hip when present, start vLLM with an OpenAI-compatible health request, then log backend provenance.",
+  },
+  {
+    offsetMs: 13_500,
+    agent: "Migration Planner",
+    toAgent: "Shared Memory",
+    role: "Patch strategist",
+    task: "ROCm migration plan",
+    leadAgent: "Migration Planner",
+    kind: "proposal",
+    replyToOffsetMs: 12_100,
+    memoryRefs: ["mem-device-resolution", "mem-rocm-acceptance"],
+    message: ({ patches }) =>
+      patches[0]
+        ? `Patch candidate for ${patches[0].file} is ready, and I am storing Build Runner's acceptance check with it.`
+        : "Patch candidate is ready, and I am storing Build Runner's acceptance check with it.",
+  },
+  {
+    offsetMs: 15_200,
+    agent: "Orchestrator",
+    toAgent: "Build Runner",
+    role: "Run coordinator",
+    task: "Build and smoke tests",
+    leadAgent: "Build Runner",
+    kind: "question",
+    memoryRefs: ["mem-device-resolution", "mem-rocm-acceptance"],
+    message:
+      () =>
+        "You are lead for validation. Look back at memory before challenging the plan: what can still fail later?",
+  },
+  {
+    offsetMs: 16_500,
+    agent: "Build Runner",
+    toAgent: "Migration Planner",
+    role: "Skeptical validator",
+    task: "Build and smoke tests",
+    leadAgent: "Build Runner",
+    kind: "challenge",
+    replyToOffsetMs: 15_200,
+    memoryRefs: ["mem-rocm-acceptance"],
+    message:
+      () =>
+        "I checked the memory. Device resolution is covered, but the Docker path can still fail. A CUDA image with ROCm notes is still a deployment trap.",
+  },
+  {
+    offsetMs: 17_800,
+    agent: "Migration Planner",
+    toAgent: "Build Runner",
+    role: "Patch strategist",
+    task: "Build and smoke tests",
+    leadAgent: "Build Runner",
+    kind: "answer",
+    replyToOffsetMs: 16_500,
+    message:
+      () =>
+        "Agreed. I will keep Dockerfile.rocm separate and avoid pretending the existing CUDA container is portable.",
+  },
+  {
+    offsetMs: 19_000,
+    agent: "Build Runner",
+    toAgent: "Shared Memory",
+    role: "Skeptical validator",
+    task: "Build and smoke tests",
+    leadAgent: "Build Runner",
+    kind: "memory",
+    replyToOffsetMs: 17_800,
+    memoryRefs: ["mem-container-split"],
+    message:
+      () =>
+        "Memory write: ROCm validation needs a separate container path plus a smoke command, not just migration notes in README.",
+  },
+  {
+    offsetMs: 20_300,
+    agent: "Orchestrator",
+    toAgent: "Benchmark Agent",
+    role: "Run coordinator",
+    task: "MI300X readiness benchmark",
+    leadAgent: "Benchmark Agent",
+    kind: "question",
+    memoryRefs: ["mem-rocm-acceptance", "mem-container-split"],
+    message:
+      () =>
+        "You are lead for measurement. Use the earlier memories and ask what numbers are safe to show before AMD access is connected.",
+  },
+  {
+    offsetMs: 21_500,
+    agent: "Benchmark Agent",
+    toAgent: "Report Agent",
+    role: "Evidence analyst",
+    task: "MI300X readiness benchmark",
+    leadAgent: "Benchmark Agent",
+    kind: "question",
+    replyToOffsetMs: 20_300,
+    memoryRefs: ["mem-rocm-acceptance", "mem-container-split"],
+    message:
+      () =>
+        "I can show estimated tokens/sec, p95 latency, memory, and bootability. How should I label estimates so the story stays credible?",
+  },
+  {
+    offsetMs: 22_700,
+    agent: "Report Agent",
+    toAgent: "Benchmark Agent",
+    role: "Submission narrator",
+    task: "MI300X readiness benchmark",
+    leadAgent: "Benchmark Agent",
+    kind: "answer",
+    replyToOffsetMs: 21_500,
+    message:
+      () =>
+        "Label estimates as a static ROCmPilot profile and reserve final proof for AMD Developer Cloud logs. Judges trust explicit provenance.",
+  },
+  {
+    offsetMs: 24_000,
+    agent: "Benchmark Agent",
+    toAgent: "Shared Memory",
+    role: "Evidence analyst",
+    task: "MI300X readiness benchmark",
+    leadAgent: "Benchmark Agent",
+    kind: "memory",
+    replyToOffsetMs: 22_700,
+    memoryRefs: ["mem-metric-provenance"],
+    message:
+      () =>
+        "Memory write: estimated metrics are acceptable only when labeled with provenance and paired with the exact AMD proof still needed.",
+  },
+  {
+    offsetMs: 25_200,
+    agent: "Orchestrator",
+    toAgent: "Report Agent",
+    role: "Run coordinator",
+    task: "Judge-ready report",
+    leadAgent: "Report Agent",
+    kind: "question",
+    memoryRefs: ["mem-device-resolution", "mem-container-split", "mem-metric-provenance"],
+    message:
+      () =>
+        "You are lead for the final report. Read the shared memory first, then ask if anyone disagrees with the submission story.",
+  },
+  {
+    offsetMs: 26_000,
+    agent: "Report Agent",
+    toAgent: "All agents",
+    role: "Submission narrator",
+    task: "Judge-ready report",
+    leadAgent: "Report Agent",
+    kind: "question",
+    replyToOffsetMs: 25_200,
+    memoryRefs: ["mem-device-resolution", "mem-container-split", "mem-metric-provenance"],
+    message:
+      () =>
+        "I read the memories. Final story: find CUDA locks, create ROCm patch path, validate container/smoke tests, show metric provenance. Any objections?",
+  },
+  {
+    offsetMs: 26_800,
+    agent: "Build Runner",
+    toAgent: "Report Agent",
+    role: "Skeptical validator",
+    task: "Judge-ready report",
+    leadAgent: "Report Agent",
+    kind: "answer",
+    replyToOffsetMs: 26_000,
+    memoryRefs: ["mem-container-split"],
+    message:
+      () =>
+        "No objection if the report says validation is complete for the demo path and pending for live MI300X logs.",
+  },
+  {
+    offsetMs: 27_400,
+    agent: "Benchmark Agent",
+    toAgent: "Report Agent",
+    role: "Evidence analyst",
+    task: "Judge-ready report",
+    leadAgent: "Report Agent",
+    kind: "answer",
+    replyToOffsetMs: 26_000,
+    memoryRefs: ["mem-metric-provenance"],
+    message:
+      () =>
+        "No objection if every metric names its source. I want the next live run to overwrite estimates with AMD SMI and vLLM logs.",
+  },
+  {
+    offsetMs: 28_200,
+    agent: "Orchestrator",
+    toAgent: "All agents",
+    role: "Run coordinator",
+    task: "Judge-ready report",
+    leadAgent: "Report Agent",
+    kind: "consensus",
+    replyToOffsetMs: 27_400,
+    memoryRefs: ["mem-device-resolution", "mem-container-split", "mem-metric-provenance"],
+    message:
+      () =>
+        "Consensus stored: ship a ROCm readiness report, patch previews, shared discussion memory, and an AMD/vLLM validation checklist. Next run should replace estimates with MI300X logs.",
+  },
+];
+
+type MemoryBlueprint = {
+  offsetMs: number;
+  id: string;
+  title: string;
+  scope: string;
+  learnedFromAgent: string;
+  summary: (context: { findings: Finding[]; patches: PatchPreview[] }) => string;
+  solution: string;
+};
+
+const WAR_ROOM_MEMORY: MemoryBlueprint[] = [
+  {
+    offsetMs: 8_200,
+    id: "mem-device-resolution",
+    title: "Device resolution pattern",
+    scope: "Runtime compatibility",
+    learnedFromAgent: "Repo Doctor",
+    summary: ({ findings }) =>
+      findings[0]
+        ? `${findings[0].category} should be handled once in a resolver instead of repeated across inference code.`
+        : "GPU backend detection should be handled once in a resolver instead of repeated across inference code.",
+    solution: "Create a backend-aware resolver that accepts HIP-backed PyTorch as CUDA-compatible and records backend provenance.",
+  },
+  {
+    offsetMs: 13_500,
+    id: "mem-rocm-acceptance",
+    title: "ROCm acceptance checks",
+    scope: "Build validation",
+    learnedFromAgent: "Build Runner",
+    summary: () =>
+      "A patch is not enough unless the run proves import, backend detection, vLLM health, and provenance logging.",
+    solution: "Use a smoke command that imports torch, reports torch.version.hip, starts vLLM, and hits the OpenAI-compatible health path.",
+  },
+  {
+    offsetMs: 19_000,
+    id: "mem-container-split",
+    title: "Separate ROCm container path",
+    scope: "Deployment safety",
+    learnedFromAgent: "Build Runner",
+    summary: () =>
+      "A CUDA image with ROCm comments still leaves teams with a deployment trap.",
+    solution: "Keep Dockerfile.rocm and ROCm launch scripts separate, with CUDA preserved only as an optional backend.",
+  },
+  {
+    offsetMs: 24_000,
+    id: "mem-metric-provenance",
+    title: "Metric provenance rule",
+    scope: "Benchmark evidence",
+    learnedFromAgent: "Benchmark Agent",
+    summary: () =>
+      "Estimated benchmark cards are useful for the MVP only when their source is explicit.",
+    solution: "Label estimates as static ROCmPilot profiles and replace them with AMD SMI plus vLLM logs when MI300X access is available.",
+  },
+];
+
+export type RunRecord = {
+  id: string;
+  sampleId: string;
+  mode: RunMode;
+  startedAt: number;
+  targetType: "sample" | "github";
+  repoUrl?: string;
+};
+
+export function getSample(sampleId: string | undefined) {
+  return SAMPLE_REPOS.find((sample) => sample.id === sampleId) ?? SAMPLE_REPOS[0];
+}
+
+function toBase64Url(value: string) {
+  return btoa(value).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+
+function fromBase64Url(value: string) {
+  const padded = value.replace(/-/g, "+").replace(/_/g, "/").padEnd(Math.ceil(value.length / 4) * 4, "=");
+  return atob(padded);
+}
+
+function buildGitHubSample(repoUrl: string): SampleRepo {
+  const parsed = parseGitHubRepoUrl(repoUrl);
+
+  return {
+    id: "github-repo",
+    name: parsed?.label ?? "Public GitHub Repository",
+    repoUrl,
+    stack: "Detected from public GitHub files",
+    model: "Detected workload",
+    description: "A public repository scanned live by ROCmPilot.",
+    risk: "ROCm compatibility depends on detected CUDA/NVIDIA assumptions and live AMD validation.",
+  };
+}
+
+export function createRunRecord(sampleId: string, mode: RunMode, repoUrl?: string): RunRecord {
+  const startedAt = Date.now();
+  const safeSampleId = getSample(sampleId).id;
+  const nonce = Math.random().toString(36).slice(2, 8);
+  const parsedRepo = isRealGitHubRepoUrl(repoUrl) ? parseGitHubRepoUrl(repoUrl) : null;
+  const targetType = parsedRepo ? "github" : "sample";
+  const payload = parsedRepo ? toBase64Url(parsedRepo.repoUrl) : safeSampleId;
+
+  return {
+    id: `run.${startedAt.toString(36)}.${mode}.${targetType}.${payload}.${nonce}`,
+    sampleId: safeSampleId,
+    mode,
+    startedAt,
+    targetType,
+    repoUrl: parsedRepo?.repoUrl,
+  };
+}
+
+export function parseRunRecord(runId: string): RunRecord | null {
+  const parts = runId.split(".");
+
+  if (parts.length !== 6 || parts[0] !== "run") {
+    return null;
+  }
+
+  const [, startedAtBase36, mode, targetType, payload] = parts;
+  const startedAt = Number.parseInt(startedAtBase36, 36);
+
+  if (
+    !Number.isFinite(startedAt) ||
+    (mode !== "mock" && mode !== "amd") ||
+    (targetType !== "sample" && targetType !== "github")
+  ) {
+    return null;
+  }
+
+  if (targetType === "github") {
+    const repoUrl = fromBase64Url(payload);
+
+    if (!isRealGitHubRepoUrl(repoUrl)) {
+      return null;
+    }
+
+    return {
+      id: runId,
+      sampleId: "qwen-vllm-cuda",
+      mode,
+      startedAt,
+      targetType,
+      repoUrl,
+    };
+  }
+
+  const sample = SAMPLE_REPOS.find((candidate) => candidate.id === payload);
+
+  if (!sample) {
+    return null;
+  }
+
+  return {
+    id: runId,
+    sampleId: sample.id,
+    mode,
+    startedAt,
+    targetType,
+  };
+}
+
+export function getModelStatus(source: GpuModelStatus["source"] = "fallback"): GpuModelStatus {
+  const endpoint = process.env.AMD_QWEN_BASE_URL?.replace(/\/$/, "");
+  const model = process.env.AMD_QWEN_MODEL ?? "Qwen/Qwen3-Coder-Next";
+  const hfModel = process.env.HF_REPORT_MODEL ?? "Qwen/Qwen2.5-Coder-7B-Instruct";
+
+  if (endpoint && source === "amd-vllm") {
+    return {
+      status: "connected",
+      label: "AMD GPU Model: Connected",
+      model,
+      endpoint,
+      detail: "Report generation used the configured ROCm/vLLM OpenAI-compatible endpoint.",
+      source,
+    };
+  }
+
+  if (source === "hf-router") {
+    return {
+      status: "connected",
+      label: "HF Router: Connected",
+      model: hfModel,
+      endpoint: "https://router.huggingface.co/v1",
+      detail: "Report generation used Hugging Face Inference Providers as the temporary model backend.",
+      source,
+    };
+  }
+
+  if (endpoint) {
+    return {
+      status: "not-configured",
+      label: "AMD GPU Model: Endpoint configured",
+      model,
+      endpoint,
+      detail: "Endpoint is configured; report generation will attempt AMD-hosted Qwen first.",
+      source,
+    };
+  }
+
+  if (process.env.HF_TOKEN) {
+    return {
+      status: "not-configured",
+      label: "HF Router: Available",
+      model: hfModel,
+      endpoint: "https://router.huggingface.co/v1",
+      detail: "Hugging Face token is configured; final report generation will use HF unless AMD is configured.",
+      source: "hf-router",
+    };
+  }
+
+  return {
+    status: "fallback",
+    label: "AMD GPU Model: Demo fallback",
+    model,
+    endpoint: "Set AMD_QWEN_BASE_URL to enable live ROCm/vLLM inference",
+    detail: "The dashboard is using deterministic fallback output so the MVP demo remains reliable.",
+    source: "fallback",
+  };
+}
+
+export function getLongContextMemoryStatus(
+  runId: string,
+  storedItems = 0,
+  recalledItems = 0,
+  source: LongContextMemoryStatus["status"] = process.env.SYNAP_API_KEY ? "configured" : "fallback"
+): LongContextMemoryStatus {
+  const conversationId = buildMemoryConversationId(runId);
+  const customerId = process.env.SYNAP_CUSTOMER_ID ?? DEFAULT_MEMORY_CUSTOMER_ID;
+  const userId = process.env.SYNAP_USER_ID ?? DEFAULT_MEMORY_USER_ID;
+
+  if (source === "connected") {
+    return {
+      status: "connected",
+      label: "Synap Memory: Connected",
+      provider: "synap",
+      conversationId,
+      scope: `${customerId}/${userId}`,
+      detail: "Report Agent stored this run and retrieved scoped long-context memory from Synap.",
+      storedItems,
+      recalledItems,
+    };
+  }
+
+  if (source === "configured") {
+    return {
+      status: "configured",
+      label: "Synap Memory: Ready",
+      provider: "synap",
+      conversationId,
+      scope: `${customerId}/${userId}`,
+      detail: "Synap is configured; the Report Agent will ingest the war-room transcript during report generation.",
+      storedItems,
+      recalledItems,
+    };
+  }
+
+  if (source === "not-configured") {
+    return {
+      status: "not-configured",
+      label: "Synap Memory: Setup needed",
+      provider: "synap",
+      conversationId,
+      scope: `${customerId}/${userId}`,
+      detail: "Set SYNAP_API_KEY and run the Synap JS runtime setup to enable persistent memory.",
+      storedItems,
+      recalledItems,
+    };
+  }
+
+  return {
+    status: "fallback",
+    label: "Synap Memory: Local fallback",
+    provider: "local",
+    conversationId,
+    scope: "current stateless run",
+    detail: "Using reconstructed run memory now; Synap can persist it across sessions once credentials are configured.",
+    storedItems,
+    recalledItems,
+  };
+}
+
+function buildTarget(record: RunRecord, analysis?: RepoAnalysis): RunTarget {
+  if (record.targetType === "github" && record.repoUrl) {
+    const parsed = parseGitHubRepoUrl(record.repoUrl);
+
+    return {
+      type: "github",
+      repoUrl: record.repoUrl,
+      label: analysis?.label ?? parsed?.label ?? "GitHub repository",
+      branch: analysis?.branch ?? parsed?.branch,
+      scanStatus: analysis?.status ?? "pending",
+      scannedFiles: analysis?.scannedFiles ?? 0,
+      note:
+        analysis?.note ??
+        "ROCmPilot will fetch public GitHub files during the Repo Doctor stage.",
+    };
+  }
+
+  const sample = getSample(record.sampleId);
+
+  return {
+    type: "sample",
+    repoUrl: sample.repoUrl,
+    label: sample.name,
+    scanStatus: "fixture",
+    scannedFiles: 4,
+    note: "Using curated sample fixtures for a reliable demo run.",
+  };
+}
+
+function buildMessageId(record: RunRecord, offsetMs: number, agent: string) {
+  return `${record.id}.${offsetMs}.${agent.toLowerCase().replace(/\W+/g, "-")}`;
+}
+
+function buildAgentMessages(
+  elapsed: number,
+  record: RunRecord,
+  target: RunTarget,
+  sample: SampleRepo,
+  findings: Finding[],
+  patches: PatchPreview[]
+): AgentMessage[] {
+  return WAR_ROOM_MESSAGES.filter((blueprint) => elapsed >= blueprint.offsetMs).map((blueprint) => ({
+    id: buildMessageId(record, blueprint.offsetMs, blueprint.agent),
+    agent: blueprint.agent,
+    toAgent: blueprint.toAgent,
+    role: blueprint.role,
+    task: blueprint.task,
+    leadAgent: blueprint.leadAgent,
+    kind: blueprint.kind,
+    message: blueprint.message({ target, sample, findings, patches }),
+    replyToId:
+      blueprint.replyToOffsetMs === undefined
+        ? undefined
+        : WAR_ROOM_MESSAGES.find((message) => message.offsetMs === blueprint.replyToOffsetMs)
+          ? buildMessageId(
+              record,
+              blueprint.replyToOffsetMs,
+              WAR_ROOM_MESSAGES.find((message) => message.offsetMs === blueprint.replyToOffsetMs)?.agent ?? "unknown"
+            )
+          : undefined,
+    memoryRefs: blueprint.memoryRefs ?? [],
+    createdAt: new Date(record.startedAt + blueprint.offsetMs).toISOString(),
+  }));
+}
+
+function buildAgentMemory(
+  elapsed: number,
+  record: RunRecord,
+  messages: AgentMessage[],
+  findings: Finding[],
+  patches: PatchPreview[]
+): AgentMemory[] {
+  return WAR_ROOM_MEMORY.filter((memory) => elapsed >= memory.offsetMs).map((memory) => ({
+    id: memory.id,
+    title: memory.title,
+    scope: memory.scope,
+    learnedFromAgent: memory.learnedFromAgent,
+    summary: memory.summary({ findings, patches }),
+    solution: memory.solution,
+    createdAt: new Date(record.startedAt + memory.offsetMs).toISOString(),
+    usedBy: messages
+      .filter((message) => message.memoryRefs.includes(memory.id) && new Date(message.createdAt).getTime() > record.startedAt + memory.offsetMs)
+      .map((message) => message.agent),
+  }));
+}
+
+export function snapshotRun(record: RunRecord, analysis?: RepoAnalysis): RocmRun {
+  const elapsed = Math.max(0, Date.now() - record.startedAt);
+  const sample =
+    record.targetType === "github" && record.repoUrl
+      ? buildGitHubSample(record.repoUrl)
+      : getSample(record.sampleId);
+  const status: RunStatus = elapsed >= TOTAL_DURATION_MS ? "completed" : "running";
+  const target = buildTarget(record, analysis);
+  let cursor = 0;
+
+  const stages = STAGES.map((stage) => {
+    const stageStart = cursor;
+    const stageEnd = cursor + stage.durationMs;
+    cursor = stageEnd;
+
+    const stageElapsed = elapsed - stageStart;
+    const progress = Math.max(0, Math.min(100, Math.round((stageElapsed / stage.durationMs) * 100)));
+    const stageStatus: StageStatus =
+      progress >= 100 ? "completed" : progress > 0 ? "running" : "pending";
+
+    return {
+      id: stage.id,
+      agent: stage.agent,
+      title: stage.title,
+      description: stage.description,
+      status: stageStatus,
+      progress,
+      startedAt: stageElapsed > 0 ? new Date(record.startedAt + stageStart).toISOString() : undefined,
+      completedAt: stageStatus === "completed" ? new Date(record.startedAt + stageEnd).toISOString() : undefined,
+    };
+  });
+
+  const allFindings = analysis?.findings.length ? analysis.findings : FINDINGS;
+  const allPatches = analysis?.patches.length ? analysis.patches : PATCHES;
+  const allBenchmarks = record.targetType === "github"
+    ? BENCHMARKS.map((benchmark) => ({
+        ...benchmark,
+        costNote: benchmark.costNote.replace("demo profile", "static ROCmPilot profile until live AMD validation"),
+      }))
+    : BENCHMARKS;
+  const allLogs =
+    record.targetType === "github"
+      ? [
+          `queued public GitHub scan for ${target.label}`,
+          ...(analysis?.logs ?? ["repo-doctor: waiting for GitHub scan results"]),
+          "build-runner: generated ROCm validation plan without mutating repository files",
+          "benchmark-agent: prepared estimated MI300X profile pending live AMD run",
+          "report-agent: preparing technical and business summary",
+        ]
+      : LOGS;
+
+  const visibleFindings =
+    elapsed > 4_000
+      ? allFindings.slice(0, Math.min(allFindings.length, Math.ceil((elapsed - 4_000) / 3_000)))
+      : [];
+  const visiblePatches =
+    elapsed > 10_000
+      ? allPatches.slice(0, Math.min(allPatches.length, Math.ceil((elapsed - 10_000) / 4_000)))
+      : [];
+  const visibleBenchmarks = elapsed > 18_000 ? allBenchmarks : allBenchmarks.slice(0, 1);
+  const visibleLogs = allLogs.slice(0, Math.min(allLogs.length, Math.max(1, Math.ceil(elapsed / 2_300))));
+  const agentMessages = buildAgentMessages(
+    elapsed,
+    record,
+    target,
+    sample,
+    visibleFindings.length ? visibleFindings : allFindings,
+    visiblePatches.length ? visiblePatches : allPatches
+  );
+  const agentMemory = buildAgentMemory(
+    elapsed,
+    record,
+    agentMessages,
+    visibleFindings.length ? visibleFindings : allFindings,
+    visiblePatches.length ? visiblePatches : allPatches
+  );
+
+  return {
+    id: record.id,
+    sample,
+    target,
+    mode: record.mode,
+    status,
+    progress: Math.min(100, Math.round((elapsed / TOTAL_DURATION_MS) * 100)),
+    startedAt: new Date(record.startedAt).toISOString(),
+    completedAt: status === "completed" ? new Date(record.startedAt + TOTAL_DURATION_MS).toISOString() : undefined,
+    stages,
+    findings: visibleFindings,
+    patches: visiblePatches,
+    logs: visibleLogs,
+    agentMessages,
+    agentMemory,
+    longContextMemory: getLongContextMemoryStatus(
+      record.id,
+      agentMemory.length,
+      agentMessages.filter((message) => message.memoryRefs.length > 0).length
+    ),
+    benchmarks: visibleBenchmarks,
+    modelStatus: getModelStatus(),
+  };
+}
+
+export function buildFallbackReport(run: RocmRun, longContext?: string) {
+  const findingList = run.findings
+    .map((finding) => `- **${finding.category}** in \`${finding.file}:${finding.line}\`: ${finding.recommendedFix}`)
+    .join("\n");
+  const memoryList = run.agentMemory
+    .map((memory) => `- **${memory.title}**: ${memory.solution}`)
+    .join("\n");
+
+  return `# ROCmPilot Migration Report
+
+## Executive Summary
+
+ROCmPilot completed a multi-agent audit for **${run.sample.name}** and produced an AMD ROCm migration path for a PyTorch/vLLM workload. The system found CUDA-only assumptions, generated ROCm patch previews, and prepared the project for validation on AMD Developer Cloud.
+
+## Agent Findings
+
+${findingList || "- Findings are still being prepared."}
+
+## Shared Agent Memory
+
+${memoryList || "- Shared memory is still being written by the agents."}
+
+## Long-Context Memory
+
+${longContext || "- Synap memory was not available for this report, so ROCmPilot used the current run's reconstructed local memory."}
+
+## AMD GPU Usage
+
+- Primary model target: **Qwen/Qwen3-Coder-Next**
+- Serving path: **ROCm + vLLM OpenAI-compatible endpoint**
+- GPU goal: run the Migration Planner or Report Agent on AMD Instinct MI300X
+- MVP fallback: deterministic report generation when the endpoint is unavailable
+
+## Business Value
+
+ROCmPilot reduces the time needed to move inference services away from NVIDIA-only assumptions. Teams get a migration checklist, patch previews, benchmark evidence, and a report they can hand to infra leads before spending engineering time on a full port.
+
+## Next Step
+
+Connect \`AMD_QWEN_BASE_URL\` to a live ROCm/vLLM endpoint and rerun the report stage to replace demo metrics with captured MI300X evidence.`;
+}
+
+export function buildReportPrompt(run: RocmRun, longContext?: string) {
+  return `Create a concise hackathon submission report for ROCmPilot.
+
+Product: multi-agent ROCm migration dashboard.
+Track: AI Agents & Agentic Workflows.
+Sample repo: ${run.sample.name} (${run.sample.stack}).
+Target: ${run.target.label} (${run.target.repoUrl}).
+Scan status: ${run.target.scanStatus}, scanned files: ${run.target.scannedFiles}.
+GPU story: Qwen3-Coder-Next served on AMD Instinct MI300X with ROCm/vLLM powers the report or migration agent when configured.
+
+Findings:
+${run.findings.map((finding) => `- ${finding.severity}: ${finding.category} in ${finding.file}:${finding.line}. Fix: ${finding.recommendedFix}`).join("\n")}
+
+Patches:
+${run.patches.map((patch) => `- ${patch.file}: ${patch.rationale}`).join("\n")}
+
+Shared memory:
+${run.agentMemory.map((memory) => `- ${memory.title}: ${memory.solution}`).join("\n")}
+
+Long-context memory from Synap or fallback memory:
+${longContext || "- No long-context memory was available beyond the current run."}
+
+Benchmarks:
+${run.benchmarks.map((benchmark) => `- ${benchmark.label}: ${benchmark.backend}, ${benchmark.tokensPerSecond} tok/s, p95 ${benchmark.p95LatencyMs}ms, ${benchmark.memoryGb}GB.`).join("\n")}
+
+Write markdown with these sections only: Executive Summary, Agent Workflow, AMD GPU Proof, Business Value, Next 48 Hours.`;
+}

src/lib/rocmpilot/github-scanner.ts

@@ -0,0 +1,462 @@
+import type { Finding, PatchPreview } from "./types";
+import { parseGitHubRepoUrl } from "./github-url";
+
+type GitHubTreeItem = {
+  path: string;
+  mode: string;
+  type: "blob" | "tree";
+  sha: string;
+  size?: number;
+  url: string;
+};
+
+type GitHubTreeResponse = {
+  tree?: GitHubTreeItem[];
+  truncated?: boolean;
+};
+
+type GitHubRepoResponse = {
+  default_branch?: string;
+};
+
+type GitHubBlobResponse = {
+  content?: string;
+  encoding?: string;
+};
+
+type ScannedFile = {
+  path: string;
+  content: string;
+};
+
+export type RepoAnalysis = {
+  status: "scanned" | "failed";
+  label: string;
+  repoUrl: string;
+  branch?: string;
+  scannedFiles: number;
+  findings: Finding[];
+  patches: PatchPreview[];
+  logs: string[];
+  stack: string;
+  note: string;
+};
+
+const globalForGitHubScan = globalThis as unknown as {
+  rocmPilotScanCache?: Map<string, { expiresAt: number; analysis: RepoAnalysis }>;
+};
+
+const scanCache = globalForGitHubScan.rocmPilotScanCache ?? new Map();
+globalForGitHubScan.rocmPilotScanCache = scanCache;
+
+function githubHeaders() {
+  const headers: Record<string, string> = {
+    Accept: "application/vnd.github+json",
+    "User-Agent": "ROCmPilot",
+    "X-GitHub-Api-Version": "2022-11-28",
+  };
+
+  if (process.env.GITHUB_TOKEN) {
+    headers.Authorization = `Bearer ${process.env.GITHUB_TOKEN}`;
+  }
+
+  return headers;
+}
+
+async function fetchGitHubJson<T>(url: string): Promise<T> {
+  const response = await fetch(url, {
+    headers: githubHeaders(),
+    next: { revalidate: 180 },
+  });
+
+  if (!response.ok) {
+    throw new Error(`GitHub returned ${response.status} for ${url}`);
+  }
+
+  return response.json() as Promise<T>;
+}
+
+function isRelevantPath(path: string) {
+  const lower = path.toLowerCase();
+
+  if (
+    lower.includes("node_modules/") ||
+    lower.includes(".git/") ||
+    lower.includes("dist/") ||
+    lower.includes("build/") ||
+    lower.includes(".next/")
+  ) {
+    return false;
+  }
+
+  return (
+    /^dockerfile/i.test(path) ||
+    lower.endsWith("docker-compose.yml") ||
+    lower.endsWith("docker-compose.yaml") ||
+    lower.endsWith("requirements.txt") ||
+    lower.endsWith("requirements-rocm.txt") ||
+    lower.endsWith("pyproject.toml") ||
+    lower.endsWith("environment.yml") ||
+    lower.endsWith("environment.yaml") ||
+    lower.endsWith(".py") ||
+    lower.endsWith(".sh") ||
+    lower.endsWith(".yaml") ||
+    lower.endsWith(".yml") ||
+    lower.includes("vllm") ||
+    lower.includes("inference") ||
+    lower.includes("serve") ||
+    lower.includes("benchmark")
+  );
+}
+
+function firstLineOf(content: string, pattern: RegExp) {
+  const lines = content.split(/\r?\n/);
+  const index = lines.findIndex((line) => pattern.test(line));
+  return index >= 0 ? index + 1 : 1;
+}
+
+function addFinding(
+  findings: Finding[],
+  finding: Omit<Finding, "id">,
+  idSeed: string
+) {
+  if (findings.length >= 10) {
+    return;
+  }
+
+  const id = `${idSeed}-${findings.length + 1}`.replace(/[^a-z0-9-]/gi, "-").toLowerCase();
+
+  if (!findings.some((existing) => existing.file === finding.file && existing.category === finding.category)) {
+    findings.push({ id, ...finding });
+  }
+}
+
+function detectFindings(files: ScannedFile[]) {
+  const findings: Finding[] = [];
+
+  for (const file of files) {
+    const lowerPath = file.path.toLowerCase();
+    const content = file.content;
+
+    if (/nvidia\/cuda|nvidia-container|--gpus\s+all|nvidia-smi/i.test(content)) {
+      addFinding(
+        findings,
+        {
+          severity: "high",
+          category: "NVIDIA container/runtime assumption",
+          file: file.path,
+          line: firstLineOf(content, /nvidia\/cuda|nvidia-container|--gpus\s+all|nvidia-smi/i),
+          explanation:
+            "The repository includes NVIDIA-specific container/runtime configuration, which will not run cleanly on AMD ROCm infrastructure.",
+          recommendedFix:
+            "Add an AMD ROCm runtime path using a ROCm/vLLM image and keep NVIDIA launch flags behind a backend-specific profile.",
+        },
+        file.path
+      );
+    }
+
+    if (/torch\.device\(\s*["']cuda["']\s*\)|\.cuda\(|\.cuda\(\)|device_map\s*=\s*["']cuda["']/i.test(content)) {
+      addFinding(
+        findings,
+        {
+          severity: "critical",
+          category: "Hardcoded CUDA device path",
+          file: file.path,
+          line: firstLineOf(content, /torch\.device\(\s*["']cuda["']\s*\)|\.cuda\(|\.cuda\(\)|device_map\s*=\s*["']cuda["']/i),
+          explanation:
+            "The code moves models/tensors directly to CUDA, so the workload needs a backend-aware device resolver before AMD validation.",
+          recommendedFix:
+            "Introduce a resolver that treats HIP-backed torch.cuda availability as ROCm and records backend provenance in logs/metrics.",
+        },
+        file.path
+      );
+    }
+
+    if (/torch\.cuda|cuda_visible_devices|hip_visible_devices/i.test(content)) {
+      addFinding(
+        findings,
+        {
+          severity: "medium",
+          category: "GPU backend detection needs abstraction",
+          file: file.path,
+          line: firstLineOf(content, /torch\.cuda|cuda_visible_devices|hip_visible_devices/i),
+          explanation:
+            "The repo checks GPU availability through vendor-specific environment or PyTorch CUDA APIs without documenting AMD behavior.",
+          recommendedFix:
+            "Centralize backend detection and expose CUDA, ROCm, and CPU as explicit runtime modes.",
+        },
+        file.path
+      );
+    }
+
+    if (/cu12|cu118|cu121|nvidia-|cupy-cuda|bitsandbytes|flash-attn|xformers/i.test(content)) {
+      addFinding(
+        findings,
+        {
+          severity: "high",
+          category: "CUDA-oriented dependency",
+          file: file.path,
+          line: firstLineOf(content, /cu12|cu118|cu121|nvidia-|cupy-cuda|bitsandbytes|flash-attn|xformers/i),
+          explanation:
+            "One or more dependencies are pinned to CUDA/NVIDIA builds, which can block ROCm package resolution.",
+          recommendedFix:
+            "Create a ROCm requirements profile and verify PyTorch/vLLM wheels against the target ROCm version.",
+        },
+        file.path
+      );
+    }
+
+    if (/vllm/i.test(content) && /tensor-parallel-size|max-model-len|served-model-name/i.test(content) === false) {
+      addFinding(
+        findings,
+        {
+          severity: "low",
+          category: "vLLM serving defaults need AMD profile",
+          file: file.path,
+          line: firstLineOf(content, /vllm/i),
+          explanation:
+            "vLLM is present, but the repo does not expose the serving knobs that matter when moving to MI300X validation.",
+          recommendedFix:
+            "Add a backend-aware vLLM launch script with model length, tensor parallelism, and metrics capture settings.",
+        },
+        file.path
+      );
+    }
+
+    if (lowerPath.includes("benchmark") && /tokens|latency|memory|throughput/i.test(content) === false) {
+      addFinding(
+        findings,
+        {
+          severity: "medium",
+          category: "Benchmark evidence incomplete",
+          file: file.path,
+          line: 1,
+          explanation:
+            "The benchmark file exists but does not obviously capture tokens/sec, latency, memory, and backend metadata.",
+          recommendedFix:
+            "Add a ROCm benchmark profile that emits AMD SMI/vLLM metrics for the final migration report.",
+        },
+        file.path
+      );
+    }
+  }
+
+  if (findings.length === 0) {
+    findings.push({
+      id: "no-direct-cuda-blockers",
+      severity: "low",
+      category: "No direct CUDA blockers in scanned files",
+      file: "repository",
+      line: 1,
+      explanation:
+        "ROCmPilot did not find obvious CUDA-only strings in the scanned files, but the workload still needs a live AMD smoke test.",
+      recommendedFix:
+        "Run the generated ROCm validation script on AMD Developer Cloud and attach the benchmark evidence to the report.",
+    });
+  }
+
+  return findings;
+}
+
+function buildPatchPreviews(findings: Finding[]): PatchPreview[] {
+  const hasDocker = findings.some((finding) => finding.category.includes("container"));
+  const hasDevice = findings.some((finding) => finding.category.includes("CUDA device") || finding.category.includes("backend"));
+  const hasDeps = findings.some((finding) => finding.category.includes("dependency"));
+  const patches: PatchPreview[] = [];
+
+  if (hasDevice) {
+    patches.push({
+      id: "device-resolver",
+      file: "src/rocmpilot_device.py",
+      rationale:
+        "Adds a reusable runtime resolver so the project can run on CUDA, ROCm-backed PyTorch, or CPU without hardcoded model code.",
+      diff: `+import torch
++
++def resolve_accelerator() -> tuple[str, str]:
++    if torch.cuda.is_available():
++        backend = "rocm" if getattr(torch.version, "hip", None) else "cuda"
++        return "cuda", backend
++    return "cpu", "cpu"
++
++DEVICE, GPU_BACKEND = resolve_accelerator()
++print(f"ROCmPilot backend={GPU_BACKEND} device={DEVICE}")
+`,
+    });
+  }
+
+  if (hasDocker) {
+    patches.push({
+      id: "dockerfile-rocm",
+      file: "Dockerfile.rocm",
+      rationale:
+        "Creates an AMD-specific runtime container while preserving the original repository for existing CUDA deployments.",
+      diff: `+FROM rocm/vllm:latest
++
++WORKDIR /workspace
++COPY . .
++ENV HIP_VISIBLE_DEVICES=0
++ENV VLLM_USE_ROCM=1
++RUN pip install --no-cache-dir -r requirements-rocm.txt
++CMD ["bash", "scripts/serve-rocm.sh"]
+`,
+    });
+  }
+
+  if (hasDeps) {
+    patches.push({
+      id: "requirements-rocm",
+      file: "requirements-rocm.txt",
+      rationale:
+        "Separates ROCm dependencies from CUDA pins so CI and AMD Developer Cloud validation can install a clean environment.",
+      diff: `+torch
++transformers
++accelerate
++vllm
++sentencepiece
++# Verify exact ROCm-compatible wheel versions in AMD Developer Cloud before production use.
+`,
+    });
+  }
+
+  patches.push({
+    id: "serve-rocm",
+    file: "scripts/serve-rocm.sh",
+    rationale:
+      "Provides the OpenAI-compatible vLLM endpoint that ROCmPilot can call for the Report Agent on AMD hardware.",
+    diff: `+#!/usr/bin/env bash
++set -euo pipefail
++
++MODEL="\${MODEL:-Qwen/Qwen3-Coder-Next}"
++PORT="\${PORT:-8000}"
++
++python -m vllm.entrypoints.openai.api_server \\
++  --model "$MODEL" \\
++  --host 0.0.0.0 \\
++  --port "$PORT" \\
++  --tensor-parallel-size "\${TENSOR_PARALLEL_SIZE:-1}" \\
++  --max-model-len "\${MAX_MODEL_LEN:-32768}"
+`,
+  });
+
+  return patches.slice(0, 4);
+}
+
+function inferStack(files: ScannedFile[]) {
+  const joined = files.map((file) => `${file.path}\n${file.content.slice(0, 2_000)}`).join("\n").toLowerCase();
+  const stack = new Set<string>();
+
+  if (joined.includes("vllm")) stack.add("vLLM");
+  if (joined.includes("torch")) stack.add("PyTorch");
+  if (joined.includes("transformers")) stack.add("Transformers");
+  if (joined.includes("fastapi")) stack.add("FastAPI");
+  if (joined.includes("dockerfile")) stack.add("Docker");
+  if (joined.includes("langchain")) stack.add("LangChain");
+  if (joined.includes("crewai")) stack.add("CrewAI");
+
+  return stack.size > 0 ? Array.from(stack).join(", ") : "Python/AI workload";
+}
+
+async function fetchRelevantFiles(owner: string, repo: string, ref: string) {
+  const treeUrl = `https://api.github.com/repos/${owner}/${repo}/git/trees/${encodeURIComponent(ref)}?recursive=1`;
+  const tree = await fetchGitHubJson<GitHubTreeResponse>(treeUrl);
+  const blobs = (tree.tree ?? [])
+    .filter((item) => item.type === "blob" && isRelevantPath(item.path) && (item.size ?? 0) <= 120_000)
+    .slice(0, 32);
+
+  const files: ScannedFile[] = [];
+
+  for (const blob of blobs) {
+    const data = await fetchGitHubJson<GitHubBlobResponse>(
+      `https://api.github.com/repos/${owner}/${repo}/git/blobs/${blob.sha}`
+    );
+
+    if (data.encoding === "base64" && data.content) {
+      files.push({
+        path: blob.path,
+        content: Buffer.from(data.content.replace(/\n/g, ""), "base64").toString("utf8"),
+      });
+    }
+  }
+
+  return files;
+}
+
+export async function analyzeGitHubRepository(repoUrl: string): Promise<RepoAnalysis> {
+  const parsed = parseGitHubRepoUrl(repoUrl);
+
+  if (!parsed) {
+    return failedAnalysis(repoUrl, "Invalid GitHub URL.");
+  }
+
+  const cacheKey = parsed.repoUrl;
+  const cached = scanCache.get(cacheKey);
+
+  if (cached && cached.expiresAt > Date.now()) {
+    return cached.analysis;
+  }
+
+  try {
+    const repo = await fetchGitHubJson<GitHubRepoResponse>(
+      `https://api.github.com/repos/${parsed.owner}/${parsed.repo}`
+    );
+    const ref = parsed.branch ?? repo.default_branch ?? "main";
+    const files = await fetchRelevantFiles(parsed.owner, parsed.repo, ref);
+    const findings = detectFindings(files);
+    const patches = buildPatchPreviews(findings);
+    const stack = inferStack(files);
+    const analysis: RepoAnalysis = {
+      status: "scanned",
+      label: parsed.label,
+      repoUrl: parsed.repoUrl,
+      branch: ref,
+      scannedFiles: files.length,
+      findings,
+      patches,
+      stack,
+      note: `Scanned ${files.length} public GitHub files from ${parsed.label}@${ref}.`,
+      logs: [
+        `github-scan: resolved ${parsed.label}@${ref}`,
+        `github-scan: selected ${files.length} relevant files for ROCm analysis`,
+        `repo-doctor: detected stack profile: ${stack}`,
+        `migration-planner: produced ${findings.length} findings and ${patches.length} patch previews`,
+      ],
+    };
+
+    scanCache.set(cacheKey, { analysis, expiresAt: Date.now() + 180_000 });
+    return analysis;
+  } catch (error) {
+    return failedAnalysis(
+      parsed.repoUrl,
+      error instanceof Error ? error.message : "Unknown GitHub scan failure.",
+      parsed.label,
+      parsed.branch
+    );
+  }
+}
+
+function failedAnalysis(repoUrl: string, message: string, label = "GitHub repository", branch?: string): RepoAnalysis {
+  return {
+    status: "failed",
+    label,
+    repoUrl,
+    branch,
+    scannedFiles: 0,
+    stack: "Public GitHub repository",
+    note: message,
+    findings: [
+      {
+        id: "github-scan-failed",
+        severity: "medium",
+        category: "GitHub scan unavailable",
+        file: "repository",
+        line: 1,
+        explanation:
+          "ROCmPilot could not fetch enough public repository data to complete a live scan. The app remains usable with sample fixtures.",
+        recommendedFix:
+          "Check that the repository is public, add GITHUB_TOKEN for higher API limits, or use the sample workload for the demo.",
+      },
+    ],
+    patches: buildPatchPreviews([]),
+    logs: [`github-scan: ${message}`, "fallback: using safe ROCm migration guidance"],
+  };
+}

src/lib/rocmpilot/github-url.ts

@@ -0,0 +1,47 @@
+export type GitHubRepoRef = {
+  owner: string;
+  repo: string;
+  branch?: string;
+  repoUrl: string;
+  label: string;
+};
+
+export function parseGitHubRepoUrl(input: string | undefined): GitHubRepoRef | null {
+  if (!input) {
+    return null;
+  }
+
+  try {
+    const url = new URL(input.trim());
+
+    if (url.hostname !== "github.com" && url.hostname !== "www.github.com") {
+      return null;
+    }
+
+    const [owner, repoWithSuffix, maybeTree, ...rest] = url.pathname
+      .split("/")
+      .filter(Boolean);
+    const repo = repoWithSuffix?.replace(/\.git$/, "");
+
+    if (!owner || !repo) {
+      return null;
+    }
+
+    const branch = maybeTree === "tree" && rest.length > 0 ? rest.join("/") : undefined;
+
+    return {
+      owner,
+      repo,
+      branch,
+      repoUrl: `https://github.com/${owner}/${repo}${branch ? `/tree/${branch}` : ""}`,
+      label: `${owner}/${repo}`,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function isRealGitHubRepoUrl(input: string | undefined) {
+  const repo = parseGitHubRepoUrl(input);
+  return Boolean(repo && repo.owner !== "example");
+}

src/lib/rocmpilot/memory-ids.ts

@@ -0,0 +1,6 @@
+export const DEFAULT_MEMORY_CUSTOMER_ID = "rocmpilot-hackathon";
+export const DEFAULT_MEMORY_USER_ID = "rocmpilot-agent-fleet";
+
+export function buildMemoryConversationId(runId: string) {
+  return `rocmpilot-${runId.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 140)}`;
+}

src/lib/rocmpilot/store.ts

@@ -0,0 +1,23 @@
+import { createRunRecord, parseRunRecord, snapshotRun } from "./data";
+import { analyzeGitHubRepository } from "./github-scanner";
+import type { RocmRun, RunMode } from "./types";
+
+export function createRun(sampleId: string, mode: RunMode = "mock", repoUrl?: string): RocmRun {
+  const record = createRunRecord(sampleId, mode, repoUrl);
+  return snapshotRun(record);
+}
+
+export async function getRun(runId: string): Promise<RocmRun | null> {
+  const record = parseRunRecord(runId);
+
+  if (!record) {
+    return null;
+  }
+
+  if (record.targetType === "github" && record.repoUrl) {
+    const analysis = await analyzeGitHubRepository(record.repoUrl);
+    return snapshotRun(record, analysis);
+  }
+
+  return snapshotRun(record);
+}

src/lib/rocmpilot/synap-memory.ts

@@ -0,0 +1,316 @@
+import type {
+  ChatMessage,
+  ContextForPromptResult,
+  ContextResponse,
+  SynapClient,
+  SynapClientOptions,
+} from "@maximem/synap-js-sdk";
+import {
+  getLongContextMemoryStatus,
+} from "./data";
+import {
+  buildMemoryConversationId,
+  DEFAULT_MEMORY_CUSTOMER_ID,
+  DEFAULT_MEMORY_USER_ID,
+} from "./memory-ids";
+import type { LongContextMemoryStatus, RocmRun } from "./types";
+
+type SynapSyncResult = {
+  status: LongContextMemoryStatus;
+  promptContext: string;
+};
+
+function parseOptionalPort(value: string | undefined) {
+  if (!value) {
+    return undefined;
+  }
+
+  const port = Number.parseInt(value, 10);
+  return Number.isFinite(port) ? port : undefined;
+}
+
+function parseOptionalBoolean(value: string | undefined) {
+  if (value === undefined) {
+    return undefined;
+  }
+
+  return ["1", "true", "yes"].includes(value.toLowerCase());
+}
+
+function getSynapIdentity(run: RocmRun) {
+  return {
+    conversationId: buildMemoryConversationId(run.id),
+    customerId: process.env.SYNAP_CUSTOMER_ID ?? DEFAULT_MEMORY_CUSTOMER_ID,
+    userId: process.env.SYNAP_USER_ID ?? DEFAULT_MEMORY_USER_ID,
+  };
+}
+
+function buildSynapMessages(run: RocmRun): ChatMessage[] {
+  const targetSummary = [
+    `ROCmPilot run ${run.id}`,
+    `Target: ${run.target.label} (${run.target.repoUrl})`,
+    `Scan status: ${run.target.scanStatus}; scanned files: ${run.target.scannedFiles}`,
+    `Goal: migrate PyTorch/vLLM workload toward AMD ROCm readiness.`,
+  ].join("\n");
+
+  const agentDiscussion = run.agentMessages.map((message) => ({
+    role: "assistant" as const,
+    content: [
+      `[${message.agent} -> ${message.toAgent}] ${message.kind.toUpperCase()}`,
+      `Task: ${message.task}`,
+      `Lead: ${message.leadAgent}`,
+      `Message: ${message.message}`,
+      message.memoryRefs.length ? `Memory refs: ${message.memoryRefs.join(", ")}` : "",
+    ]
+      .filter(Boolean)
+      .join("\n"),
+    metadata: {
+      agent: message.agent,
+      toAgent: message.toAgent,
+      kind: message.kind,
+      task: message.task,
+      leadAgent: message.leadAgent,
+      runId: run.id,
+    },
+  }));
+
+  const sharedMemory = run.agentMemory.map((memory) => ({
+    role: "assistant" as const,
+    content: [
+      `Shared memory: ${memory.title}`,
+      `Scope: ${memory.scope}`,
+      `Learned from: ${memory.learnedFromAgent}`,
+      `Summary: ${memory.summary}`,
+      `Reusable solution: ${memory.solution}`,
+      memory.usedBy.length ? `Reused by: ${Array.from(new Set(memory.usedBy)).join(", ")}` : "",
+    ]
+      .filter(Boolean)
+      .join("\n"),
+    metadata: {
+      memoryId: memory.id,
+      scope: memory.scope,
+      learnedFromAgent: memory.learnedFromAgent,
+      runId: run.id,
+    },
+  }));
+
+  return [
+    {
+      role: "user",
+      content: targetSummary,
+      metadata: {
+        runId: run.id,
+        target: run.target.label,
+        repository: run.target.repoUrl,
+      },
+    },
+    ...agentDiscussion,
+    ...sharedMemory,
+  ];
+}
+
+function buildLocalMemoryContext(run: RocmRun) {
+  const memories = run.agentMemory
+    .map((memory) => `- ${memory.title} (${memory.scope}): ${memory.solution}`)
+    .join("\n");
+  const recentDiscussion = run.agentMessages
+    .slice(-8)
+    .map((message) => `- ${message.agent} -> ${message.toAgent}: ${message.message}`)
+    .join("\n");
+
+  return [
+    "Current run memory:",
+    memories || "- No shared memory has been written yet.",
+    "",
+    "Recent agent discussion:",
+    recentDiscussion || "- No agent discussion is available yet.",
+  ].join("\n");
+}
+
+function countContextItems(context: ContextResponse | null) {
+  if (!context) {
+    return 0;
+  }
+
+  return (
+    (context.facts?.length ?? 0) +
+    (context.preferences?.length ?? 0) +
+    (context.episodes?.length ?? 0) +
+    (context.emotions?.length ?? 0) +
+    (context.temporalEvents?.length ?? 0)
+  );
+}
+
+function summarizeContext(
+  context: ContextResponse | null,
+  promptContext: ContextForPromptResult | null
+) {
+  const sections: string[] = [];
+
+  if (promptContext?.formattedContext) {
+    sections.push(`Synap compacted context:\n${promptContext.formattedContext}`);
+  }
+
+  if (context?.facts?.length) {
+    sections.push(
+      `Synap facts:\n${context.facts
+        .slice(0, 5)
+        .map((fact) => `- ${fact.content}`)
+        .join("\n")}`
+    );
+  }
+
+  if (context?.episodes?.length) {
+    sections.push(
+      `Synap episodes:\n${context.episodes
+        .slice(0, 5)
+        .map((episode) => `- ${episode.summary}`)
+        .join("\n")}`
+    );
+  }
+
+  if (context?.preferences?.length) {
+    sections.push(
+      `Synap preferences:\n${context.preferences
+        .slice(0, 5)
+        .map((preference) => `- ${preference.content}`)
+        .join("\n")}`
+    );
+  }
+
+  return sections.join("\n\n");
+}
+
+function synapOptions(): SynapClientOptions {
+  return {
+    apiKey: process.env.SYNAP_API_KEY,
+    instanceId: process.env.SYNAP_INSTANCE_ID,
+    baseUrl: process.env.SYNAP_BASE_URL,
+    grpcHost: process.env.SYNAP_GRPC_HOST,
+    grpcPort: parseOptionalPort(process.env.SYNAP_GRPC_PORT),
+    grpcUseTls: parseOptionalBoolean(process.env.SYNAP_GRPC_TLS),
+    autoSetup: parseOptionalBoolean(process.env.SYNAP_AUTO_SETUP) ?? false,
+    requestTimeoutMs: 10_000,
+    initTimeoutMs: 10_000,
+    ingestTimeoutMs: 10_000,
+    onLog: (level, message) => {
+      if (level === "error") {
+        console.warn(`Synap ${level}: ${message}`);
+      }
+    },
+  } as SynapClientOptions & { instanceId?: string };
+}
+
+async function shutdownClient(client: SynapClient | null) {
+  if (!client) {
+    return;
+  }
+
+  try {
+    await client.shutdown();
+  } catch (error) {
+    console.warn("Synap shutdown warning:", error);
+  }
+}
+
+export async function syncRunMemoryWithSynap(run: RocmRun): Promise<SynapSyncResult> {
+  const localContext = buildLocalMemoryContext(run);
+  const identity = getSynapIdentity(run);
+
+  if (!process.env.SYNAP_API_KEY) {
+    return {
+      status: getLongContextMemoryStatus(
+        run.id,
+        run.agentMemory.length,
+        run.agentMessages.filter((message) => message.memoryRefs.length > 0).length,
+        "fallback"
+      ),
+      promptContext: localContext,
+    };
+  }
+
+  let client: SynapClient | null = null;
+
+  try {
+    const { createClient } = await import("@maximem/synap-js-sdk");
+    client = createClient(synapOptions());
+    await client.init();
+
+    const messages = buildSynapMessages(run);
+
+    await client.addMemory({
+      userId: identity.userId,
+      customerId: identity.customerId,
+      conversationId: identity.conversationId,
+      sessionId: run.id,
+      documentId: run.id,
+      documentType: "ai-chat-conversation",
+      documentCreatedAt: run.startedAt,
+      mode: "long-range",
+      metadata: {
+        product: "ROCmPilot",
+        track: "AI Agents & Agentic Workflows",
+        targetLabel: run.target.label,
+        targetRepo: run.target.repoUrl,
+        scanStatus: run.target.scanStatus,
+        agentMessages: run.agentMessages.length,
+        sharedMemories: run.agentMemory.length,
+      },
+      messages,
+    });
+
+    const [contextResult, promptContextResult] = await Promise.allSettled([
+      client.fetchUserContext({
+        userId: identity.userId,
+        customerId: identity.customerId,
+        conversationId: identity.conversationId,
+        searchQuery: [
+          "ROCm migration blockers",
+          "CUDA assumptions and AMD validation",
+          "agent decisions from prior ROCmPilot runs",
+        ],
+        maxResults: 8,
+        mode: "accurate",
+      }),
+      client.getContextForPrompt({
+        conversationId: identity.conversationId,
+        style: "structured",
+      }),
+    ]);
+
+    const context = contextResult.status === "fulfilled" ? contextResult.value : null;
+    const promptContext =
+      promptContextResult.status === "fulfilled" ? promptContextResult.value : null;
+    const synapContext = summarizeContext(context, promptContext);
+    const recalledItems =
+      countContextItems(context) + (promptContext?.recentMessageCount ?? 0);
+
+    return {
+      status: getLongContextMemoryStatus(
+        run.id,
+        messages.length,
+        recalledItems,
+        "connected"
+      ),
+      promptContext: synapContext || localContext,
+    };
+  } catch (error) {
+    console.warn("Synap memory fallback:", error);
+
+    return {
+      status: {
+        ...getLongContextMemoryStatus(
+          run.id,
+          run.agentMemory.length,
+          run.agentMessages.filter((message) => message.memoryRefs.length > 0).length,
+          "fallback"
+        ),
+        detail:
+          "Synap credentials are present, but the SDK runtime could not complete ingestion. Using local run memory for this report.",
+      },
+      promptContext: localContext,
+    };
+  } finally {
+    await shutdownClient(client);
+  }
+}