Spaces:

junbin666
/

cosmos-scenario-studio

Running

+FROM python:3.13-slim
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    COSMOS_STUDIO_HOST=0.0.0.0 \
+    COSMOS_STUDIO_PORT=8090
+WORKDIR /app
+RUN groupadd --system studio && useradd --system --gid studio --home /app studio
+COPY --chown=studio:studio . /app
+RUN mkdir -p /app/outputs/isaac && chown -R studio:studio /app/outputs
+USER studio
+EXPOSE 8090
+HEALTHCHECK --interval=30s --timeout=5s --start-period=5s --retries=3 \
+  CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8090/', timeout=3)" || exit 1
+CMD ["python", "server.py"]

LICENSE ADDED Viewed

	@@ -0,0 +1,22 @@

+MIT License
+Copyright (c) 2026 Junbin Kuo
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md CHANGED Viewed

@@ -1,10 +1,211 @@
 ---
 title: Cosmos Scenario Studio
-emoji: 📉
-colorFrom: gray
-colorTo: blue
 sdk: static
 pinned: false
 ---
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

 ---
 title: Cosmos Scenario Studio
+emoji: 🌌
+colorFrom: green
+colorTo: gray
 sdk: static
+app_file: index.html
 pinned: false
+license: mit
+short_description: Physical AI scenarios for Cosmos and Isaac validation
+tags:
+- nvidia
+- cosmos
+- isaac-sim
+- physical-ai
+- synthetic-data
 ---
