diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7a04377b..45c1b12c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,12 +8,35 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 ### Added
+- **Enhanced Skip Functionality with Prerequisite Finding**
+  - New skip reason selection UI when skipping a problem (Too difficult, Don't understand, Not relevant, Other)
+  - "Don't understand" skips now find and replace with easier prerequisite problems
+  - "Too difficult" skips weaken problem graph relationships for future recommendations
+  - "Free skip" detection: problems with no relationships to attempted problems have no graph penalty
+  - Smart prerequisite search prioritizes problems by difficulty (Easy > Medium > Hard) and connection strength
+
+- **Guard Rail 4: Poor Performance Protection**
+  - New session composition safety for users promoted via stagnation escape hatch
+  - When at Hard cap with <50% recent accuracy: limits Hard problems to 1 per session
+  - Replaces excess Hard problems with Medium to prevent overwhelming struggling users
+  - Tracks promotion type (standard_volume_gate vs stagnation_escape_hatch) for intelligent session balancing
+
 - **Enhanced "I'm Stuck" Button** (#234)
   - Now extends timer by 5 minutes when clicked
   - Automatically opens hints panel to help user get unstuck
   - Records user intent for session analytics
 
 ### Fixed
+- **Native Dropdown Broken in Chrome Extension Content Scripts**
+  - Fixed dropdown menus (select elements) flashing and immediately closing when clicked on Problem Submission page
+  - Root cause: Chrome browser update changed how native `<select>` elements work in extension content scripts
+  - Created `SimpleSelect.jsx` custom dropdown component that renders within React DOM instead of using browser-native UI
+  - Custom dropdown includes full keyboard navigation (Arrow keys, Enter, Space, Escape), click-outside-to-close, and maintains visual consistency
+  - Changed CSS containment from `contain: layout size style` to `contain: paint style` on `.cm-sidenav` in main.css
+  - Changed CSS containment from `contain: layout` to `contain: paint style` in probrec.css (2 instances)
+  - CSS containment with `layout` was preventing dropdowns from rendering outside their container bounds
+  - Maintains compatibility with react-hook-form and all existing functionality
+
 - **Problem List Not Updating After Submission**
   - Fixed problems not being removed from generator list after submitting a solution
   - Root cause: Sidebar unmounting fix (Dec 23) prevented natural data refresh on remount
@@ -58,6 +81,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - Updated CLAUDE.md with theming guidelines
 
 ### Tests
+- Added Guard Rail 4 unit tests for poor performance protection trigger conditions
+- Added escape hatch promotion type tracking tests (standard_volume_gate vs stagnation_escape_hatch)
+- Added backward compatibility tests for Guard Rails 1-3
 - Added regression test for timer settings cache clearing
 - Added regression tests for cross-context theme sync
 - Added comprehensive tests for `ProblemGeneratorHooks` message listeners
diff --git a/chrome-extension-app/public/manifest.json b/chrome-extension-app/public/manifest.json
index 30cec055..ec59563f 100644
--- a/chrome-extension-app/public/manifest.json
+++ b/chrome-extension-app/public/manifest.json
@@ -1,6 +1,6 @@
 {
   "name": "CodeMaster - Algorithm Learning Assistant",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Master algorithms with personalized spaced repetition and pattern ladders. Track your LeetCode progress with smart analytics.",
   "manifest_version": 3,
   "homepage_url": "https://github.com/smithrashell/CodeMaster",
@@ -46,8 +46,7 @@
       "run_at": "document_idle",
       "js": [
         "content.js"
-      ],
-      "media": []
+      ]
     }
   ],
   "web_accessible_resources": [
diff --git a/chrome-extension-app/src/background/handlers/problemHandlers.js b/chrome-extension-app/src/background/handlers/problemHandlers.js
index 40221fd1..2bd4e0bb 100644
--- a/chrome-extension-app/src/background/handlers/problemHandlers.js
+++ b/chrome-extension-app/src/background/handlers/problemHandlers.js
@@ -15,6 +15,13 @@
 import { ProblemService } from "../../shared/services/problem/problemService.js";
 import { AttemptsService } from "../../shared/services/attempts/attemptsService.js";
 import { getProblemWithOfficialDifficulty } from "../../shared/db/stores/problems.js";
+import {
+  weakenRelationshipsForSkip,
+  hasRelationshipsToAttempted,
+  findPrerequisiteProblem
+} from "../../shared/db/stores/problem_relationships.js";
+import { SessionService } from "../../shared/services/session/sessionService.js";
+import { getLatestSession } from "../../shared/db/stores/sessions.js";
 
 /**
  * Handler: getProblemByDescription
@@ -113,13 +120,93 @@ export function handleProblemSubmitted(request, dependencies, sendResponse, fini
 
 /**
  * Handler: skipProblem
- * Acknowledges problem skip request
+ * Handles problem skip with reason-based behavior
+ *
+ * Skip reasons and their actions:
+ * - "too_difficult": Weaken graph relationships (if problem has connections)
+ * - "dont_understand": Find prerequisite problem as replacement
+ * - "not_relevant": Just remove from session
+ * - "other": Just remove from session
+ *
+ * Free skip: Problems with zero relationships to attempted problems get no graph penalty
  */
 export function handleSkipProblem(request, dependencies, sendResponse, finishRequest) {
-  console.log("⏭️ Skipping problem:", request.consentScriptData?.leetcode_id || "unknown");
-  // Acknowledge the skip request - no additional processing needed
-  sendResponse({ message: "Problem skipped successfully" });
-  finishRequest();
+  const leetcodeId = request.leetcodeId || request.problemData?.leetcode_id || request.consentScriptData?.leetcode_id;
+  const VALID_SKIP_REASONS = ['too_difficult', 'dont_understand', 'not_relevant', 'other'];
+  const skipReason = VALID_SKIP_REASONS.includes(request.skipReason) ? request.skipReason : 'other';
+
+  // Input validation
+  if (!leetcodeId) {
+    console.error("❌ skipProblem called without valid leetcodeId");
+    sendResponse({ error: "Invalid problem ID", message: "Problem skip failed" });
+    finishRequest();
+    return true;
+  }
+
+  console.log(`⏭️ Skipping problem ${leetcodeId} - Reason: ${skipReason}`);
+
+  (async () => {
+    try {
+      const result = {
+        message: "Problem skipped successfully",
+        skipReason,
+        prerequisite: null,
+        graphUpdated: false,
+        freeSkip: false
+      };
+
+      // Check if this is a "free skip" (no relationships to attempted problems)
+      const hasRelationships = await hasRelationshipsToAttempted(leetcodeId);
+      result.freeSkip = !hasRelationships;
+
+      // Handle based on skip reason
+      if (skipReason === 'too_difficult') {
+        // Weaken graph relationships for "too difficult" skips (if has relationships)
+        if (hasRelationships) {
+          const weakenResult = await weakenRelationshipsForSkip(leetcodeId);
+          result.graphUpdated = weakenResult.updated > 0;
+          console.log(`📉 Graph updated: ${weakenResult.updated} relationships weakened`);
+        }
+        // Always remove from session
+        await SessionService.skipProblem(leetcodeId);
+        console.log(`✅ Removed problem ${leetcodeId} from session`);
+      } else if (skipReason === 'dont_understand') {
+        // Find prerequisite problem for "don't understand" skips
+        // Get current session to exclude problems already in it
+        const session = await getLatestSession();
+        const excludeIds = session?.problems?.map(p => p.leetcode_id) || [];
+
+        const prerequisite = await findPrerequisiteProblem(leetcodeId, excludeIds);
+        if (prerequisite) {
+          result.prerequisite = prerequisite;
+          result.replaced = true;
+          console.log(`🎓 Found prerequisite: ${prerequisite.title}`);
+          // Remove skipped problem and add prerequisite as replacement
+          await SessionService.skipProblem(leetcodeId, prerequisite);
+          console.log(`✅ Replaced problem ${leetcodeId} with prerequisite ${prerequisite.leetcode_id || prerequisite.id}`);
+        } else {
+          // No prerequisite found, just remove
+          await SessionService.skipProblem(leetcodeId);
+          console.log(`✅ Removed problem ${leetcodeId} from session (no prerequisite found)`);
+        }
+      } else {
+        // "not_relevant" or "other" - just remove from session
+        await SessionService.skipProblem(leetcodeId);
+        console.log(`✅ Removed problem ${leetcodeId} from session`);
+      }
+
+      sendResponse(result);
+    } catch (error) {
+      console.error("❌ Error in skipProblem handler:", error);
+      sendResponse({
+        message: "Problem skipped with errors",
+        error: error.message
+      });
+    } finally {
+      finishRequest();
+    }
+  })();
+
   return true;
 }
 
diff --git a/chrome-extension-app/src/content/App.jsx b/chrome-extension-app/src/content/App.jsx
index 143e5bed..a536bb2f 100644
--- a/chrome-extension-app/src/content/App.jsx
+++ b/chrome-extension-app/src/content/App.jsx
@@ -6,6 +6,7 @@ import ProbStat from "./features/statistics/ProblemStats";
 import Main, { Menubutton } from "./features/navigation/main";
 import ProbGen from "./features/problems/ProblemGenerator";
 import ProbTime from "./features/problems/ProblemTime";
+import SkipReason from "./features/problems/SkipReason";
 import Settings from "./features/settings/settings";
 import TimerBanner from "./components/timer/timercomponent";
 // Removed Mantine CSS import - not needed in content script
@@ -252,6 +253,19 @@ const Router = () => {
               </div>
             }
           />
+          <Route
+            path="/SkipReason"
+            element={
+              <div className="main-content">
+                <ErrorBoundary
+                  section="Skip Reason"
+                  fallback={GenericErrorFallback}
+                >
+                  <SkipReason />
+                </ErrorBoundary>
+              </div>
+            }
+          />
           <Route
             path="/Timer"
             element={
diff --git a/chrome-extension-app/src/content/css/main.css b/chrome-extension-app/src/content/css/main.css
index e302e572..afb492d8 100644
--- a/chrome-extension-app/src/content/css/main.css
+++ b/chrome-extension-app/src/content/css/main.css
@@ -357,10 +357,9 @@ body[data-theme="light"] .cm-extension #cm-menuButton:hover {
   );
   height: 100vh;
   max-height: 100vh;
-  /* Prevent affecting page layout */
-  contain: layout size style;
-  /* Ensure sidebar doesn't compete with dropdown z-index */
-  z-index: 9000 !important;
+  /* Prevent affecting page layout - use paint/style containment only
+     Note: 'layout' containment can break native <select> dropdowns */
+  contain: paint style;
   padding: var(--cm-content-padding);
   background-color: var(--cm-bg);
   border: 2px solid var(--cm-bg);
diff --git a/chrome-extension-app/src/content/css/probrec.css b/chrome-extension-app/src/content/css/probrec.css
index 632b6376..cc24d44d 100644
--- a/chrome-extension-app/src/content/css/probrec.css
+++ b/chrome-extension-app/src/content/css/probrec.css
@@ -1701,7 +1701,8 @@ html body .cm-extension .cd-sidenav.problem-sidebar-view .cd-sidenav__content {
   scroll-behavior: smooth !important;
   /* Ensure content can't escape container */
   position: relative !important;
-  contain: layout !important;
+  /* Use paint/style containment only - layout containment breaks native <select> dropdowns */
+  contain: paint style !important;
 }
 
 /* Override height constraints when strategy map content is expanded */
@@ -1736,8 +1737,8 @@ html body .cm-extension .cm-sidenav.problem-sidebar-view,
 html body .cm-extension .cd-sidenav.problem-sidebar-view,
 html body .problem-sidebar {
   overflow-y: visible !important;
-  /* Ensure parent allows child to handle overflow */
-  contain: layout !important;
+  /* Use paint/style containment only - layout containment breaks native <select> dropdowns */
+  contain: paint style !important;
 }
 
 /* COPY EXISTING APP SCROLLBAR STYLING FOR PROBLEM SIDEBAR */
@@ -2435,4 +2436,140 @@ button.tag-strategy-button-expanded,
   box-sizing: border-box !important;
 }
 
