ape-claw 0.1.6 → 0.1.8

package/ui/forge/js/forge-data.js

@@ -32,6 +32,12 @@ let currentAttachments = [];
 let searchPage = 1;
 let searchTotal = 0;
 const SEARCH_LIMIT = 30;
+let dragDropInstallBound = false;
+
+function isHostedForge() {
+  const host = String(window.location.hostname || "");
+  return host.includes("apeclaw.ai") || host.includes("vercel.app") || host.includes("railway.app");
+}
 
 /* ══════════════════════════════════════════════════════════
    Fetch helpers
@@ -165,23 +171,27 @@ function inferCategory(skill) {
 }
 
 /* ══════════════════════════════════════════════════════════
-   Load installed skills (seed + user only — NOT the catalog)
+   Load installed skills (OpenClaw files + user index)
    The full 10K+ catalog is for the browser drawer, not the robot.
    ══════════════════════════════════════════════════════════ */
 async function loadInstalledSkills() {
-  const [seedRes, userRes, starterRes] = await Promise.all([
+  const [seedRes, userRes, starterRes, openclawRes] = await Promise.all([
     fetchJSON("/api/skills/search?source=seed&limit=500", {}, { retries: 1 }),
     fetchJSON("/api/skillcards/user", {}, { retries: 1 }),
     fetchJSON("/api/pod/starter-pack", {}, { retries: 1, timeoutMs: 12000 }),
+    isHostedForge()
+      ? Promise.resolve(null)
+      : fetchJSON("/api/skills/openclaw-installed?limit=2000", {}, { retries: 1, timeoutMs: 10000 }),
   ]);
 
   const seedSkills = seedRes?.results || [];
   const userSkills = (userRes?.skills || []).map(s => ({ ...s, source: "user" }));
   const starterSkills = (starterRes?.skills || []).map(s => ({ ...s, source: "starter-pack" }));
+  const openclawSkills = (openclawRes?.skills || []).map(s => ({ ...s, source: "openclaw-installed" }));
 
   const seen = new Set();
   const merged = [];
-  for (const s of [...seedSkills, ...starterSkills, ...userSkills]) {
+  for (const s of [...openclawSkills, ...userSkills, ...starterSkills, ...seedSkills]) {
     if (s.slug && !seen.has(s.slug)) {
       seen.add(s.slug);
       merged.push(s);
@@ -404,10 +414,6 @@ function refreshIdentityStatus() {
 async function installSkill(skill) {
   saveAuth();
   const headers = authHeaders();
-  if (!headers["x-agent-id"]) {
-    toast("Enter Agent ID and Token to install skills", "error");
-    return;
-  }
 
   toast(`Installing ${skill.name || skill.slug}...`, "info", 2000);
 
@@ -451,10 +457,6 @@ async function installSkill(skill) {
 async function uninstallSkill(fileName, displayName) {
   saveAuth();
   const headers = authHeaders();
-  if (!headers["x-agent-id"]) {
-    toast("Enter Agent ID and Token to uninstall skills", "error");
-    return;
-  }
 
   if (!confirm(`Uninstall "${displayName}"? This will remove the skill from your agent.`)) return;
 
@@ -581,6 +583,285 @@ function initSkillBrowser() {
   document.getElementById("forgeFilterOnchain")?.addEventListener("change", () => { searchPage = 1; searchSkills(); });
   document.getElementById("forgeFilterRisk")?.addEventListener("change", () => { searchPage = 1; searchSkills(); });
   document.getElementById("forgeFilterSource")?.addEventListener("change", () => { searchPage = 1; searchSkills(); });
+  initSkillDragDropInstall();
+}
+
+function initSkillDragDropInstall() {
+  if (dragDropInstallBound) return;
+  const viewport = document.getElementById("forgeViewport");
+  if (!viewport) return;
+  dragDropInstallBound = true;
+
+  function clearDropState() {
+    viewport.classList.remove("forge-drop-active");
+  }
+
+  viewport.addEventListener("dragenter", (e) => {
+    const slug = e.dataTransfer?.getData("text/forge-skill-slug");
+    if (!slug) return;
+    e.preventDefault();
+    viewport.classList.add("forge-drop-active");
+  });
+
+  viewport.addEventListener("dragover", (e) => {
+    const hasSkillSlug = Array.from(e.dataTransfer?.types || []).includes("text/forge-skill-slug");
+    if (!hasSkillSlug) return;
+    e.preventDefault();
+    e.dataTransfer.dropEffect = "copy";
+    viewport.classList.add("forge-drop-active");
+  });
+
+  viewport.addEventListener("dragleave", (e) => {
+    if (!viewport.contains(e.relatedTarget)) clearDropState();
+  });
+
+  viewport.addEventListener("drop", async (e) => {
+    const slug = e.dataTransfer?.getData("text/forge-skill-slug");
+    clearDropState();
+    if (!slug) return;
+    e.preventDefault();
+    const skill = allLibrarySkills.find((s) => s.slug === slug);
+    if (!skill) {
+      toast("Could not resolve dropped skill", "error");
+      return;
+    }
+    if (isInstalled(skill.slug)) {
+      toast(`${skill.name || skill.slug} is already installed`, "info");
+      return;
+    }
+    await installSkill(skill);
+  });
+}
+
+/* ══════════════════════════════════════════════════════════
+   OpenClaw env editor (top-right HUD button)
+   ══════════════════════════════════════════════════════════ */
+const OPENCLAW_ENV_FIELDS = [
+  { key: "OPENAI_API_KEY", sensitive: true },
+  { key: "ANTHROPIC_API_KEY", sensitive: true },
+  { key: "PERPLEXITY_API_KEY", sensitive: true },
+  { key: "GROQ_API_KEY", sensitive: true },
+  { key: "TOGETHER_API_KEY", sensitive: true },
+  { key: "OLLAMA_HOST", sensitive: false },
+  { key: "OLLAMA_BASE_URL", sensitive: false },
+];
+
+function initOpenClawEnvEditor() {
+  const openBtn = document.getElementById("forgeEnvBtn");
+  const closeBtn = document.getElementById("forgeEnvClose");
+  const saveBtn = document.getElementById("forgeEnvSave");
+  const reloadBtn = document.getElementById("forgeEnvReload");
+  const backdrop = document.getElementById("forgeEnvBackdrop");
+  const modal = document.getElementById("forgeEnvModal");
+  const note = document.getElementById("forgeEnvNote");
+  const providerStatus = document.getElementById("forgeEnvProviderStatus");
+  const form = document.getElementById("forgeEnvForm");
+  if (!openBtn || !modal || !form) return;
+  if (isHostedForge()) {
+    openBtn.style.display = "none";
+    return;
+  }
+
+  let envValues = {};
+  let customEnvValues = {};
+  const removedCustomKeys = new Set();
+
+  function setOpen(isOpen) {
+    modal.setAttribute("data-open", isOpen ? "1" : "0");
+    backdrop?.setAttribute("data-open", isOpen ? "1" : "0");
+  }
+
+  function renderProviderChip(status) {
+    if (!providerStatus) return;
+    if (!status) {
+      providerStatus.dataset.state = "err";
+      providerStatus.textContent = "Provider unknown (could not reach gateway status)";
+      return;
+    }
+    if (status.configured) {
+      providerStatus.dataset.state = "ok";
+      const transport = `${status.provider || "openclaw-gateway"} · ${status.model || "main session"}`;
+      const hintProvider = String(status.llmProviderHint || "").trim();
+      const hintModel = String(status.llmModelHint || "").trim();
+      if (hintProvider || hintModel) {
+        providerStatus.textContent = `Active: ${transport} (LLM: ${hintProvider || "unknown"}${hintModel ? `/${hintModel}` : ""})`;
+      } else {
+        providerStatus.textContent = `Active: ${transport}`;
+      }
+      return;
+    }
+    providerStatus.dataset.state = "warn";
+    providerStatus.textContent = "Gateway not ready yet. Save env and run: openclaw gateway start";
+  }
+
+  async function refreshProviderChip() {
+    if (!providerStatus) return;
+    providerStatus.dataset.state = "loading";
+    providerStatus.textContent = "Checking active provider...";
+    const status = await fetchJSON("/api/forge/status", {}, { retries: 1, timeoutMs: 8000 });
+    renderProviderChip(status);
+  }
+
+  function buildEnvRow({ key, value, sensitive = false, isCustom = false }) {
+    const row = document.createElement("div");
+    row.className = "forge-env-row";
+    const keyEl = document.createElement("div");
+    keyEl.className = "forge-env-key";
+    keyEl.textContent = key;
+    const valueWrap = document.createElement("div");
+    valueWrap.className = "forge-env-value-wrap";
+    const input = document.createElement("input");
+    input.className = "forge-env-input";
+    input.type = sensitive ? "password" : "text";
+    input.autocomplete = "off";
+    input.spellcheck = false;
+    input.value = String(value || "");
+    input.placeholder = sensitive ? "Enter key (leave empty to disable)" : "Optional";
+    if (isCustom) input.dataset.customEnvKey = key;
+    else input.dataset.envKey = key;
+    valueWrap.appendChild(input);
+    if (isCustom) {
+      const removeBtn = document.createElement("button");
+      removeBtn.type = "button";
+      removeBtn.className = "forge-env-remove";
+      removeBtn.textContent = "Remove";
+      removeBtn.addEventListener("click", () => {
+        removedCustomKeys.add(key);
+        row.remove();
+      });
+      valueWrap.appendChild(removeBtn);
+    }
+    row.append(keyEl, valueWrap);
+    return row;
+  }
+
+  function buildAddCustomRow() {
+    const row = document.createElement("div");
+    row.className = "forge-env-add-row";
+    row.innerHTML = `
+      <input class="forge-env-input" id="forgeEnvNewKey" type="text" placeholder="CUSTOM_API_KEY" autocomplete="off" spellcheck="false" />
+      <input class="forge-env-input" id="forgeEnvNewValue" type="text" placeholder="Value" autocomplete="off" spellcheck="false" />
+      <button class="forge-btn forge-btn-secondary" id="forgeEnvAddCustom" type="button">Add</button>
+    `;
+    row.querySelector("#forgeEnvAddCustom")?.addEventListener("click", () => {
+      const keyEl = row.querySelector("#forgeEnvNewKey");
+      const valEl = row.querySelector("#forgeEnvNewValue");
+      const rawKey = String(keyEl?.value || "").trim();
+      if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(rawKey)) {
+        toast("Invalid env key format", "error");
+        return;
+      }
+      const key = rawKey;
+      if (OPENCLAW_ENV_FIELDS.some((f) => f.key === key) || form.querySelector(`[data-custom-env-key="${key}"]`)) {
+        toast("Env key already exists in editor", "info");
+        return;
+      }
+      const rowNode = buildEnvRow({ key, value: String(valEl?.value || ""), isCustom: true });
+      row.before(rowNode);
+      if (keyEl) keyEl.value = "";
+      if (valEl) valEl.value = "";
+      removedCustomKeys.delete(key);
+    });
+    return row;
+  }
+
+  function renderForm(values = {}) {
+    form.replaceChildren();
+    for (const field of OPENCLAW_ENV_FIELDS) {
+      form.appendChild(buildEnvRow({
+        key: field.key,
+        value: String(values[field.key] || ""),
+        sensitive: field.sensitive,
+      }));
+    }
+    const sub = document.createElement("div");
+    sub.className = "forge-env-subtitle";
+    sub.textContent = "Additional .env keys";
+    form.appendChild(sub);
+    const customKeys = Object.keys(customEnvValues).sort((a, b) => a.localeCompare(b));
+    for (const key of customKeys) {
+      form.appendChild(buildEnvRow({ key, value: customEnvValues[key], isCustom: true }));
+    }
+    form.appendChild(buildAddCustomRow());
+  }
+
+  async function loadEnv() {
+    note.textContent = "Loading OpenClaw env from local machine...";
+    try {
+      const data = await fetchJSON("/api/openclaw/env", {}, { retries: 1, timeoutMs: 7000 });
+      if (!data?.ok) {
+        note.textContent = "Could not load OpenClaw env. This endpoint is local-only.";
+        if (providerStatus) {
+          providerStatus.dataset.state = "warn";
+          providerStatus.textContent = "Env editor unavailable in this browser context";
+        }
+        toast("Unable to load OpenClaw env from this browser context", "error");
+        return;
+      }
+      envValues = data.values || {};
+      customEnvValues = data.customValues || {};
+      removedCustomKeys.clear();
+      renderForm(envValues);
+      note.textContent = `Editing ${data.envPath}. Changes apply to Forge/OpenClaw provider detection.`;
+    } finally {
+      // Always refresh gateway/provider chip, even if env endpoint is unavailable.
+      await refreshProviderChip();
+    }
+  }
+
+  async function saveEnv() {
+    const updates = {};
+    form.querySelectorAll("[data-env-key]").forEach((input) => {
+      const key = input.dataset.envKey;
+      const value = String(input.value || "").trim();
+      if (envValues[key] !== value) updates[key] = value;
+    });
+    form.querySelectorAll("[data-custom-env-key]").forEach((input) => {
+      const key = input.dataset.customEnvKey;
+      const value = String(input.value || "").trim();
+      if ((customEnvValues[key] || "") !== value) updates[key] = value;
+    });
+    for (const key of removedCustomKeys) updates[key] = "";
+    if (Object.keys(updates).length === 0) {
+      toast("No env changes to save", "info");
+      return;
+    }
+    if (saveBtn) saveBtn.disabled = true;
+    try {
+      const res = await fetch("/api/openclaw/env", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ updates }),
+      });
+      const data = await res.json().catch(() => null);
+      if (!res.ok || !data?.ok) {
+        throw new Error(data?.error || `HTTP ${res.status}`);
+      }
+      toast("OpenClaw env saved. Forge will use new values immediately.", "success");
+      await loadEnv();
+      const status = await fetchJSON("/api/forge/status", {}, { retries: 1, timeoutMs: 10000 });
+      forgeAgentOnline = !!(status?.configured);
+      renderProviderChip(status);
+      updateHeader();
+    } catch (err) {
+      toast(`Env save failed: ${err.message}`, "error", 5000);
+    } finally {
+      if (saveBtn) saveBtn.disabled = false;
+    }
+  }
+
+  openBtn.addEventListener("click", async () => {
+    setOpen(true);
+    await loadEnv();
+    form.querySelector(".forge-env-input")?.focus();
+  });
+  closeBtn?.addEventListener("click", () => setOpen(false));
+  backdrop?.addEventListener("click", () => setOpen(false));
+  reloadBtn?.addEventListener("click", async () => { await loadEnv(); });
+  saveBtn?.addEventListener("click", saveEnv);
+  window.addEventListener("keydown", (e) => {
+    if (e.key === "Escape" && modal.getAttribute("data-open") === "1") setOpen(false);
+  });
 }
 
 async function searchSkills() {
@@ -661,6 +942,18 @@ function renderSearchResults(results) {
   }).join("");
 
   container.querySelectorAll("[data-install-slug]").forEach(btn => {
+    const card = btn.closest(".forge-skill-card");
+    if (card) {
+      card.draggable = true;
+      card.addEventListener("dragstart", (e) => {
+        e.dataTransfer?.setData("text/forge-skill-slug", btn.getAttribute("data-install-slug") || "");
+        if (e.dataTransfer) e.dataTransfer.effectAllowed = "copy";
+        toast("Drop this skill onto the bot viewport to install", "info", 1200);
+      });
+      card.addEventListener("dragend", () => {
+        document.getElementById("forgeViewport")?.classList.remove("forge-drop-active");
+      });
+    }
     btn.addEventListener("click", (e) => {
       e.stopPropagation();
       const slug = btn.getAttribute("data-install-slug");
@@ -785,6 +1078,7 @@ async function init() {
     updateHeader();
     initShareToX();
     initSkillBrowser();
+    initOpenClawEnvEditor();
 
     if (!loaded || loaded.length === 0) {
       updateProgress(0, 0);

package/ui/forge/js/forge-scene.js

@@ -238,7 +238,7 @@ export let robotGroup, attachmentGroup, energyNetworkGroup, platformGroup;
 export let coreMesh, visorMesh, spineSegments = [];
 let ambientParticles, energyStreams, bloomPass, ssaoPass, filmGrainPass;
 let autoRotateTimer = null;
-let bloomEnabled = true;
+let bloomEnabled = false;
 let selectedAttachment = null;
 let glowRings = [];
 let exhaustFlames = [];
@@ -251,9 +251,23 @@ let heatShimmerMeshes = [];
 let robotPowered = false;
 let powerLevel = 0;
 let powerDownTimer = null;
+let robotEmissiveMaterials = [];
 const POWER_UP_SPEED = 2.5;
 const POWER_DOWN_SPEED = 1.2;
 const POWER_DOWN_DELAY = 4000;
+const MOTION_BOUNDS_RADIUS = 2.0;
+const MOTION_REACH_EPSILON = 0.25;
+const MOTION_TURN_LERP = 1.2;
+const MOTION_SPEED_LERP = 1.0;
+const MOTION_WALK_SPEED = 0.3;
+const MOTION_REPICK_MS = 12_000;
+const motionState = {
+  speed: 0,
+  targetX: 0,
+  targetZ: 0,
+  activeUntil: 0,
+  lastPickAt: 0,
+};
 
 const viewportEl = () => document.getElementById("forgeViewport");
 const canvasEl = () => document.getElementById("forgeCanvas");
@@ -2330,6 +2344,132 @@ function schedulePowerDown() {
   }, POWER_DOWN_DELAY);
 }
 
+function pickAutonomousTarget() {
+  const r = 0.4 + Math.random() * (MOTION_BOUNDS_RADIUS - 0.4);
+  const a = Math.random() * Math.PI * 2;
+  motionState.targetX = Math.cos(a) * r;
+  motionState.targetZ = Math.sin(a) * r;
+  motionState.lastPickAt = Date.now();
+}
+
+function normalizeAngle(v) {
+  let a = v;
+  while (a > Math.PI) a -= Math.PI * 2;
+  while (a < -Math.PI) a += Math.PI * 2;
+  return a;
+}
+
+function updateAutonomousMotion(dt) {
+  if (!robotGroup) return;
+  const now = Date.now();
+  const active = now < motionState.activeUntil;
+  if (active && (motionState.lastPickAt === 0 || now - motionState.lastPickAt > MOTION_REPICK_MS)) {
+    pickAutonomousTarget();
+  }
+
+  const cx = robotGroup.position.x;
+  const cz = robotGroup.position.z;
+  const dx = motionState.targetX - cx;
+  const dz = motionState.targetZ - cz;
+  const dist = Math.hypot(dx, dz);
+  const hasTarget = active && dist > MOTION_REACH_EPSILON;
+  const desiredSpeed = hasTarget ? MOTION_WALK_SPEED : 0;
+  motionState.speed += (desiredSpeed - motionState.speed) * Math.min(1, dt * MOTION_SPEED_LERP);
+  if (motionState.speed < 0.002) motionState.speed = 0;
+
+  if (motionState.speed > 0.002 && dist > 0.001) {
+    const step = Math.min(dist, motionState.speed * dt);
+    const nx = cx + (dx / dist) * step;
+    const nz = cz + (dz / dist) * step;
+    const rr = Math.hypot(nx, nz);
+    if (rr > MOTION_BOUNDS_RADIUS) {
+      robotGroup.position.x = (nx / rr) * MOTION_BOUNDS_RADIUS;
+      robotGroup.position.z = (nz / rr) * MOTION_BOUNDS_RADIUS;
+    } else {
+      robotGroup.position.x = nx;
+      robotGroup.position.z = nz;
+    }
+    const desiredYaw = Math.atan2(dx, dz);
+    const delta = normalizeAngle(desiredYaw - robotGroup.rotation.y);
+    robotGroup.rotation.y += delta * Math.min(1, dt * MOTION_TURN_LERP);
+  } else if (hasTarget && dist <= MOTION_REACH_EPSILON) {
+    motionState.lastPickAt = now;
+  }
+}
+
+export function setMotionIntent(intent = {}) {
+  const type = String(intent?.type || "").toLowerCase();
+  if (!type) return;
+  if (type === "halt") {
+    motionState.activeUntil = 0;
+    motionState.speed = 0;
+    return;
+  }
+  if (type === "patrol" || type === "wander") {
+    const dur = Math.max(4000, Math.min(30_000, Number(intent.durationMs || 15000)));
+    motionState.activeUntil = Date.now() + dur;
+    pickAutonomousTarget();
+    powerOn();
+    schedulePowerDown();
+    return;
+  }
+  if (type === "goto") {
+    const x = Number(intent.x);
+    const z = Number(intent.z);
+    if (!Number.isFinite(x) || !Number.isFinite(z)) return;
+    const rr = Math.hypot(x, z);
+    if (rr > MOTION_BOUNDS_RADIUS) {
+      motionState.targetX = (x / rr) * MOTION_BOUNDS_RADIUS;
+      motionState.targetZ = (z / rr) * MOTION_BOUNDS_RADIUS;
+    } else {
+      motionState.targetX = x;
+      motionState.targetZ = z;
+    }
+    const dur = Math.max(3000, Math.min(30_000, Number(intent.durationMs || 12000)));
+    motionState.activeUntil = Date.now() + dur;
+    motionState.lastPickAt = Date.now();
+    powerOn();
+    schedulePowerDown();
+  }
+}
+
+function cacheRobotEmissiveMaterials() {
+  robotEmissiveMaterials = [];
+  if (!robotGroup) return;
+  robotGroup.traverse((node) => {
+    if (!node?.isMesh || !node.material) return;
+    const mats = Array.isArray(node.material) ? node.material : [node.material];
+    for (const mat of mats) {
+      if (typeof mat?.emissiveIntensity !== "number") continue;
+      if (mat.userData?._baseRobotEmissive === undefined) {
+        if (!mat.userData) mat.userData = {};
+        mat.userData._baseRobotEmissive = mat.emissiveIntensity;
+      }
+      robotEmissiveMaterials.push(mat);
+    }
+  });
+}
+
+function applyRobotPowerToStaticEmissive(power) {
+  for (const mat of robotEmissiveMaterials) {
+    const base = Number(mat?.userData?._baseRobotEmissive ?? 0);
+    mat.emissiveIntensity = base * power;
+    const isGlowMaterial = base >= 0.6;
+    if (isGlowMaterial && mat?.transparent) {
+      if (mat.userData._baseRobotOpacity === undefined) {
+        mat.userData._baseRobotOpacity = Number(mat.opacity ?? 1);
+      }
+      mat.opacity = Number(mat.userData._baseRobotOpacity || 1) * power;
+    }
+    if (isGlowMaterial && typeof mat?.transmission === "number") {
+      if (mat.userData._baseRobotTransmission === undefined) {
+        mat.userData._baseRobotTransmission = Number(mat.transmission ?? 0);
+      }
+      mat.transmission = Number(mat.userData._baseRobotTransmission || 0) * power;
+    }
+  }
+}
+
 export function toggleRobotPower() {
   if (robotPowered) {
     robotPowered = false;
@@ -2347,6 +2487,7 @@ function animate() {
   const dt = 1 / 60;
 
   controls.update();
+  updateAutonomousMotion(dt);
 
   // ── Power level ramp (smooth on/off transition) ──
   const targetPower = robotPowered ? 1.0 : 0.0;
@@ -2356,6 +2497,7 @@ function animate() {
     powerLevel = Math.max(powerLevel - dt * POWER_DOWN_SPEED, 0.0);
   }
   const pw = powerLevel;
+  applyRobotPowerToStaticEmissive(pw);
 
   // Core reactor pulse
   if (coreMesh) {
@@ -2378,10 +2520,17 @@ function animate() {
     const scanPulse = Math.exp(-30 * (scanPhase - 0.5) * (scanPhase - 0.5)) * 0.12;
     const speakBurst = agentSpeaking ? Math.sin(time * 8) * 0.04 + Math.random() * 0.03 : 0;
 
-    visorMesh.material.transmission = 0.4 + 0.42 * pw + (vBreath + vNoise + scanPulse * 0.3) * pw;
-    visorMesh.material.emissiveIntensity = ((2.0 + 0.4 * Math.sin(time * 2.5) + scanPulse * 2.0 + speakBurst) * sp) * pw;
-    visorMesh.material.opacity = 0.5 + 0.34 * pw + (vBreath * 0.5 + scanPulse * 0.1) * pw;
-    visorMesh.material.iridescence = (0.5 + 0.15 * Math.sin(time * 1.2)) * pw;
+    if (pw <= 0.0001) {
+      visorMesh.material.transmission = 0;
+      visorMesh.material.emissiveIntensity = 0;
+      visorMesh.material.opacity = 0.02;
+      visorMesh.material.iridescence = 0;
+    } else {
+      visorMesh.material.transmission = 0.02 + (0.4 + 0.42 * pw + (vBreath + vNoise + scanPulse * 0.3) * pw) * pw;
+      visorMesh.material.emissiveIntensity = ((2.0 + 0.4 * Math.sin(time * 2.5) + scanPulse * 2.0 + speakBurst) * sp) * pw;
+      visorMesh.material.opacity = (0.3 + 0.34 * pw + (vBreath * 0.5 + scanPulse * 0.1) * pw) * pw;
+      visorMesh.material.iridescence = (0.5 + 0.15 * Math.sin(time * 1.2)) * pw;
+    }
   }
 
   // Joint glow rings pulse
@@ -2430,25 +2579,33 @@ function animate() {
 
   if (idleAnimatorFn) idleAnimatorFn(time);
 
-  // ── Procedural idle motion ──
-  const sp = agentSpeaking ? 1.8 : 1.0;
+  // ── Procedural idle + walk motion ──
+  // sp: subtle emphasis when speaking (1.15x, not 1.8x — keep it grounded)
+  // gait: 0 = idle, 1 = full walk (normalized to MOTION_WALK_SPEED)
+  const sp = agentSpeaking ? 1.15 : 1.0;
+  const gait = Math.min(1, Math.max(0, motionState.speed / MOTION_WALK_SPEED));
+  const walkFreq = 2.8;
+
   if (robotGroup) {
-    robotGroup.position.y = Math.sin(time * 1.2) * 0.025 * sp;
-    robotGroup.rotation.x = Math.sin(time * 0.7) * 0.006 * sp;
-    robotGroup.position.x = Math.sin(time * 0.35) * 0.012 * sp;
+    // Idle: very subtle breathing bob. Walk: gentle step-bob.
+    robotGroup.position.y = Math.sin(time * (1.0 + gait * walkFreq)) * (0.015 + gait * 0.01) * sp;
+    // Body lean into walk direction
+    robotGroup.rotation.x = Math.sin(time * (0.6 + gait * walkFreq)) * (0.003 + gait * 0.006) * sp;
   }
   if (headPivotRef) {
-    headPivotRef.rotation.y = Math.sin(time * 0.3) * 0.12 * sp;
-    headPivotRef.rotation.x = Math.sin(time * 0.5 + 0.3) * 0.04 * sp;
-    headPivotRef.rotation.z = Math.sin(time * 0.22) * 0.018 * sp;
+    // Head look: slow idle scan; during walk, slight stabilization counter-sway
+    headPivotRef.rotation.y = Math.sin(time * (0.25 + gait * 0.6)) * (0.06 + gait * 0.015) * sp;
+    headPivotRef.rotation.x = Math.sin(time * (0.4 + gait * 0.5) + 0.3) * (0.02 + gait * 0.008) * sp;
+    headPivotRef.rotation.z = Math.sin(time * 0.18) * 0.01 * sp;
   }
   if (leftArmPivotRef) {
-    leftArmPivotRef.rotation.x = Math.sin(time * 0.8) * 0.04 * sp;
-    leftArmPivotRef.rotation.z = Math.sin(time * 0.55) * 0.025 * sp;
+    // Arms: very gentle idle sway; during walk, mild opposite-phase pendulum swing
+    leftArmPivotRef.rotation.x = Math.sin(time * (0.6 + gait * walkFreq)) * (0.015 + gait * 0.05) * sp;
+    leftArmPivotRef.rotation.z = Math.sin(time * (0.4 + gait * 1.2)) * (0.01 + gait * 0.018) * sp;
   }
   if (rightArmPivotRef) {
-    rightArmPivotRef.rotation.x = Math.sin(time * 0.8 + 1.5) * 0.04 * sp;
-    rightArmPivotRef.rotation.z = -Math.sin(time * 0.55 + 0.4) * 0.025 * sp;
+    rightArmPivotRef.rotation.x = Math.sin(time * (0.6 + gait * walkFreq) + Math.PI) * (0.015 + gait * 0.05) * sp;
+    rightArmPivotRef.rotation.z = -Math.sin(time * (0.4 + gait * 1.2) + 0.4) * (0.01 + gait * 0.018) * sp;
   }
 
   // Handheld camera sway (applied to scene root to avoid fighting OrbitControls)
@@ -2693,6 +2850,8 @@ export function initForgeScene() {
     requestAnimationFrame(() => {
       const t0 = performance.now();
       robotGroup.add(buildChassis());
+      cacheRobotEmissiveMaterials();
+      applyRobotPowerToStaticEmissive(0);
       console.log(`[forge] chassis built in ${(performance.now() - t0).toFixed(0)}ms, geo cache: ${_geoCache.size} entries`);
       resolve();
     });
@@ -2711,7 +2870,7 @@ export function initForgeScene() {
     composer.addPass(ssaoPass);
   } catch { /* SSAO unavailable — continue without it */ }
 
-  bloomPass = new UnrealBloomPass(new THREE.Vector2(w, h), 0.7, 0.35, 0.85);
+  bloomPass = new UnrealBloomPass(new THREE.Vector2(w, h), bloomEnabled ? 0.55 : 0, 0.35, 0.85);
   composer.addPass(bloomPass);
 
   outlinePass = new OutlinePass(new THREE.Vector2(w, h), scene, camera);
@@ -2753,6 +2912,7 @@ export function initForgeScene() {
   animate();
 
   window.__forgeSetSpeaking = setAgentSpeaking;
+  window.__forgeSetMotionIntent = setMotionIntent;
 
   _chassisReady.then(() => {
     playCinematicIntro(() => {

package/ui/index.html

@@ -869,9 +869,9 @@ footer::before{
         <div class="setup-step" data-setup-mode="quick">
           <div class="setup-step-num">1</div>
           <h3>Install ApeClaw</h3>
-          <pre>npx ape-claw skill install</pre>
-          <p class="note">Run in any terminal. Requires <a href="https://openclaw.ai" target="_blank" rel="noopener">OpenClaw</a> + Node.js. Installs the core skill and prompts to add 61 curated skills (starter pack). Skills are installed to <code>~/.openclaw/skills/</code>.</p>
-          <p class="note" style="margin-top:4px">Add <code>--starter-pack</code> to skip the prompt. Add <code>--scope local</code> to install into the current project only.</p>
+          <pre>npx --yes ape-claw@latest skill install</pre>
+          <p class="note">Run in any terminal. Requires <a href="https://openclaw.ai" target="_blank" rel="noopener">OpenClaw</a> + Node.js. Installs the core skill, prompts to add 61 curated skills (starter pack), and prompts for the local Forge dashboard upgrade flow. Skills are installed to <code>~/.openclaw/skills/</code>.</p>
+          <p class="note" style="margin-top:4px">Add <code>--starter-pack</code> to skip the prompt. Add <code>--scope local</code> to install into the current project only. Open Forge any time with <code>npx --yes ape-claw@latest dashboard</code>.</p>
         </div>
         <div class="setup-step" data-setup-mode="quick">
           <div class="setup-step-num">2</div>