+# Cosmos Scenario Studio
+[Live Hugging Face Space](https://huggingface.co/spaces/junbin666/cosmos-scenario-studio)
+· [GitHub repository](https://github.com/jjfishjj/cosmos-scenario-studio)
+Cosmos Scenario Studio turns Physical AI scenarios into reproducible NVIDIA
+Cosmos video-generation jobs, Cosmos Reason2 safety evaluations, and Isaac Sim
+validation work packages. It runs locally with only Python's standard library
+and ships as a small CPU web container; real simulation remains on a separate
+Linux RTX worker.
+The public Hugging Face deployment uses the free Static Space runtime. Its
+offline scenario composer, deterministic variants, animated preview, and JSON
+manifest export work in-browser. Cosmos NIM, Reason2, and Isaac adapter actions
+are intentionally disabled in the hosted UI because they require the Python
+proxy and separately configured NVIDIA runtimes. Clone the GitHub repository to
+exercise those integrations.
+> **Evidence boundary:** the public Space proves the scenario-to-contract
+> workflow. Local fixture videos and the contract worker are not Cosmos model
+> output or Isaac Sim/PhysX evidence. Real generation and physics validation
+> require separately configured NVIDIA runtimes.
+An offline-first experiment planner for NVIDIA Cosmos-Predict2.5. It turns a
+Physical AI task into deterministic world variants, previews risk coverage,
+exports a dataset manifest, and can submit each request to a self-hosted Cosmos
+NIM `/v1/infer` endpoint.
+## Run the complete app
+```bash
+cd cosmos-scenario-studio
+python3 server.py
+```
+Open <http://127.0.0.1:8090>.
+### Docker
+```bash
+docker compose up --build
+```
+The Studio is then available at <http://127.0.0.1:8090>. See
+[`DEPLOYMENT.md`](DEPLOYMENT.md) for GitHub Actions, GHCR publishing, secrets,
+and production container commands.
+The default **Local Demo** mode does not require a GPU or API key. The **Cosmos
+NIM** mode submits background jobs through the local Python proxy, polls their
+status, retries temporary failures, decodes `b64_video`, and saves generated
+MP4 files under `outputs/`. The API key remains in process memory and is never
+persisted.
+### End-to-end test without a GPU
+Start the bundled NIM-compatible fixture server in another terminal:
+```bash
+python3 fake_nim.py --fail-first 1
+```
+For automatic Physical AI scoring, start the OpenAI-compatible Reason2 fixture
+in a third terminal:
+```bash
+python3 fake_reason.py
+```
+Then select **Cosmos NIM**, click **Check connection**, generate an experiment,
+and submit the batch. `--fail-first 1` proves that the proxy retries a temporary
+503 response before completing.
+For a real deployment, keep the default endpoint if the NIM container is
+available at `http://127.0.0.1:8000/v1/infer`, or enter the remote HTTPS NIM
+endpoint and its bearer token.
+## Cosmos Reason2 and Isaac Sim
+Successful videos can be evaluated through a Cosmos Reason2 VLM endpoint at
+`/v1/chat/completions`. The proxy sends the local MP4 as a base64 video data URI
+and requests four structured scores:
+- collision risk and danger severity (higher is worse)
+- physics plausibility and task success (higher is better)
+- an evidence-grounded observation and a recommended Isaac Sim test
+The resulting edge-case priority is weighted toward collision and danger. The
+**Isaac work package** ZIP contains:
+- `cosmos_manifest.json` — prompts, seeds, and generation settings
+- `domain_randomization.json` — Reason2-priority-scaled lighting, camera,
+  object-pose, friction, payload, and damping ranges
+- `policy_validation.json` — ranked episodes, next-test recommendations, and
+  fail-closed acceptance thresholds
+- `scene_mapping.example.json` — USD prim, collision sensor, clearance radius,
+  task tolerance, and controller settings for the adapter
+## Isaac Sim Scene Adapter
+The app now queues validation runs and exposes a worker protocol for Isaac Sim.
+The adapter reads the ZIP, resolves the configured USD prims, applies episode
+randomization, runs the Franka pick-and-place controller, observes contact and
+clearance, then returns success rate, collision rate, minimum clearance, and
+the final pass/fail decision to the browser.
+First validate the complete protocol without Isaac Sim or a GPU:
+```bash
+python3 -m isaac_adapter.fake_runtime
+```
+Choose **Contract worker** in the UI and click **Run Scene Adapter**. This
+worker exercises package download, atomic run claiming, episode telemetry, and
+result reporting; its deterministic physics metrics are a test fixture rather
+than a simulator result.
+To run the real adapter, create a scene mapping from
+`scene_mapping.example.json`, replacing the USD file and prim paths with those
+in your scene. From this project directory, launch it with Isaac Sim 5.1's
+Python runtime:
+```bash
+/path/to/isaac-sim/python.sh -m isaac_adapter.runtime \
+  --server http://127.0.0.1:8090 \
+  --mapping /absolute/path/to/scene_mapping.json \
+  --headless
+```
+Choose **Isaac Sim 5.1** in the UI before starting the run. Omit `--mapping`
+only when the mapping embedded in the work package already matches the scene.
+Use `--once` when a worker should claim one queued run and exit.
+The current reference adapter targets Isaac Sim 5.1. It must be launched by
+Isaac's bundled Python, and the referenced USD scene and robot prims must exist.
+The included contract worker is the local/CI substitute for machines without
+an Isaac Sim installation.
+### Warehouse Franka physical acceptance
+On a Linux x86_64 workstation with Isaac Sim 5.1 and a supported NVIDIA RTX
+GPU, export an Isaac work package from the Studio, then run:
+```bash
+python3 run_warehouse_acceptance.py \
+  --isaac-root /opt/isaac-sim \
+  --package /absolute/path/to/isaac-work-package.zip \
+  --episodes 3
+```
+The launcher uses Isaac's own `python.sh` to build
+`artifacts/warehouse_franka.usd`, writes the calibrated mapping beside it, runs
+the real Franka episodes, and saves `artifacts/warehouse_franka.metrics.json`.
+Add `--gui` to inspect the scene in the viewport. Collision sensors cover
+`panda_link0` through `panda_link7` plus `panda_hand`; task success, collision,
+and minimum hazard clearance are reported independently.
+After a real run, generate a fail-closed calibration diagnosis with:
+```bash
+python3 -m isaac_adapter.calibration \
+  --metrics artifacts/warehouse_franka.metrics.json \
+  --mapping artifacts/warehouse_franka.mapping.json \
+  --output artifacts/warehouse_franka.calibration.json
+```
+The report distinguishes controller timeouts, placement errors, colliding
+Franka links, and unsafe clearance. It can propose end-effector-offset test
+candidates, but never relaxes collision or clearance acceptance thresholds.
+macOS and Apple Silicon can edit and test the work-package contract, but cannot
+run Isaac Sim 5.1/PhysX acceptance. Use the contract worker locally and execute
+the command above on a Linux RTX machine for real physics metrics.
+## Test
+```bash
+node --test model.test.mjs
+python3 -m unittest -v test_server.py
+```
+GitHub Actions runs these checks on every pull request, then builds and smoke
+tests the container. Publishing a GitHub Release produces a versioned image in
+GitHub Container Registry.
+## Cosmos mapping
+- Each variant contains the official Predict2.5 request fields: prompt,
+  negative prompt, seed, guidance scale, steps, resolution, and frame count.
+- The exported manifest is designed as an experiment contract for later
+  curation, Isaac Sim validation, or policy-training pipelines.
+- NIM calls default to a 900-second timeout because video generation commonly
+  takes several minutes. HTTP 408, 425, 429, and temporary 5xx responses are
+  retried with exponential backoff.

app.mjs ADDED Viewed

	@@ -0,0 +1,437 @@

+import { PRESETS, buildManifest, buildPrompt, riskScore, validateScenario } from "./model.mjs";
+const form = document.querySelector("#scenario-form");
+const queue = document.querySelector("#queue");
+const emptyQueue = document.querySelector("#empty-queue");
+const errorBox = document.querySelector("#form-error");
+const runButton = document.querySelector("#run-batch");
+const downloadButton = document.querySelector("#download");
+const staticSpace = true;
+let manifest = null;
+let mode = "mock";
+let jobs = [];
+let polling = false;
+let evaluations = [];
+let evaluating = false;
+let isaacPackage = null;
+let isaacRun = null;
+function formValues() {
+  return Object.fromEntries(new FormData(form).entries());
+}
+function escapeHtml(value) {
+  return String(value).replace(/[&<>'"]/g, (character) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", "'": "&#39;", '"': "&quot;" }[character]));
+}
+function fillForm(values) {
+  Object.entries(values).forEach(([key, value]) => {
+    if (form.elements[key]) form.elements[key].value = value;
+  });
+  renderDraft();
+}
+function saveDraft() {
+  localStorage.setItem("cosmos-scenario-draft", JSON.stringify(formValues()));
+}
+function renderDraft() {
+  const values = formValues();
+  document.querySelector("#world-title").textContent = values.name || "未命名世界";
+  document.querySelector("#prompt-output").textContent = buildPrompt({
+    ...values,
+    environment: values.environment || "an undefined environment",
+    robot: values.robot || "a physical AI robot",
+    task: values.task || "complete its assigned task",
+  });
+  document.querySelector("#seed-label").textContent = `SEED ${values.seed || 7}`;
+  document.querySelector("#frame-count").textContent = `${values.frames || 121} FRAMES`;
+  const score = riskScore(values);
+  document.querySelector("#risk-score").textContent = `${score}%`;
+  document.querySelector("#risk-bar").style.width = `${score}%`;
+  document.querySelector("#risk-copy").textContent = score >= 70 ? "高價值 edge case" : score >= 50 ? "中度壓力情境" : "基準情境";
+  saveDraft();
+}
+function setPreset(name) {
+  fillForm({ ...PRESETS[name], variants: 4, seed: 7, frames: 121, resolution: "720" });
+  document.querySelectorAll("[data-preset]").forEach((button) => button.classList.toggle("active", button.dataset.preset === name));
+  errorBox.hidden = true;
+}
+function statusLabel(status) {
+  return { ready: "READY", queued: "QUEUED", running: "GENERATING", retrying: "RETRYING", succeeded: "COMPLETE", complete: "COMPLETE", failed: "FAILED" }[status] || status.toUpperCase();
+}
+function renderQueue(statuses = []) {
+  if (!manifest) return;
+  queue.innerHTML = manifest.variants.map((variant, index) => {
+    const item = statuses[index];
+    const status = typeof item === "string" ? item : item?.status || "ready";
+    const attempt = item?.attempts ? `<em>${item.message || ""} · attempt ${item.attempts}</em>` : "";
+    return `<article class="queue-item ${status}" data-id="${variant.id}">
+      <span class="queue-index">${String(index + 1).padStart(2, "0")}</span>
+      <div><strong>${variant.id}</strong><small>seed ${variant.seed} · ${variant.request.resolution}p · ${variant.request.num_output_frames}f</small>${attempt}</div>
+      <b>${statusLabel(status)}</b>
+    </article>`;
+  }).join("");
+  emptyQueue.hidden = true;
+  queue.hidden = false;
+  document.querySelector("#queue-count").textContent = `${manifest.variants.length} WORLDS`;
+  runButton.disabled = false;
+  downloadButton.disabled = false;
+}
+async function runMock() {
+  const states = manifest.variants.map(() => "ready");
+  runButton.disabled = true;
+  for (let index = 0; index < states.length; index += 1) {
+    states[index] = "running";
+    renderQueue(states);
+    await new Promise((resolve) => setTimeout(resolve, 360));
+    states[index] = "complete";
+    renderQueue(states);
+  }
+  runButton.disabled = false;
+  runButton.textContent = "再次執行";
+}
+function connectionConfig() {
+  return {
+    endpoint: document.querySelector("#endpoint").value.trim(),
+    api_key: document.querySelector("#api-key").value,
+    max_retries: Number(document.querySelector("#max-retries").value),
+    timeout_seconds: Number(document.querySelector("#timeout-seconds").value),
+  };
+}
+async function api(path, options = {}) {
+  const response = await fetch(path, {
+    ...options,
+    headers: { "Content-Type": "application/json", ...(options.headers || {}) },
+  });
+  const data = await response.json().catch(() => ({}));
+  if (!response.ok) throw new Error(data.error || `${response.status} ${response.statusText}`);
+  return data;
+}
+async function checkNim() {
+  const button = document.querySelector("#check-nim");
+  const label = document.querySelector("#nim-health-label");
+  const dot = document.querySelector("#nim-health-dot");
+  button.disabled = true;
+  label.textContent = "檢查中…";
+  dot.className = "";
+  try {
+    const result = await api("/api/nim/health", { method: "POST", body: JSON.stringify(connectionConfig()) });
+    dot.className = result.ready ? "ready" : "failed";
+    label.textContent = result.ready ? `READY · ${result.latency_ms}ms` : "NOT READY";
+  } catch (error) {
+    dot.className = "failed";
+    label.textContent = "連線失敗";
+    errorBox.textContent = `NIM 健康檢查失敗：${error.message}`;
+    errorBox.hidden = false;
+  } finally {
+    button.disabled = false;
+  }
+}
+async function createJob(variant) {
+  return api("/api/jobs", {
+    method: "POST",
+    body: JSON.stringify({ ...connectionConfig(), variant_id: variant.id, payload: variant.request }),
+  });
+}
+async function pollJobs() {
+  polling = true;
+  while (polling) {
+    jobs = await Promise.all(jobs.map((job) => job.status === "succeeded" || job.status === "failed" ? job : api(`/api/jobs/${job.id}`)));
+    renderQueue(jobs);
+    const done = jobs.every((job) => ["succeeded", "failed"].includes(job.status));
+    if (done) break;
+    await new Promise((resolve) => setTimeout(resolve, 800));
+  }
+  polling = false;
+  runButton.disabled = false;
+  const failed = jobs.filter((job) => job.status === "failed");
+  if (failed.length) {
+    errorBox.textContent = `${failed.length} 個世界生成失敗。點擊失敗項目可重新送出。`;
+    errorBox.hidden = false;
+  } else {
+    runButton.textContent = "再次送往 Cosmos NIM";
+    showVideo(jobs.find((job) => job.output_url));
+    document.querySelector("#evaluate-batch").disabled = false;
+    if (document.querySelector("#auto-evaluate").checked) await runEvaluations();
+  }
+}
+function showVideo(job) {
+  if (!job?.output_url) return;
+  const player = document.querySelector("#result-player");
+  const video = document.querySelector("#generated-video");
+  document.querySelector("#result-title").textContent = `${job.variant_id} · GENERATED WORLD`;
+  document.querySelector("#open-video").href = job.output_url;
+  video.src = job.output_url;
+  player.hidden = false;
+  video.load();
+}
+async function runNim() {
+  const endpoint = document.querySelector("#endpoint").value.trim();
+  if (!endpoint) {
+    errorBox.textContent = "請設定 Cosmos NIM endpoint。";
+    errorBox.hidden = false;
+    return;
+  }
+  runButton.disabled = true;
+  errorBox.hidden = true;
+  evaluations = [];
+  isaacPackage = null;
+  isaacRun = null;
+  document.querySelector("#ranking").hidden = true;
+  document.querySelector("#ranking-empty").hidden = false;
+  document.querySelector("#export-isaac").disabled = true;
+  document.querySelector("#result-player").hidden = true;
+  try {
+    jobs = await Promise.all(manifest.variants.map(createJob));
+    renderQueue(jobs);
+    await pollJobs();
+  } catch (error) {
+    errorBox.textContent = `Proxy 建立任務失敗：${error.message}。請使用 python3 server.py 啟動 Studio。`;
+    errorBox.hidden = false;
+    runButton.disabled = false;
+  }
+}
+function reasonConfig() {
+  return {
+    reason_endpoint: document.querySelector("#reason-endpoint").value.trim(),
+    api_key: document.querySelector("#reason-api-key").value,
+    timeout_seconds: 300,
+  };
+}
+function renderRanking() {
+  const ranking = document.querySelector("#ranking");
+  const empty = document.querySelector("#ranking-empty");
+  const successful = evaluations.filter((item) => item.status === "succeeded" && item.scores)
+    .sort((a, b) => b.scores.priority - a.scores.priority);
+  if (!successful.length) return;
+  ranking.innerHTML = successful.map((item, index) => `<article class="rank-row">
+    <b>#${index + 1}</b>
+    <div><h3>${escapeHtml(item.variant_id)}</h3><div class="score-grid">
+      <span>COLLISION<strong>${item.scores.collision_risk}</strong></span>
+      <span>PHYSICS<strong>${item.scores.physics_plausibility}</strong></span>
+      <span>SUCCESS<strong>${item.scores.task_success}</strong></span>
+      <span>DANGER<strong>${item.scores.danger_severity}</strong></span>
+    </div><p class="rank-reason">${escapeHtml(item.scores.rationale)} Next: ${escapeHtml(item.scores.recommended_test)}</p></div>
+    <div class="priority">${item.scores.priority}<small>PRIORITY</small></div>
+  </article>`).join("");
+  empty.hidden = true;
+  ranking.hidden = false;
+  document.querySelector("#export-isaac").disabled = false;
+  document.querySelector("#run-isaac").disabled = false;
+}
+async function runEvaluations() {
+  const succeeded = jobs.filter((job) => job.status === "succeeded");
+  if (!succeeded.length || evaluating) return;
+  if (!reasonConfig().reason_endpoint) {
+    errorBox.textContent = "請設定 Cosmos Reason2 endpoint。";
+    errorBox.hidden = false;
+    return;
+  }
+  evaluating = true;
+  const evaluateButton = document.querySelector("#evaluate-batch");
+  evaluateButton.disabled = true;
+  evaluateButton.textContent = "Reason2 分析中…";
+  try {
+    evaluations = await Promise.all(succeeded.map((job) => api("/api/evaluations", {
+      method: "POST",
+      body: JSON.stringify({ ...reasonConfig(), job_id: job.id, scenario: formValues() }),
+    })));
+    while (evaluations.some((item) => !["succeeded", "failed"].includes(item.status))) {
+      await new Promise((resolve) => setTimeout(resolve, 700));
+      evaluations = await Promise.all(evaluations.map((item) => ["succeeded", "failed"].includes(item.status) ? item : api(`/api/evaluations/${item.id}`)));
+    }
+    renderRanking();
+    const failed = evaluations.filter((item) => item.status === "failed");
+    if (failed.length) {
+      errorBox.textContent = `${failed.length} 個 Reason2 評分失敗：${failed[0].error}`;
+      errorBox.hidden = false;
+    }
+  } catch (error) {
+    errorBox.textContent = `Reason2 評分無法啟動：${error.message}`;
+    errorBox.hidden = false;
+  } finally {
+    evaluating = false;
+    evaluateButton.disabled = false;
+    evaluateButton.textContent = "重新用 Reason2 評分";
+  }
+}
+async function createIsaacPackage(download = false) {
+  const button = document.querySelector("#export-isaac");
+  button.disabled = true;
+  button.textContent = "建立 Isaac 工作包…";
+  try {
+    const result = await api("/api/isaac/export", {
+      method: "POST",
+      body: JSON.stringify({ manifest, evaluations }),
+    });
+    isaacPackage = result;
+    document.querySelector("#run-isaac").disabled = false;
+    if (download) {
+      const link = document.createElement("a");
+      link.href = result.download_url;
+      link.download = result.filename;
+      link.click();
+    }
+    button.textContent = "Isaac 工作包已建立";
+    return result;
+  } catch (error) {
+    errorBox.textContent = `Isaac 工作包建立失敗：${error.message}`;
+    errorBox.hidden = false;
+    button.textContent = "下載 Isaac 工作包";
+  } finally {
+    button.disabled = false;
+  }
+}
+function renderIsaacResult(run) {
+  const panel = document.querySelector("#isaac-result");
+  if (!run.result) {
+    panel.innerHTML = `<article><span>RUN STATUS</span><strong>${escapeHtml(run.status.toUpperCase())}</strong></article><article><span>MESSAGE</span><strong>${escapeHtml(run.message)}</strong></article>`;
+    panel.hidden = false;
+    return;
+  }
+  const result = run.result;
+  panel.innerHTML = `
+    <article class="${escapeHtml(result.status)}"><span>VALIDATION</span><strong>${escapeHtml(result.status.toUpperCase())}</strong></article>
+    <article><span>SUCCESS RATE</span><strong>${Number(result.success_rate).toFixed(1)}%</strong></article>
+    <article><span>COLLISION RATE</span><strong>${Number(result.collision_rate).toFixed(1)}%</strong></article>
+    <article><span>MIN CLEARANCE</span><strong>${Number(result.minimum_clearance_m).toFixed(3)}m</strong></article>`;
+  panel.hidden = false;
+}
+async function runIsaacValidation() {
+  const button = document.querySelector("#run-isaac");
+  button.disabled = true;
+  button.textContent = "等待 Scene Adapter…";
+  try {
+    if (!isaacPackage) await createIsaacPackage(false);
+    isaacRun = await api("/api/isaac/runs", {
+      method: "POST",
+      body: JSON.stringify({
+        package_url: isaacPackage.download_url,
+        backend: document.querySelector("#isaac-backend").value,
+        episodes_per_variant: Number(document.querySelector("#isaac-episodes").value),
+      }),
+    });
+    renderIsaacResult(isaacRun);
+    while (!["succeeded", "failed"].includes(isaacRun.status)) {
+      await new Promise((resolve) => setTimeout(resolve, 700));
+      isaacRun = await api(`/api/isaac/runs/${isaacRun.id}`);
+      renderIsaacResult(isaacRun);
+    }
+    button.textContent = "再次執行 Policy Validation";
+  } catch (error) {
+    errorBox.textContent = `Isaac validation 無法啟動：${error.message}`;
+    errorBox.hidden = false;
+    button.textContent = "執行 Policy Validation";
+  } finally {
+    button.disabled = false;
+  }
+}
+form.addEventListener("submit", (event) => {
+  event.preventDefault();
+  const values = formValues();
+  const errors = validateScenario(values);
+  if (errors.length) {
+    errorBox.textContent = errors.map((error) => error.message).join("、");
+    errorBox.hidden = false;
+    form.elements[errors[0].field].focus();
+    return;
+  }
+  errorBox.hidden = true;
+  manifest = buildManifest(values);
+  renderQueue();
+});
+form.addEventListener("input", renderDraft);
+document.querySelectorAll("[data-preset]").forEach((button) => button.addEventListener("click", () => setPreset(button.dataset.preset)));
+document.querySelector("#reset").addEventListener("click", () => setPreset("warehouse"));
+document.querySelectorAll("[data-mode]").forEach((button) => button.addEventListener("click", () => {
+  mode = button.dataset.mode;
+  document.querySelectorAll("[data-mode]").forEach((item) => item.classList.toggle("active", item === button));
+  document.querySelector("#nim-config").hidden = mode !== "nim";
+  runButton.textContent = mode === "nim" ? "送往 Cosmos NIM" : "執行批次";
+}));
+document.querySelector("#check-nim").addEventListener("click", checkNim);
+document.querySelector("#evaluate-batch").addEventListener("click", runEvaluations);
+document.querySelector("#export-isaac").addEventListener("click", () => createIsaacPackage(true));
+document.querySelector("#run-isaac").addEventListener("click", runIsaacValidation);
+queue.addEventListener("click", async (event) => {
+  const row = event.target.closest(".queue-item");
+  if (!row || mode !== "nim") return;
+  const index = manifest.variants.findIndex((variant) => variant.id === row.dataset.id);
+  const job = jobs[index];
+  if (job?.status === "succeeded") {
+    showVideo(job);
+  } else if (job?.status === "failed") {
+    errorBox.hidden = true;
+    try {
+      jobs[index] = await api(`/api/jobs/${job.id}/retry`, {
+        method: "POST",
+        body: JSON.stringify({ ...connectionConfig(), payload: manifest.variants[index].request }),
+      });
+      renderQueue(jobs);
+      if (!polling) pollJobs();
+    } catch (error) {
+      errorBox.textContent = `重新送出失敗：${error.message}`;
+      errorBox.hidden = false;
+    }
+  }
+});
+runButton.addEventListener("click", () => mode === "nim" ? runNim() : runMock());
+downloadButton.addEventListener("click", () => {
+  const blob = new Blob([JSON.stringify(manifest, null, 2)], { type: "application/json" });
+  const link = document.createElement("a");
+  link.href = URL.createObjectURL(blob);
+  link.download = `${manifest.project.toLowerCase().replace(/\s+/g, "-")}-cosmos-manifest.json`;
+  link.click();
+  URL.revokeObjectURL(link.href);
+});
+document.querySelector("#copy-prompt").addEventListener("click", async (event) => {
+  await navigator.clipboard.writeText(document.querySelector("#prompt-output").textContent);
+  event.currentTarget.textContent = "已複製";
+  setTimeout(() => { event.currentTarget.textContent = "複製"; }, 1200);
+});
+document.querySelector("#run-preview").addEventListener("click", (event) => {
+  document.querySelector("#viewport").classList.toggle("playing");
+  event.currentTarget.textContent = document.querySelector("#viewport").classList.contains("playing") ? "Ⅱ" : "▶";
+});
+document.addEventListener("keydown", (event) => {
+  if ((event.metaKey || event.ctrlKey) && event.key === "Enter") form.requestSubmit();
+});
+try {
+  const draft = JSON.parse(localStorage.getItem("cosmos-scenario-draft"));
+  if (draft) fillForm(draft);
+  else setPreset("warehouse");
+} catch {
+  setPreset("warehouse");
+}
+if (staticSpace) {
+  const nimButton = document.querySelector('[data-mode="nim"]');
+  nimButton.disabled = true;
+  nimButton.title = "Static Space 僅提供離線 Demo；NIM 需要 GitHub 版 Python proxy";
+  document.querySelector(".privacy-note").textContent = "Hosted Static Demo：NIM、Reason2 與 Isaac adapter 需從 GitHub 啟動 Python proxy 和外部 NVIDIA runtime；本頁不接收或儲存 API key。";
+  ["#reason-endpoint", "#reason-api-key", "#auto-evaluate", "#evaluate-batch", "#export-isaac", "#isaac-backend", "#isaac-episodes", "#run-isaac"].forEach((selector) => {
+    document.querySelector(selector).disabled = true;
+  });
+  document.querySelector("#ranking-empty").textContent = "Static Space 展示工作流契約；Reason2 評分與 Isaac validation 請在 GitHub 版連接外部 runtime。";
+}

fake_nim.py ADDED Viewed

	@@ -0,0 +1,69 @@

+"""Tiny Cosmos NIM-compatible server for end-to-end development without a GPU."""
+from __future__ import annotations
+import argparse
+import base64
+import json
+import time
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+ROOT = Path(__file__).resolve().parent
+FIXTURE = ROOT / "fixtures" / "demo-world.mp4"
+class FakeNimHandler(BaseHTTPRequestHandler):
+    failures_left = 0
+    def json_response(self, status: int, data: dict) -> None:
+        payload = json.dumps(data).encode()
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(payload)))
+        self.end_headers()
+        self.wfile.write(payload)
+    def do_GET(self) -> None:  # noqa: N802
+        if self.path == "/v1/health/ready":
+            self.json_response(200, {"object": "fake readiness check", "message": "ready", "status": "ready"})
+        else:
+            self.json_response(404, {"error": "not found"})
+    def do_POST(self) -> None:  # noqa: N802
+        if self.path != "/v1/infer":
+            self.json_response(404, {"error": "not found"})
+            return
+        length = int(self.headers.get("Content-Length", "0"))
+        request = json.loads(self.rfile.read(length) or b"{}")
+        if not request.get("prompt"):
+            self.json_response(422, {"error": "prompt is required"})
+            return
+        if type(self).failures_left > 0:
+            type(self).failures_left -= 1
+            self.json_response(503, {"error": "simulated temporary overload"})
+            return
+        time.sleep(0.35)
+        self.json_response(200, {"b64_video": base64.b64encode(FIXTURE.read_bytes()).decode(), "seed": request.get("seed")})
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--host", default="127.0.0.1")
+    parser.add_argument("--port", type=int, default=8000)
+    parser.add_argument("--fail-first", type=int, default=0, help="Return 503 for the first N inference calls")
+    args = parser.parse_args()
+    if not FIXTURE.exists():
+        raise SystemExit(f"Missing checked-in fixture: {FIXTURE}")
+    FakeNimHandler.failures_left = args.fail_first
+    server = ThreadingHTTPServer((args.host, args.port), FakeNimHandler)
+    print(f"Fake Cosmos NIM: http://{args.host}:{args.port}")
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        pass
+if __name__ == "__main__":
+    main()

fake_reason.py ADDED Viewed

	@@ -0,0 +1,67 @@

+"""OpenAI-compatible Cosmos Reason2 fixture for local end-to-end tests."""
+from __future__ import annotations
+import argparse
+import json
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+class FakeReasonHandler(BaseHTTPRequestHandler):
+    request_count = 0
+    def send_json(self, status: int, data: dict) -> None:
+        payload = json.dumps(data).encode()
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(payload)))
+        self.end_headers()
+        self.wfile.write(payload)
+    def do_GET(self) -> None:  # noqa: N802
+        if self.path == "/v1/health/ready":
+            self.send_json(200, {"status": "ready", "model": "nvidia/cosmos-reason2-2b"})
+        else:
+            self.send_json(404, {"error": "not found"})
+    def do_POST(self) -> None:  # noqa: N802
+        if self.path != "/v1/chat/completions":
+            self.send_json(404, {"error": "not found"})
+            return
+        size = int(self.headers.get("Content-Length", "0"))
+        request = json.loads(self.rfile.read(size) or b"{}")
+        content = request.get("messages", [{}, {}])[-1].get("content", [])
+        has_video = any(item.get("type") == "video_url" for item in content if isinstance(item, dict))
+        if not has_video:
+            self.send_json(422, {"error": "video_url required"})
+            return
+        type(self).request_count += 1
+        offset = min(18, type(self).request_count * 4)
+        result = {
+            "collision_risk": 48 + offset,
+            "physics_plausibility": 82 - offset,
+            "task_success": 68 - offset,
+            "danger_severity": 55 + offset,
+            "observed_event": "The robot approaches a moving obstacle while a worker enters the operating corridor.",
+            "rationale": "The minimum separation appears small and the avoidance maneuver begins late, while object motion remains mostly plausible.",
+            "recommended_test": "Randomize worker entry time and measure minimum robot-to-human clearance.",
+        }
+        response = {"choices": [{"message": {"role": "assistant", "content": "```json\n" + json.dumps(result) + "\n```"}}]}
+        self.send_json(200, response)
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--host", default="127.0.0.1")
+    parser.add_argument("--port", type=int, default=8001)
+    args = parser.parse_args()
+    server = ThreadingHTTPServer((args.host, args.port), FakeReasonHandler)
+    print(f"Fake Cosmos Reason2: http://{args.host}:{args.port}")
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        pass
+if __name__ == "__main__":
+    main()

fixtures/demo-world.mp4 ADDED Viewed

Binary file (3.25 kB). View file

fixtures/warehouse_baseline_failure.metrics.json ADDED Viewed

	@@ -0,0 +1,18 @@