+/* ============================================================================
+   SKIP REASON PAGE STYLES
+   ============================================================================ */
+
+.cm-extension .skip-reason-container {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+  padding: 8px 0;
+}
+
+.cm-extension .skip-reason-prompt {
+  font-size: 14px;
+  color: var(--cm-text);
+  margin: 0;
+  line-height: 1.5;
+}
+
+.cm-extension .skip-reason-prompt strong {
+  color: var(--cm-text);
+}
+
+.cm-extension .skip-reason-options {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+
+.cm-extension .skip-reason-option {
+  display: flex;
+  align-items: flex-start;
+  gap: 12px;
+  padding: 12px;
+  border: 1px solid var(--cm-border);
+  border-radius: 8px;
+  background-color: var(--cm-card-bg);
+  cursor: pointer;
+  transition: all 0.15s ease;
+  text-align: left;
+  width: 100%;
+}
+
+.cm-extension .skip-reason-option:hover {
+  border-color: var(--cm-primary);
+  background-color: var(--cm-bg-secondary);
+}
+
+.cm-extension .skip-reason-option.selected {
+  border-color: var(--cm-primary);
+  background-color: var(--cm-accent-bg);
+}
+
+.cm-extension .skip-reason-emoji {
+  font-size: 20px;
+  line-height: 1;
+  flex-shrink: 0;
+}
+
+.cm-extension .skip-reason-text {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+}
+
+.cm-extension .skip-reason-label {
+  font-size: 14px;
+  font-weight: 500;
+  color: var(--cm-text);
+}
+
+.cm-extension .skip-reason-description {
+  font-size: 12px;
+  color: var(--cm-text-dimmed);
+}
+
+.cm-extension .skip-reason-other-input {
+  width: 100%;
+  padding: 10px 12px;
+  border: 1px solid var(--cm-border);
+  border-radius: 6px;
+  background-color: var(--cm-card-bg);
+  color: var(--cm-text);
+  font-size: 13px;
+  font-family: inherit;
+  resize: vertical;
+  min-height: 60px;
+}
+
+.cm-extension .skip-reason-other-input:focus {
+  outline: none;
+  border-color: var(--cm-primary);
+}
+
+.cm-extension .skip-reason-other-input::placeholder {
+  color: var(--cm-text-dimmed);
+}
+
+.cm-extension .skip-reason-actions {
+  display: flex;
+  gap: 8px;
+  margin-top: 8px;
+}
+
+.cm-extension .skip-reason-cancel-btn {
+  flex: 1;
+}
+
+.cm-extension .skip-reason-submit-btn {
+  flex: 2;
+}
+
+.cm-extension .skip-reason-submit-btn:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+.cm-extension .skip-reason-hint {
+  font-size: 12px;
+  color: var(--cm-text-dimmed);
+  background-color: var(--cm-accent-bg);
+  padding: 10px 12px;
+  border-radius: 6px;
+  margin: 0;
+  line-height: 1.4;
+}
+
+.cm-extension .skip-reason-error {
+  font-size: 13px;
+  color: var(--cm-status-hard);
+  background-color: rgba(239, 68, 68, 0.1);
+  padding: 10px 12px;
+  border-radius: 6px;
+  margin: 0;
+  line-height: 1.4;
+}
+
 
diff --git a/chrome-extension-app/src/content/features/problems/ProblemDetail.jsx b/chrome-extension-app/src/content/features/problems/ProblemDetail.jsx
index 64ded01d..daedd9ec 100644
--- a/chrome-extension-app/src/content/features/problems/ProblemDetail.jsx
+++ b/chrome-extension-app/src/content/features/problems/ProblemDetail.jsx
@@ -112,7 +112,7 @@ const useProblemData = (routeState) => {
 /**
  * Navigation and action handlers
  */
-const useProblemActions = ({ navigate, setIsAppOpen, problemData, interviewConfig, sessionType, routeState, showPageTour }) => {
+const useProblemActions = ({ navigate, setIsAppOpen, problemData, interviewConfig, sessionType, _routeState, showPageTour }) => {
   const _handleClose = () => {
     setIsAppOpen(false);
   };
@@ -140,13 +140,11 @@ const useProblemActions = ({ navigate, setIsAppOpen, problemData, interviewConfi
   };
 
   const handleSkip = () => {
-    if (chrome?.runtime?.sendMessage) {
-      chrome.runtime.sendMessage({
-        type: "skipProblem",
-        consentScriptData: routeState?.problemData,
-      });
-    }
-    navigate("/Probgen");
+    navigate("/SkipReason", {
+      state: {
+        problemData: problemData,
+      },
+    });
   };
 
   return { handleNewAttempt, handleSkip };
@@ -377,7 +375,7 @@ const ProbDetail = ({ isLoading }) => {
   const { showTour: showPageTour } = usePageTour();
   
   const { handleNewAttempt, handleSkip } = useProblemActions({
-    navigate, setIsAppOpen, problemData: finalProblemData, interviewConfig, sessionType, routeState, showPageTour
+    navigate, setIsAppOpen, problemData: finalProblemData, interviewConfig, sessionType, _routeState: routeState, showPageTour
   });
 
   // Memoize problem tags to prevent array recreation
diff --git a/chrome-extension-app/src/content/features/problems/SkipReason.jsx b/chrome-extension-app/src/content/features/problems/SkipReason.jsx
new file mode 100644
index 00000000..7a61ca52
--- /dev/null
+++ b/chrome-extension-app/src/content/features/problems/SkipReason.jsx
@@ -0,0 +1,186 @@
+import { useState } from "react";
+import { useLocation, useNavigate } from "react-router-dom";
+import "../../css/probrec.css";
+import Header from "../../components/navigation/header";
+import { useNav } from "../../../shared/provider/navprovider";
+import { useAnimatedClose } from "../../../shared/hooks/useAnimatedClose";
+import Button from "../../components/ui/Button.jsx";
+import ChromeAPIErrorHandler from "../../../shared/services/chrome/chromeAPIErrorHandler.js";
+import logger from "../../../shared/utils/logging/logger.js";
+
+const SKIP_REASONS = [
+  {
+    value: 'too_difficult',
+    label: 'Too difficult',
+    description: 'This problem is above my current skill level',
+    emoji: '🔥'
+  },
+  {
+    value: 'dont_understand',
+    label: "Don't understand",
+    description: 'The problem statement or concept is unclear',
+    emoji: '❓'
+  },
+  {
+    value: 'not_relevant',
+    label: 'Not relevant',
+    description: "This problem doesn't fit my learning goals",
+    emoji: '🎯'
+  },
+  {
+    value: 'other',
+    label: 'Other',
+    description: 'Another reason',
+    emoji: '💭'
+  },
+];
+
+const SkipReasonOption = ({ reason, isSelected, onSelect }) => (
+  <button
+    className={`skip-reason-option ${isSelected ? 'selected' : ''}`}
+    onClick={() => onSelect(reason.value)}
+    type="button"
+  >
+    <span className="skip-reason-emoji">{reason.emoji}</span>
+    <div className="skip-reason-text">
+      <span className="skip-reason-label">{reason.label}</span>
+      <span className="skip-reason-description">{reason.description}</span>
+    </div>
+  </button>
+);
+
+function SkipReason() {
+  const { isAppOpen, setIsAppOpen } = useNav();
+  const { shouldRender, isClosing } = useAnimatedClose(isAppOpen);
+  const { state: routeState } = useLocation();
+  const navigate = useNavigate();
+
+  const [selectedReason, setSelectedReason] = useState(null);
+  const [otherText, setOtherText] = useState('');
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const [error, setError] = useState(null);
+
+  const problemData = routeState?.problemData;
+  const problemTitle = problemData?.title || 'this problem';
+  const MAX_OTHER_TEXT_LENGTH = 500;
+
+  const handleClose = () => {
+    setIsAppOpen(false);
+  };
+
+  const handleBack = () => {
+    navigate(-1);
+  };
+
+  const handleSubmit = async () => {
+    if (!selectedReason || isSubmitting) return;
+
+    setIsSubmitting(true);
+    setError(null);
+
+    try {
+      // Sanitize otherText input
+      const sanitizedOtherText = selectedReason === 'other'
+        ? otherText?.trim().slice(0, MAX_OTHER_TEXT_LENGTH) || null
+        : null;
+
+      const response = await ChromeAPIErrorHandler.sendMessageWithRetry({
+        type: "skipProblem",
+        leetcodeId: problemData?.leetcode_id,
+        problemData: problemData,
+        skipReason: selectedReason,
+        otherText: sanitizedOtherText,
+      });
+
+      logger.info("Skip problem response:", response);
+
+      // Check for error in response
+      if (response?.error) {
+        setError(response.error);
+        setIsSubmitting(false);
+        return;
+      }
+
+      // Navigate back to generator - the prerequisite (if found) is now in the session
+      if (response?.prerequisite && response?.replaced) {
+        logger.info("Prerequisite added to session:", response.prerequisite.title);
+      }
+      // Go back to generator to show updated problem list
+      navigate("/Probgen");
+    } catch (err) {
+      logger.error("Error skipping problem:", err);
+      setError("Failed to skip problem. Please try again.");
+      setIsSubmitting(false);
+    }
+  };
+
+  if (!shouldRender) return null;
+
+  return (
+    <div
+      id="cm-mySidenav"
+      className={`cm-sidenav${isClosing ? ' cm-closing' : ''}`}
+    >
+      <Header title="Skip Problem" onClose={handleClose} />
+      <div className="cm-sidenav__content">
+        <div className="skip-reason-container">
+          <p className="skip-reason-prompt">
+            Why are you skipping <strong>{problemTitle}</strong>?
+          </p>
+
+          <div className="skip-reason-options">
+            {SKIP_REASONS.map((reason) => (
+              <SkipReasonOption
+                key={reason.value}
+                reason={reason}
+                isSelected={selectedReason === reason.value}
+                onSelect={setSelectedReason}
+              />
+            ))}
+          </div>
+
+          {selectedReason === 'other' && (
+            <textarea
+              className="skip-reason-other-input"
+              placeholder="Tell us more (optional)"
+              value={otherText}
+              onChange={(e) => setOtherText(e.target.value)}
+              maxLength={MAX_OTHER_TEXT_LENGTH}
+              rows={2}
+            />
+          )}
+
+          {error && (
+            <p className="skip-reason-error">{error}</p>
+          )}
+
+          <div className="skip-reason-actions">
+            <Button
+              variant="ghost"
+              onClick={handleBack}
+              className="skip-reason-cancel-btn"
+            >
+              Cancel
+            </Button>
+            <Button
+              variant="default"
+              onClick={handleSubmit}
+              disabled={!selectedReason || isSubmitting}
+              className="skip-reason-submit-btn"
+            >
+              {isSubmitting ? 'Skipping...' : 'Skip Problem'}
+            </Button>
+          </div>
+
+          {selectedReason === 'dont_understand' && (
+            <p className="skip-reason-hint">
+              We will try to find an easier related problem to help you understand the concepts.
+            </p>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}
+
+export default SkipReason;
diff --git a/chrome-extension-app/src/shared/components/ui/SimpleSelect.jsx b/chrome-extension-app/src/shared/components/ui/SimpleSelect.jsx
index a3187856..ff5874bb 100644
--- a/chrome-extension-app/src/shared/components/ui/SimpleSelect.jsx
+++ b/chrome-extension-app/src/shared/components/ui/SimpleSelect.jsx
@@ -1,16 +1,19 @@
-import React from 'react';
+import React, { useState, useRef, useEffect } from 'react';
 
 /**
- * SimpleSelect - A reusable, styled select component for Chrome extension content scripts
- * 
+ * SimpleSelect - A custom dropdown component for Chrome extension content scripts
+ *
+ * Uses a custom dropdown instead of native <select> to work around Chrome
+ * extension content script issues with native select dropdowns.
+ *
  * Features:
- * - Uses native HTML <select> for maximum compatibility
- * - Styled with CSS variables for theme consistency  
+ * - Custom dropdown that renders within React DOM (not browser native)
+ * - Styled with CSS variables for theme consistency
  * - Supports React.forwardRef for form libraries
- * - Custom dropdown arrow styling
+ * - Keyboard navigation (Arrow keys, Enter, Escape)
+ * - Click outside to close
  * - Focus and error states
- * - Lightweight alternative to complex UI libraries
- * 
+ *
  * @param {Object} props
  * @param {string} props.value - Current selected value
  * @param {Function} props.onChange - Change handler function
@@ -19,13 +22,110 @@ import React from 'react';
  * @param {...*} props.props - Additional props passed to select element
  * @param {Ref} ref - Forwarded ref for form libraries
  */
-const SimpleSelect = React.forwardRef(({ value, onChange, children, error, ...props }, ref) => (
-  <select
-    ref={ref}
-    value={value}
-    onChange={onChange}
-    className="cm-simple-select"
-    style={{
+const SimpleSelect = React.forwardRef(({ value, onChange, children, error, ...props }, ref) => {
+  const [isOpen, setIsOpen] = useState(false);
+  const [focusedIndex, setFocusedIndex] = useState(-1);
+  const containerRef = useRef(null);
+  const dropdownRef = useRef(null);
+
+  // Parse children to extract options
+  const options = React.Children.toArray(children)
+    .filter(child => child.type === 'option')
+    .map(child => ({
+      value: child.props.value,
+      label: child.props.children,
+      disabled: child.props.disabled
+    }));
+
+  // Find the currently selected option's label
+  const selectedOption = options.find(opt => String(opt.value) === String(value));
+  const displayText = selectedOption?.label || options[0]?.label || 'Select...';
+
+  // Close dropdown when clicking outside
+  useEffect(() => {
+    const handleClickOutside = (event) => {
+      if (containerRef.current && !containerRef.current.contains(event.target)) {
+        setIsOpen(false);
+      }
+    };
+
+    if (isOpen) {
+      // Use capture phase to catch events before they're stopped
+      document.addEventListener('mousedown', handleClickOutside, true);
+      return () => document.removeEventListener('mousedown', handleClickOutside, true);
+    }
+  }, [isOpen]);
+
+  // Handle keyboard navigation
+  const handleKeyDown = (e) => {
+    if (!isOpen) {
+      if (e.key === 'Enter' || e.key === ' ' || e.key === 'ArrowDown') {
+        e.preventDefault();
+        setIsOpen(true);
+        setFocusedIndex(options.findIndex(opt => String(opt.value) === String(value)));
+      }
+      return;
+    }
+
+    switch (e.key) {
+      case 'Escape':
+        e.preventDefault();
+        setIsOpen(false);
+        break;
+      case 'ArrowDown':
+        e.preventDefault();
+        setFocusedIndex(prev => {
+          const next = prev + 1;
+          return next >= options.length ? 0 : next;
+        });
+        break;
+      case 'ArrowUp':
+        e.preventDefault();
+        setFocusedIndex(prev => {
+          const next = prev - 1;
+          return next < 0 ? options.length - 1 : next;
+        });
+        break;
+      case 'Enter':
+      case ' ':
+        e.preventDefault();
+        if (focusedIndex >= 0 && !options[focusedIndex]?.disabled) {
+          handleSelect(options[focusedIndex].value);
+        }
+        break;
+      default:
+        break;
+    }
+  };
+
+  const handleSelect = (optionValue) => {
+    // Create a synthetic event similar to native select onChange
+    const syntheticEvent = {
+      target: { value: optionValue },
+      currentTarget: { value: optionValue },
+      preventDefault: () => {},
+      stopPropagation: () => {}
+    };
+    onChange(syntheticEvent);
+    setIsOpen(false);
+  };
+
+  const toggleDropdown = (e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    setIsOpen(!isOpen);
+    if (!isOpen) {
+      setFocusedIndex(options.findIndex(opt => String(opt.value) === String(value)));
+    }
+  };
+
+  const baseStyles = {
+    container: {
+      position: 'relative',
+      width: '100%',
+      maxWidth: '100%',
+    },
+    trigger: {
       width: '100%',
       maxWidth: '100%',
       padding: '6px 8px',
@@ -39,29 +139,133 @@ const SimpleSelect = React.forwardRef(({ value, onChange, children, error, ...pr
       cursor: 'pointer',
       transition: 'all 0.2s ease',
       boxShadow: '0 1px 2px rgba(0, 0, 0, 0.05)',
-      appearance: 'none', // Remove default styling
       backgroundImage: `url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' fill='none' viewBox='0 0 20 20'%3e%3cpath stroke='%236b7280' stroke-linecap='round' stroke-linejoin='round' stroke-width='1.5' d='M6 8l4 4 4-4'/%3e%3c/svg%3e")`,
       backgroundPosition: 'right 8px center',
       backgroundRepeat: 'no-repeat',
       backgroundSize: '16px',
-      paddingRight: '32px'
-    }}
-    onFocus={(e) => {
-      e.target.style.borderColor = error ? '#ef4444' : 'var(--cm-active-blue)';
-      e.target.style.boxShadow = error 
-        ? '0 0 0 3px rgba(239, 68, 68, 0.1)' 
-        : '0 0 0 3px rgba(37, 99, 235, 0.1)';
-    }}
-    onBlur={(e) => {
-      e.target.style.borderColor = error ? '#ef4444' : 'var(--cm-border)';
-      e.target.style.boxShadow = '0 1px 2px rgba(0, 0, 0, 0.05)';
-    }}
-    {...props}
-  >
-    {children}
-  </select>
-));
+      paddingRight: '32px',
+      textAlign: 'left',
+      display: 'block',
+    },
+    dropdown: {
+      position: 'absolute',
+      top: '100%',
+      left: 0,
+      right: 0,
+      marginTop: '4px',
+      backgroundColor: 'var(--cm-card-bg)',
+      border: '1px solid var(--cm-border)',
+      borderRadius: '6px',
+      boxShadow: '0 4px 12px rgba(0, 0, 0, 0.15)',
+      zIndex: 10000,
+      maxHeight: '200px',
+      overflowY: 'auto',
+      overflowX: 'hidden',
+    },
+    option: {
+      padding: '8px 12px',
+      cursor: 'pointer',
+      fontSize: '13px',
+      color: 'var(--cm-text)',
+      backgroundColor: 'transparent',
+      transition: 'background-color 0.15s ease',
+      textAlign: 'left',
+    },
+    optionHovered: {
+      backgroundColor: 'var(--cm-active-blue)',
+      color: 'white',
+    },
+    optionSelected: {
+      backgroundColor: 'rgba(37, 99, 235, 0.1)',
+    },
+    optionDisabled: {
+      color: 'var(--cm-link-color)',
+      cursor: 'not-allowed',
+      opacity: 0.6,
+    }
+  };
+
+  return (
+    <div
+      ref={containerRef}
+      style={baseStyles.container}
+      className="cm-simple-select-container"
+    >
+      <button
+        ref={ref}
+        type="button"
+        onClick={toggleDropdown}
+        onKeyDown={handleKeyDown}
+        style={{
+          ...baseStyles.trigger,
+          borderColor: isOpen
+            ? (error ? '#ef4444' : 'var(--cm-active-blue)')
+            : (error ? '#ef4444' : 'var(--cm-border)'),
+          boxShadow: isOpen
+            ? (error ? '0 0 0 3px rgba(239, 68, 68, 0.1)' : '0 0 0 3px rgba(37, 99, 235, 0.1)')
+            : '0 1px 2px rgba(0, 0, 0, 0.05)',
+        }}
+        aria-haspopup="listbox"
+        aria-expanded={isOpen}
+        className="cm-simple-select"
+        {...props}
+      >
+        {displayText}
+      </button>
+
+      {isOpen && (
+        <div
+          ref={dropdownRef}
+          style={baseStyles.dropdown}
+          role="listbox"
+          className="cm-simple-select-dropdown"
+        >
+          {options.map((option, index) => {
+            const isSelected = String(option.value) === String(value);
+            const isFocused = index === focusedIndex;
+            const isDisabled = option.disabled;
+
+            return (
+              <div
+                key={option.value}
+                role="option"
+                tabIndex={isDisabled ? -1 : 0}
+                aria-selected={isSelected}
+                aria-disabled={isDisabled}
+                onClick={(e) => {
+                  e.preventDefault();
+                  e.stopPropagation();
+                  if (!isDisabled) {
+                    handleSelect(option.value);
+                  }
+                }}
+                onKeyDown={(e) => {
+                  if (e.key === 'Enter' || e.key === ' ') {
+                    e.preventDefault();
+                    if (!isDisabled) {
+                      handleSelect(option.value);
+                    }
+                  }
+                }}
+                onMouseEnter={() => !isDisabled && setFocusedIndex(index)}
+                style={{
+                  ...baseStyles.option,
+                  ...(isSelected && !isFocused ? baseStyles.optionSelected : {}),
+                  ...(isFocused && !isDisabled ? baseStyles.optionHovered : {}),
+                  ...(isDisabled ? baseStyles.optionDisabled : {}),
+                }}
+                className="cm-simple-select-option"
+              >
+                {option.label}
+              </div>
+            );
+          })}
+        </div>
+      )}
+    </div>
+  );
+});
 
 SimpleSelect.displayName = 'SimpleSelect';
 
-export default SimpleSelect;
\ No newline at end of file
+export default SimpleSelect;
diff --git a/chrome-extension-app/src/shared/db/stores/__tests__/sessionEscapeHatchHelpers.test.js b/chrome-extension-app/src/shared/db/stores/__tests__/sessionEscapeHatchHelpers.test.js
new file mode 100644
index 00000000..1ace2b69
--- /dev/null
+++ b/chrome-extension-app/src/shared/db/stores/__tests__/sessionEscapeHatchHelpers.test.js
@@ -0,0 +1,316 @@
+/**
+ * Tests for Session Escape Hatch Helpers
+ *
+ * Tests promotion type tracking (current_promotion_type) used by
+ * Guard Rail 4 (poor performance protection) in session composition.
+ */
+
+import { applyEscapeHatchLogic } from '../sessionEscapeHatchHelpers.js';
+
+// Mock logger to suppress console output during tests
+jest.mock('../../../utils/logging/logger.js', () => ({
+  __esModule: true,
+  default: {
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    debug: jest.fn(),
+  },
+}));
+
+// Mock sessionAnalytics (not used in these specific tests but imported by the module)
+jest.mock('../sessionAnalytics.js', () => ({
+  getRecentSessionAnalytics: jest.fn(() => Promise.resolve([])),
+}));
+
+describe('Session Escape Hatch Helpers', () => {
+  // Suppress console.log from the source file
+  beforeEach(() => {
+    jest.spyOn(console, 'log').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe('current_promotion_type tracking', () => {
+    it('initializes current_promotion_type as null for new session state', () => {
+      const sessionState = {
+        current_difficulty_cap: 'Easy',
+        difficulty_time_stats: {
+          easy: { problems: 0, total_time: 0, avg_time: 0 },
+          medium: { problems: 0, total_time: 0, avg_time: 0 },
+          hard: { problems: 0, total_time: 0, avg_time: 0 }
+        }
+      };
+
+      applyEscapeHatchLogic(sessionState, 0.8, {}, new Date());
+
+      expect(sessionState.escape_hatches).toBeDefined();
+      expect(sessionState.escape_hatches.current_promotion_type).toBeNull();
+    });
+
+    it('sets current_promotion_type to standard_volume_gate on standard promotion', () => {
+      const sessionState = {
+        current_difficulty_cap: 'Easy',
+        difficulty_time_stats: {
+          easy: { problems: 4, total_time: 2400, avg_time: 600 },
+          medium: { problems: 0, total_time: 0, avg_time: 0 },
+          hard: { problems: 0, total_time: 0, avg_time: 0 }
+        }
+      };
+
+      // 4 problems + 80% accuracy = standard promotion criteria met
+      applyEscapeHatchLogic(sessionState, 0.8, {}, new Date());
+
+      expect(sessionState.current_difficulty_cap).toBe('Medium');
+      expect(sessionState.escape_hatches.current_promotion_type).toBe('standard_volume_gate');
+    });
+
+    it('sets current_promotion_type to stagnation_escape_hatch on stagnation promotion', () => {
+      const sessionState = {
+        current_difficulty_cap: 'Easy',
+        difficulty_time_stats: {
+          easy: { problems: 8, total_time: 4800, avg_time: 600 },
+          medium: { problems: 0, total_time: 0, avg_time: 0 },
+          hard: { problems: 0, total_time: 0, avg_time: 0 }
+        }
+      };
+
+      // 8 problems = stagnation escape (regardless of accuracy)
+      applyEscapeHatchLogic(sessionState, 0.3, {}, new Date());
+
+      expect(sessionState.current_difficulty_cap).toBe('Medium');
+      expect(sessionState.escape_hatches.current_promotion_type).toBe('stagnation_escape_hatch');
+    });
+
+    it('preserves current_promotion_type across calls without promotion', () => {
+      const sessionState = {
+        current_difficulty_cap: 'Hard',
+        difficulty_time_stats: {
+          easy: { problems: 0, total_time: 0, avg_time: 0 },
+          medium: { problems: 0, total_time: 0, avg_time: 0 },
+          hard: { problems: 2, total_time: 3600, avg_time: 1800 }
+        },
+        escape_hatches: {
+          sessions_at_current_difficulty: 3,
+          current_promotion_type: 'stagnation_escape_hatch',
+          activated_escape_hatches: [],
+          last_difficulty_promotion: '2024-01-01T00:00:00.000Z',
+          sessions_without_promotion: 0
+        }
+      };
+
+      // No promotion should occur (already at Hard, not enough problems)
+      applyEscapeHatchLogic(sessionState, 0.5, {}, new Date());
+
+      // Promotion type should be preserved since no new promotion occurred
+      expect(sessionState.escape_hatches.current_promotion_type).toBe('stagnation_escape_hatch');
+    });
+
+    it('clears activated_escape_hatches on promotion but keeps promotion type', () => {
+      const sessionState = {
+        current_difficulty_cap: 'Easy',
+        difficulty_time_stats: {
+          easy: { problems: 8, total_time: 4800, avg_time: 600 },
+          medium: { problems: 0, total_time: 0, avg_time: 0 },
+          hard: { problems: 0, total_time: 0, avg_time: 0 }
+        },
+        escape_hatches: {
+          sessions_at_current_difficulty: 5,
+          current_promotion_type: null,
+          activated_escape_hatches: ['some-previous-hatch'],
+          last_difficulty_promotion: null,
+          sessions_without_promotion: 3
+        }
+      };
+
+      applyEscapeHatchLogic(sessionState, 0.3, {}, new Date());
+
+      // After promotion, activated_escape_hatches should be cleared
+      expect(sessionState.escape_hatches.activated_escape_hatches).toEqual([]);
+      // But promotion type should be set
+      expect(sessionState.escape_hatches.current_promotion_type).toBe('stagnation_escape_hatch');
+    });
+
+    it('tracks stagnation activation in activated_escape_hatches before promotion', () => {
+      const sessionState = {
+        current_difficulty_cap: 'Easy',
+        difficulty_time_stats: {
+          easy: { problems: 8, total_time: 4800, avg_time: 600 },
+          medium: { problems: 0, total_time: 0, avg_time: 0 },
+          hard: { problems: 0, total_time: 0, avg_time: 0 }
+        }
+      };
+
+      applyEscapeHatchLogic(sessionState, 0.3, {}, new Date());
+
+      // After promotion via stagnation, activated_escape_hatches is cleared
+      // but we can verify the promotion type indicates stagnation
+      expect(sessionState.escape_hatches.current_promotion_type).toBe('stagnation_escape_hatch');
+    });
+  });
+
+  describe('standard promotion flow', () => {
+    it('promotes from Easy to Medium with 4+ problems and 80%+ accuracy', () => {
+      const sessionState = {
+        current_difficulty_cap: 'Easy',
+        difficulty_time_stats: {
+          easy: { problems: 5, total_time: 3000, avg_time: 600 },
+          medium: { problems: 0, total_time: 0, avg_time: 0 },
+          hard: { problems: 0, total_time: 0, avg_time: 0 }
+        }
+      };
+
+      applyEscapeHatchLogic(sessionState, 0.85, {}, new Date());
+
+      expect(sessionState.current_difficulty_cap).toBe('Medium');
+      expect(sessionState.escape_hatches.current_promotion_type).toBe('standard_volume_gate');
+    });
+
+    it('promotes from Medium to Hard with 4+ problems and 80%+ accuracy', () => {
+      const sessionState = {
+        current_difficulty_cap: 'Medium',
+        difficulty_time_stats: {
+          easy: { problems: 0, total_time: 0, avg_time: 0 },
+          medium: { problems: 4, total_time: 4800, avg_time: 1200 },
+          hard: { problems: 0, total_time: 0, avg_time: 0 }
+        }
+      };
+
+      applyEscapeHatchLogic(sessionState, 0.8, {}, new Date());
+
+      expect(sessionState.current_difficulty_cap).toBe('Hard');
+      expect(sessionState.escape_hatches.current_promotion_type).toBe('standard_volume_gate');
+    });
+
+    it('does NOT promote when accuracy below 80% and problems below 8', () => {
+      const sessionState = {
+        current_difficulty_cap: 'Easy',
+        difficulty_time_stats: {
+          easy: { problems: 4, total_time: 2400, avg_time: 600 },
+          medium: { problems: 0, total_time: 0, avg_time: 0 },
+          hard: { problems: 0, total_time: 0, avg_time: 0 }
+        }
+      };
+
+      applyEscapeHatchLogic(sessionState, 0.7, {}, new Date());
+
+      expect(sessionState.current_difficulty_cap).toBe('Easy');
+      expect(sessionState.escape_hatches.current_promotion_type).toBeNull();
+    });
+  });
+
+  describe('stagnation escape flow', () => {
+    it('promotes via stagnation with 8+ problems regardless of accuracy', () => {
+      const sessionState = {
+        current_difficulty_cap: 'Medium',
+        difficulty_time_stats: {
+          easy: { problems: 0, total_time: 0, avg_time: 0 },
+          medium: { problems: 10, total_time: 12000, avg_time: 1200 },
+          hard: { problems: 0, total_time: 0, avg_time: 0 }
+        }
+      };
+
+      // Even with very low accuracy
+      applyEscapeHatchLogic(sessionState, 0.2, {}, new Date());
+
+      expect(sessionState.current_difficulty_cap).toBe('Hard');
+      expect(sessionState.escape_hatches.current_promotion_type).toBe('stagnation_escape_hatch');
+    });
+
+    it('prefers standard promotion over stagnation when both criteria met', () => {
+      const sessionState = {
+        current_difficulty_cap: 'Easy',
+        difficulty_time_stats: {
+          easy: { problems: 10, total_time: 6000, avg_time: 600 },
+          medium: { problems: 0, total_time: 0, avg_time: 0 },
+          hard: { problems: 0, total_time: 0, avg_time: 0 }
+        }
+      };
+
+      // Both standard (10 >= 4, 90% >= 80%) and stagnation (10 >= 8) criteria met
+      applyEscapeHatchLogic(sessionState, 0.9, {}, new Date());
+
+      expect(sessionState.current_difficulty_cap).toBe('Medium');
+      // Standard promotion takes precedence
+      expect(sessionState.escape_hatches.current_promotion_type).toBe('standard_volume_gate');
+    });
+  });
+
+  describe('Hard cap behavior', () => {
+    it('does NOT promote beyond Hard', () => {
+      const sessionState = {
+        current_difficulty_cap: 'Hard',
+        difficulty_time_stats: {
+          easy: { problems: 0, total_time: 0, avg_time: 0 },
+          medium: { problems: 0, total_time: 0, avg_time: 0 },
+          hard: { problems: 10, total_time: 18000, avg_time: 1800 }
+        },
+        escape_hatches: {
+          sessions_at_current_difficulty: 5,
+          current_promotion_type: 'standard_volume_gate',
+          activated_escape_hatches: [],
+          last_difficulty_promotion: '2024-01-01T00:00:00.000Z',
+          sessions_without_promotion: 0
+        }
+      };
+
+      const initialPromotionType = sessionState.escape_hatches.current_promotion_type;
+      applyEscapeHatchLogic(sessionState, 0.95, {}, new Date());
+
+      // Should still be at Hard
+      expect(sessionState.current_difficulty_cap).toBe('Hard');
+      // Promotion type should be preserved (no new promotion occurred)
+      expect(sessionState.escape_hatches.current_promotion_type).toBe(initialPromotionType);
+    });
+  });
+
+  describe('sessions_at_current_difficulty tracking', () => {
+    it('resets sessions_at_current_difficulty on promotion', () => {
+      const sessionState = {
+        current_difficulty_cap: 'Easy',
+        difficulty_time_stats: {
+          easy: { problems: 4, total_time: 2400, avg_time: 600 },
+          medium: { problems: 0, total_time: 0, avg_time: 0 },
+          hard: { problems: 0, total_time: 0, avg_time: 0 }
+        },
+        escape_hatches: {
+          sessions_at_current_difficulty: 5,
+          current_promotion_type: null,
+          activated_escape_hatches: [],
+          last_difficulty_promotion: null,
+          sessions_without_promotion: 3
+        }
+      };
+
+      applyEscapeHatchLogic(sessionState, 0.8, {}, new Date());
+
+      // After promotion, sessions counter should be reset to 0
+      expect(sessionState.escape_hatches.sessions_at_current_difficulty).toBe(0);
+    });
+
+    it('increments sessions_at_current_difficulty when no promotion', () => {
+      const sessionState = {
+        current_difficulty_cap: 'Easy',
+        difficulty_time_stats: {
+          easy: { problems: 2, total_time: 1200, avg_time: 600 },
+          medium: { problems: 0, total_time: 0, avg_time: 0 },
+          hard: { problems: 0, total_time: 0, avg_time: 0 }
+        },
+        escape_hatches: {
+          sessions_at_current_difficulty: 3,
+          current_promotion_type: null,
+          activated_escape_hatches: [],
+          last_difficulty_promotion: null,
+          sessions_without_promotion: 2
+        }
+      };
+
+      applyEscapeHatchLogic(sessionState, 0.5, {}, new Date());
+
+      // Should be incremented (3 + 1 = 4)
+      expect(sessionState.escape_hatches.sessions_at_current_difficulty).toBe(4);
+    });
+  });
+});
diff --git a/chrome-extension-app/src/shared/db/stores/problem_relationships.js b/chrome-extension-app/src/shared/db/stores/problem_relationships.js
index 8378f4c9..0ac2d7e6 100644
--- a/chrome-extension-app/src/shared/db/stores/problem_relationships.js
+++ b/chrome-extension-app/src/shared/db/stores/problem_relationships.js
@@ -867,3 +867,229 @@ export function calculateAndTrimProblemRelationships({
 
   return { problemGraph, removedRelationships };
 }
+
+/**
+ * Weaken relationships for a skipped problem (used when user skips as "too difficult")
+ * Applies a penalty similar to failure (-0.4) to relationships with recent successful problems
+ * @param {number} problemId - The LeetCode ID of the skipped problem
+ * @returns {Promise<{updated: number}>} Number of relationships updated
+ */
+export async function weakenRelationshipsForSkip(problemId) {
+  if (!problemId) {
+    console.warn("⚠️ weakenRelationshipsForSkip called without problemId");
+    return { updated: 0 };
+  }
+
+  console.log(`⏭️ Weakening relationships for skipped problem: ${problemId}`);
+
+  try {
+    // Get recent successful attempts
+    const recentSuccesses = await getUserRecentAttempts(5);
+
+    if (recentSuccesses.length === 0) {
+      console.log("📝 No recent successful attempts - nothing to weaken");
+      return { updated: 0 };
+    }
+
+    let updatedCount = 0;
+    const SKIP_PENALTY = -0.4; // Same as failure penalty
+
+    for (const recent of recentSuccesses) {
+      const recentId = recent.leetcode_id;
+      if (!recentId || recentId === problemId) continue;
+
+      // Get current strength
+      const currentStrength = await getRelationshipStrength(problemId, recentId);
+      const newStrength = Math.max(0.5, (currentStrength || 2.0) + SKIP_PENALTY);
+
+      // Update relationship strength
+      await updateRelationshipStrength(problemId, recentId, newStrength);
+      updatedCount++;
+
+      console.log(`  📉 Weakened ${problemId} <-> ${recentId}: ${currentStrength?.toFixed(2) || 'new'} -> ${newStrength.toFixed(2)}`);
+    }
+
+    console.log(`✅ Weakened ${updatedCount} relationships for skipped problem ${problemId}`);
+    return { updated: updatedCount };
+  } catch (error) {
+    console.error("❌ Error weakening relationships for skip:", error);
+    return { updated: 0 };
+  }
+}
+
+/**
+ * Get relationships for a specific problem using indexes (optimized)
+ * Instead of loading all 29,840 relationships, only loads relationships for this problem
+ * @param {number} problemId - The LeetCode ID to get relationships for
+ * @returns {Promise<Object>} Map of related problem IDs to strength values
+ */
+async function getRelationshipsForProblem(problemId) {
+  const db = await openDB();
+  const relationships = {};
+
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction("problem_relationships", "readonly");
+    const store = tx.objectStore("problem_relationships");
+
+    // Query using problem_id1 index
+    const index1 = store.index("problem_id1");
+    const request1 = index1.getAll(Number(problemId));
+
+    request1.onsuccess = () => {
+      const results = request1.result || [];
+      results.forEach(r => {
+        relationships[Number(r.problem_id2)] = r.strength;
+      });
+
+      // Also query problem_id2 index (bidirectional relationships)
+      const index2 = store.index("problem_id2");
+      const request2 = index2.getAll(Number(problemId));
+
+      request2.onsuccess = () => {
+        const results2 = request2.result || [];
+        results2.forEach(r => {
+          // Don't overwrite if already exists from problem_id1
+          if (!(Number(r.problem_id1) in relationships)) {
+            relationships[Number(r.problem_id1)] = r.strength;
+          }
+        });
+        resolve(relationships);
+      };
+      request2.onerror = () => reject(request2.error);
+    };
+    request1.onerror = () => reject(request1.error);
+  });
+}
+
+/**
+ * Check if a problem has any relationships to problems the user has attempted
+ * Used to determine if a skip should be "free" (no graph penalty)
+ * @param {number} problemId - The LeetCode ID to check
+ * @returns {Promise<boolean>} True if the problem has relationships to attempted problems
+ */
+export async function hasRelationshipsToAttempted(problemId) {
+  if (!problemId) return false;
+
+  try {
+    // Get only relationships for this specific problem (optimized - uses indexes)
+    const problemRelationships = await getRelationshipsForProblem(problemId);
+    const relatedIds = Object.keys(problemRelationships).map(Number);
+
+    if (relatedIds.length === 0) {
+      console.log(`📍 Problem ${problemId} has no relationships - free skip`);
+      return false;
+    }
+
+    // Get all attempted problem IDs from problems store
+    const db = await openDB();
+    const attemptedIds = await new Promise((resolve, reject) => {
+      const transaction = db.transaction("problems", "readonly");
+      const store = transaction.objectStore("problems");
+      const request = store.getAllKeys();  // Optimized: only get keys, not full records
+
+      request.onsuccess = () => {
+        const ids = new Set((request.result || []).map(Number));
+        resolve(ids);
+      };
+      request.onerror = () => reject(request.error);
+    });
+
+    // Check if any relationships connect to attempted problems
+    const hasConnection = relatedIds.some(id => attemptedIds.has(id));
+
+    console.log(`📍 Problem ${problemId} has ${relatedIds.length} relationships, ${hasConnection ? 'connected' : 'not connected'} to attempted problems`);
+    return hasConnection;
+  } catch (error) {
+    console.error("❌ Error checking relationships:", error);
+    return true; // Default to having relationships (safer)
+  }
+}
+
+/**
+ * Find a prerequisite (easier related) problem for "don't understand" skips
+ * @param {number} problemId - The LeetCode ID of the problem being skipped
+ * @param {Array<number>} excludeIds - Problem IDs to exclude (already in session)
+ * @returns {Promise<Object|null>} A prerequisite problem or null if none found
+ */
+export async function findPrerequisiteProblem(problemId, excludeIds = []) {
+  if (!problemId) return null;
+
+  console.log(`🔍 Finding prerequisite for problem ${problemId}`);
+
+  try {
+    // Get the skipped problem details
+    const allProblems = await fetchAllProblems();
+    const skippedProblem = allProblems.find(p =>
+      Number(p.leetcode_id) === Number(problemId) || Number(p.id) === Number(problemId)
+    );
+
+    if (!skippedProblem) {
+      console.warn(`⚠️ Could not find problem ${problemId} in database`);
+      return null;
+    }
+
+    const skippedTags = skippedProblem.Tags || skippedProblem.tags || [];
+    const skippedDifficulty = skippedProblem.difficulty || 'Medium';
+
+    // Determine target difficulty (one level easier)
+    const difficultyOrder = { 'Easy': 0, 'Medium': 1, 'Hard': 2 };
+    const targetDifficultyNum = Math.max(0, (difficultyOrder[skippedDifficulty] || 1) - 1);
+    const targetDifficulty = Object.keys(difficultyOrder).find(k => difficultyOrder[k] === targetDifficultyNum) || 'Easy';
+
+    console.log(`  Looking for ${targetDifficulty} problems with tags: ${skippedTags.slice(0, 3).join(', ')}`);
+
+    // Get relationships for this specific problem (optimized - uses indexes instead of loading all 29k records)
+    const problemRelationships = await getRelationshipsForProblem(problemId);
+
+    // Filter and score candidate problems
+    const excludeSet = new Set(excludeIds.map(Number));
+    excludeSet.add(Number(problemId));
+
+    const candidates = allProblems
+      .filter(p => {
+        const pId = Number(p.leetcode_id || p.id);
+        if (excludeSet.has(pId)) return false;
+
+        // Must be same or easier difficulty
+        const pDiff = difficultyOrder[p.difficulty] ?? 1;
+        if (pDiff > targetDifficultyNum) return false;
+
+        // Must share at least one tag
+        const pTags = p.Tags || p.tags || [];
+        const sharedTags = pTags.filter(t => skippedTags.includes(t));
+        if (sharedTags.length === 0) return false;
+
+        return true;
+      })
+      .map(p => {
+        const pId = Number(p.leetcode_id || p.id);
+        const pTags = p.Tags || p.tags || [];
+        const sharedTags = pTags.filter(t => skippedTags.includes(t));
+        const relationshipStrength = problemRelationships[pId] || 2.0;
+
+        // Score based on: shared tags, relationship strength, prefer easier
+        const tagScore = sharedTags.length / Math.max(skippedTags.length, 1);
+        const strengthScore = relationshipStrength / 5.0; // Normalize to 0-1
+        const difficultyBonus = difficultyOrder[p.difficulty] === targetDifficultyNum ? 0.2 : 0;
+
+        return {
+          problem: p,
+          score: tagScore * 0.4 + strengthScore * 0.4 + difficultyBonus + 0.2
+        };
+      })
+      .sort((a, b) => b.score - a.score);
+
+    if (candidates.length === 0) {
+      console.log(`  No prerequisite candidates found for problem ${problemId}`);
+      return null;
+    }
+
+    const best = candidates[0];
+    console.log(`✅ Found prerequisite: ${best.problem.title} (${best.problem.difficulty}) with score ${best.score.toFixed(2)}`);
+
+    return best.problem;
+  } catch (error) {
+    console.error("❌ Error finding prerequisite:", error);
+    return null;
+  }
+}
diff --git a/chrome-extension-app/src/shared/db/stores/sessionEscapeHatchHelpers.js b/chrome-extension-app/src/shared/db/stores/sessionEscapeHatchHelpers.js
index 68b64d93..18f6cd36 100644
--- a/chrome-extension-app/src/shared/db/stores/sessionEscapeHatchHelpers.js
+++ b/chrome-extension-app/src/shared/db/stores/sessionEscapeHatchHelpers.js
@@ -72,6 +72,7 @@ function initializeEscapeHatches(sessionState) {
       last_difficulty_promotion: null,
       sessions_without_promotion: 0,
       activated_escape_hatches: [],
+      current_promotion_type: null,  // 'standard_volume_gate' | 'stagnation_escape_hatch' | null
     };
   }
 
@@ -127,7 +128,8 @@ function promoteDifficulty(context, newDifficulty) {
   sessionState.current_difficulty_cap = newDifficulty;
   escapeHatches.last_difficulty_promotion = now.toISOString();
   escapeHatches.sessions_at_current_difficulty = 0;
-  escapeHatches.activated_escape_hatches = [];
+  escapeHatches.current_promotion_type = promotionReason;  // Store promotion type for session composition safety
+  escapeHatches.activated_escape_hatches = [];  // Clear activation history
 
   if (promotionReason === "stagnation_escape_hatch") {
     logger.info(`Difficulty cap upgraded via STAGNATION ESCAPE: ${oldDifficulty} → ${newDifficulty} (${problemsAtDifficulty} problems)`);
diff --git a/chrome-extension-app/src/shared/services/problem/problemService.js b/chrome-extension-app/src/shared/services/problem/problemService.js
index 6135b4c0..ae08bcac 100644
--- a/chrome-extension-app/src/shared/services/problem/problemService.js
+++ b/chrome-extension-app/src/shared/services/problem/problemService.js
@@ -299,11 +299,12 @@ export const ProblemService = {
     const deduplicated = deduplicateById(sessionProblems);
     const finalSession = deduplicated.slice(0, sessionLength);
 
-    await checkSafetyGuardRails(finalSession, currentDifficultyCap);
+    const { rebalancedSession } = await checkSafetyGuardRails(finalSession, currentDifficultyCap);
+    const sessionToNormalize = rebalancedSession || finalSession;
 
     logger.info("Normalizing session problems to standard structure...");
     const normalizedProblems = normalizeProblems(
-      finalSession.map((p, index) => ({ ...p, _sourceIndex: index, _hasUUID: !!p.problem_id })),
+      sessionToNormalize.map((p, index) => ({ ...p, _sourceIndex: index, _hasUUID: !!p.problem_id })),
       'session_creation'
     );
     logger.info(`Normalized ${normalizedProblems.length} problems`);
diff --git a/chrome-extension-app/src/shared/services/problem/problemServiceSession.js b/chrome-extension-app/src/shared/services/problem/problemServiceSession.js
index 58826fcf..2339205d 100644
--- a/chrome-extension-app/src/shared/services/problem/problemServiceSession.js
+++ b/chrome-extension-app/src/shared/services/problem/problemServiceSession.js
@@ -12,6 +12,9 @@ import { getTagMastery } from "../../db/stores/tag_mastery.js";
 import logger from "../../utils/logging/logger.js";
 import { selectOptimalProblems } from "../../db/stores/problem_relationships.js";
 import { applySafetyGuardRails } from "../../utils/session/sessionBalancing.js";
+import { getRecentSessionAnalytics } from "../../db/stores/sessionAnalytics.js";
+import { getPatternLadders } from "../../utils/leitner/patternLadderUtils.js";
+import { getTagRelationships } from "../../db/stores/tag_relationships.js";
 import {
   enrichReviewProblem,
   normalizeReviewProblem,
@@ -173,15 +176,158 @@ export function addFallbackProblems(sessionProblems, sessionLength, allProblems)
 export async function checkSafetyGuardRails(finalSession, currentDifficultyCap) {
   const sessionState = await StorageService.getSessionState();
   const sessionsAtCurrentDifficulty = sessionState?.escape_hatches?.sessions_at_current_difficulty || 0;
+  const currentPromotionType = sessionState?.escape_hatches?.current_promotion_type || null;
+
+  // Get recent performance for guard rail check
+  const recentPerformance = await getRecentPerformanceForGuardRails();
 
   const guardRailResult = applySafetyGuardRails(
     finalSession,
     currentDifficultyCap,
-    sessionsAtCurrentDifficulty
+    sessionsAtCurrentDifficulty,
+    recentPerformance,
+    currentPromotionType
   );
 
   if (guardRailResult.needsRebalance) {
     logger.warn(`Session difficulty imbalance detected: ${guardRailResult.message}`);
+
+    if (guardRailResult.guardRailType === 'poor_performance_protection') {
+      const rebalancedSession = await rebalanceSessionForPoorPerformance([...finalSession], guardRailResult);
+      return { rebalancedSession, guardRailResult };
+    }
+  }
+
+  return { rebalancedSession: null, guardRailResult };
+}
+
+async function getRecentPerformanceForGuardRails() {
+  try {
+    const recentAnalytics = await getRecentSessionAnalytics(3);
+    if (!recentAnalytics || recentAnalytics.length === 0) return null;
+
+    const totalAccuracy = recentAnalytics.reduce((sum, s) => sum + (s.accuracy || 0), 0);
+    return {
+      accuracy: totalAccuracy / recentAnalytics.length,
+      sessionsAnalyzed: recentAnalytics.length
+    };
+  } catch (error) {
+    logger.warn("Failed to get recent performance:", error);
+    return null;
+  }
+}
+
+async function rebalanceSessionForPoorPerformance(session, guardRailResult) {
+  const { excessHard, replacementDifficulty } = guardRailResult;
+
+  // Identify Hard problems to remove (from end of list)
+  const hardProblems = session.filter(p => p.difficulty === 'Hard');
+  const problemsToRemove = hardProblems.slice(-excessHard);
+  const removedIds = new Set(problemsToRemove.map(p => p.id || p.leetcode_id));
+
+  // Get tags from removed problems for finding related replacements
+  const removedTags = new Set();
+  problemsToRemove.forEach(p => {
+    (p.tags || []).forEach(tag => removedTags.add(tag.toLowerCase()));
+  });
+
+  // Find replacement problems from related ladders
+  const replacements = await findReplacementProblems(
+    Array.from(removedTags),
+    excessHard,
+    replacementDifficulty,
+    removedIds,
+    session
+  );
+
+  // Remove excess Hard problems
+  for (let i = session.length - 1; i >= 0; i--) {
+    const problemId = session[i].id || session[i].leetcode_id;
+    if (removedIds.has(problemId)) {
+      session.splice(i, 1);
+    }
+  }
+
+  // Add replacements
+  session.push(...replacements);
+
+  logger.info(`Rebalanced: removed ${excessHard} Hard, added ${replacements.length} ${replacementDifficulty}`);
+  return session;
+}
+
+async function findReplacementProblems(primaryTags, count, targetDifficulty, excludeIds, currentSession) {
+  try {
+    const ladders = await getPatternLadders();
+    const tagRelationships = await getTagRelationships();
+    const currentSessionIds = new Set(currentSession.map(p => p.id || p.leetcode_id));
+    const allExcludeIds = new Set([...excludeIds, ...currentSessionIds]);
+
+    const candidates = [];
+
+    // Step 1: Try primary tags first
+    for (const tag of primaryTags) {
+      const ladder = ladders[tag];
+      if (ladder?.problems) {
+        const matching = ladder.problems.filter(p =>
+          p.difficulty === targetDifficulty && !p.attempted && !allExcludeIds.has(p.id)
+        );
+        candidates.push(...matching.map(p => ({ ...p, sourceTag: tag, relationScore: 1.0 })));
+      }
+    }
+
+    // Step 2: Try related tags (sorted by relationship strength)
+    for (const tag of primaryTags) {
+      const related = tagRelationships[tag];
+      if (!related) continue;
+
+      // Sort related tags by strength (descending)
+      const sortedRelated = Object.entries(related)
+        .sort(([, a], [, b]) => b - a)
+        .slice(0, 5);  // Top 5 related tags
+
+      for (const [relatedTag, strength] of sortedRelated) {
+        if (candidates.length >= count * 2) break;
+
+        const ladder = ladders[relatedTag];
+        if (ladder?.problems) {
+          const matching = ladder.problems.filter(p =>
+            p.difficulty === targetDifficulty && !p.attempted && !allExcludeIds.has(p.id)
+          );
+          candidates.push(...matching.map(p => ({ ...p, sourceTag: relatedTag, relationScore: strength })));
+        }
+      }
+    }
+
+    // Step 3: Fall back to Easy if not enough Medium
+    if (candidates.length < count && targetDifficulty === 'Medium') {
+      for (const tag of primaryTags) {
+        const ladder = ladders[tag];
+        if (ladder?.problems) {
+          const easyProblems = ladder.problems.filter(p =>
+            p.difficulty === 'Easy' && !p.attempted && !allExcludeIds.has(p.id)
+          );
+          candidates.push(...easyProblems.map(p => ({ ...p, sourceTag: tag, relationScore: 0.5 })));
+        }
+      }
+    }
+
+    // Deduplicate and select top by relation score
+    candidates.sort((a, b) => b.relationScore - a.relationScore);
+    const seen = new Set();
+    const selected = [];
+    for (const candidate of candidates) {
+      if (selected.length >= count) break;
+      if (!seen.has(candidate.id)) {
+        seen.add(candidate.id);
+        selected.push(candidate);
+      }
+    }
+
+    logger.info(`Found ${selected.length} replacement problems from related ladders`);
+    return selected;
+  } catch (error) {
+    logger.error("Error finding replacement problems:", error);
+    return [];
   }
 }
 
diff --git a/chrome-extension-app/src/shared/services/session/sessionService.js b/chrome-extension-app/src/shared/services/session/sessionService.js
index dda06c94..8cc94702 100644
--- a/chrome-extension-app/src/shared/services/session/sessionService.js
+++ b/chrome-extension-app/src/shared/services/session/sessionService.js
@@ -23,6 +23,7 @@ import {
   getOrCreateSessionAtomic,
 } from "../../db/stores/sessions.js";
 import { ProblemService } from "../problem/problemService.js";
+import { normalizeProblem } from "../problem/problemNormalizer.js";
 import { StorageService } from "../storage/storageService.js";
 import { FocusCoordinationService } from "../focus/focusCoordinationService.js";
 import { v4 as uuidv4 } from "uuid";
@@ -872,15 +873,36 @@ export const SessionService = {
   },
 
   /**
-   * Skips a problem from the session.
+   * Skips a problem from the session, optionally replacing it with another.
+   * @param {number} leetCodeID - The LeetCode ID of the problem to skip
+   * @param {Object|null} replacementProblem - Optional problem to add as replacement
+   * @returns {Promise<Object|null>} The updated session or null
    */
-  async skipProblem(leetCodeID) {
+  async skipProblem(leetCodeID, replacementProblem = null) {
     const session = await getLatestSession();
     if (!session) return null;
 
+    // Remove the skipped problem
     session.problems = session.problems.filter(
       (p) => p.leetcode_id !== leetCodeID
     );
+
+    // Add replacement problem if provided
+    if (replacementProblem) {
+      const problemWithReason = {
+        ...replacementProblem,
+        selectionReason: {
+          type: 'prerequisite',
+          details: { skippedProblemId: leetCodeID },
+          shortText: 'Prerequisite',
+          fullText: 'Easier problem to help understand skipped concept'
+        }
+      };
+      const normalizedReplacement = normalizeProblem(problemWithReason, 'prerequisite');
+      session.problems.push(normalizedReplacement);
+      logger.info(`➕ Added prerequisite to session: ${normalizedReplacement.title}`);
+    }
+
     await saveSessionToStorage(session, true);
     return session;
   },
diff --git a/chrome-extension-app/src/shared/utils/__tests__/sessionBalancing.test.js b/chrome-extension-app/src/shared/utils/__tests__/sessionBalancing.test.js
new file mode 100644
index 00000000..f4ac1a27
--- /dev/null
+++ b/chrome-extension-app/src/shared/utils/__tests__/sessionBalancing.test.js
@@ -0,0 +1,244 @@
+/**
+ * Tests for Session Balancing Guard Rails
+ *
+ * Tests Guard Rail 4 (poor performance protection) and backward compatibility
+ * with existing guard rails 1-3.
+ */
+
+import { applySafetyGuardRails } from '../session/sessionBalancing.js';
+
+// Mock logger to suppress console output during tests
+jest.mock('../logging/logger.js', () => ({
+  __esModule: true,
+  default: {
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    debug: jest.fn(),
+  },
+}));
+
+describe('Session Balancing - Guard Rails', () => {
+  // Helper to create mock problems with specified difficulty distribution
+  const createProblems = (easy, medium, hard) => [
+    ...Array(easy).fill(null).map((_, i) => ({
+      id: i + 1,
+      difficulty: 'Easy',
+      title: `Easy Problem ${i + 1}`
+    })),
+    ...Array(medium).fill(null).map((_, i) => ({
+      id: easy + i + 1,
+      difficulty: 'Medium',
+      title: `Medium Problem ${i + 1}`
+    })),
+    ...Array(hard).fill(null).map((_, i) => ({
+      id: easy + medium + i + 1,
+      difficulty: 'Hard',
+      title: `Hard Problem ${i + 1}`
+    }))
+  ];
+
+  describe('Guard Rail 4: Poor Performance Protection', () => {
+    const stagnationPromotion = 'stagnation_escape_hatch';
+    const standardPromotion = 'standard_volume_gate';
+    const poorPerformance = { accuracy: 0.40, sessionsAnalyzed: 3 };
+    const goodPerformance = { accuracy: 0.60, sessionsAnalyzed: 3 };
+
+    it('triggers when all conditions met: Hard cap, stagnation, poor accuracy, multiple Hard', () => {
+      const problems = createProblems(2, 2, 3); // 3 Hard problems
+      const result = applySafetyGuardRails(problems, 'Hard', 5, poorPerformance, stagnationPromotion);
+
+      expect(result.needsRebalance).toBe(true);
+      expect(result.guardRailType).toBe('poor_performance_protection');
+      expect(result.excessHard).toBe(2); // 3 - 1 = 2 excess
+      expect(result.replacementDifficulty).toBe('Medium');
+    });
+
+    it('does NOT trigger when accuracy >= 50%', () => {
+      const problems = createProblems(2, 2, 3);
+      const result = applySafetyGuardRails(problems, 'Hard', 5, goodPerformance, stagnationPromotion);
+
+      expect(result.needsRebalance).toBe(false);
+    });
+
+    it('does NOT trigger for standard_volume_gate promotion', () => {
+      const problems = createProblems(2, 2, 3);
+      const result = applySafetyGuardRails(problems, 'Hard', 5, poorPerformance, standardPromotion);
+
+      expect(result.needsRebalance).toBe(false);
+    });
+
+    it('does NOT trigger Guard Rail 4 when Hard count is 1 or less', () => {
+      // Note: With Hard count = 1, Guard Rail 2 may trigger (minimum 2 Hard for Hard cap)
+      // This test verifies Guard Rail 4 specifically does not trigger
+      const problems = createProblems(4, 2, 1); // Only 1 Hard
+      const result = applySafetyGuardRails(problems, 'Hard', 5, poorPerformance, stagnationPromotion);
+
+      // Guard Rail 4 should not trigger (it requires Hard > 1)
+      // Guard Rail 2 may trigger instead (requiring minimum 2 Hard)
+      expect(result.guardRailType).not.toBe('poor_performance_protection');
+    });
+
+    it('does NOT trigger when recentPerformance is null', () => {
+      const problems = createProblems(2, 2, 3);
+      const result = applySafetyGuardRails(problems, 'Hard', 5, null, stagnationPromotion);
+
+      expect(result.needsRebalance).toBe(false);
+    });
+
+    it('does NOT trigger when difficulty cap is Medium', () => {
+      const problems = createProblems(2, 2, 3);
+      const result = applySafetyGuardRails(problems, 'Medium', 5, poorPerformance, stagnationPromotion);
+
+      // May trigger other guard rails but not Guard Rail 4
+      expect(result.guardRailType).not.toBe('poor_performance_protection');
+    });
+
+    it('does NOT trigger when difficulty cap is Easy', () => {
+      const problems = createProblems(2, 2, 3);
+      const result = applySafetyGuardRails(problems, 'Easy', 5, poorPerformance, stagnationPromotion);
+
+      // Should not trigger Guard Rail 4 at Easy cap
+      expect(result.guardRailType).not.toBe('poor_performance_protection');
+    });
+
+    it('handles boundary: exactly 50% accuracy does NOT trigger', () => {
+      const problems = createProblems(2, 2, 3);
+      const boundaryPerformance = { accuracy: 0.50, sessionsAnalyzed: 3 };
+      const result = applySafetyGuardRails(problems, 'Hard', 5, boundaryPerformance, stagnationPromotion);
+
+      // 50% is the threshold, so exactly 50% should NOT trigger
+      expect(result.guardRailType).not.toBe('poor_performance_protection');
+    });
+
+    it('handles boundary: 49% accuracy triggers', () => {
+      const problems = createProblems(2, 2, 3);
+      const boundaryPerformance = { accuracy: 0.49, sessionsAnalyzed: 3 };
+      const result = applySafetyGuardRails(problems, 'Hard', 5, boundaryPerformance, stagnationPromotion);
+
+      expect(result.needsRebalance).toBe(true);
+      expect(result.guardRailType).toBe('poor_performance_protection');
+    });
+
+    it('returns correct excessHard count for various Hard counts', () => {
+      // Test with 4 Hard problems - should have 3 excess (4 - 1)
+      const problems4Hard = createProblems(2, 1, 4);
+      const result4 = applySafetyGuardRails(problems4Hard, 'Hard', 5, poorPerformance, stagnationPromotion);
+      expect(result4.excessHard).toBe(3);
+
+      // Test with 2 Hard problems - should have 1 excess (2 - 1)
+      const problems2Hard = createProblems(3, 2, 2);
+      const result2 = applySafetyGuardRails(problems2Hard, 'Hard', 5, poorPerformance, stagnationPromotion);
+      expect(result2.excessHard).toBe(1);
+    });
+
+    it('does not trigger with null promotion type', () => {
+      const problems = createProblems(2, 2, 3);
+      const result = applySafetyGuardRails(problems, 'Hard', 5, poorPerformance, null);
+
+      expect(result.needsRebalance).toBe(false);
+    });
+
+    it('does not trigger with undefined promotion type', () => {
+      const problems = createProblems(2, 2, 3);
+      const result = applySafetyGuardRails(problems, 'Hard', 5, poorPerformance, undefined);
+
+      expect(result.needsRebalance).toBe(false);
+    });
+  });
+
+  // Existing guard rails should still work
+  describe('Guard Rails 1-3 backward compatibility', () => {
+    describe('Guard Rail 1: Medium cap minimum Medium problems', () => {
+      it('triggers when Medium cap but only 1 Medium problem (session >= 4)', () => {
+        const problems = createProblems(5, 1, 0); // Only 1 Medium at Medium cap
+        const result = applySafetyGuardRails(problems, 'Medium', 5, null, null);
+
+        expect(result.needsRebalance).toBe(true);
+        expect(result.target.Medium).toBe(2);
+      });
+
+      it('does NOT trigger when enough Medium problems exist', () => {
+        const problems = createProblems(3, 3, 0); // 3 Medium problems
+        const result = applySafetyGuardRails(problems, 'Medium', 5, null, null);
+
+        expect(result.needsRebalance).toBe(false);
+      });
+
+      it('does NOT trigger when Medium count is 0 (handles case of no Medium problems gracefully)', () => {
+        const problems = createProblems(6, 0, 0); // No Medium problems
+        const result = applySafetyGuardRails(problems, 'Medium', 5, null, null);
+
+        // Guard rail only triggers when Medium > 0 but < minMedium
+        expect(result.needsRebalance).toBe(false);
+      });
+
+      it('does NOT trigger when session length is small (< 4)', () => {
+        const problems = createProblems(2, 1, 0); // Small session
+        const result = applySafetyGuardRails(problems, 'Medium', 5, null, null);
+
+        expect(result.needsRebalance).toBe(false);
+      });
+    });
+
+    describe('Guard Rail 2: Hard cap minimum Hard problems', () => {
+      it('triggers when Hard cap but only 1 Hard problem (session >= 5)', () => {
+        const problems = createProblems(3, 2, 1); // Only 1 Hard at Hard cap
+        const result = applySafetyGuardRails(problems, 'Hard', 5, null, null);
+
+        expect(result.needsRebalance).toBe(true);
+        expect(result.target.Hard).toBe(2);
+      });
+
+      it('does NOT trigger when enough Hard problems exist', () => {
+        const problems = createProblems(2, 2, 3); // 3 Hard problems
+        const result = applySafetyGuardRails(problems, 'Hard', 5, null, null);
+
+        expect(result.needsRebalance).toBe(false);
+      });
+
+      it('does NOT trigger when Hard count is 0', () => {
+        const problems = createProblems(3, 3, 0); // No Hard problems
+        const result = applySafetyGuardRails(problems, 'Hard', 5, null, null);
+
+        // Guard rail only triggers when Hard > 0 but < minHard
+        expect(result.needsRebalance).toBe(false);
+      });
+    });
+
+    describe('Guard Rail 3: First sessions at new difficulty', () => {
+      it('triggers when first session at Medium cap with insufficient Medium problems', () => {
+        const problems = createProblems(4, 1, 0); // Only 1 Medium
+        const result = applySafetyGuardRails(problems, 'Medium', 0, null, null); // sessionsAtCurrentDifficulty = 0
+
+        expect(result.needsRebalance).toBe(true);
+        expect(result.target.Medium).toBe(2);
+      });
+
+      it('triggers when first session at Hard cap with insufficient Hard problems', () => {
+        const problems = createProblems(3, 2, 1); // Only 1 Hard
+        const result = applySafetyGuardRails(problems, 'Hard', 0, null, null); // sessionsAtCurrentDifficulty = 0
+
+        expect(result.needsRebalance).toBe(true);
+        expect(result.target.Hard).toBe(2);
+      });
+
+      it('does NOT trigger at Easy cap (even for first session)', () => {
+        const problems = createProblems(5, 0, 0);
+        const result = applySafetyGuardRails(problems, 'Easy', 0, null, null);
+
+        expect(result.needsRebalance).toBe(false);
+      });
+
+      it('does NOT trigger after 2+ sessions at current difficulty', () => {
+        const problems = createProblems(4, 1, 0);
+        const result = applySafetyGuardRails(problems, 'Medium', 2, null, null); // sessionsAtCurrentDifficulty = 2
+
+        // Guard rail 3 doesn't apply, but guard rail 1 might
+        // With 1 Medium and Medium cap at session length 5, guard rail 1 applies
+        // This test just verifies guard rail 3 logic (sessionsAtCurrentDifficulty >= 2)
+        expect(result.message).not.toContain('First session');
+      });
+    });
+  });
+});
diff --git a/chrome-extension-app/src/shared/utils/session/sessionBalancing.js b/chrome-extension-app/src/shared/utils/session/sessionBalancing.js
index 1e72d2a4..a14b59c7 100644
--- a/chrome-extension-app/src/shared/utils/session/sessionBalancing.js
+++ b/chrome-extension-app/src/shared/utils/session/sessionBalancing.js
@@ -70,13 +70,22 @@ export function calculateAccuracyAtDifficulty(difficulty, difficultyTimeStats, r
  * - At Medium cap: At least 2 Medium problems (or 25% if session > 8)
  * - At Hard cap: At least 2 Hard problems (or 20% if session > 10)
  * - First 2 sessions at new difficulty: At least 2 problems at cap difficulty
+ * - Stagnation escape with poor performance: Limit Hard to 1 problem
  *
  * @param {Array} problems - Selected problems for the session
  * @param {string} currentDifficultyCap - Current difficulty cap ('Easy', 'Medium', 'Hard')
  * @param {number} sessionsAtCurrentDifficulty - Number of sessions at current difficulty
- * @returns {Object} { needsRebalance: boolean, target: {difficulty: count}, message: string }
+ * @param {Object|null} recentPerformance - Recent performance data { accuracy, sessionsAnalyzed }
+ * @param {string|null} currentPromotionType - How user reached current difficulty ('standard_volume_gate' | 'stagnation_escape_hatch' | null)
+ * @returns {Object} { needsRebalance: boolean, target: {difficulty: count}, message: string, guardRailType?: string }
  */
-export function applySafetyGuardRails(problems, currentDifficultyCap, sessionsAtCurrentDifficulty) {
+export function applySafetyGuardRails(
+  problems,
+  currentDifficultyCap,
+  sessionsAtCurrentDifficulty,
+  recentPerformance = null,
+  currentPromotionType = null
+) {
   const sessionLength = problems.length;
 
   // Count current difficulty distribution
@@ -134,6 +143,27 @@ export function applySafetyGuardRails(problems, currentDifficultyCap, sessionsAt
     }
   }
 
+  // Guard Rail 4: Poor Performance Protection
+  // When at Hard cap via stagnation escape with poor accuracy, limit Hard to 1
+  if (currentDifficultyCap === 'Hard' && recentPerformance !== null) {
+    const isStagnationPromotion = currentPromotionType === 'stagnation_escape_hatch';
+    const isPoorPerformance = recentPerformance.accuracy < 0.5;  // 50% threshold
+    const maxHard = 1;  // ALWAYS max 1 Hard for stagnation + poor performance
+
+    if (isStagnationPromotion && isPoorPerformance && counts.Hard > maxHard) {
+      const message = `Stagnation escape with ${(recentPerformance.accuracy * 100).toFixed(0)}% accuracy - limiting Hard to ${maxHard} (was ${counts.Hard})`;
+      logger.warn(`⚖️ Guard rail 4 triggered: ${message}`);
+      return {
+        needsRebalance: true,
+        target: { Hard: maxHard },
+        excessHard: counts.Hard - maxHard,
+        replacementDifficulty: 'Medium',
+        message,
+        guardRailType: 'poor_performance_protection'
+      };
+    }
+  }
+
   logger.info(`✅ Guard rails passed: Session difficulty distribution is acceptable`);
   return { needsRebalance: false };
 }