diff --git a/src/App.tsx b/src/App.tsx
index 6923db49..b25c1fd9 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -5,6 +5,7 @@ import { InputEnvironmentPanel } from "@/components/features/input/InputEnvironm
 import { LicenseNotice } from "@/components/LicenseNotice";
 import { ErrorBoundary } from "@/components/ErrorBoundary";
 import { usePipelineState } from "@/lib/stores/pipelineStore";
+import { hasSelectedModel } from "@/lib/pipelineValidation";
 import type { ReportArea } from "@/lib/issueReport";
 import { VramEstimateBanner } from "@/components/features/VramEstimateBanner";
 import { KbSyncIndicator } from "@/components/features/KbSyncIndicator";
@@ -236,12 +237,14 @@ function Dashboard() {
               <div className="space-y-0.5">
                 {SECTIONS.map(({ id, step, label, icon: Icon }) => {
                   const isActive = activeView === id;
+                  const modelSelected = hasSelectedModel(pipelineState);
+                  const isIncomplete = !modelSelected && id !== "input";
                   return (
                     <button
                       key={id}
                       type="button"
-                      title={`${step} ${label}`}
-                      aria-label={`${step} ${label}`}
+                      title={isIncomplete ? `${step} ${label} — select a model first` : `${step} ${label}`}
+                      aria-label={isIncomplete ? `${step} ${label}, incomplete` : `${step} ${label}`}
                       onClick={() => scrollToSection(id)}
                       aria-current={isActive ? "step" : undefined}
                       disabled={isOliveRunning && id !== "execute" && id !== "playground"}
@@ -258,11 +261,17 @@ function Dashboard() {
                     >
                       <span
                         className={cn(
-                          "text-[11px] tabular-nums shrink-0 w-5 text-center wide:text-left",
+                          "relative text-[11px] tabular-nums shrink-0 w-5 text-center wide:text-left",
                           isActive ? "text-electric-blue" : "text-slate-400",
                         )}
                       >
                         {step}
+                        {isIncomplete && (
+                          <span
+                            className="absolute -top-0.5 -right-0.5 wide:right-auto wide:left-[calc(100%-2px)] h-1.5 w-1.5 rounded-full bg-amber-500"
+                            aria-hidden
+                          />
+                        )}
                       </span>
                       <Icon
                         className={cn(
diff --git a/src/components/features/execute/BatchProcessingPanel.tsx b/src/components/features/execute/BatchProcessingPanel.tsx
index 1bd9bbdf..f2dd5312 100644
--- a/src/components/features/execute/BatchProcessingPanel.tsx
+++ b/src/components/features/execute/BatchProcessingPanel.tsx
@@ -297,6 +297,7 @@ function uiStateForBatchJob(job: BatchJob, state: UIState): UIState {
   return {
     ...state,
     modelSource: job.modelSource,
+    localFiles: state.localFiles,
     hfModelId: job.modelSource === "huggingface" ? job.modelIdentifier : state.hfModelId,
     azureModelPath: job.modelSource === "azure" ? job.modelIdentifier : state.azureModelPath,
     ihvProvider: job.provider,
diff --git a/src/components/features/execute/ExecutionWorkspace.tsx b/src/components/features/execute/ExecutionWorkspace.tsx
index 85d49c45..79f3a3bf 100644
--- a/src/components/features/execute/ExecutionWorkspace.tsx
+++ b/src/components/features/execute/ExecutionWorkspace.tsx
@@ -477,8 +477,10 @@ export function ExecutionWorkspace({
     executionStatus,
     executionExitCode,
     gpuMetrics,
+    runRecipeJson,
     handleExecuteLive,
     handleCancelJob,
+    runRecipeJsonRef,
   } = useOliveStream({
     state,
     hardwareProbe,
@@ -577,6 +579,15 @@ export function ExecutionWorkspace({
     }
   }, [executionStatus, executionLogs, fetchKeyedDiagnostic]);
 
+  // Capture the submitted recipe when Execute completes so Playground uses the exact recipe that ran,
+  // not a rebuilt version that might include post-run state edits.
+  const setCapturedRunRecipe = usePlaygroundStore((s) => s.setCapturedRunRecipe);
+  useEffect(() => {
+    if (executionStatus === "completed" && runRecipeJsonRef.current) {
+      setCapturedRunRecipe(runRecipeJsonRef.current);
+    }
+  }, [executionStatus, setCapturedRunRecipe, runRecipeJsonRef]);
+
   // Auto-save completed diagnoses to history
   const prevDiagnosticRef = useRef(mcpDiagnostic);
   useEffect(() => {
diff --git a/src/components/features/execute/recipe-graph/RecipeValidationPanel.tsx b/src/components/features/execute/recipe-graph/RecipeValidationPanel.tsx
index 65b8f1e9..81dbf0a2 100644
--- a/src/components/features/execute/recipe-graph/RecipeValidationPanel.tsx
+++ b/src/components/features/execute/recipe-graph/RecipeValidationPanel.tsx
@@ -94,7 +94,7 @@ export function RecipeValidationPanel({ state, setState }: RecipeValidationPanel
   const [showCompatDetails, setShowCompatDetails] = useState(false);
   const [refreshKey, setRefreshKey] = useState(0);
   const forceRefreshRef = useRef(false);
-  const { diagnostic: mcpDiagnostic, isDiagnosing: mcpDiagnosing, fetchDiagnostic } = useMcpDiagnostic();
+  const { diagnostic: mcpDiagnostic, isDiagnosing: mcpDiagnosing, fetchDiagnostic, clearDiagnostic } = useMcpDiagnostic();
 
   const validation = getPipelineValidation(state);
   // Pass-parameter advisories (quant method preferences, precision tips, etc.) are all
@@ -219,16 +219,21 @@ export function RecipeValidationPanel({ state, setState }: RecipeValidationPanel
     // Reset ref and clear stale diagnostics when model is deselected.
     if (!modelSelected) {
       prevIssueCountRef.current = 0;
+      clearDiagnostic();
       return;
     }
     const criticalIssues = validation.issues.filter((i) => i.severity === "critical");
     const count = criticalIssues.length;
-    if (count === 0 || count === prevIssueCountRef.current) return;
+    if (count === 0) {
+      prevIssueCountRef.current = 0;
+      return;
+    }
+    if (count === prevIssueCountRef.current) return;
     prevIssueCountRef.current = count;
 
     const logLines = criticalIssues.map((i) => `[VALIDATION] ${i.title}: ${i.description}`);
     fetchDiagnostic(logLines);
-  }, [validation.issues, modelSelected, fetchDiagnostic]);
+  }, [validation.issues, modelSelected, fetchDiagnostic, clearDiagnostic]);
 
   // Hardware-specific parameter validation (synchronous, cheap — runs every render with state)
   const paramWarnings = validatePassParameters(state, activePassNames, recipe);
diff --git a/src/components/features/execute/useOliveStream.ts b/src/components/features/execute/useOliveStream.ts
index 844286a4..f3f8f793 100644
--- a/src/components/features/execute/useOliveStream.ts
+++ b/src/components/features/execute/useOliveStream.ts
@@ -26,6 +26,7 @@ export interface UseOliveStreamReturn {
   gpuMetrics: GpuMetrics | null;
   handleExecuteLive: () => Promise<void>;
   handleCancelJob: () => Promise<void>;
+  runRecipeJsonRef: React.MutableRefObject<string | null>;
 }
 
 type TerminalStatus = "completed" | "failed" | "cancelled";
@@ -540,5 +541,6 @@ export function useOliveStream({
     gpuMetrics,
     handleExecuteLive,
     handleCancelJob,
+    runRecipeJsonRef,
   };
 }
diff --git a/src/components/features/ihv/HardwareCompatibilityMatrix.tsx b/src/components/features/ihv/HardwareCompatibilityMatrix.tsx
index b33809ee..7e63fea8 100644
--- a/src/components/features/ihv/HardwareCompatibilityMatrix.tsx
+++ b/src/components/features/ihv/HardwareCompatibilityMatrix.tsx
@@ -54,14 +54,14 @@ export function HardwareCompatibilityMatrix({
     <TooltipProvider delayDuration={150}>
       <div className="overflow-hidden rounded-xl border border-slate-800/80 bg-slate-950/25 mt-2 shadow-xl animate-in fade-in duration-300">
         <div
-          className="overflow-x-auto focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-electric-blue focus-visible:ring-offset-2 focus-visible:ring-offset-slate-950"
+          className="max-h-[560px] overflow-auto focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-electric-blue focus-visible:ring-offset-2 focus-visible:ring-offset-slate-950"
           tabIndex={0}
           role="region"
           aria-label="Pass and execution provider compatibility matrix"
         >
           <table className="w-full text-left border-collapse min-w-[720px]">
-            <thead>
-              <tr className="border-b border-slate-800/80 bg-slate-900/30">
+            <thead className="sticky top-0 z-10">
+              <tr className="border-b border-slate-800/80 bg-slate-900">
                 {/* Header Cell 1 */}
                 <th className="p-2 px-3 text-[11px] font-mono font-semibold tracking-wider text-slate-400 w-[200px]">
                   PASS
diff --git a/src/components/features/ihv/HardwareProviderCard.tsx b/src/components/features/ihv/HardwareProviderCard.tsx
index d64f2ded..5c1ffbaa 100644
--- a/src/components/features/ihv/HardwareProviderCard.tsx
+++ b/src/components/features/ihv/HardwareProviderCard.tsx
@@ -2,7 +2,7 @@
  * Single IHV provider selection card (conflicts, install CTAs, local detection).
  * Extracted from IHVIntegrationPanel to keep that panel under CodeFactor complexity limits.
  */
-import { memo, type ReactNode } from "react";
+import { memo, useState, useEffect, type ReactNode } from "react";
 import {
   Tooltip,
   TooltipContent,
@@ -58,6 +58,7 @@ import {
   XCircle,
   Globe,
   ExternalLink,
+  ChevronDown,
 } from "lucide-react";
 
 export interface HardwareProviderCardProps {
@@ -123,6 +124,7 @@ function resolveCardChrome(input: {
   badgeText: string;
   BadgeIcon: typeof CheckCircle | null;
   badgeColor: string;
+  badgeIconColor?: string;
 } {
   const base =
     "relative flex flex-col rounded-xl border p-4.5 transition-all duration-200 cursor-pointer min-w-0 max-w-full overflow-hidden ";
@@ -227,7 +229,8 @@ function resolveCardChrome(input: {
       cardClasses: base + "border-emerald-900/40 bg-emerald-950/10 opacity-95 hover:border-emerald-500/40",
       badgeText: "Compatible, runtime available",
       BadgeIcon: CheckCircle,
-      badgeColor: "bg-emerald-500/10 text-emerald-400 border-emerald-500/20",
+      badgeColor: "bg-slate-800/60 text-slate-300 border-slate-700/60",
+      badgeIconColor: "text-emerald-400",
     };
   }
   if (needsPluginInstall && !detectedLocally && !probeLoading) {
@@ -269,7 +272,8 @@ function resolveCardChrome(input: {
     cardClasses: base + "border-slate-800/80 bg-slate-900/40 hover:bg-slate-900 hover:border-slate-700",
     badgeText: "Compatible with active passes",
     BadgeIcon: CheckCircle,
-    badgeColor: "bg-emerald-500/10 text-emerald-400 border-emerald-500/15",
+    badgeColor: "bg-slate-800/60 text-slate-300 border-slate-700/60",
+    badgeIconColor: "text-emerald-400",
   };
 }
 
@@ -848,14 +852,18 @@ export const HardwareProviderCard = memo(function HardwareProviderCard({
   onInstallOrtGpu,
 }: HardwareProviderCardProps) {
   const isSelected = state.ihvProvider === p.id;
+  // Selected card starts open so the active target's details aren't hidden behind a click.
+  const [isExpanded, setIsExpanded] = useState(isSelected);
+  useEffect(() => {
+    setIsExpanded(isSelected);
+  }, [isSelected]);
   const Icon = p.icon;
   const pConflicts = getProviderConflicts(p.id, state.passes);
   const cardHasCritical = pConflicts.some((c) => c.severity === "critical");
   const cardHardwareBlocked =
     !isExportTargetProvider(p.id) &&
     !isPlatformLocalProvider(p.id) &&
-    (Boolean(getProviderHardwareBlock(p.id, hardwareProbe)) ||
-      (p.id === "CPUExecutionProvider" && !hardwareProbe));
+    Boolean(getProviderHardwareBlock(p.id, hardwareProbe));
   const cardBlocked = cardHasCritical || cardHardwareBlocked;
   const cardHasWarning = pConflicts.some((c) => c.severity === "warning");
   const showSwitchAssist = pConflicts.length > 0 && (isSelected || !cardBlocked);
@@ -885,7 +893,7 @@ export const HardwareProviderCard = memo(function HardwareProviderCard({
   const hardwareCompatibleNotDetected =
     p.id === "DmlExecutionProvider" && directMlNeedsInstall && !detectedLocally;
 
-  const { cardClasses, badgeText, BadgeIcon, badgeColor } = resolveCardChrome({
+  const { cardClasses, badgeText, BadgeIcon, badgeColor, badgeIconColor } = resolveCardChrome({
     isSelected,
     cardBlocked,
     cardHardwareBlocked,
@@ -901,6 +909,7 @@ export const HardwareProviderCard = memo(function HardwareProviderCard({
   });
   const hardwareDetail = hardwareDetailFor(p.id, hardwareProbe);
 
+  const detailsId = `hardware-provider-details-${p.id}`;
   const onSelect = () =>
     selectProvider(p.id, state, setState, hardwareProbe, detectedProviders, pConflicts, isSelected);
 
@@ -926,7 +935,9 @@ export const HardwareProviderCard = memo(function HardwareProviderCard({
             <span
               className={`inline-flex items-center gap-1 text-[9px] font-mono uppercase tracking-wider font-extrabold px-2 py-0.5 rounded border ${badgeColor}`}
             >
-              {BadgeIcon ? <BadgeIcon className="h-3 w-3" aria-hidden /> : null}
+              {BadgeIcon ? (
+                <BadgeIcon className={cn("h-3 w-3", badgeIconColor)} aria-hidden />
+              ) : null}
               {badgeText}
             </span>
           </div>
@@ -959,71 +970,90 @@ export const HardwareProviderCard = memo(function HardwareProviderCard({
               </div>
             </TooltipContent>
           </Tooltip>
-          {detectedLocally && hardwareDetail ? (
-            <p className="text-xs text-emerald-400/90 font-mono break-words">{hardwareDetail}</p>
-          ) : null}
-          <ProviderPluginInstalls
-            providerId={p.id}
-            hardwareProbe={hardwareProbe}
-            trtRtxNeedsInstall={trtRtxNeedsInstall}
-            trtNeedsInstall={trtNeedsInstall}
-            openvinoNeedsInstall={openvinoNeedsInstall}
-            hardwareInstallBusy={hardwareInstallBusy}
-            installingTrtRtx={installingTrtRtx}
-            installTrtRtxError={installTrtRtxError}
-            installTrtRtxLog={installTrtRtxLog}
-            onInstallTensorRtRtx={onInstallTensorRtRtx}
-            installingTrt={installingTrt}
-            installTrtError={installTrtError}
-            installTrtLog={installTrtLog}
-            onInstallTensorRt={onInstallTensorRt}
-            openvinoInstall={openvinoInstall}
-            qnnInstall={qnnInstall}
-            directMlInstall={directMlInstall}
-            isPreMaxwellBox={isPreMaxwellBox}
-            cudaNeedsOrtGpuInstall={cudaNeedsOrtGpuInstall}
-            cudaToolkitMissingAndEpWorks={cudaToolkitMissingAndEpWorks}
-            cudaToolkitMissing={cudaToolkitMissing}
-            cudaEpInVenv={cudaEpInVenv}
-            nvidiaGpus={nvidiaGpus}
-            installingOrtGpu={installingOrtGpu}
-            installOrtGpuError={installOrtGpuError}
-            installOrtGpuLog={installOrtGpuLog}
-            onInstallOrtGpu={onInstallOrtGpu}
-          />
-          {p.id === "OpenVINOExecutionProvider" ? (
-            <OpenVinoDeviceHint hardwareProbe={hardwareProbe} />
-          ) : null}
-          {isWebGpuTarget ? (
-            <p className="text-xs text-slate-500 mt-0.5 leading-relaxed">
-              Not a local Python EP. Select to build web-oriented recipes, then use{" "}
-              <span className="text-slate-400">Recipe &amp; run → Browser Test</span> / WebGPU benchmark in
-              Chrome or Edge 113+.
-            </p>
-          ) : null}
-          {isExportTarget && !isWebGpuTarget ? (
-            <p className="text-xs text-slate-500 mt-0.5 leading-relaxed">
-              {isLegacyTarget
-                ? "Legacy export path (prefer QNN for Snapdragon). Not available for Studio Execute Live."
-                : "Export / deploy target only. Not a local Python EP, so Execute Live stays blocked."}
-            </p>
-          ) : null}
-          {isPlatformTarget && !detectedLocally && !probeLoading ? (
-            <p className="text-xs text-slate-500 mt-0.5 leading-relaxed">
-              Platform EP: selectable for recipes; Execute Live requires a matching ORT probe hit on this host.
-            </p>
-          ) : null}
-          {!detectedLocally &&
-            !probeLoading &&
-            !isExportTarget &&
-            !isPlatformTarget &&
-            !needsPluginInstall ? (
-            <p className="text-xs text-slate-600">
-              {p.id === "CPUExecutionProvider"
-                ? "Hardware detection unavailable. CPU status is unknown."
-                : "No matching hardware found locally. You can still select for remote/cross-compile targets."}
-            </p>
-          ) : null}
+          <button
+            type="button"
+            onClick={(e) => {
+              e.stopPropagation();
+              setIsExpanded((v) => !v);
+            }}
+            className="flex items-center gap-1 text-[11px] text-slate-500 hover:text-slate-400 transition-colors cursor-pointer"
+            aria-expanded={isExpanded}
+            aria-controls={detailsId}
+          >
+            <ChevronDown
+              className={cn("h-3 w-3 transition-transform", isExpanded && "rotate-180")}
+            />
+            {isExpanded ? "Hide details" : "Show details"}
+          </button>
+          {isExpanded && (
+            <div id={detailsId}>
+              {detectedLocally && hardwareDetail ? (
+                <p className="text-xs text-emerald-400/90 font-mono break-words">{hardwareDetail}</p>
+              ) : null}
+              <ProviderPluginInstalls
+                providerId={p.id}
+                hardwareProbe={hardwareProbe}
+                trtRtxNeedsInstall={trtRtxNeedsInstall}
+                trtNeedsInstall={trtNeedsInstall}
+                openvinoNeedsInstall={openvinoNeedsInstall}
+                hardwareInstallBusy={hardwareInstallBusy}
+                installingTrtRtx={installingTrtRtx}
+                installTrtRtxError={installTrtRtxError}
+                installTrtRtxLog={installTrtRtxLog}
+                onInstallTensorRtRtx={onInstallTensorRtRtx}
+                installingTrt={installingTrt}
+                installTrtError={installTrtError}
+                installTrtLog={installTrtLog}
+                onInstallTensorRt={onInstallTensorRt}
+                openvinoInstall={openvinoInstall}
+                qnnInstall={qnnInstall}
+                directMlInstall={directMlInstall}
+                isPreMaxwellBox={isPreMaxwellBox}
+                cudaNeedsOrtGpuInstall={cudaNeedsOrtGpuInstall}
+                cudaToolkitMissingAndEpWorks={cudaToolkitMissingAndEpWorks}
+                cudaToolkitMissing={cudaToolkitMissing}
+                cudaEpInVenv={cudaEpInVenv}
+                nvidiaGpus={nvidiaGpus}
+                installingOrtGpu={installingOrtGpu}
+                installOrtGpuError={installOrtGpuError}
+                installOrtGpuLog={installOrtGpuLog}
+                onInstallOrtGpu={onInstallOrtGpu}
+              />
+              {p.id === "OpenVINOExecutionProvider" ? (
+                <OpenVinoDeviceHint hardwareProbe={hardwareProbe} />
+              ) : null}
+              {isWebGpuTarget ? (
+                <p className="text-xs text-slate-500 mt-0.5 leading-relaxed">
+                  Not a local Python EP. Select to build web-oriented recipes, then use{" "}
+                  <span className="text-slate-400">Recipe &amp; run → Browser Test</span> / WebGPU benchmark in
+                  Chrome or Edge 113+.
+                </p>
+              ) : null}
+              {isExportTarget && !isWebGpuTarget ? (
+                <p className="text-xs text-slate-500 mt-0.5 leading-relaxed">
+                  {isLegacyTarget
+                    ? "Legacy export path (prefer QNN for Snapdragon). Not available for Studio Execute Live."
+                    : "Export / deploy target only. Not a local Python EP, so Execute Live stays blocked."}
+                </p>
+              ) : null}
+              {isPlatformTarget && !detectedLocally && !probeLoading ? (
+                <p className="text-xs text-slate-500 mt-0.5 leading-relaxed">
+                  Platform EP: selectable for recipes; Execute Live requires a matching ORT probe hit on this host.
+                </p>
+              ) : null}
+              {!detectedLocally &&
+                !probeLoading &&
+                !isExportTarget &&
+                !isPlatformTarget &&
+                !needsPluginInstall ? (
+                <p className="text-xs text-slate-600">
+                  {p.id === "CPUExecutionProvider"
+                    ? "Hardware detection unavailable. CPU status is unknown."
+                    : "No matching hardware found locally. You can still select for remote/cross-compile targets."}
+                </p>
+              ) : null}
+            </div>
+          )}
         </div>
 
         <div className="flex items-center justify-center shrink-0">
diff --git a/src/components/features/ihv/ProviderCardGrid.test.tsx b/src/components/features/ihv/ProviderCardGrid.test.tsx
new file mode 100644
index 00000000..b5b1ed01
--- /dev/null
+++ b/src/components/features/ihv/ProviderCardGrid.test.tsx
@@ -0,0 +1,62 @@
+import { describe, it, expect, vi } from "vitest";
+import { screen, render } from "@testing-library/react";
+import { ProviderCardGrid } from "./ProviderCardGrid";
+import { createMockUIState } from "../__tests__/testUtils";
+import { PROVIDER_CATALOG } from "@/lib/providerCatalog";
+import { getProviderRuntimeKind } from "@/lib/providerRuntimeKind";
+import type { IHVProvider } from "@/types";
+
+describe("ProviderCardGrid", () => {
+  const defaultProps = {
+    probeLoading: false,
+    localAccelerators: PROVIDER_CATALOG.filter((p) => getProviderRuntimeKind(p.id) === "local"),
+    exportAndPlatformTargets: PROVIDER_CATALOG.filter((p) => getProviderRuntimeKind(p.id) !== "local"),
+    providerCardProps: {
+      state: createMockUIState({ ihvProvider: "CPUExecutionProvider" }),
+      setState: vi.fn(),
+      hardwareProbe: null,
+      probeLoading: false,
+      detectedProviders: ["CPUExecutionProvider" as IHVProvider],
+      trtRtxNeedsInstall: false,
+      trtNeedsInstall: false,
+      openvinoNeedsInstall: false,
+      hardwareInstallBusy: false,
+      installingTrtRtx: false,
+      installTrtRtxError: null,
+      installTrtRtxLog: [],
+      onInstallTensorRtRtx: vi.fn(),
+      installingTrt: false,
+      installTrtError: null,
+      installTrtLog: [],
+      onInstallTensorRt: vi.fn(),
+      openvinoInstall: { state: { installing: false, error: null, log: [] }, install: vi.fn() },
+      qnnInstall: { state: { installing: false, testing: false, error: null, log: [] }, install: vi.fn(), testNpu: vi.fn() },
+      directMlInstall: { state: { installing: false, error: null, log: [] }, install: vi.fn() },
+      isPreMaxwellBox: false,
+      cudaNeedsOrtGpuInstall: false,
+      cudaToolkitMissingAndEpWorks: false,
+      cudaToolkitMissing: false,
+      cudaEpInVenv: false,
+      nvidiaGpus: [],
+      installingOrtGpu: false,
+      installOrtGpuError: null,
+      installOrtGpuLog: [],
+      onInstallOrtGpu: vi.fn(),
+    },
+  };
+
+  it("does not classify CPU as hardware-blocked when hardwareProbe is null", () => {
+    render(<ProviderCardGrid {...defaultProps} />);
+
+    // CPU provider header
+    const cpuHeader = screen.getByText("Native CPU");
+    expect(cpuHeader).toBeTruthy();
+
+    // The container for Native CPU should contain "Active Target" badge
+    const cpuCard = cpuHeader.closest(".relative");
+    expect(cpuCard).toBeTruthy();
+    expect(cpuCard?.textContent).toContain("Active Target");
+    expect(cpuCard?.textContent).not.toContain("Unavailable hardware");
+    expect(cpuCard?.textContent).not.toContain("Not on this system");
+  });
+});
diff --git a/src/components/features/ihv/ProviderCardGrid.tsx b/src/components/features/ihv/ProviderCardGrid.tsx
index 837fea89..b95e27ba 100644
--- a/src/components/features/ihv/ProviderCardGrid.tsx
+++ b/src/components/features/ihv/ProviderCardGrid.tsx
@@ -2,11 +2,12 @@
  * ProviderCardGrid — Provider card grid with local accelerators and export/platform sections.
  * Extracted from IHVIntegrationPanel (Task 6).
  */
-import { useState, useEffect } from "react";
+import { useState, useEffect, useMemo } from "react";
 import { TooltipProvider } from "@/components/ui/Tooltip";
 import { HardwareProviderCard, type HardwareProviderCardProps } from "./HardwareProviderCard";
 import { ChevronDown, RefreshCw } from "lucide-react";
 import { cn } from "@/lib/utils";
+import { isProviderDetectedLocally } from "@/lib/hardwareProbe";
 import type { ProviderCatalogEntry } from "@/lib/providerCatalog";
 
 export interface ProviderCardGridProps {
@@ -34,6 +35,37 @@ export function ProviderCardGrid({
     setShowExportTargets(selectedIsExportTarget);
   }, [selectedIsExportTarget]);
 
+  // Within local accelerators, cards for hardware not actually detected on this machine
+  // (e.g. CoreML on a Windows box) are rarely the pick — collapse them the same way
+  // export/platform targets collapse, unless the active selection is one of them.
+  // However, if probe is still loading or failed (null), show all locals together since we
+  // can't reliably distinguish detected from undetected without probe results.
+  const { detectedLocal, undetectedLocal } = useMemo(() => {
+    const hardwareProbe = providerCardProps.hardwareProbe;
+    const detected: ProviderCatalogEntry[] = [];
+    const undetected: ProviderCatalogEntry[] = [];
+
+    // Only split if probe data is available; otherwise treat all as detected since detection is unavailable.
+    if (!hardwareProbe && !probeLoading) {
+      // Probe finished but returned null (error case) — show all, don't split
+      return { detectedLocal: localAccelerators, undetectedLocal: [] };
+    }
+
+    for (const p of localAccelerators) {
+      if (isProviderDetectedLocally(p.id, hardwareProbe)) detected.push(p);
+      else undetected.push(p);
+    }
+    return { detectedLocal: detected, undetectedLocal: undetected };
+  }, [localAccelerators, providerCardProps.hardwareProbe, probeLoading]);
+
+  const selectedIsUndetectedLocal = undetectedLocal.some(
+    (p) => p.id === providerCardProps.state.ihvProvider,
+  );
+  const [showUndetectedLocal, setShowUndetectedLocal] = useState(selectedIsUndetectedLocal);
+  useEffect(() => {
+    setShowUndetectedLocal(selectedIsUndetectedLocal);
+  }, [selectedIsUndetectedLocal]);
+
   if (probeLoading) {
     return (
       <div className="rounded-xl border border-slate-800/80 bg-slate-950/40 p-8 text-center text-sm text-slate-500">
@@ -51,10 +83,37 @@ export function ProviderCardGrid({
             Local accelerators
           </p>
           <div className="grid gap-4 min-w-0 w-full">
-            {localAccelerators.map((p) => (
+            {detectedLocal.map((p) => (
               <HardwareProviderCard key={p.id} provider={p} {...providerCardProps} />
             ))}
           </div>
+          {undetectedLocal.length > 0 && (
+            <>
+              <button
+                type="button"
+                onClick={() => setShowUndetectedLocal((v) => !v)}
+                className="flex w-full items-center justify-between gap-2 text-left cursor-pointer group"
+                aria-expanded={showUndetectedLocal}
+              >
+                <span className="text-[11px] font-mono uppercase tracking-wider text-slate-500 group-hover:text-slate-400">
+                  {showUndetectedLocal ? "Hide" : "Show"} other targets ({undetectedLocal.length})
+                </span>
+                <ChevronDown
+                  className={cn(
+                    "h-3.5 w-3.5 text-slate-500 shrink-0 transition-transform group-hover:text-slate-400",
+                    showUndetectedLocal && "rotate-180",
+                  )}
+                />
+              </button>
+              {showUndetectedLocal && (
+                <div className="grid gap-4 min-w-0 w-full">
+                  {undetectedLocal.map((p) => (
+                    <HardwareProviderCard key={p.id} provider={p} {...providerCardProps} />
+                  ))}
+                </div>
+              )}
+            </>
+          )}
         </div>
 
         <div className="space-y-3">
diff --git a/src/components/features/input/CompatStatus.tsx b/src/components/features/input/CompatStatus.tsx
index a03cb763..efffd2e1 100644
--- a/src/components/features/input/CompatStatus.tsx
+++ b/src/components/features/input/CompatStatus.tsx
@@ -4,12 +4,13 @@ import type { RecipeHardwareCompatTier } from "@/lib/recipeHardwareCompatibility
 
 const TIER_UI: Record<
   RecipeHardwareCompatTier,
-  { label: string; Icon: typeof CheckCircle2; className: string }
+  { label: string; Icon: typeof CheckCircle2; className: string; iconClassName?: string }
 > = {
   compatible: {
     label: "Compatible",
     Icon: CheckCircle2,
-    className: "text-emerald-400 border-emerald-500/30 bg-emerald-500/10",
+    className: "text-slate-300 border-slate-700 bg-slate-900/60",
+    iconClassName: "text-emerald-400",
   },
   unavailable: {
     label: "Incompatible",
@@ -37,7 +38,7 @@ interface CompatStatusPillProps {
  * @param size - The badge size
  */
 export function CompatStatusPill({ tier, className, size = "sm" }: CompatStatusPillProps) {
-  const { label, Icon, className: tierClass } = TIER_UI[tier];
+  const { label, Icon, className: tierClass, iconClassName } = TIER_UI[tier];
   return (
     <span
       className={cn(
@@ -47,7 +48,10 @@ export function CompatStatusPill({ tier, className, size = "sm" }: CompatStatusP
         className,
       )}
     >
-      <Icon className={size === "sm" ? "h-3 w-3" : "h-3.5 w-3.5"} aria-hidden />
+      <Icon
+        className={cn(size === "sm" ? "h-3 w-3" : "h-3.5 w-3.5", iconClassName)}
+        aria-hidden
+      />
       <span>{label}</span>
     </span>
   );
diff --git a/src/components/features/playground/PlaygroundPanel.test.tsx b/src/components/features/playground/PlaygroundPanel.test.tsx
index 9e98dd1d..26f125d3 100644
--- a/src/components/features/playground/PlaygroundPanel.test.tsx
+++ b/src/components/features/playground/PlaygroundPanel.test.tsx
@@ -8,7 +8,11 @@ import { PlaygroundPanel } from "./PlaygroundPanel";
 import { usePlaygroundStore } from "@/lib/stores/playgroundStore";
 
 vi.mock("./InBrowserValidation", () => ({
-  InBrowserValidation: () => <div data-testid="browser-test-panel">Browser Test Panel</div>,
+  InBrowserValidation: ({ recipeJson }: { recipeJson?: string }) => (
+    <div data-testid="browser-test-panel" data-recipe-json={recipeJson ?? ""}>
+      Browser Test Panel
+    </div>
+  ),
 }));
 
 vi.mock("./WebGpuBenchmarkPanel", () => ({
@@ -86,4 +90,47 @@ describe("PlaygroundPanel", () => {
       true,
     );
   });
+
+  it("passes capturedRunRecipe to InBrowserValidation only if it uses WebGpuExecutionProvider", async () => {
+    const cudaRecipe = JSON.stringify({
+      systems: {
+        gpu: {
+          config: {
+            accelerators: [{ execution_providers: ["CUDAExecutionProvider"] }],
+          },
+        },
+      },
+    });
+
+    usePlaygroundStore.getState().setCapturedRunRecipe(cudaRecipe);
+    const { unmount } = render(<PlaygroundPanel />);
+
+    await waitFor(() => {
+      expect(screen.getByTestId("browser-test-panel")).toBeTruthy();
+    });
+
+    // CUDA captured recipe should NOT be passed to Browser Test
+    expect(screen.getByTestId("browser-test-panel").getAttribute("data-recipe-json")).toBe("");
+    unmount();
+
+    const webGpuRecipe = JSON.stringify({
+      systems: {
+        gpu: {
+          config: {
+            accelerators: [{ execution_providers: ["WebGpuExecutionProvider"] }],
+          },
+        },
+      },
+    });
+
+    usePlaygroundStore.getState().setCapturedRunRecipe(webGpuRecipe);
+    render(<PlaygroundPanel />);
+
+    await waitFor(() => {
+      expect(screen.getByTestId("browser-test-panel")).toBeTruthy();
+    });
+
+    // WebGPU captured recipe SHOULD be passed to Browser Test
+    expect(screen.getByTestId("browser-test-panel").getAttribute("data-recipe-json")).toBe(webGpuRecipe);
+  });
 });
diff --git a/src/components/features/playground/PlaygroundPanel.tsx b/src/components/features/playground/PlaygroundPanel.tsx
index 3964dbed..4fcdabc4 100644
--- a/src/components/features/playground/PlaygroundPanel.tsx
+++ b/src/components/features/playground/PlaygroundPanel.tsx
@@ -6,6 +6,7 @@ import { usePlaygroundStore, type PlaygroundSubView } from "@/lib/stores/playgro
 import { usePipelineState } from "@/lib/stores/pipelineStore";
 import { buildRecipeJsonFromState } from "@/lib/recipePipeline";
 import { hasSelectedModel } from "@/lib/pipelineValidation";
+import { mapExecutionProviderFromRecipe } from "@/lib/oliveRecipeHub";
 
 /* ------------------------------------------------------------------ */
 /*  Lazy sub-view imports                                               */
@@ -58,17 +59,34 @@ function LoadingFallback({ label }: { label: string }) {
 /*  PlaygroundPanel                                                     */
 /* ------------------------------------------------------------------ */
 
+function isWebGpuRecipe(recipeJson: string): boolean {
+  try {
+    const parsed = JSON.parse(recipeJson);
+    return mapExecutionProviderFromRecipe(parsed) === "WebGpuExecutionProvider";
+  } catch {
+    return false;
+  }
+}
+
 export function PlaygroundPanel() {
   const activeSubView = usePlaygroundStore((s) => s.activeSubView);
   const setActiveSubView = usePlaygroundStore((s) => s.setActiveSubView);
+  const capturedRunRecipe = usePlaygroundStore((s) => s.capturedRunRecipe);
   const { state } = usePipelineState();
-  // Ties the Browser Test hint back to the recipe actually configured in steps 01-03,
-  // instead of always being hidden (it was previously hardcoded to undefined).
+  // Memoize captured WebGPU recipe check so JSON parsing doesn't re-run on frequent pipeline state edits.
+  const isCapturedWebGpu = useMemo(() => {
+    return Boolean(capturedRunRecipe && isWebGpuRecipe(capturedRunRecipe));
+  }, [capturedRunRecipe]);
+
+  // Use the recipe from the last successful Execute run if available (preserves context even if
+  // user modifies state afterward). Fallback to building from current state for manual Browser Test.
   // Only pass recipe if provider is WebGPU; other providers should not show this hint.
-  const recipeJson = useMemo(
-    () => (hasSelectedModel(state) && state.ihvProvider === "WebGpuExecutionProvider" ? buildRecipeJsonFromState(state) : undefined),
-    [state],
-  );
+  const recipeJson = useMemo(() => {
+    if (isCapturedWebGpu && capturedRunRecipe) return capturedRunRecipe;
+    return hasSelectedModel(state) && state.ihvProvider === "WebGpuExecutionProvider"
+      ? buildRecipeJsonFromState(state)
+      : undefined;
+  }, [isCapturedWebGpu, capturedRunRecipe, state]);
 
   // Keep-alive: seed from store so remounts don't blank a restored sub-view
   const [visitedSubViews, setVisitedSubViews] = useState<Set<string>>(
diff --git a/src/lib/hardwareProbe.test.ts b/src/lib/hardwareProbe.test.ts
index 629ed139..10d29e3b 100644
--- a/src/lib/hardwareProbe.test.ts
+++ b/src/lib/hardwareProbe.test.ts
@@ -6,6 +6,7 @@ import {
   computeQnnCompatibleHardware,
   getProviderAvailabilityBlock,
   isNvidiaGpuTensorRtFamily,
+  isProviderDetectedLocally,
   mergeDetectedProviders,
   parseComputeCapability,
   pickRecommendedProvider,
@@ -655,3 +656,27 @@ describe("mergeDetectedProviders QNN", () => {
     ).toBe(false);
   });
 });
+
+describe("isProviderDetectedLocally", () => {
+  it("always detects CPUExecutionProvider locally even when probe is null", () => {
+    expect(isProviderDetectedLocally("CPUExecutionProvider", null)).toBe(true);
+    expect(isProviderDetectedLocally("CPUExecutionProvider", undefined)).toBe(true);
+  });
+
+  it("checks probe detectedProviders for GPU providers", () => {
+    const probe = {
+      probedAt: "now",
+      platform: { os: "win", arch: "x64", cpuModel: "CPU", cpuCores: 4 },
+      detectedProviders: ["CPUExecutionProvider", "CUDAExecutionProvider"],
+      recommendedProvider: "CUDAExecutionProvider",
+      notes: [],
+    } as HardwareProbeResult;
+
+    expect(isProviderDetectedLocally("CUDAExecutionProvider", probe)).toBe(true);
+    expect(isProviderDetectedLocally("ROCMExecutionProvider", probe)).toBe(false);
+  });
+
+  it("returns false for non-CPU providers when probe is null", () => {
+    expect(isProviderDetectedLocally("CUDAExecutionProvider", null)).toBe(false);
+  });
+});
diff --git a/src/lib/hardwareProbe.ts b/src/lib/hardwareProbe.ts
index 5ffe2e98..ab53ab81 100644
--- a/src/lib/hardwareProbe.ts
+++ b/src/lib/hardwareProbe.ts
@@ -565,6 +565,9 @@ export function isProviderDetectedLocally(
   provider: IHVProvider,
   probe: HardwareProbeResult | null | undefined,
 ): boolean {
+  if (provider === "CPUExecutionProvider") {
+    return true;
+  }
   if (!probe) {
     return false;
   }
diff --git a/src/lib/hooks/useMcpDiagnostic.ts b/src/lib/hooks/useMcpDiagnostic.ts
index 1a24757d..2f3b8172 100644
--- a/src/lib/hooks/useMcpDiagnostic.ts
+++ b/src/lib/hooks/useMcpDiagnostic.ts
@@ -18,6 +18,8 @@ interface UseMcpDiagnosticReturn {
    * they need (single state, keyed Record, etc.).
    */
   fetchDiagnostic: (logs: string[]) => Promise<McpDiagnostic | null>;
+  /** Clear the stored diagnostic and abort any in-flight fetch. */
+  clearDiagnostic: () => void;
 }
 
 /**
@@ -67,7 +69,14 @@ export function useMcpDiagnostic(): UseMcpDiagnosticReturn {
     }
   }, []);
 
-  return { diagnostic, isDiagnosing, error, fetchDiagnostic };
+  const clearDiagnostic = useCallback(() => {
+    abortRef.current?.abort();
+    setDiagnostic(null);
+    setError(null);
+    setIsDiagnosing(false);
+  }, []);
+
+  return { diagnostic, isDiagnosing, error, fetchDiagnostic, clearDiagnostic };
 }
 
 /**
diff --git a/src/lib/oliveRecipeHub.ts b/src/lib/oliveRecipeHub.ts
index 7b06f89f..db9e5c5e 100644
--- a/src/lib/oliveRecipeHub.ts
+++ b/src/lib/oliveRecipeHub.ts
@@ -192,7 +192,7 @@ export async function fetchOliveRecipesCatalogItem(
  *
  * @returns The first recognized execution provider, or `undefined` when the recipe has no recognized provider.
  */
-function mapExecutionProviderFromRecipe(parsed: unknown): IHVProvider | undefined {
+export function mapExecutionProviderFromRecipe(parsed: unknown): IHVProvider | undefined {
   const recipe = parsed as Record<string, unknown> | undefined;
   const systems = recipe?.systems as Record<string, unknown> | undefined;
   if (systems && typeof systems === "object") {
diff --git a/src/lib/stores/playgroundStore.ts b/src/lib/stores/playgroundStore.ts
index 2323218b..d3f0e5c4 100644
--- a/src/lib/stores/playgroundStore.ts
+++ b/src/lib/stores/playgroundStore.ts
@@ -40,6 +40,9 @@ interface PlaygroundStore {
   slotB: ArenaSlotConfig;
   setSlotA: (patch: Partial<ArenaSlotConfig>) => void;
   setSlotB: (patch: Partial<ArenaSlotConfig>) => void;
+  /** Recipe JSON captured from the last successful Execute run. */
+  capturedRunRecipe: string | undefined;
+  setCapturedRunRecipe: (recipe: string | undefined) => void;
   /** Reset session-scoped Playground fields (does not touch pipeline state). */
   resetPlayground: () => void;
 }
@@ -51,10 +54,13 @@ export const usePlaygroundStore = create<PlaygroundStore>((set) => ({
   slotB: defaultArenaSlot(),
   setSlotA: (patch) => set((s) => ({ slotA: { ...s.slotA, ...patch } })),
   setSlotB: (patch) => set((s) => ({ slotB: { ...s.slotB, ...patch } })),
+  capturedRunRecipe: undefined,
+  setCapturedRunRecipe: (recipe) => set({ capturedRunRecipe: recipe }),
   resetPlayground: () =>
     set({
       activeSubView: "browser-test",
       slotA: defaultArenaSlot(),
       slotB: defaultArenaSlot(),
+      capturedRunRecipe: undefined,
     }),
 }));