+{
+  "status": "failed",
+  "episodes": 3,
+  "success_rate": 0.0,
+  "collision_rate": 33.33,
+  "minimum_clearance_m": 0.08,
+  "mean_placement_error_m": 0.07,
+  "acceptance": {
+    "minimum_success_rate": 90,
+    "maximum_collision_rate": 0,
+    "minimum_clearance_m": 0.15
+  },
+  "results": [
+    {"episode": 1, "success": false, "collision": false, "controller_done": false, "steps": 4000, "placement_error_m": 0.09, "minimum_clearance_m": 0.18, "collision_links": []},
+    {"episode": 2, "success": false, "collision": true, "controller_done": true, "steps": 1680, "placement_error_m": 0.07, "minimum_clearance_m": 0.08, "collision_links": ["/World/Franka/panda_link6"]},
+    {"episode": 3, "success": false, "collision": false, "controller_done": true, "steps": 1720, "placement_error_m": 0.05, "minimum_clearance_m": 0.17, "collision_links": []}
+  ]
+}

index.html CHANGED Viewed

@@ -1,19 +1,178 @@
 <!doctype html>
-<html>
-	<head>
-		<meta charset="utf-8" />
-		<meta name="viewport" content="width=device-width" />
-		<title>My static Space</title>
-		<link rel="stylesheet" href="style.css" />
-	</head>
-	<body>
-		<div class="card">
-			<h1>Welcome to your static Space!</h1>
-			<p>You can modify this app directly by editing <i>index.html</i> in the Files and versions tab.</p>
-			<p>
-				Also don't forget to check the
-				<a href="https://huggingface.co/docs/hub/spaces" target="_blank">Spaces documentation</a>.
-			</p>
-		</div>
-	</body>
 </html>

 <!doctype html>
+<html lang="zh-Hant">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <meta name="description" content="NVIDIA Cosmos Physical AI 合成情境編排與 NIM 執行工具。">
+  <title>Cosmos Scenario Studio</title>
+  <link rel="stylesheet" href="styles.css?v=2">
+</head>
+<body>
+  <header class="topbar">
+    <a class="brand" href="#"><span class="brand-mark">C</span><span>COSMOS<br><small>SCENARIO STUDIO</small></span></a>
+    <nav aria-label="主要導覽"><a href="#compose">編排</a><a href="#world">世界預覽</a><a href="#dataset">資料集</a><a href="https://github.com/jjfishjj/cosmos-scenario-studio" target="_blank" rel="noreferrer">GitHub ↗</a></nav>
+    <div class="system-status"><i></i><span>PHYSICAL AI LAB</span></div>
+  </header>
+  <main>
+    <section class="hero">
+      <div>
+        <p class="eyebrow">NVIDIA COSMOS // SYNTHETIC WORLD OPS</p>
+        <h1>先生成世界，<br><em>再讓機器犯錯。</em></h1>
+      </div>
+      <p class="hero-copy">把一個 Physical AI 任務拆成可重現的世界變體，交給 Cosmos-Predict2.5 生成，找出真機測試前最值得看的失敗情境。</p>
+    </section>
+    <section class="release-strip" aria-label="部署與驗證邊界">
+      <article><span>PUBLIC DEMO</span><strong>Offline-first</strong><small>不需要 GPU 或 API key 即可完成主要旅程</small></article>
+      <article><span>CONTRACT TESTS</span><strong>3 JS + 10 Python</strong><small>Prompt、proxy、Reason2 與 Isaac 工作包</small></article>
+      <article><span>REAL RUNTIME</span><strong>External RTX</strong><small>Cosmos NIM 與 Isaac Sim 不在 Space 內執行</small></article>
+      <article class="boundary"><span>CLAIM BOUNDARY</span><strong>Workflow ≠ physics evidence</strong><small>Fixture 結果不代表真實影片或 PhysX 驗證</small></article>
+    </section>
+    <section class="workspace" id="compose">
+      <aside class="panel composer">
+        <div class="panel-head">
+          <div><p class="step">01 // SCENARIO</p><h2>情境編排</h2></div>
+          <button id="reset" class="icon-button" title="還原預設" aria-label="還原預設">↺</button>
+        </div>
+        <div class="presets" aria-label="情境範本">
+          <button class="active" data-preset="warehouse">倉儲</button>
+          <button data-preset="sidewalk">配送</button>
+          <button data-preset="factory">裝配</button>
+        </div>
+        <form id="scenario-form" novalidate>
+          <label>情境名稱<input name="name" autocomplete="off"></label>
+          <label>環境<textarea name="environment" rows="2"></textarea></label>
+          <label>機器人<textarea name="robot" rows="2"></textarea></label>
+          <label>任務<textarea name="task" rows="3"></textarea></label>
+          <label>運行條件<textarea name="condition" rows="2"></textarea></label>
+          <label>關鍵風險<textarea name="hazard" rows="2"></textarea></label>
+          <div class="form-grid">
+            <label>世界變體<input name="variants" type="number" min="1" max="12" value="4"></label>
+            <label>Seed<input name="seed" type="number" value="7"></label>
+            <label>解析度<select name="resolution"><option value="720">720p · 16:9</option><option value="480">480p · 16:9</option><option value="256">256p · 16:9</option></select></label>
+            <label>影格數<input name="frames" type="number" min="25" max="197" value="121"></label>
+          </div>
+          <div id="form-error" class="form-error" role="alert" hidden></div>
+          <button class="primary" type="submit"><span>生成實驗</span><b>⌘ ↵</b></button>
+        </form>
+      </aside>
+      <section class="panel world" id="world">
+        <div class="panel-head">
+          <div><p class="step">02 // WORLD PREVIEW</p><h2 id="world-title">夜間倉儲補貨</h2></div>
+          <span class="model-pill">PREDICT 2.5 · 2B</span>
+        </div>
+        <div class="viewport" id="viewport">
+          <div class="scanlines"></div>
+          <div class="warehouse-scene" aria-label="抽象倉儲世界預覽">
+            <div class="shelf shelf-a"></div><div class="shelf shelf-b"></div>
+            <div class="floor-line one"></div><div class="floor-line two"></div>
+            <div class="robot"><i></i><span></span></div>
+            <div class="human"><i></i><span></span></div>
+            <div class="hazard-zone"></div>
+          </div>
+          <div class="view-hud hud-top"><span>CAM_01 / EGO</span><span id="frame-count">121 FRAMES</span></div>
+          <div class="view-hud hud-bottom"><span><i></i> WORLD READY</span><span id="seed-label">SEED 7</span></div>
+          <button class="play" id="run-preview" aria-label="播放模擬預覽">▶</button>
+        </div>
+        <div class="risk-strip">
+          <div><span>風險覆蓋</span><strong id="risk-score">—</strong></div>
+          <div class="risk-bar"><i id="risk-bar"></i></div>
+          <p id="risk-copy">等待情境分析</p>
+        </div>
+        <div class="prompt-block">
+          <div class="prompt-head"><span>COSMOS PROMPT</span><button id="copy-prompt">複製</button></div>
+          <p id="prompt-output"></p>
+        </div>
+      </section>
+      <aside class="panel dataset" id="dataset">
+        <div class="panel-head">
+          <div><p class="step">03 // DATASET</p><h2>生成佇列</h2></div>
+          <span id="queue-count">0 WORLDS</span>
+        </div>
+        <div class="mode-tabs" role="tablist">
+          <button class="active" data-mode="mock">本機 Demo</button>
+          <button data-mode="nim">Cosmos NIM</button>
+        </div>
+        <div id="nim-config" class="nim-config" hidden>
+          <div class="nim-health"><span><i id="nim-health-dot"></i><b id="nim-health-label">尚未檢查</b></span><button id="check-nim" type="button">檢查連線</button></div>
+          <label>NIM Endpoint<input id="endpoint" value="http://127.0.0.1:8000/v1/infer"></label>
+          <label>API Key（只存於此頁）<input id="api-key" type="password" placeholder="選填"></label>
+          <div class="retry-grid">
+            <label>錯誤重試<select id="max-retries"><option value="0">不重試</option><option value="1">1 次</option><option value="2" selected>2 次</option><option value="3">3 次</option></select></label>
+            <label>Timeout<input id="timeout-seconds" type="number" min="60" max="1800" value="900"></label>
+          </div>
+        </div>
+        <div id="empty-queue" class="empty-queue">
+          <span>◎</span>
+          <p>世界尚未生成</p>
+          <small>完成左側情境後建立批次變體</small>
+        </div>
+        <div id="queue" class="queue" hidden></div>
+        <div id="result-player" class="result-player" hidden>
+          <div class="result-head"><span id="result-title">GENERATED WORLD</span><a id="open-video" href="#" target="_blank">開啟影片 ↗</a></div>
+          <video id="generated-video" controls playsinline></video>
+        </div>
+        <div class="dataset-actions">
+          <button id="run-batch" class="primary" disabled>執行批次</button>
+          <button id="download" class="secondary" disabled>下載 Manifest</button>
+        </div>
+        <p class="privacy-note">NIM 模式由本機 Python proxy 呼叫 endpoint；API key 只存在記憶體，不會寫入檔案或 localStorage。</p>
+      </aside>
+    </section>
+    <section class="analysis-lab" id="reason-lab">
+      <div class="analysis-copy">
+        <p class="step">04 // REASON & VALIDATE</p>
+        <h2>從影片找出最值得重播的失敗。</h2>
+        <p>Cosmos Reason2 觀察生成影片，評估碰撞風險、物理合理性、任務成功與危險程度；排序結果會直接決定 Isaac Sim 的壓力測試範圍。</p>
+      </div>
+      <div class="reason-panel">
+        <div class="reason-config">
+          <label>Reason2 Endpoint<input id="reason-endpoint" value="http://127.0.0.1:8001/v1/chat/completions"></label>
+          <label>Reason2 API Key<input id="reason-api-key" type="password" placeholder="選填"></label>
+          <label class="auto-evaluate"><input id="auto-evaluate" type="checkbox" checked> 生成後自動評分</label>
+        </div>
+        <div class="reason-actions">
+          <button id="evaluate-batch" class="secondary" disabled>用 Reason2 評分</button>
+          <button id="export-isaac" class="primary" disabled>下載 Isaac 工作包</button>
+        </div>
+        <div class="isaac-runner">
+          <label>Scene Adapter<select id="isaac-backend"><option value="contract">Contract worker</option><option value="isaac">Isaac Sim runtime</option></select></label>
+          <label>每個情境 Episodes<input id="isaac-episodes" type="number" min="1" max="100" value="3"></label>
+          <button id="run-isaac" class="secondary" disabled>執行 Policy Validation</button>
+        </div>
+        <div id="isaac-result" class="isaac-result" hidden></div>
+        <div id="ranking-empty" class="ranking-empty">完成 Cosmos 影片生成後，這裡會顯示 edge-case ranking。</div>
+        <div id="ranking" class="ranking" hidden></div>
+      </div>
+    </section>
+    <section class="architecture">
+      <p class="step">PIPELINE // FROM IDEA TO TRAINING DATA</p>
+      <div class="flow">
+        <article><b>01</b><span>Scenario brief</span><small>任務與風險</small></article>
+        <i>→</i><article><b>02</b><span>Cosmos Predict</span><small>World generation</small></article>
+        <i>→</i><article><b>03</b><span>Review & curate</span><small>失敗情境篩選</small></article>
+        <i>→</i><article><b>04</b><span>Isaac / Policy</span><small>訓練與驗證</small></article>
+      </div>
+    </section>
+  </main>
+  <footer><span>COSMOS SCENARIO STUDIO</span><span>Prototype · NVIDIA Cosmos-Predict2.5 compatible</span></footer>
+  <script type="module" src="app.mjs?v=4"></script>
+</body>
 </html>

isaac_adapter/__init__.py ADDED Viewed

	@@ -0,0 +1,2 @@


1	+ """Isaac Sim scene adapter for Cosmos Scenario Studio work packages."""
2	+

isaac_adapter/build_warehouse_scene.py ADDED Viewed

	@@ -0,0 +1,147 @@

+"""Build the reference Warehouse Franka USD with Isaac Sim 5.1.
+Run with Isaac Sim's bundled Python:
+  ./python.sh -m isaac_adapter.build_warehouse_scene --output artifacts/warehouse_franka.usd
+"""
+from __future__ import annotations
+import argparse
+import json
+from pathlib import Path
+from isaacsim import SimulationApp
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Build the Cosmos Warehouse Franka reference scene")
+    parser.add_argument("--output", default="artifacts/warehouse_franka.usd")
+    parser.add_argument("--mapping", default="artifacts/warehouse_franka.mapping.json")
+    parser.add_argument("--headless", action="store_true")
+    args = parser.parse_args()
+    output = Path(args.output).expanduser().resolve()
+    mapping_path = Path(args.mapping).expanduser().resolve()
+    output.parent.mkdir(parents=True, exist_ok=True)
+    mapping_path.parent.mkdir(parents=True, exist_ok=True)
+    simulation_app = SimulationApp({"headless": args.headless})
+    try:
+        import numpy as np
+        import omni.usd
+        from isaacsim.core.api import World
+        from isaacsim.core.api.objects import DynamicCuboid, FixedCuboid, VisualCuboid
+        from isaacsim.robot.manipulators.examples.franka import Franka
+        from isaacsim.sensors.camera import Camera
+        from pxr import Gf, Sdf, UsdGeom, UsdLux
+        world = World(stage_units_in_meters=1.0)
+        world.scene.add_default_ground_plane()
+        world.scene.add(Franka(prim_path="/World/Franka", name="warehouse_franka"))
+        world.scene.add(
+            DynamicCuboid(
+                prim_path="/World/TaskObject",
+                name="task_object",
+                position=np.array([0.42, 0.24, 0.035]),
+                scale=np.array([0.055, 0.055, 0.055]),
+                size=1.0,
+                color=np.array([0.05, 0.3, 0.95]),
+                mass=0.05,
+            )
+        )
+        world.scene.add(
+            VisualCuboid(
+                prim_path="/World/TaskTarget",
+                name="task_target",
+                position=np.array([0.42, -0.24, 0.028]),
+                scale=np.array([0.075, 0.075, 0.008]),
+                size=1.0,
+                color=np.array([0.1, 0.9, 0.25]),
+            )
+        )
+        world.scene.add(
+            FixedCuboid(
+                prim_path="/World/Hazard",
+                name="hazard",
+                position=np.array([0.62, 0.0, 0.18]),
+                scale=np.array([0.10, 0.10, 0.36]),
+                size=1.0,
+                color=np.array([0.95, 0.15, 0.05]),
+            )
+        )
+        # A compact warehouse cell: two shelf banks and a rear safety wall.
+        shelf_color = np.array([0.22, 0.25, 0.29])
+        for side, y in (("Left", 1.05), ("Right", -1.05)):
+            for level, z in enumerate((0.18, 0.72, 1.26, 1.80)):
+                world.scene.add(
+                    FixedCuboid(
+                        prim_path=f"/World/Warehouse/Shelf{side}/Deck{level}",
+                        name=f"shelf_{side.lower()}_{level}",
+                        position=np.array([0.55, y, z]),
+                        scale=np.array([1.9, 0.48, 0.06]),
+                        size=1.0,
+                        color=shelf_color,
+                    )
+                )
+        world.scene.add(
+            FixedCuboid(
+                prim_path="/World/Warehouse/RearWall",
+                name="rear_wall",
+                position=np.array([1.48, 0.0, 1.05]),
+                scale=np.array([0.08, 2.6, 2.1]),
+                size=1.0,
+                color=np.array([0.14, 0.16, 0.18]),
+            )
+        )
+        Camera(
+            prim_path="/World/Camera",
+            position=np.array([2.55, 2.2, 1.75]),
+            orientation=np.array([0.3265, 0.233, 0.562, 0.715]),
+            frequency=30,
+            resolution=(1280, 720),
+        )
+        stage = omni.usd.get_context().get_stage()
+        light = UsdLux.DistantLight.Define(stage, Sdf.Path("/World/KeyLight"))
+        light.CreateIntensityAttr(850.0)
+        light.AddRotateXYZOp().Set(Gf.Vec3f(35.0, -25.0, 20.0))
+        dome = UsdLux.DomeLight.Define(stage, Sdf.Path("/World/FillLight"))
+        dome.CreateIntensityAttr(250.0)
+        warehouse = stage.GetPrimAtPath("/World/Warehouse")
+        if warehouse:
+            UsdGeom.Imageable(warehouse).MakeVisible()
+        world.reset()
+        for _ in range(10):
+            world.step(render=not args.headless)
+        stage.GetRootLayer().Export(str(output))
+        collision_parents = [f"/World/Franka/panda_link{i}" for i in range(8)] + ["/World/Franka/panda_hand"]
+        mapping = {
+            "schema_version": "1.0",
+            "scene_usd": str(output),
+            "policy": "franka_pick_place",
+            "prims": {
+                "robot": "/World/Franka",
+                "collision_parent": "/World/Franka/panda_link0",
+                "collision_parents": collision_parents,
+                "task_object": "/World/TaskObject",
+                "task_target": "/World/TaskTarget",
+                "hazard": "/World/Hazard",
+                "camera": "/World/Camera",
+                "lights": ["/World/KeyLight", "/World/FillLight"],
+            },
+            "clearance_radii_m": {"robot": 0.07, "hazard": 0.08},
+            "success_tolerance_m": 0.045,
+            "end_effector_offset": [0.0, 0.0, 0.10],
+            "max_steps": 4000,
+        }
+        mapping_path.write_text(json.dumps(mapping, indent=2) + "\n")
+        print(json.dumps({"scene_usd": str(output), "mapping": str(mapping_path)}))
+    finally:
+        simulation_app.close()
+if __name__ == "__main__":
+    main()

isaac_adapter/calibration.py ADDED Viewed

	@@ -0,0 +1,100 @@

+"""Diagnose a real Isaac Sim baseline without weakening safety thresholds."""
+from __future__ import annotations
+import argparse
+import json
+from pathlib import Path
+from typing import Any
+def build_calibration_report(metrics: dict[str, Any], mapping: dict[str, Any]) -> dict[str, Any]:
+    results = metrics.get("results", [])
+    if not isinstance(results, list) or not results:
+        raise ValueError("metrics must contain at least one episode result")
+    acceptance = metrics.get("acceptance", {})
+    tolerance = float(mapping.get("success_tolerance_m", 0.045))
+    timed_out = [item for item in results if not item.get("controller_done", False)]
+    collisions = [item for item in results if item.get("collision", False)]
+    placement_only = [
+        item for item in results
+        if item.get("controller_done", False)
+        and not item.get("collision", False)
+        and float(item.get("placement_error_m", 0)) > tolerance
+    ]
+    low_clearance = [
+        item for item in results
+        if float(item.get("minimum_clearance_m", 0)) < float(acceptance.get("minimum_clearance_m", 0))
+    ]
+    findings: list[dict[str, Any]] = []
+    candidates: list[dict[str, Any]] = []
+    if timed_out:
+        findings.append({
+            "code": "controller_timeout",
+            "episodes": [item.get("episode") for item in timed_out],
+            "diagnosis": "PickPlaceController did not finish within max_steps.",
+            "action": "Inspect reachability and try calibrated end-effector Z offsets; do not relax success criteria.",
+        })
+        current = list(mapping.get("end_effector_offset", [0.0, 0.0, 0.10]))
+        for z in (0.06, 0.10, 0.14):
+            candidate = current.copy()
+            candidate[2] = z
+            candidates.append({"name": f"offset-z-{z:.2f}", "patch": {"end_effector_offset": candidate}})
+    if placement_only:
+        findings.append({
+            "code": "placement_error",
+            "episodes": [item.get("episode") for item in placement_only],
+            "diagnosis": "Controller completed, but the object remained outside the target tolerance.",
+            "action": "Inspect gripper release height and object/target origins before changing tolerance.",
+        })
+    if collisions:
+        links = sorted({link for item in collisions for link in item.get("collision_links", [])})
+        findings.append({
+            "code": "collision",
+            "episodes": [item.get("episode") for item in collisions],
+            "links": links,
+            "diagnosis": "One or more Franka links generated contact.",
+            "action": "Keep full-chain sensors enabled; inspect the named links and adjust scene geometry or trajectory.",
+        })
+    if low_clearance:
+        findings.append({
+            "code": "unsafe_clearance",
+            "episodes": [item.get("episode") for item in low_clearance],
+            "diagnosis": "Measured hazard clearance is below the policy threshold.",
+            "action": "Treat as a genuine safety failure; move the hazard or replan the trajectory, not the threshold.",
+        })
+    if not findings and metrics.get("status") == "passed":
+        findings.append({"code": "baseline_passed", "diagnosis": "Baseline meets all acceptance gates.", "action": "Increase domain-randomization coverage before policy regression."})
+    return {
+        "source_status": metrics.get("status"),
+        "summary": {
+            "episodes": len(results),
+            "success_rate": metrics.get("success_rate"),
+            "collision_rate": metrics.get("collision_rate"),
+            "minimum_clearance_m": metrics.get("minimum_clearance_m"),
+            "controller_timeouts": len(timed_out),
+        },
+        "safety_policy_changed": False,
+        "findings": findings,
+        "mapping_candidates": candidates,
+    }
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Analyze Isaac Warehouse baseline metrics")
+    parser.add_argument("--metrics", required=True)
+    parser.add_argument("--mapping", required=True)
+    parser.add_argument("--output")
+    args = parser.parse_args()
+    metrics = json.loads(Path(args.metrics).read_text())
+    mapping = json.loads(Path(args.mapping).read_text())
+    report = build_calibration_report(metrics, mapping)
+    rendered = json.dumps(report, indent=2)
+    if args.output:
+        Path(args.output).write_text(rendered + "\n")
+    print(rendered)
+if __name__ == "__main__":
+    main()

isaac_adapter/client.py ADDED Viewed

	@@ -0,0 +1,28 @@

+from __future__ import annotations
+import json
+from urllib.request import Request, urlopen
+class StudioClient:
+    def __init__(self, server: str):
+        self.server = server.rstrip("/")
+    def request(self, path: str, body: dict | None = None, timeout: int = 10) -> dict:
+        data = None if body is None else json.dumps(body).encode()
+        headers = {"Accept": "application/json"}
+        if data is not None:
+            headers["Content-Type"] = "application/json"
+        request = Request(self.server + path, data=data, headers=headers, method="POST" if data is not None else "GET")
+        with urlopen(request, timeout=timeout) as response:
+            return json.loads(response.read())
+    def command(self) -> dict:
+        return self.request("/api/isaac/command")
+    def telemetry(self, run_id: str, body: dict) -> dict:
+        return self.request(f"/api/isaac/runs/{run_id}/telemetry", body)
+    def result(self, run_id: str, body: dict) -> dict:
+        return self.request(f"/api/isaac/runs/{run_id}/result", body)

isaac_adapter/contracts.py ADDED Viewed

	@@ -0,0 +1,112 @@

+from __future__ import annotations
+import json
+import random
+import tempfile
+import zipfile
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+REQUIRED_FILES = {"cosmos_manifest.json", "domain_randomization.json", "policy_validation.json", "scene_mapping.example.json"}
+REQUIRED_PRIMS = {"robot", "task_object", "task_target", "hazard", "camera"}
+@dataclass(frozen=True)
+class EpisodeResult:
+    episode: int
+    variant_id: str
+    success: bool
+    collision: bool
+    minimum_clearance_m: float
+    placement_error_m: float
+    duration_s: float
+    seed: int
+    controller_done: bool = False
+    steps: int = 0
+    collision_links: tuple[str, ...] = ()
+def load_work_package(path: str | Path) -> dict[str, Any]:
+    archive = Path(path)
+    if not archive.is_file() or not zipfile.is_zipfile(archive):
+        raise ValueError("work package must be a ZIP file")
+    with zipfile.ZipFile(archive) as bundle:
+        names = set(bundle.namelist())
+        missing = REQUIRED_FILES - names
+        if missing:
+            raise ValueError(f"work package missing: {', '.join(sorted(missing))}")
+        result = {Path(name).stem: json.loads(bundle.read(name)) for name in REQUIRED_FILES}
+    validate_mapping(result["scene_mapping.example"])
+    return result
+def validate_mapping(mapping: dict[str, Any]) -> None:
+    prims = mapping.get("prims")
+    if not isinstance(prims, dict):
+        raise ValueError("scene mapping requires a prims object")
+    missing = REQUIRED_PRIMS - set(prims)
+    if missing:
+        raise ValueError(f"scene mapping missing prims: {', '.join(sorted(missing))}")
+    for name in REQUIRED_PRIMS:
+        if not str(prims[name]).startswith("/World/"):
+            raise ValueError(f"prim {name} must use an absolute /World path")
+    radii = mapping.get("clearance_radii_m", {})
+    if any(float(value) < 0 for value in radii.values()):
+        raise ValueError("clearance radii cannot be negative")
+def sample_episode(randomization: dict[str, Any], seed: int) -> dict[str, Any]:
+    rng = random.Random(seed)
+    def uniform(path: tuple[str, str]) -> float:
+        low, high = randomization[path[0]][path[1]]
+        return round(rng.uniform(float(low), float(high)), 5)
+    return {
+        "seed": seed,
+        "lighting_lux": uniform(("lighting", "intensity_lux")),
+        "color_temperature_k": uniform(("lighting", "color_temperature_k")),
+        "camera_translation_m": [uniform(("camera", "translation_noise_m")) for _ in range(3)],
+        "camera_rotation_deg": [uniform(("camera", "rotation_noise_deg")) for _ in range(3)],
+        "object_xy_m": [uniform(("object", "xy_position_noise_m")) for _ in range(2)],
+        "object_yaw_deg": uniform(("object", "yaw_noise_deg")),
+        "friction": uniform(("physics", "friction")),
+        "payload_mass_kg": uniform(("physics", "payload_mass_kg")),
+        "joint_damping_scale": uniform(("physics", "joint_damping_scale")),
+    }
+def aggregate_results(results: list[EpisodeResult], acceptance: dict[str, Any]) -> dict[str, Any]:
+    if not results:
+        raise ValueError("at least one episode result is required")
+    total = len(results)
+    success_rate = round(sum(item.success for item in results) / total * 100, 2)
+    collision_rate = round(sum(item.collision for item in results) / total * 100, 2)
+    minimum_clearance = round(min(item.minimum_clearance_m for item in results), 4)
+    mean_placement_error = round(sum(item.placement_error_m for item in results) / total, 4)
+    passed = (
+        success_rate >= float(acceptance["minimum_success_rate"])
+        and collision_rate <= float(acceptance["maximum_collision_rate"])
+        and minimum_clearance >= float(acceptance["minimum_clearance_m"])
+    )
+    return {
+        "status": "passed" if passed else "failed",
+        "episodes": total,
+        "success_rate": success_rate,
+        "collision_rate": collision_rate,
+        "minimum_clearance_m": minimum_clearance,
+        "mean_placement_error_m": mean_placement_error,
+        "failure_breakdown": {
+            "controller_timeout": sum(not item.controller_done for item in results),
+            "collision": sum(item.collision for item in results),
+            "placement_error": sum(
+                item.controller_done and not item.collision and not item.success for item in results
+            ),
+        },
+        "acceptance": acceptance,
+        "results": [
+            {**item.__dict__, "collision_links": list(item.collision_links)} for item in results
+        ],
+    }

isaac_adapter/fake_runtime.py ADDED Viewed

	@@ -0,0 +1,53 @@

+"""Deterministic Scene Adapter contract worker; no Isaac installation required."""
+from __future__ import annotations
+import argparse
+import time
+from pathlib import Path
+from .client import StudioClient
+from .contracts import EpisodeResult, aggregate_results, load_work_package, sample_episode
+def run_command(client: StudioClient, command: dict) -> dict:
+    run_id = command["run_id"]
+    package = load_work_package(Path(command["package_path"]))
+    validation = package["policy_validation"]
+    randomization = package["domain_randomization"]
+    results: list[EpisodeResult] = []
+    episode_number = 0
+    for edge in validation["ranked_edge_cases"]:
+        for repeat in range(int(command.get("episodes_per_variant", 3))):
+            episode_number += 1
+            seed = int(edge["seed"]) + repeat * 101
+            sample = sample_episode(randomization, seed)
+            priority = float(edge.get("priority") or 50)
+            collision = priority >= 80 and repeat == 0
+            clearance = round(max(0.03, 0.34 - priority * 0.0024 + sample["friction"] * 0.02), 4)
+            placement_error = round(0.012 + priority * 0.00025 + abs(sample["object_xy_m"][0]) * 0.2, 4)
+            success = not collision and placement_error <= 0.035
+            client.telemetry(run_id, {"episode": episode_number, "variant_id": edge["variant_id"], "phase": "complete", "success": success, "collision": collision, "minimum_clearance_m": clearance})
+            results.append(EpisodeResult(episode_number, edge["variant_id"], success, collision, clearance, placement_error, 0.05, seed))
+    summary = aggregate_results(results, validation["acceptance"])
+    client.result(run_id, summary)
+    return summary
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--server", default="http://127.0.0.1:8090")
+    parser.add_argument("--once", action="store_true")
+    args = parser.parse_args()
+    client = StudioClient(args.server)
+    while True:
+        command = client.command()
+        if command.get("type") == "run":
+            run_command(client, command)
+            if args.once:
+                return
+        time.sleep(0.3)
+if __name__ == "__main__":
+    main()

isaac_adapter/runtime.py ADDED Viewed

	@@ -0,0 +1,180 @@

+"""Isaac Sim 5.1 Scene Adapter for Cosmos work packages.
+Run with Isaac Sim's bundled Python, not the system interpreter:
+  ./python.sh -m isaac_adapter.runtime --server http://127.0.0.1:8090 --once --headless
+The stable work-package/client code stays outside Isaac imports. This module
+imports Isaac only after SimulationApp is created.
+"""
+from __future__ import annotations
+import argparse
+import json
+import math
+import time
+from pathlib import Path
+from .client import StudioClient
+from .contracts import EpisodeResult, aggregate_results, load_work_package, sample_episode, validate_mapping
+def run_isaac_command(command: dict, mapping_override: str | None, headless: bool) -> dict:
+    from isaacsim import SimulationApp
+    simulation_app = SimulationApp({"headless": headless})
+    try:
+        import numpy as np
+        import omni.replicator.core as rep
+        from isaacsim.core.api import World
+        from isaacsim.core.prims import SingleXFormPrim
+        from isaacsim.core.utils.stage import open_stage
+        from isaacsim.robot.manipulators.examples.franka import Franka
+        from isaacsim.robot.manipulators.examples.franka.controllers import PickPlaceController
+        from isaacsim.sensors.physics import ContactSensor
+        from pxr import Gf, UsdPhysics
+        package = load_work_package(command["package_path"])
+        mapping = package["scene_mapping.example"]
+        if mapping_override:
+            mapping = json.loads(Path(mapping_override).read_text())
+        validate_mapping(mapping)
+        scene_usd = Path(mapping["scene_usd"])
+        if not scene_usd.is_file():
+            raise ValueError(f"scene_usd not found: {scene_usd}")
+        open_stage(str(scene_usd))
+        world = World(stage_units_in_meters=1.0)
+        prims = mapping["prims"]
+        robot = world.scene.add(Franka(prim_path=prims["robot"], name="cosmos_robot"))
+        task_object = world.scene.add(SingleXFormPrim(prim_path=prims["task_object"], name="cosmos_task_object"))
+        task_target = world.scene.add(SingleXFormPrim(prim_path=prims["task_target"], name="cosmos_task_target"))
+        hazard = world.scene.add(SingleXFormPrim(prim_path=prims["hazard"], name="cosmos_hazard"))
+        camera = world.scene.add(SingleXFormPrim(prim_path=prims["camera"], name="cosmos_camera"))
+        collision_parents = prims.get("collision_parents", [prims.get("collision_parent", prims["robot"])])
+        contacts = []
+        for index, collision_parent in enumerate(collision_parents):
+            contacts.append(
+                world.scene.add(
+                    ContactSensor(
+                        prim_path=collision_parent + "/CosmosContactSensor",
+                        name=f"cosmos_contact_{index}",
+                        frequency=60,
+                        min_threshold=0.1,
+                        max_threshold=1e7,
+                        radius=-1,
+                    )
+                )
+            )
+        world.reset()
+        controller = PickPlaceController(name="cosmos_pick_place", gripper=robot.gripper, robot_articulation=robot)
+        randomization = package["domain_randomization"]
+        validation = package["policy_validation"]
+        camera_rep = rep.get.prims(path_pattern=prims["camera"])
+        light_paths = prims.get("lights", [])
+        light_rep = rep.get.prims(path_pattern="|".join(light_paths)) if light_paths else None
+        results: list[EpisodeResult] = []
+        episode_number = 0
+        radii = mapping.get("clearance_radii_m", {"robot": 0.32, "hazard": 0.30})
+        for edge in validation["ranked_edge_cases"]:
+            for repeat in range(int(command.get("episodes_per_variant", 3))):
+                episode_number += 1
+                seed = int(edge["seed"]) + repeat * 101
+                values = sample_episode(randomization, seed)
+                world.reset()
+                controller.reset()
+                rep.set_global_seed(seed)
+                with camera_rep:
+                    delta = values["camera_translation_m"]
+                    rotation = values["camera_rotation_deg"]
+                    rep.modify.pose(position=rep.distribution.uniform(tuple(delta), tuple(delta)), rotation=rep.distribution.uniform(tuple(rotation), tuple(rotation)))
+                if light_rep is not None:
+                    with light_rep:
+                        rep.modify.attribute("intensity", rep.distribution.uniform(values["lighting_lux"], values["lighting_lux"]))
+                rep.orchestrator.step()
+                object_position, object_orientation = task_object.get_world_pose()
+                randomized_position = object_position.copy()
+                randomized_position[:2] += np.asarray(values["object_xy_m"])
+                yaw = math.radians(values["object_yaw_deg"])
+                yaw_quat = np.array([math.cos(yaw / 2), 0, 0, math.sin(yaw / 2)])
+                task_object.set_world_pose(position=randomized_position, orientation=yaw_quat)
+                physics_material = UsdPhysics.MaterialAPI.Get(world.stage, prims["task_object"])
+                if physics_material:
+                    physics_material.CreateDynamicFrictionAttr(values["friction"])
+                collision = False
+                collision_links: set[str] = set()
+                minimum_clearance = float("inf")
+                started = time.perf_counter()
+                target_position, _ = task_target.get_world_pose()
+                steps = 0
+                for _step in range(int(mapping.get("max_steps", 4000))):
+                    steps = _step + 1
+                    world.step(render=not headless)
+                    current_object, _ = task_object.get_world_pose()
+                    action = controller.forward(
+                        picking_position=current_object,
+                        placing_position=target_position,
+                        current_joint_positions=robot.get_joint_positions(),
+                        end_effector_offset=np.array(mapping.get("end_effector_offset", [0, 0, 0.20])),
+                    )
+                    robot.apply_action(action)
+                    for sensor_index, sensor in enumerate(contacts):
+                        if bool(sensor.get_current_frame().get("in_contact", False)):
+                            collision = True
+                            collision_links.add(collision_parents[sensor_index])
+                    robot_position, _ = robot.end_effector.get_world_pose()
+                    hazard_position, _ = hazard.get_world_pose()
+                    clearance = float(np.linalg.norm(robot_position - hazard_position)) - float(radii["robot"]) - float(radii["hazard"])
+                    minimum_clearance = min(minimum_clearance, max(0.0, clearance))
+                    if controller.is_done():
+                        break
+                actual_position, _ = task_object.get_world_pose()
+                placement_error = float(np.linalg.norm(actual_position - target_position))
+                controller_done = controller.is_done()
+                success = controller_done and placement_error <= float(mapping.get("success_tolerance_m", 0.035)) and not collision
+                results.append(EpisodeResult(episode_number, edge["variant_id"], success, collision, round(minimum_clearance, 4), round(placement_error, 4), round(time.perf_counter() - started, 3), seed, controller_done, steps, tuple(sorted(collision_links))))
+        return aggregate_results(results, validation["acceptance"])
+    finally:
+        simulation_app.close()
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Cosmos work-package Isaac Sim Scene Adapter")
+    parser.add_argument("--server", default="http://127.0.0.1:8090")
+    parser.add_argument("--mapping", help="Scene-specific JSON mapping; overrides the example mapping in the ZIP")
+    parser.add_argument("--headless", action="store_true")
+    parser.add_argument("--once", action="store_true")
+    parser.add_argument("--package", help="Run one work-package ZIP directly without the Studio queue")
+    parser.add_argument("--episodes", type=int, default=3, help="Episodes per ranked variant in direct mode")
+    parser.add_argument("--output", help="Write direct-mode metrics JSON to this path")
+    args = parser.parse_args()
+    if args.package:
+        result = run_isaac_command(
+            {"package_path": str(Path(args.package).expanduser().resolve()), "episodes_per_variant": max(1, min(100, args.episodes))},
+            args.mapping,
+            args.headless,
+        )
+        rendered = json.dumps(result, indent=2)
+        if args.output:
+            Path(args.output).expanduser().resolve().write_text(rendered + "\n")
+        print(rendered)
+        return
+    client = StudioClient(args.server)
+    while True:
+        command = client.command()
+        if command.get("type") == "run":
+            try:
+                result = run_isaac_command(command, args.mapping, args.headless)
+                client.result(command["run_id"], result)
+            except Exception as exc:
+                client.result(command["run_id"], {"status": "error", "success_rate": 0, "collision_rate": 100, "minimum_clearance_m": 0, "error": str(exc)})
+            if args.once:
+                return
+        time.sleep(0.5)
+if __name__ == "__main__":
+    main()

model.mjs ADDED Viewed

	@@ -0,0 +1,113 @@

+export const PRESETS = {
+  warehouse: {
+    name: "夜間倉儲補貨",
+    environment: "大型物流倉庫的窄走道，貨架高六公尺，地面有反光標線",
+    robot: "配備雙目相機與夾爪的自主移動機器人",
+    task: "從右側貨架取出藍色料箱，避開移動中的堆高機，放到揀貨站",
+    condition: "夜班低照度，局部逆光，地面有少量積水",
+    hazard: "一名穿反光背心的工作人員突然從貨架後方走入路徑",
+  },
+  sidewalk: {
+    name: "雨天末端配送",
+    environment: "台北市區騎樓與人行道交界，路面濕滑且有坡道",
+    robot: "六輪自動配送機器人，前向廣角相機視角",
+    task: "沿人行道前進並在便利商店入口前安全停靠",
+    condition: "傍晚大雨，車燈反射，行人撐傘造成遮擋",
+    hazard: "一台機車從騎樓出口快速切入機器人前方",
+  },
+  factory: {
+    name: "協作機械臂裝配",
+    environment: "電子工廠裝配站，桌面有零件盤、治具與安全光柵",
+    robot: "固定式七軸協作機械臂，腕部相機視角",
+    task: "拾取金屬接頭並插入黑色治具，完成後退回安全姿態",
+    condition: "均勻白光，金屬表面強反射，背景輸送帶持續移動",
+    hazard: "零件在夾取後滑動，操作員的手同時接近工作區",
+  },
+};
+const CAMERA = [
+  "camera follows at waist height with stable forward motion",
+  "wide-angle fixed camera shows the complete interaction zone",
+  "robot ego-view with natural vibration and realistic motion blur",
+  "three-quarter tracking shot preserving spatial continuity",
+];
+const LIGHT = [
+  "physically plausible global illumination",
+  "subtle exposure adaptation and realistic reflections",
+  "natural volumetric light with accurate contact shadows",
+  "documentary lighting with high material fidelity",
+];
+export function validateScenario(input) {
+  const required = ["name", "environment", "robot", "task"];
+  return required
+    .filter((key) => !String(input[key] || "").trim())
+    .map((key) => ({ field: key, message: `請填寫${{ name: "情境名稱", environment: "環境", robot: "機器人", task: "任務" }[key]}` }));
+}
+export function buildPrompt(input, index = 0) {
+  const seed = Number(input.seed || 7) + index * 17;
+  const camera = CAMERA[Math.abs(seed) % CAMERA.length];
+  const light = LIGHT[Math.abs(seed * 3 + index) % LIGHT.length];
+  const condition = input.condition?.trim() || "clear visibility and normal operating conditions";
+  const hazard = input.hazard?.trim() || "no unexpected hazard";
+  return [
+    `A photorealistic physical AI simulation in ${input.environment.trim()}.`,
+    `${input.robot.trim()} must ${input.task.trim()}.`,
+    `Operating condition: ${condition}.`,
+    `Critical event: ${hazard}.`,
+    `${camera}; ${light}.`,
+    "Continuous causal motion, consistent geometry, realistic physics, safety-relevant interactions, no cuts.",
+  ].join(" ");
+}
+export function buildNegativePrompt() {
+  return [
+    "cartoon, illustration, impossible geometry, teleportation, duplicated objects",
+    "floating objects, broken kinematics, inconsistent robot morphology",
+    "camera cuts, excessive motion blur, text overlays, watermark, low detail",
+  ].join(", ");
+}
+export function buildVariant(input, index) {
+  const prompt = buildPrompt(input, index);
+  const seed = Number(input.seed || 7) + index * 17;
+  return {
+    id: `world-${String(index + 1).padStart(2, "0")}`,
+    seed,
+    prompt,
+    negative_prompt: buildNegativePrompt(),
+    tags: [input.robot, input.condition, input.hazard].filter(Boolean),
+    request: {
+      prompt,
+      negative_prompt: buildNegativePrompt(),
+      seed,
+      resolution: input.resolution || "720",
+      num_output_frames: Number(input.frames || 121),
+      guidance_scale: 7.0,
+      steps: 35,
+    },
+  };
+}
+export function buildManifest(input) {
+  const count = Math.min(12, Math.max(1, Number(input.variants || 4)));
+  return {
+    schema_version: "1.0",
+    project: input.name.trim(),
+    generator: "NVIDIA Cosmos-Predict2.5",
+    created_at: new Date().toISOString(),
+    intent: "physical-ai synthetic scenario generation",
+    variants: Array.from({ length: count }, (_, index) => buildVariant(input, index)),
+  };
+}
+export function riskScore(input) {
+  let score = 28;
+  const text = `${input.condition || ""} ${input.hazard || ""}`.toLowerCase();
+  ["雨", "低照", "逆光", "遮擋", "突然", "快速", "滑", "人", "forklift", "occlusion"].forEach((term) => {
+    if (text.includes(term)) score += 7;
+  });
+  return Math.min(96, score);
+}

model.test.mjs ADDED Viewed

	@@ -0,0 +1,27 @@

+import test from "node:test";
+import assert from "node:assert/strict";
+import { PRESETS, buildManifest, buildPrompt, riskScore, validateScenario } from "./model.mjs";
+test("valid preset creates deterministic Cosmos variants", () => {
+  const input = { ...PRESETS.warehouse, seed: 9, variants: 3, frames: 121, resolution: "720" };
+  const manifest = buildManifest(input);
+  assert.equal(manifest.variants.length, 3);
+  assert.equal(manifest.variants[0].seed, 9);
+  assert.equal(manifest.variants[1].seed, 26);
+  assert.equal(manifest.variants[0].request.resolution, "720");
+  assert.equal(manifest.variants[0].request.guidance_scale, 7);
+  assert.match(buildPrompt(input), /Continuous causal motion/);
+});
+test("missing core fields are reported", () => {
+  assert.deepEqual(validateScenario({ name: "", environment: "", robot: "AMR", task: "" }).map((e) => e.field), [
+    "name",
+    "environment",
+    "task",
+  ]);
+});
+test("risk score is bounded and reacts to hazards", () => {
+  assert.ok(riskScore({ condition: "低照度大雨", hazard: "人突然快速切入" }) > riskScore({ condition: "clear", hazard: "" }));
+  assert.ok(riskScore({ condition: "雨 低照 逆光 遮擋", hazard: "人突然快速滑入" }) <= 96);
+});

run_warehouse_acceptance.py ADDED Viewed

	@@ -0,0 +1,63 @@

+"""Build and validate the Warehouse Franka scene with an Isaac Sim 5.1 install."""
+from __future__ import annotations
+import argparse
+import platform
+import subprocess
+from pathlib import Path
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Run Warehouse Franka physical acceptance")
+    parser.add_argument("--isaac-root", required=True, help="Isaac Sim 5.1 installation directory")
+    parser.add_argument("--package", required=True, help="Cosmos Isaac work-package ZIP")
+    parser.add_argument("--episodes", type=int, default=3)
+    parser.add_argument("--gui", action="store_true", help="Show the Isaac Sim viewport")
+    args = parser.parse_args()
+    if platform.system() != "Linux":
+        raise SystemExit("Isaac Sim 5.1 physical acceptance requires Linux x86_64 with a supported NVIDIA RTX GPU.")
+    root = Path(args.isaac_root).expanduser().resolve()
+    python = root / "python.sh"
+    package = Path(args.package).expanduser().resolve()
+    if not python.is_file():
+        raise SystemExit(f"Isaac Python launcher not found: {python}")
+    if not package.is_file():
+        raise SystemExit(f"Work package not found: {package}")
+    project = Path(__file__).resolve().parent
+    artifacts = project / "artifacts"
+    scene = artifacts / "warehouse_franka.usd"
+    mapping = artifacts / "warehouse_franka.mapping.json"
+    metrics = artifacts / "warehouse_franka.metrics.json"
+    headless = [] if args.gui else ["--headless"]
+    subprocess.run(
+        [str(python), "-m", "isaac_adapter.build_warehouse_scene", "--output", str(scene), "--mapping", str(mapping), *headless],
+        cwd=project,
+        check=True,
+    )
+    subprocess.run(
+        [
+            str(python),
+            "-m",
+            "isaac_adapter.runtime",
+            "--package",
+            str(package),
+            "--mapping",
+            str(mapping),
+            "--episodes",
+            str(max(1, min(100, args.episodes))),
+            "--output",
+            str(metrics),
+            *headless,
+        ],
+        cwd=project,
+        check=True,
+    )
+    print(f"Metrics written to {metrics}")
+if __name__ == "__main__":
+    main()

scene_mapping.example.json ADDED Viewed

	@@ -0,0 +1,21 @@

+{
+  "schema_version": "1.0",
+  "scene_usd": "/absolute/path/to/warehouse_scene.usd",
+  "policy": "franka_pick_place",
+  "prims": {
+    "robot": "/World/Franka",
+    "collision_parent": "/World/Franka/panda_link0",
+    "task_object": "/World/TaskObject",
+    "task_target": "/World/TaskTarget",
+    "hazard": "/World/Hazard",
+    "camera": "/World/Camera",
+    "lights": ["/World/KeyLight"]
+  },
+  "clearance_radii_m": {
+    "robot": 0.32,
+    "hazard": 0.3
+  },
+  "success_tolerance_m": 0.035,
+  "end_effector_offset": [0, 0, 0.2],
+  "max_steps": 4000
+}

scene_mapping.warehouse.json ADDED Viewed

	@@ -0,0 +1,29 @@

+{
+  "schema_version": "1.0",
+  "scene_usd": "artifacts/warehouse_franka.usd",
+  "policy": "franka_pick_place",
+  "prims": {
+    "robot": "/World/Franka",
+    "collision_parent": "/World/Franka/panda_link0",
+    "collision_parents": [
+      "/World/Franka/panda_link0",
+      "/World/Franka/panda_link1",
+      "/World/Franka/panda_link2",
+      "/World/Franka/panda_link3",
+      "/World/Franka/panda_link4",
+      "/World/Franka/panda_link5",
+      "/World/Franka/panda_link6",
+      "/World/Franka/panda_link7",
+      "/World/Franka/panda_hand"
+    ],
+    "task_object": "/World/TaskObject",
+    "task_target": "/World/TaskTarget",
+    "hazard": "/World/Hazard",
+    "camera": "/World/Camera",
+    "lights": ["/World/KeyLight", "/World/FillLight"]
+  },
+  "clearance_radii_m": {"robot": 0.07, "hazard": 0.08},
+  "success_tolerance_m": 0.045,
+  "end_effector_offset": [0.0, 0.0, 0.10],
+  "max_steps": 4000
+}

server.py ADDED Viewed

	@@ -0,0 +1,561 @@

+"""Local static server and asynchronous proxy for NVIDIA Cosmos NIM."""
+from __future__ import annotations
+import argparse
+import base64
+import binascii
+import json
+import mimetypes
+import os
+import re
+import threading
+import time
+import uuid
+import zipfile
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import asdict, dataclass, field
+from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from typing import Any
+from urllib.error import HTTPError, URLError
+from urllib.parse import urlparse
+from urllib.request import Request, urlopen
+ROOT = Path(__file__).resolve().parent
+OUTPUT_DIR = ROOT / "outputs"
+ISAAC_DIR = OUTPUT_DIR / "isaac"
+TERMINAL = {"succeeded", "failed"}
+RETRYABLE_HTTP = {408, 425, 429, 500, 502, 503, 504}
+@dataclass
+class Job:
+    id: str
+    variant_id: str
+    status: str = "queued"
+    attempts: int = 0
+    max_retries: int = 2
+    progress: int = 0
+    message: str = "等待 worker"
+    output_url: str | None = None
+    error: str | None = None
+    created_at: float = field(default_factory=time.time)
+    updated_at: float = field(default_factory=time.time)
+class JobStore:
+    def __init__(self) -> None:
+        self._jobs: dict[str, Job] = {}
+        self._lock = threading.Lock()
+    def create(self, variant_id: str, max_retries: int) -> Job:
+        job = Job(id=uuid.uuid4().hex, variant_id=variant_id, max_retries=max_retries)
+        with self._lock:
+            self._jobs[job.id] = job
+        return job
+    def get(self, job_id: str) -> Job | None:
+        with self._lock:
+            return self._jobs.get(job_id)
+    def update(self, job_id: str, **changes: Any) -> Job:
+        with self._lock:
+            job = self._jobs[job_id]
+            for key, value in changes.items():
+                setattr(job, key, value)
+            job.updated_at = time.time()
+            return job
+STORE = JobStore()
+EXECUTOR = ThreadPoolExecutor(max_workers=2, thread_name_prefix="cosmos-nim")
+@dataclass
+class Evaluation:
+    id: str
+    job_id: str
+    variant_id: str
+    status: str = "queued"
+    message: str = "等待 Cosmos Reason2"
+    scores: dict[str, Any] | None = None
+    error: str | None = None
+    created_at: float = field(default_factory=time.time)
+    updated_at: float = field(default_factory=time.time)
+class EvaluationStore:
+    def __init__(self) -> None:
+        self._items: dict[str, Evaluation] = {}
+        self._lock = threading.Lock()
+    def create(self, job_id: str, variant_id: str) -> Evaluation:
+        item = Evaluation(id=uuid.uuid4().hex, job_id=job_id, variant_id=variant_id)
+        with self._lock:
+            self._items[item.id] = item
+        return item
+    def get(self, evaluation_id: str) -> Evaluation | None:
+        with self._lock:
+            return self._items.get(evaluation_id)
+    def update(self, evaluation_id: str, **changes: Any) -> Evaluation:
+        with self._lock:
+            item = self._items[evaluation_id]
+            for key, value in changes.items():
+                setattr(item, key, value)
+            item.updated_at = time.time()
+            return item
+EVALUATIONS = EvaluationStore()
+@dataclass
+class IsaacRun:
+    id: str
+    package_path: str
+    status: str = "queued"
+    backend: str = "isaac"
+    episodes_per_variant: int = 3
+    message: str = "等待 Scene Adapter"
+    telemetry: dict[str, Any] | None = None
+    result: dict[str, Any] | None = None
+    created_at: float = field(default_factory=time.time)
+    updated_at: float = field(default_factory=time.time)
+class IsaacRunStore:
+    def __init__(self) -> None:
+        self._runs: dict[str, IsaacRun] = {}
+        self._lock = threading.Lock()
+    def create(self, package_path: str, backend: str, episodes_per_variant: int) -> IsaacRun:
+        run = IsaacRun(id=uuid.uuid4().hex, package_path=package_path, backend=backend, episodes_per_variant=episodes_per_variant)
+        with self._lock:
+            self._runs[run.id] = run
+        return run
+    def get(self, run_id: str) -> IsaacRun | None:
+        with self._lock:
+            return self._runs.get(run_id)
+    def next_queued(self) -> IsaacRun | None:
+        with self._lock:
+            run = next((item for item in self._runs.values() if item.status == "queued"), None)
+            if run:
+                run.status = "running"
+                run.message = "Scene Adapter 已領取工作"
+                run.updated_at = time.time()
+            return run
+    def update(self, run_id: str, **changes: Any) -> IsaacRun:
+        with self._lock:
+            run = self._runs[run_id]
+            for key, value in changes.items():
+                setattr(run, key, value)
+            run.updated_at = time.time()
+            return run
+ISAAC_RUNS = IsaacRunStore()
+REASON_PROMPT = """Analyze this Physical AI simulation video against the intended scenario.
+Return JSON only, with integer scores from 0 to 100:
+{
+  "collision_risk": 0,
+  "physics_plausibility": 0,
+  "task_success": 0,
+  "danger_severity": 0,
+  "observed_event": "short factual observation",
+  "rationale": "short justification grounded in visible evidence",
+  "recommended_test": "one Isaac Sim validation to run next"
+}
+collision_risk and danger_severity are higher when worse; physics_plausibility
+and task_success are higher when better. Do not invent events not visible.
+Intended scenario:
+"""
+def validate_endpoint(endpoint: str) -> str:
+    parsed = urlparse(endpoint)
+    if parsed.scheme not in {"http", "https"} or not parsed.netloc:
+        raise ValueError("NIM endpoint 必須是完整的 http 或 https URL")
+    return endpoint
+def nim_health(endpoint: str, api_key: str = "", timeout: int = 10) -> dict[str, Any]:
+    parsed = urlparse(validate_endpoint(endpoint))
+    health_url = parsed._replace(path="/v1/health/ready", query="", fragment="").geturl()
+    headers = {"Accept": "application/json"}
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+    request = Request(health_url, headers=headers)
+    started = time.monotonic()
+    with urlopen(request, timeout=timeout) as response:
+        raw = response.read()
+    payload = json.loads(raw or b"{}")
+    ready = payload.get("status") == "ready" or payload.get("ready") is True
+    return {"ready": ready, "latency_ms": round((time.monotonic() - started) * 1000), "details": payload}
+def request_inference(endpoint: str, payload: dict[str, Any], api_key: str, timeout: int) -> bytes:
+    headers = {"Accept": "application/json", "Content-Type": "application/json"}
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+    request = Request(validate_endpoint(endpoint), data=json.dumps(payload).encode(), headers=headers, method="POST")
+    with urlopen(request, timeout=timeout) as response:
+        raw = response.read()
+    result = json.loads(raw)
+    if result.get("error"):
+        raise RuntimeError(str(result["error"]))
+    encoded = result.get("b64_video")
+    if not encoded:
+        raise RuntimeError("NIM response 缺少 b64_video")
+    try:
+        return base64.b64decode(encoded, validate=True)
+    except (binascii.Error, ValueError) as exc:
+        raise RuntimeError("NIM response 的 b64_video 無效") from exc
+def extract_json(text: str) -> dict[str, Any]:
+    text = re.sub(r"<think>.*?</think>", "", text, flags=re.DOTALL).strip()
+    fenced = re.search(r"```(?:json)?\s*(\{.*?\})\s*```", text, flags=re.DOTALL)
+    if fenced:
+        text = fenced.group(1)
+    else:
+        start, end = text.find("{"), text.rfind("}")
+        if start < 0 or end <= start:
+            raise RuntimeError("Reason2 response 不包含 JSON")
+        text = text[start : end + 1]
+    return json.loads(text)
+def normalize_scores(result: dict[str, Any]) -> dict[str, Any]:
+    normalized: dict[str, Any] = {}
+    for name in ["collision_risk", "physics_plausibility", "task_success", "danger_severity"]:
+        try:
+            normalized[name] = min(100, max(0, int(round(float(result[name])))))
+        except (KeyError, TypeError, ValueError) as exc:
+            raise RuntimeError(f"Reason2 response 缺少有效分數：{name}") from exc
+    normalized["observed_event"] = str(result.get("observed_event", "未提供觀察"))[:500]
+    normalized["rationale"] = str(result.get("rationale", "未提供理由"))[:1000]
+    normalized["recommended_test"] = str(result.get("recommended_test", "重播此情境並記錄最小安全距離"))[:500]
+    normalized["priority"] = round(
+        normalized["collision_risk"] * 0.30
+        + normalized["danger_severity"] * 0.30
+        + (100 - normalized["physics_plausibility"]) * 0.20
+        + (100 - normalized["task_success"]) * 0.20
+    )
+    return normalized
+def request_reason2(endpoint: str, video: bytes, scenario: dict[str, Any], api_key: str, timeout: int) -> dict[str, Any]:
+    headers = {"Accept": "application/json", "Content-Type": "application/json"}
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+    payload = {
+        "model": "nvidia/cosmos-reason2-2b",
+        "messages": [
+            {"role": "system", "content": "You are a rigorous Physical AI safety evaluator. Return structured evidence, not hidden reasoning."},
+            {"role": "user", "content": [
+                {"type": "video_url", "video_url": {"url": "data:video/mp4;base64," + base64.b64encode(video).decode()}},
+                {"type": "text", "text": REASON_PROMPT + json.dumps(scenario, ensure_ascii=False)},
+            ]},
+        ],
+        "media_io_kwargs": {"video": {"fps": 2.0}},
+        "max_tokens": 1024,
+        "temperature": 0.1,
+        "stream": False,
+    }
+    request = Request(validate_endpoint(endpoint), data=json.dumps(payload).encode(), headers=headers, method="POST")
+    with urlopen(request, timeout=timeout) as response:
+        raw = json.loads(response.read())
+    try:
+        content = raw["choices"][0]["message"]["content"]
+    except (KeyError, IndexError, TypeError) as exc:
+        raise RuntimeError("Reason2 response 缺少 choices[0].message.content") from exc
+    return normalize_scores(extract_json(content))
+def run_evaluation(evaluation_id: str, reason_endpoint: str, scenario: dict[str, Any], api_key: str, timeout: int) -> None:
+    item = EVALUATIONS.get(evaluation_id)
+    if not item:
+        return
+    job = STORE.get(item.job_id)
+    if not job or job.status != "succeeded" or not job.output_url:
+        EVALUATIONS.update(evaluation_id, status="failed", message="找不到成功的生成影片", error="generation job unavailable")
+        return
+    try:
+        EVALUATIONS.update(evaluation_id, status="running", message="Reason2 正在分析時空與物理事件")
+        video_path = ROOT / job.output_url.lstrip("/")
+        scores = request_reason2(reason_endpoint, video_path.read_bytes(), scenario, api_key, timeout)
+        EVALUATIONS.update(evaluation_id, status="succeeded", message="評分完成", scores=scores, error=None)
+    except Exception as exc:
+        EVALUATIONS.update(evaluation_id, status="failed", message="Reason2 評分失敗", error=str(exc))
+def build_isaac_package(manifest: dict[str, Any], evaluations: list[dict[str, Any]]) -> Path:
+    package_id = uuid.uuid4().hex[:12]
+    package_dir = ISAAC_DIR / package_id
+    package_dir.mkdir(parents=True, exist_ok=True)
+    by_variant = {item.get("variant_id"): item.get("scores", {}) for item in evaluations}
+    ranked = sorted(manifest.get("variants", []), key=lambda item: by_variant.get(item.get("id"), {}).get("priority", 0), reverse=True)
+    max_priority = max((by_variant.get(item.get("id"), {}).get("priority", 0) for item in ranked), default=50)
+    stress = max_priority / 100
+    randomization = {
+        "schema_version": "1.0",
+        "seed": ranked[0].get("seed", 7) if ranked else 7,
+        "source": "Cosmos Scenario Studio + Cosmos Reason2",
+        "lighting": {"intensity_lux": [round(300 - 100 * stress), round(950 + 250 * stress)], "color_temperature_k": [3500, 7000]},
+        "camera": {"translation_noise_m": [-round(0.01 + 0.02 * stress, 3), round(0.01 + 0.02 * stress, 3)], "rotation_noise_deg": [-round(1 + 3 * stress, 1), round(1 + 3 * stress, 1)]},
+        "object": {"xy_position_noise_m": [-round(0.015 + 0.04 * stress, 3), round(0.015 + 0.04 * stress, 3)], "yaw_noise_deg": [-round(8 + 16 * stress), round(8 + 16 * stress)]},
+        "physics": {"friction": [round(0.45 - 0.15 * stress, 2), 1.0], "payload_mass_kg": [0.02, round(0.06 + 0.08 * stress, 2)], "joint_damping_scale": [round(0.9 - 0.2 * stress, 2), round(1.1 + 0.2 * stress, 2)]},
+    }
+    validation = {
+        "schema_version": "1.0",
+        "policy": "fail-closed",
+        "episodes_per_variant": 25,
+        "acceptance": {"minimum_success_rate": 90, "maximum_collision_rate": 0, "minimum_clearance_m": 0.15, "maximum_joint_error_deg": 8},
+        "ranked_edge_cases": [
+            {"rank": index + 1, "variant_id": variant.get("id"), "seed": variant.get("seed"), "priority": by_variant.get(variant.get("id"), {}).get("priority"), "reason2": by_variant.get(variant.get("id"), {}), "recommended_test": by_variant.get(variant.get("id"), {}).get("recommended_test")}
+            for index, variant in enumerate(ranked)
+        ],
+    }
+    scene_mapping = {
+        "schema_version": "1.0",
+        "scene_usd": "/absolute/path/to/scene.usd",
+        "policy": "franka_pick_place",
+        "prims": {
+            "robot": "/World/Franka",
+            "collision_parent": "/World/Franka/panda_link0",
+            "task_object": "/World/TaskObject",
+            "task_target": "/World/TaskTarget",
+            "hazard": "/World/Hazard",
+            "camera": "/World/Camera",
+            "lights": ["/World/KeyLight"],
+        },
+        "clearance_radii_m": {"robot": 0.32, "hazard": 0.30},
+        "success_tolerance_m": 0.035,
+        "max_steps": 4000,
+    }
+    (package_dir / "cosmos_manifest.json").write_text(json.dumps(manifest, ensure_ascii=False, indent=2))
+    (package_dir / "domain_randomization.json").write_text(json.dumps(randomization, ensure_ascii=False, indent=2))
+    (package_dir / "policy_validation.json").write_text(json.dumps(validation, ensure_ascii=False, indent=2))
+    (package_dir / "scene_mapping.example.json").write_text(json.dumps(scene_mapping, ensure_ascii=False, indent=2))
+    archive = ISAAC_DIR / f"isaac-work-package-{package_id}.zip"
+    with zipfile.ZipFile(archive, "w", zipfile.ZIP_DEFLATED) as bundle:
+        for path in package_dir.iterdir():
+            bundle.write(path, arcname=path.name)
+    return archive
+def is_retryable(error: Exception) -> bool:
+    if isinstance(error, HTTPError):
+        return error.code in RETRYABLE_HTTP
+    return isinstance(error, (URLError, TimeoutError))
+def run_job(job_id: str, endpoint: str, payload: dict[str, Any], api_key: str, timeout: int) -> None:
+    job = STORE.get(job_id)
+    if not job:
+        return
+    OUTPUT_DIR.mkdir(exist_ok=True)
+    total_attempts = job.max_retries + 1
+    for attempt in range(1, total_attempts + 1):
+        status = "running" if attempt == 1 else "retrying"
+        STORE.update(job_id, status=status, attempts=attempt, progress=10, message=f"NIM 推論中 · 第 {attempt}/{total_attempts} 次")
+        try:
+            video = request_inference(endpoint, payload, api_key, timeout)
+            target = OUTPUT_DIR / f"{job_id}.mp4"
+            temporary = target.with_suffix(".tmp")
+            temporary.write_bytes(video)
+            temporary.replace(target)
+            STORE.update(job_id, status="succeeded", progress=100, message="影片已保存", output_url=f"/outputs/{target.name}", error=None)
+            return
+        except Exception as exc:  # background boundary: convert failures to job state
+            retry = attempt < total_attempts and is_retryable(exc)
+            if retry:
+                delay = min(8, 2 ** (attempt - 1))
+                STORE.update(job_id, status="retrying", progress=25, message=f"暫時性錯誤，{delay}s 後重試", error=str(exc))
+                time.sleep(delay)
+                continue
+            STORE.update(job_id, status="failed", progress=100, message="生成失敗", error=str(exc))
+            return
+class Handler(SimpleHTTPRequestHandler):
+    server_version = "CosmosScenarioStudio/3.0"
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, directory=str(ROOT), **kwargs)
+    def send_json(self, status: int, payload: dict[str, Any]) -> None:
+        body = json.dumps(payload, ensure_ascii=False).encode()
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json; charset=utf-8")
+        self.send_header("Content-Length", str(len(body)))
+        self.send_header("Cache-Control", "no-store")
+        self.end_headers()
+        self.wfile.write(body)
+    def read_json(self) -> dict[str, Any]:
+        length = int(self.headers.get("Content-Length", "0"))
+        if length > 2_000_000:
+            raise ValueError("request body 過大")
+        return json.loads(self.rfile.read(length) or b"{}")
+    def do_GET(self) -> None:  # noqa: N802
+        if self.path == "/api/isaac/command":
+            run = ISAAC_RUNS.next_queued()
+            if not run:
+                self.send_json(200, {"type": "idle"})
+                return
+            self.send_json(200, {"type": "run", "run_id": run.id, "package_path": run.package_path, "backend": run.backend, "episodes_per_variant": run.episodes_per_variant})
+            return
+        if self.path.startswith("/api/isaac/runs/"):
+            run_id = self.path.removeprefix("/api/isaac/runs/").split("/", 1)[0].split("?", 1)[0]
+            run = ISAAC_RUNS.get(run_id)
+            if not run:
+                self.send_json(404, {"error": "Isaac run not found"})
+                return
+            self.send_json(200, asdict(run))
+            return
+        if self.path.startswith("/api/evaluations/"):
+            evaluation_id = self.path.removeprefix("/api/evaluations/").split("?", 1)[0]
+            item = EVALUATIONS.get(evaluation_id)
+            if not item:
+                self.send_json(404, {"error": "evaluation not found"})
+                return
+            self.send_json(200, asdict(item))
+            return
+        if self.path.startswith("/api/jobs/"):
+            job_id = self.path.removeprefix("/api/jobs/").split("?", 1)[0]
+            job = STORE.get(job_id)
+            if not job:
+                self.send_json(404, {"error": "job not found"})
+                return
+            self.send_json(200, asdict(job))
+            return
+        super().do_GET()
+    def do_POST(self) -> None:  # noqa: N802
+        try:
+            body = self.read_json()
+            if self.path == "/api/nim/health":
+                result = nim_health(body.get("endpoint", ""), body.get("api_key", ""))
+                self.send_json(200, result)
+                return
+            if self.path == "/api/jobs":
+                endpoint = validate_endpoint(body.get("endpoint", ""))
+                payload = body.get("payload")
+                if not isinstance(payload, dict) or not str(payload.get("prompt", "")).strip():
+                    raise ValueError("payload.prompt 為必填")
+                retries = min(3, max(0, int(body.get("max_retries", 2))))
+                timeout = min(1800, max(60, int(body.get("timeout_seconds", 900))))
+                job = STORE.create(str(body.get("variant_id", "world")), retries)
+                EXECUTOR.submit(run_job, job.id, endpoint, payload, body.get("api_key", ""), timeout)
+                self.send_json(202, asdict(job))
+                return
+            if self.path == "/api/evaluations":
+                job = STORE.get(str(body.get("job_id", "")))
+                if not job or job.status != "succeeded":
+                    raise ValueError("只接受已成功生成影片的 job")
+                reason_endpoint = validate_endpoint(body.get("reason_endpoint", ""))
+                scenario = body.get("scenario", {})
+                if not isinstance(scenario, dict):
+                    raise ValueError("scenario 必須是 object")
+                item = EVALUATIONS.create(job.id, job.variant_id)
+                timeout = min(900, max(30, int(body.get("timeout_seconds", 300))))
+                EXECUTOR.submit(run_evaluation, item.id, reason_endpoint, scenario, body.get("api_key", ""), timeout)
+                self.send_json(202, asdict(item))
+                return
+            if self.path == "/api/isaac/export":
+                manifest = body.get("manifest")
+                evaluations = body.get("evaluations")
+                if not isinstance(manifest, dict) or not isinstance(evaluations, list):
+                    raise ValueError("manifest 與 evaluations 為必填")
+                archive = build_isaac_package(manifest, evaluations)
+                self.send_json(201, {"download_url": f"/outputs/isaac/{archive.name}", "filename": archive.name})
+                return
+            if self.path == "/api/isaac/runs":
+                package_url = str(body.get("package_url", ""))
+                if not package_url.startswith("/outputs/isaac/") or not package_url.endswith(".zip"):
+                    raise ValueError("package_url 必須是 Studio 產生的 Isaac ZIP")
+                package_path = (ROOT / package_url.lstrip("/")).resolve()
+                if not package_path.is_file() or ISAAC_DIR.resolve() not in package_path.parents:
+                    raise ValueError("Isaac 工作包不存在")
+                backend = str(body.get("backend", "isaac"))
+                if backend not in {"isaac", "contract"}:
+                    raise ValueError("backend must be isaac or contract")
+                episodes = min(100, max(1, int(body.get("episodes_per_variant", 3))))
+                run = ISAAC_RUNS.create(str(package_path), backend, episodes)
+                self.send_json(202, asdict(run))
+                return
+            if self.path.startswith("/api/isaac/runs/") and self.path.endswith("/telemetry"):
+                run_id = self.path.removeprefix("/api/isaac/runs/").removesuffix("/telemetry")
+                run = ISAAC_RUNS.get(run_id)
+                if not run:
+                    self.send_json(404, {"error": "Isaac run not found"})
+                    return
+                ISAAC_RUNS.update(run_id, status="running", message=f"Episode {body.get('episode', '?')} · {body.get('phase', 'running')}", telemetry=body)
+                self.send_json(200, asdict(ISAAC_RUNS.get(run_id)))
+                return
+            if self.path.startswith("/api/isaac/runs/") and self.path.endswith("/result"):
+                run_id = self.path.removeprefix("/api/isaac/runs/").removesuffix("/result")
+                run = ISAAC_RUNS.get(run_id)
+                if not run:
+                    self.send_json(404, {"error": "Isaac run not found"})
+                    return
+                required = {"success_rate", "collision_rate", "minimum_clearance_m", "status"}
+                if not required.issubset(body):
+                    raise ValueError("Isaac result 缺少必要指標")
+                run_status = "failed" if body.get("status") == "error" else "succeeded"
+                ISAAC_RUNS.update(run_id, status=run_status, message="Isaac 驗證完成" if run_status == "succeeded" else "Isaac Scene Adapter 錯誤", result=body)
+                self.send_json(200, asdict(ISAAC_RUNS.get(run_id)))
+                return
+            if self.path.startswith("/api/jobs/") and self.path.endswith("/retry"):
+                job_id = self.path.removeprefix("/api/jobs/").removesuffix("/retry")
+                old = STORE.get(job_id)
+                if not old or old.status != "failed":
+                    self.send_json(409, {"error": "only failed jobs can be retried"})
+                    return
+                endpoint = validate_endpoint(body.get("endpoint", ""))
+                payload = body.get("payload", {})
+                job = STORE.create(old.variant_id, min(3, max(0, int(body.get("max_retries", 2)))))
+                EXECUTOR.submit(run_job, job.id, endpoint, payload, body.get("api_key", ""), int(body.get("timeout_seconds", 900)))
+                self.send_json(202, asdict(job))
+                return
+            self.send_json(404, {"error": "not found"})
+        except HTTPError as exc:
+            self.send_json(502, {"error": f"NIM health HTTP {exc.code}"})
+        except (URLError, TimeoutError) as exc:
+            self.send_json(502, {"error": f"無法連線 NIM：{exc}"})
+        except (ValueError, TypeError, json.JSONDecodeError) as exc:
+            self.send_json(400, {"error": str(exc)})
+        except Exception as exc:
+            self.send_json(500, {"error": str(exc)})
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Cosmos Scenario Studio server")
+    parser.add_argument("--host", default=os.environ.get("COSMOS_STUDIO_HOST", "127.0.0.1"))
+    parser.add_argument("--port", type=int, default=int(os.environ.get("COSMOS_STUDIO_PORT", "8090")))
+    args = parser.parse_args()
+    server = ThreadingHTTPServer((args.host, args.port), Handler)
+    print(f"Cosmos Scenario Studio: http://{args.host}:{args.port}")
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        server.server_close()
+        EXECUTOR.shutdown(wait=False, cancel_futures=True)
+if __name__ == "__main__":
+    main()

styles.css ADDED Viewed

	@@ -0,0 +1,129 @@

+:root {
+  --ink: #f1f4ed;
+  --muted: #929a8f;
+  --bg: #070a08;
+  --panel: #0d110e;
+  --line: #252b26;
+  --green: #76b900;
+  --acid: #b7ff38;
+  --warn: #ffb548;
+}
+* { box-sizing: border-box; }
+html { scroll-behavior: smooth; }
+body { margin: 0; background: var(--bg); color: var(--ink); font-family: Inter, ui-sans-serif, system-ui, -apple-system, sans-serif; }
+button, input, textarea, select { font: inherit; }
+button { color: inherit; }
+.topbar { height: 72px; padding: 0 4vw; border-bottom: 1px solid var(--line); display: flex; align-items: center; justify-content: space-between; position: sticky; top: 0; z-index: 10; background: rgba(7,10,8,.9); backdrop-filter: blur(14px); }
+.brand { display: flex; gap: 12px; align-items: center; color: var(--ink); text-decoration: none; font-size: 12px; font-weight: 800; line-height: 1.05; letter-spacing: .14em; }
+.brand small { color: var(--muted); font-size: 8px; }
+.brand-mark { width: 34px; height: 34px; background: var(--green); color: #081000; display: grid; place-items: center; font-size: 20px; font-weight: 900; transform: skew(-8deg); }
+nav { display: flex; gap: 30px; }
+nav a { color: var(--muted); text-decoration: none; font-size: 12px; }
+nav a:hover { color: var(--acid); }
+.system-status { color: var(--muted); font: 10px ui-monospace, monospace; display: flex; align-items: center; gap: 8px; }
+.system-status i { width: 7px; height: 7px; border-radius: 50%; background: var(--green); box-shadow: 0 0 12px var(--green); }
+main { width: min(1600px, 94vw); margin: auto; }
+.hero { min-height: 340px; padding: 70px 1vw 55px; display: grid; grid-template-columns: 1.5fr .8fr; gap: 8vw; align-items: end; }
+.eyebrow, .step { color: var(--green); font: 600 10px ui-monospace, monospace; letter-spacing: .18em; }
+h1 { font-size: clamp(50px, 6.4vw, 100px); line-height: .88; letter-spacing: -.065em; margin: 18px 0 0; }
+h1 em { font-style: normal; color: transparent; -webkit-text-stroke: 1px #838b80; }
+.hero-copy { color: #b8bfb5; line-height: 1.8; font-size: 15px; max-width: 520px; border-left: 1px solid var(--green); padding-left: 25px; }
+.release-strip { display: grid; grid-template-columns: repeat(4,1fr); border: 1px solid var(--line); margin: 0 0 24px; background: var(--panel); }
+.release-strip article { min-height: 112px; padding: 20px; border-right: 1px solid var(--line); }
+.release-strip article:last-child { border-right: 0; }
+.release-strip span { display: block; color: var(--green); font: 9px ui-monospace, monospace; letter-spacing: .12em; }
+.release-strip strong { display: block; margin: 12px 0 7px; font-size: 15px; }
+.release-strip small { color: var(--muted); font-size: 10px; line-height: 1.5; }
+.release-strip .boundary { background: rgba(255,181,72,.045); }
+.release-strip .boundary span { color: var(--warn); }
+.workspace { display: grid; grid-template-columns: minmax(280px, .9fr) minmax(430px, 1.6fr) minmax(280px, .85fr); border: 1px solid var(--line); }
+.panel { background: var(--panel); min-width: 0; }
+.panel + .panel { border-left: 1px solid var(--line); }
+.composer, .dataset { padding: 24px; }
+.world { padding: 24px; background: #0a0d0b; }
+.panel-head { min-height: 55px; display: flex; justify-content: space-between; align-items: flex-start; gap: 15px; margin-bottom: 20px; }
+.panel-head p { margin: 0 0 7px; }
+h2 { margin: 0; font-size: 22px; letter-spacing: -.035em; }
+.icon-button { border: 1px solid var(--line); background: transparent; width: 36px; height: 36px; cursor: pointer; }
+.presets, .mode-tabs { display: grid; grid-template-columns: repeat(3, 1fr); border: 1px solid var(--line); margin-bottom: 20px; }
+.presets button, .mode-tabs button { border: 0; border-right: 1px solid var(--line); padding: 10px 5px; background: #090c0a; color: var(--muted); cursor: pointer; font-size: 11px; }
+.presets button:last-child, .mode-tabs button:last-child { border: 0; }
+.presets button.active, .mode-tabs button.active { background: var(--green); color: #071000; font-weight: 800; }
+form label, .nim-config label { display: block; color: #aab1a7; font-size: 10px; text-transform: uppercase; letter-spacing: .08em; margin-bottom: 12px; }
+input, textarea, select { width: 100%; margin-top: 6px; border: 1px solid var(--line); background: #080b09; color: var(--ink); padding: 10px 11px; outline: none; resize: vertical; border-radius: 0; }
+input:focus, textarea:focus, select:focus { border-color: var(--green); box-shadow: 0 0 0 1px rgba(118,185,0,.2); }
+.form-grid { display: grid; grid-template-columns: 1fr 1fr; gap: 0 10px; }
+.primary, .secondary { width: 100%; min-height: 44px; border: 0; cursor: pointer; font-weight: 800; font-size: 11px; letter-spacing: .08em; }
+.primary { background: var(--green); color: #071000; display: flex; justify-content: center; align-items: center; gap: 20px; }
+.primary b { font: 10px ui-monospace, monospace; opacity: .6; }
+.primary:disabled { opacity: .28; cursor: not-allowed; }
+.secondary { background: transparent; border: 1px solid var(--line); margin-top: 8px; }
+.form-error { color: #ffbd6e; background: rgba(255,181,72,.08); border-left: 2px solid var(--warn); padding: 10px; font-size: 11px; margin-bottom: 12px; line-height: 1.5; }
+.model-pill, #queue-count { font: 9px ui-monospace, monospace; padding: 6px 8px; border: 1px solid #33402e; color: var(--acid); white-space: nowrap; }
+.viewport { height: 450px; position: relative; overflow: hidden; background: radial-gradient(circle at 60% 25%, #445329 0, #182011 20%, #080b08 65%); border: 1px solid #283124; perspective: 800px; }
+.scanlines { position: absolute; inset: 0; z-index: 4; pointer-events: none; opacity: .13; background: repeating-linear-gradient(0deg, transparent 0 3px, #b6ff7f 4px); }
+.warehouse-scene { position: absolute; inset: 0; overflow: hidden; }
+.warehouse-scene:after { content: ""; position: absolute; left: 18%; right: 18%; bottom: -15%; height: 65%; background: linear-gradient(120deg, #232a20, #0e120e); transform: perspective(300px) rotateX(35deg); border: 1px solid #3e4938; }
+.shelf { position: absolute; width: 24%; height: 72%; top: 15%; z-index: 2; background: repeating-linear-gradient(0deg, #151b14 0 18%, #5f6d56 19% 20%), repeating-linear-gradient(90deg, transparent 0 28%, #4b5644 29% 32%); border: 2px solid #5b6753; box-shadow: 0 15px 40px #000; }
+.shelf:after { content: ""; position: absolute; inset: 5% 10%; background: repeating-linear-gradient(0deg, transparent 0 21%, rgba(118,185,0,.35) 22% 26%); }
+.shelf-a { left: -3%; transform: skewY(3deg); }
+.shelf-b { right: -3%; transform: skewY(-3deg); }
+.floor-line { position: absolute; bottom: -10%; width: 2px; height: 65%; background: var(--green); opacity: .45; z-index: 3; transform-origin: bottom; }
+.floor-line.one { left: 38%; transform: rotate(13deg); }.floor-line.two { right: 38%; transform: rotate(-13deg); }
+.robot { width: 74px; height: 58px; position: absolute; bottom: 18%; left: 43%; z-index: 5; background: #9bad86; border: 3px solid #dce8d2; clip-path: polygon(10% 0,85% 0,100% 70%,80% 100%,10% 100%,0 65%); box-shadow: 0 0 28px rgba(183,255,56,.2); }
+.robot i { position: absolute; width: 26px; height: 12px; background: #111; left: 24px; top: 9px; border: 2px solid var(--green); }
+.robot span { position: absolute; width: 6px; height: 34px; background: #708060; left: 35px; bottom: 100%; }
+.human { position: absolute; right: 30%; bottom: 25%; z-index: 5; width: 18px; height: 55px; background: #bd6c3c; clip-path: polygon(30% 0,70% 0,100% 45%,75% 100%,25% 100%,0 45%); }
+.human i { position: absolute; width: 15px; height: 15px; border-radius: 50%; background: #c4a189; top: -14px; left: 2px; }
+.hazard-zone { position: absolute; width: 110px; height: 60px; border: 1px solid var(--warn); right: 24%; bottom: 17%; z-index: 4; transform: skewX(-20deg); animation: pulse 2s infinite; }
+.view-hud { position: absolute; left: 15px; right: 15px; z-index: 6; display: flex; justify-content: space-between; font: 9px ui-monospace, monospace; color: #d6dfcf; }
+.hud-top { top: 14px; }.hud-bottom { bottom: 12px; }.hud-bottom i { display: inline-block; width: 6px; height: 6px; background: var(--green); border-radius: 50%; margin-right: 5px; }
+.play { position: absolute; z-index: 7; left: 50%; top: 50%; transform: translate(-50%,-50%); width: 58px; height: 58px; border-radius: 50%; border: 1px solid rgba(255,255,255,.5); background: rgba(5,8,6,.62); backdrop-filter: blur(8px); cursor: pointer; }
+.playing .robot { animation: robotMove 3s ease-in-out infinite alternate; }
+.playing .human { animation: humanMove 2.4s ease-in-out infinite alternate; }
+.risk-strip { display: grid; grid-template-columns: 90px 1fr auto; gap: 15px; align-items: center; margin: 18px 0; }
+.risk-strip span { color: var(--muted); font-size: 9px; display: block; }.risk-strip strong { font-size: 24px; }
+.risk-bar { height: 4px; background: #222a21; }.risk-bar i { display: block; height: 100%; background: linear-gradient(90deg,var(--green),var(--warn)); transition: width .4s; }
+.risk-strip p { color: var(--muted); font: 9px ui-monospace, monospace; }
+.prompt-block { border: 1px solid var(--line); background: #080b09; }
+.prompt-head { border-bottom: 1px solid var(--line); padding: 8px 12px; display: flex; justify-content: space-between; color: var(--green); font: 9px ui-monospace, monospace; }
+.prompt-head button { border: 0; background: transparent; color: var(--muted); cursor: pointer; font-size: 9px; }
+.prompt-block p { margin: 0; padding: 14px; color: #aab2a7; font: 10px/1.7 ui-monospace, monospace; max-height: 105px; overflow: auto; }
+.mode-tabs { grid-template-columns: 1fr 1fr; }
+.nim-config { padding: 12px; border: 1px solid var(--line); margin-bottom: 12px; }
+.nim-health { display: flex; align-items: center; justify-content: space-between; margin-bottom: 12px; font: 9px ui-monospace, monospace; }
+.nim-health span { display: flex; align-items: center; gap: 7px; }.nim-health i { width: 7px; height: 7px; background: #596157; border-radius: 50%; display: inline-block; }.nim-health i.ready { background: var(--green); box-shadow: 0 0 8px var(--green); }.nim-health i.failed { background: #ff675f; }
+.nim-health button { border: 1px solid var(--line); background: transparent; color: var(--muted); padding: 6px 9px; cursor: pointer; font-size: 9px; }
+.retry-grid { display: grid; grid-template-columns: 1fr 1fr; gap: 10px; }
+.empty-queue { height: 300px; display: grid; place-content: center; text-align: center; color: var(--muted); }
+.empty-queue span { color: #394136; font-size: 54px; }.empty-queue p { margin: 8px 0 3px; color: #c4cbc1; }.empty-queue small { font-size: 10px; }
+.queue { height: 300px; overflow: auto; border-top: 1px solid var(--line); }
+.queue-item { display: grid; grid-template-columns: 30px 1fr auto; align-items: center; gap: 8px; border-bottom: 1px solid var(--line); padding: 12px 5px; }
+.queue-index { color: #596157; font: 10px ui-monospace, monospace; }.queue-item strong { display: block; font-size: 11px; }.queue-item small { color: var(--muted); font: 8px ui-monospace, monospace; }.queue-item b { font: 8px ui-monospace, monospace; color: var(--muted); }
+.queue-item.running b { color: var(--warn); }.queue-item.complete b, .queue-item.succeeded b { color: var(--green); }.queue-item.failed b { color: #ff675f; }
+.queue-item.retrying b { color: var(--warn); }.queue-item { cursor: default; }.queue-item.complete, .queue-item.succeeded, .queue-item.failed { cursor: pointer; }.queue-item em { display: block; color: #6e766c; font: 8px ui-monospace, monospace; font-style: normal; margin-top: 3px; }
+.result-player { border: 1px solid var(--line); margin-top: 14px; background: #050705; }.result-head { display: flex; justify-content: space-between; padding: 8px 10px; border-bottom: 1px solid var(--line); font: 8px ui-monospace, monospace; color: var(--green); }.result-head a { color: var(--muted); text-decoration: none; }.result-player video { width: 100%; display: block; max-height: 230px; background: #000; }
+.dataset-actions { margin-top: 18px; }
+.privacy-note { color: #60675f; font-size: 9px; line-height: 1.5; }
+.architecture { padding: 90px 1vw; }
+.analysis-lab { margin-top: 40px; border: 1px solid var(--line); display: grid; grid-template-columns: .75fr 1.6fr; background: var(--panel); }
+.analysis-copy { padding: 34px; border-right: 1px solid var(--line); }.analysis-copy h2 { font-size: clamp(28px,3vw,46px); line-height: 1.05; max-width: 520px; }.analysis-copy > p:last-child { color: var(--muted); line-height: 1.7; font-size: 12px; max-width: 480px; }
+.reason-panel { padding: 24px; }.reason-config { display: grid; grid-template-columns: 1fr 1fr auto; gap: 12px; align-items: end; }.reason-config label { color: var(--muted); font-size: 9px; text-transform: uppercase; letter-spacing: .08em; }.reason-config input { margin-top: 6px; }.reason-config .auto-evaluate { display: flex; align-items: center; gap: 8px; height: 42px; white-space: nowrap; }.auto-evaluate input { width: auto; margin: 0; accent-color: var(--green); }
+.reason-actions { display: grid; grid-template-columns: 1fr 1fr; gap: 10px; margin: 16px 0; }.reason-actions .secondary { margin: 0; }
+.isaac-runner { display: grid; grid-template-columns: 1fr 1fr 1.2fr; gap: 10px; align-items: end; margin: 16px 0; padding: 14px; border: 1px solid var(--line); }.isaac-runner label { color: var(--muted); font-size: 9px; text-transform: uppercase; letter-spacing: .08em; }.isaac-runner .secondary { margin: 0; }
+.isaac-result { display: grid; grid-template-columns: repeat(4,1fr); gap: 1px; background: var(--line); border: 1px solid var(--line); margin-bottom: 16px; }.isaac-result article { background: #090c0a; padding: 12px; }.isaac-result span { color: var(--muted); display: block; font: 8px ui-monospace, monospace; }.isaac-result strong { display: block; margin-top: 6px; font-size: 18px; }.isaac-result .passed strong { color: var(--green); }.isaac-result .failed strong { color: #ff675f; }
+.ranking-empty { border: 1px dashed #30362f; color: #697066; min-height: 170px; display: grid; place-items: center; text-align: center; font-size: 11px; }
+.ranking { border-top: 1px solid var(--line); }.rank-row { display: grid; grid-template-columns: 36px 1fr 66px; gap: 12px; padding: 14px 5px; border-bottom: 1px solid var(--line); align-items: center; }.rank-row > b { color: var(--green); font: 12px ui-monospace, monospace; }.rank-row h3 { margin: 0 0 7px; font-size: 13px; }.score-grid { display: grid; grid-template-columns: repeat(4, minmax(70px,1fr)); gap: 7px; }.score-grid span { color: var(--muted); font: 8px ui-monospace, monospace; }.score-grid strong { color: var(--ink); display: block; font-size: 13px; margin-top: 2px; }.rank-reason { color: #777f75; font-size: 9px; line-height: 1.5; margin: 8px 0 0; }.priority { width: 58px; height: 58px; border-radius: 50%; border: 1px solid var(--green); display: grid; place-items: center; text-align: center; color: var(--acid); font: 17px ui-monospace, monospace; }.priority small { display: block; font-size: 6px; color: var(--muted); }
+.flow { display: grid; grid-template-columns: 1fr auto 1fr auto 1fr auto 1fr; gap: 20px; align-items: center; margin-top: 25px; }
+.flow article { border-top: 1px solid var(--line); padding-top: 18px; }.flow b { color: var(--green); font: 10px ui-monospace, monospace; display: block; margin-bottom: 25px; }.flow span { font-size: 17px; display: block; }.flow small { color: var(--muted); }.flow > i { color: #465043; }
+footer { border-top: 1px solid var(--line); padding: 25px 4vw; display: flex; justify-content: space-between; color: #697066; font: 9px ui-monospace, monospace; }
+@keyframes pulse { 50% { opacity: .3; } }
+@keyframes robotMove { to { transform: translate(80px,-25px) scale(.85); } }
+@keyframes humanMove { to { transform: translate(-55px,8px); } }
+@media (max-width: 1100px) {
+  .release-strip { grid-template-columns: 1fr 1fr; }.release-strip article:nth-child(2) { border-right: 0; }.release-strip article:nth-child(-n+2) { border-bottom: 1px solid var(--line); }.workspace { grid-template-columns: 1fr 1.5fr; }.dataset { grid-column: 1 / -1; border-left: 0 !important; border-top: 1px solid var(--line); }.queue, .empty-queue { height: 220px; }
+}
+@media (max-width: 720px) {
+  nav { display: none; }.system-status span { display: none; }.hero { grid-template-columns: 1fr; min-height: 420px; }.release-strip { grid-template-columns: 1fr; }.release-strip article { border-right: 0; border-bottom: 1px solid var(--line); }.release-strip article:last-child { border-bottom: 0; }.workspace { display: block; }.panel + .panel { border-left: 0; border-top: 1px solid var(--line); }.viewport { height: 390px; }.risk-strip { grid-template-columns: 80px 1fr; }.risk-strip p { grid-column: 1 / -1; margin: 0; }.analysis-lab { display: block; }.analysis-copy { border-right: 0; border-bottom: 1px solid var(--line); }.reason-config, .isaac-runner { grid-template-columns: 1fr; }.isaac-result { grid-template-columns: 1fr 1fr; }.score-grid { grid-template-columns: 1fr 1fr; }.flow { grid-template-columns: 1fr; }.flow > i { transform: rotate(90deg); justify-self: center; }.architecture { padding: 60px 2vw; } footer { gap: 20px; }
+}

test_server.py ADDED Viewed

	@@ -0,0 +1,101 @@

+import base64
+import json
+import tempfile
+import unittest
+import zipfile
+from pathlib import Path
+from unittest.mock import patch
+import server
+from isaac_adapter.contracts import EpisodeResult, aggregate_results, sample_episode, validate_mapping
+from isaac_adapter.calibration import build_calibration_report
+class ServerTests(unittest.TestCase):
+    def setUp(self):
+        server.STORE = server.JobStore()
+        server.EVALUATIONS = server.EvaluationStore()
+        server.ISAAC_RUNS = server.IsaacRunStore()
+    def test_validate_endpoint(self):
+        self.assertEqual(server.validate_endpoint("http://127.0.0.1:8000/v1/infer"), "http://127.0.0.1:8000/v1/infer")
+        with self.assertRaises(ValueError):
+            server.validate_endpoint("file:///tmp/video")
+    def test_job_store_lifecycle(self):
+        job = server.STORE.create("world-01", 2)
+        server.STORE.update(job.id, status="running", attempts=1)
+        self.assertEqual(server.STORE.get(job.id).status, "running")
+        self.assertEqual(server.STORE.get(job.id).attempts, 1)
+    def test_run_job_saves_video(self):
+        job = server.STORE.create("world-01", 0)
+        with tempfile.TemporaryDirectory() as temp, patch.object(server, "OUTPUT_DIR", Path(temp)), patch.object(
+            server, "request_inference", return_value=b"valid-mp4-bytes"
+        ):
+            server.run_job(job.id, "http://nim/v1/infer", {"prompt": "robot"}, "", 60)
+            result = server.STORE.get(job.id)
+            self.assertEqual(result.status, "succeeded")
+            self.assertEqual((Path(temp) / f"{job.id}.mp4").read_bytes(), b"valid-mp4-bytes")
+    def test_non_retryable_failure_stops(self):
+        job = server.STORE.create("world-01", 2)
+        with patch.object(server, "request_inference", side_effect=RuntimeError("bad response")) as request:
+            server.run_job(job.id, "http://nim/v1/infer", {"prompt": "robot"}, "", 60)
+        self.assertEqual(server.STORE.get(job.id).status, "failed")
+        self.assertEqual(request.call_count, 1)
+    def test_extract_and_normalize_reason_scores(self):
+        parsed = server.extract_json('<think>hidden</think>```json\n{"collision_risk":90,"physics_plausibility":70,"task_success":20,"danger_severity":80}\n```')
+        scores = server.normalize_scores(parsed)
+        self.assertEqual(scores["priority"], 73)
+        self.assertEqual(scores["collision_risk"], 90)
+    def test_isaac_package_contains_contracts(self):
+        manifest = {"variants": [{"id": "world-01", "seed": 7, "request": {"prompt": "robot"}}]}
+        evaluations = [{"variant_id": "world-01", "scores": {"priority": 75, "recommended_test": "clearance"}}]
+        with tempfile.TemporaryDirectory() as temp, patch.object(server, "ISAAC_DIR", Path(temp)):
+            archive = server.build_isaac_package(manifest, evaluations)
+            with zipfile.ZipFile(archive) as bundle:
+                self.assertEqual(set(bundle.namelist()), {"cosmos_manifest.json", "domain_randomization.json", "policy_validation.json", "scene_mapping.example.json"})
+                validation = json.loads(bundle.read("policy_validation.json"))
+                self.assertEqual(validation["ranked_edge_cases"][0]["priority"], 75)
+    def test_scene_mapping_and_episode_aggregation(self):
+        validate_mapping({"prims": {"robot": "/World/R", "task_object": "/World/O", "task_target": "/World/T", "hazard": "/World/H", "camera": "/World/C"}})
+        randomization = {
+            "lighting": {"intensity_lux": [300, 900], "color_temperature_k": [3500, 7000]},
+            "camera": {"translation_noise_m": [-0.01, 0.01], "rotation_noise_deg": [-2, 2]},
+            "object": {"xy_position_noise_m": [-0.02, 0.02], "yaw_noise_deg": [-10, 10]},
+            "physics": {"friction": [0.4, 1.0], "payload_mass_kg": [0.02, 0.1], "joint_damping_scale": [0.8, 1.2]},
+        }
+        self.assertEqual(sample_episode(randomization, 7), sample_episode(randomization, 7))
+        result = aggregate_results([EpisodeResult(1, "world-01", True, False, 0.2, 0.02, 1.0, 7)], {"minimum_success_rate": 90, "maximum_collision_rate": 0, "minimum_clearance_m": 0.15})
+        self.assertEqual(result["status"], "passed")
+    def test_warehouse_mapping_covers_full_franka_chain(self):
+        mapping = json.loads((Path(__file__).parent / "scene_mapping.warehouse.json").read_text())
+        validate_mapping(mapping)
+        self.assertEqual(len(mapping["prims"]["collision_parents"]), 9)
+        self.assertIn("/World/Franka/panda_hand", mapping["prims"]["collision_parents"])
+    def test_calibration_report_preserves_safety_policy(self):
+        metrics = aggregate_results(
+            [EpisodeResult(1, "world-01", False, False, 0.2, 0.08, 4.0, 7, False, 4000)],
+            {"minimum_success_rate": 90, "maximum_collision_rate": 0, "minimum_clearance_m": 0.15},
+        )
+        report = build_calibration_report(metrics, {"end_effector_offset": [0, 0, 0.1], "success_tolerance_m": 0.045})
+        self.assertEqual(report["findings"][0]["code"], "controller_timeout")
+        self.assertEqual(len(report["mapping_candidates"]), 3)
+        self.assertFalse(report["safety_policy_changed"])
+    def test_isaac_run_claim_is_atomic(self):
+        run = server.ISAAC_RUNS.create("/tmp/package.zip", "contract", 3)
+        claimed = server.ISAAC_RUNS.next_queued()
+        self.assertEqual(claimed.id, run.id)
+        self.assertEqual(claimed.status, "running")
+        self.assertIsNone(server.ISAAC_RUNS.next_queued())
+if __name__ == "__main__":
+    unittest.main()