diff --git a/.vscodeignore b/.vscodeignore
index e8335426..2e1354a1 100644
--- a/.vscodeignore
+++ b/.vscodeignore
@@ -27,4 +27,6 @@ tsconfig_test.json
 # <— unignore webview assets
 !src/manage/webviews/html/**
 !src/manage/webviews/css/**
-!src/manage/webviews/webviewScripts/**
\ No newline at end of file
+!src/manage/webviews/webviewScripts/**
+!src/requirements/webviews/css/**
+!src/requirements/webviews/webviewScripts/**
\ No newline at end of file
diff --git a/docs/reqs2x/reqs2x_documentation.md b/docs/reqs2x/reqs2x_documentation.md
index bf0ff9a1..9fadc680 100644
--- a/docs/reqs2x/reqs2x_documentation.md
+++ b/docs/reqs2x/reqs2x_documentation.md
@@ -34,8 +34,7 @@ Remove any existing versions of the VectorCAST VS-Code extension.
 
 
 ### VS Code Extensions
-1.  Install the **Excel Viewer** extension (`GrapeCity.gc-excelviewer`) to view/edit Excel sheets directly in VS Code (optional). Alternatively, use MS Excel to view/edit Excel sheets.
-2.  Install the **VectorCAST Text Explorer** VS-Code extension from the Microsoft Marketplace.
+1.  Install the **VectorCAST Text Explorer** VS-Code extension from the Microsoft Marketplace.
 
 ### Configuration
 1.  Activate the extension: Press `Ctrl+Shift+P`, search for **Vectorcast Test Explorer**, and press `Enter`.
@@ -94,7 +93,7 @@ Remove any existing versions of the VectorCAST VS-Code extension.
 
 ## 2. Generating Tests from Requirements
 
-The demo release includes an Excel file with requirements and requirements-to-code traceability.
+The demo release ships with requirements including requirements-to-code traceability. To use them, import them into the environment which will set up a requirements gateway (RGW). The RGW is the single source of truth — the extension reads from and writes to it directly.
 
 ![Reqs2x demo requirements](./screenshots/VectorCAST_Reqs2x_demo_requirements.png)
 
@@ -102,13 +101,10 @@ The demo release includes an Excel file with requirements and requirements-to-co
 
 ### Initial Setup
 1.  Click the **Flask icon** (Test Explorer) on the left sidebar to show the environment tree.
-2.  Right-click `TUTORIAL_C` and select **VectorCAST -> Show Requirements**. The requirements webview will appear.
-3.  Right-click `TUTORIAL_C` and select **VectorCAST -> Populate RGW from Requirements**.
-    *   *Note: This creates a requirements gateway and populates it from the Excel sheet. Wait for the notification (approx. 3-5 seconds).*
-    *   If you do not have the requirements-to-code traceability for a function, Reqs2x will generate it automatically with your approval.
+2. Right-click `TUTORIAL_C` and select **VectorCAST -> Import Requirements**. Choose the file `reqs-TUTORIAL_C/reqs.xlsx`. This will load the requirements into the environment.
+2.  Right-click `TUTORIAL_C` and select **VectorCAST -> Show Requirements**. The requirements webview will appear, rendered directly from the RGW.
 ![Reqs2x demo show requirements](./screenshots/VectorCAST_Reqs2x_show_requirements.png)
 ![Reqs2x demo requirements webview](./screenshots/VectorCAST_Reqs2x_requirements_webview.png)
-![Reqs2x demo populate RGW](./screenshots/VectorCAST_Reqs2x_populate_rgw.png)
 
 ### Test Generation
 1.  Right-click `TUTORIAL_C` and select **VectorCAST -> Generate Tests from Requirements**.
@@ -143,12 +139,11 @@ The demo release includes an Excel file with requirements and requirements-to-co
 
 
 1.  **Modify requirement**:
-    *   Open `reqs.xlsx` using the Excel Viewer.
-    *   Find `FR27` (Add Included Dessert). 
+    *   Edit the requirement directly in the requirements gateway (RGW) in the Requirements view. Open it by selecting ``VectorCAST -> Show Requirements`.
+    *   Find `FR27` (Add Included Dessert).
     *   Change the free dessert for `steak, caesar salad and mixed drink` from `pie` to `cake`.
     *   Change the free dessert for `lobster, green salad and wine` from `cake` to `pie`.
-    *   Save (`Ctrl+S`) and close the tab.
-    *   Right-click `TUTORIAL_C` and select **VectorCAST -> Populate RGW from Requirements** to push the change to the requirements gateway. You will be prompted to accept replacing the old requirements gateway with the new one. 
+    *   Save the change. The extension always reads from the RGW, so no further sync step is required.
 
 2.  **Update tests**:
     *   In Test Explorer, find the `Add_Included_Dessert` node.
diff --git a/package.json b/package.json
index 32402e3e..9fa3e65e 100644
--- a/package.json
+++ b/package.json
@@ -242,7 +242,8 @@
       {
         "command": "vectorcastTestExplorer.generateRequirements",
         "category": "VectorCAST Test Explorer",
-        "title": "Generate Requirements"
+        "title": "Generate Requirements",
+        "enablement": "testId not in vectorcastTestExplorer.vcastRequirementsAvailable"
       },
       {
         "command": "vectorcastTestExplorer.insertBasisPathTestsFromEditor",
@@ -307,7 +308,8 @@
       {
         "command": "vectorcastTestExplorer.generateTestsFromRequirements",
         "category": "VectorCAST Test Explorer",
-        "title": "Generate Tests from Requirements"
+        "title": "Generate Tests from Requirements",
+        "enablement": "testId in vectorcastTestExplorer.vcastRequirementsAvailable"
       },
       {
         "command": "vectorcastTestExplorer.viewMCDCReport",
@@ -317,22 +319,26 @@
       {
         "command": "vectorcastTestExplorer.showRequirements",
         "category": "VectorCAST Test Explorer",
-        "title": "Show Requirements"
+        "title": "Show Requirements",
+        "enablement": "testId in vectorcastTestExplorer.vcastRequirementsAvailable"
       },
       {
         "command": "vectorcastTestExplorer.removeRequirements",
         "category": "VectorCAST Test Explorer",
-        "title": "Remove Requirements"
+        "title": "Remove Requirements",
+        "enablement": "testId in vectorcastTestExplorer.vcastRequirementsAvailable"
       },
       {
-        "command": "vectorcastTestExplorer.importRequirementsFromGateway",
+        "command": "vectorcastTestExplorer.importRequirements",
         "category": "VectorCAST Test Explorer",
-        "title": "Import Requirements from Gateway"
+        "title": "Import Requirements",
+        "enablement": "testId not in vectorcastTestExplorer.vcastRequirementsAvailable"
       },
       {
-        "command": "vectorcastTestExplorer.populateRequirementsGateway",
+        "command": "vectorcastTestExplorer.exportRequirements",
         "category": "VectorCAST Test Explorer",
-        "title": "Populate RGW from Requirements"
+        "title": "Export Requirements",
+        "enablement": "testId not in vectorcastTestExplorer.vcastEnviroList || testId in vectorcastTestExplorer.vcastRequirementsAvailable"
       },
       {
         "command": "vectorcastTestExplorer.testLLMConfiguration",
@@ -927,12 +933,12 @@
           "when": "never"
         },
         {
-          "command": "vectorcastTestExplorer.importRequirementsFromGateway",
-          "when": "never"
+          "command": "vectorcastTestExplorer.importRequirements",
+          "when": "vectorcastTestExplorer.reqs2xFeatureEnabled"
         },
         {
-          "command": "vectorcastTestExplorer.populateRequirementsGateway",
-          "when": "never"
+          "command": "vectorcastTestExplorer.exportRequirements",
+          "when": "vectorcastTestExplorer.reqs2xFeatureEnabled"
         },
         {
           "command": "vectorcastTestExplorer.testLLMConfiguration",
@@ -1184,19 +1190,24 @@
         "when": "testId in vectorcastTestExplorer.globalProjectCompilers"
       },
       {
-        "command": "vectorcastTestExplorer.importRequirementsFromGateway",
+        "command": "vectorcastTestExplorer.generateRequirements",
         "group": "vcast@8",
-        "when": "testId =~ /^vcast:.*$/ && testId in vectorcastTestExplorer.vcastEnviroList && vectorcastTestExplorer.reqs2xFeatureEnabled && testId not in vectorcastTestExplorer.vcastRequirementsAvailable && vectorcastTestExplorer.generateRequirementsEnabled"
+        "when": "testId =~ /^vcast:[^|]+$/ && testId in vectorcastTestExplorer.vcastEnviroList && vectorcastTestExplorer.reqs2xFeatureEnabled"
       },
       {
-        "command": "vectorcastTestExplorer.generateRequirements",
+        "command": "vectorcastTestExplorer.importRequirements",
         "group": "vcast@8",
-        "when": "testId =~ /^vcast:.*$/ && testId in vectorcastTestExplorer.vcastEnviroList && vectorcastTestExplorer.reqs2xFeatureEnabled && testId not in vectorcastTestExplorer.vcastRequirementsAvailable && vectorcastTestExplorer.generateRequirementsEnabled"
+        "when": "testId =~ /^vcast:[^|]+$/ && testId in vectorcastTestExplorer.vcastEnviroList && vectorcastTestExplorer.reqs2xFeatureEnabled"
       },
       {
         "command": "vectorcastTestExplorer.showRequirements",
         "group": "vcast@9",
-        "when": "testId =~ /^vcast:.*$/ && testId in vectorcastTestExplorer.vcastEnviroList && vectorcastTestExplorer.reqs2xFeatureEnabled && testId in vectorcastTestExplorer.vcastRequirementsAvailable && vectorcastTestExplorer.generateRequirementsEnabled"
+        "when": "testId =~ /^vcast:[^|]+$/ && testId in vectorcastTestExplorer.vcastEnviroList && vectorcastTestExplorer.reqs2xFeatureEnabled"
+      },
+      {
+        "command": "vectorcastTestExplorer.exportRequirements",
+        "group": "vcast@9",
+        "when": "testId =~ /^vcast:[^|]+$/ && testId in vectorcastTestExplorer.vcastEnviroList && vectorcastTestExplorer.reqs2xFeatureEnabled"
       },
       {
         "command": "vectorcastTestExplorer.generateTestsFromRequirements",
@@ -1206,12 +1217,7 @@
       {
         "command": "vectorcastTestExplorer.removeRequirements",
         "group": "vcast@9",
-        "when": "testId =~ /^vcast:.*$/ && vectorcastTestExplorer.reqs2xFeatureEnabled && testId in vectorcastTestExplorer.vcastRequirementsAvailable && vectorcastTestExplorer.generateRequirementsEnabled"
-      },
-      {
-        "command": "vectorcastTestExplorer.populateRequirementsGateway",
-        "group": "vcast@9",
-        "when": "testId =~ /^vcast:.*$/ && vectorcastTestExplorer.reqs2xFeatureEnabled && testId in vectorcastTestExplorer.vcastRequirementsAvailable && vectorcastTestExplorer.generateRequirementsEnabled"
+        "when": "testId =~ /^vcast:[^|]+$/ && vectorcastTestExplorer.reqs2xFeatureEnabled"
       },
       {
         "command": "vectorcastTestExplorer.viewResults",
@@ -1303,9 +1309,7 @@
   "dependencies": {
     "@vscode/vsce": "^2.32.0",
     "axios": "^1.7.7",
-    "convert-excel-to-json": "^1.7.0",
     "crc-32": "^1.2.0",
-    "csv-parse": "^5.6.0",
     "glob": "^7.1.7",
     "hasbin": "^1.2.3",
     "jsonc-parser": "^3.2.1",
@@ -1315,7 +1319,6 @@
     "tslib": "^1.9.3",
     "vscode-languageclient": "^5.2.1",
     "vscode-languageserver": "^5.2.1",
-    "xlsx": "^0.18.5",
     "xo": "^0.58.0"
   },
   "extensionDependencies": [],
diff --git a/src/extension.ts b/src/extension.ts
index 7d859e6c..bedabb52 100644
--- a/src/extension.ts
+++ b/src/extension.ts
@@ -125,22 +125,36 @@ import {
 } from "./vcastInstallation";
 
 import {
+  clearVcastRepositoryInConfig,
   findRelevantRequirementGateway,
-  generateRequirementsHtml,
-  parseRequirementsFromFile,
-  performLLMProviderUsableCheck,
-  requirementsFileWatcher,
+} from "./requirements/rgwPath";
+import {
+  setupRequirementsFileWatchers,
   updateRequirementsAvailability,
-} from "./requirements/requirementsUtils";
+} from "./requirements/availability";
+import { performLLMProviderUsableCheck } from "./requirements/llmProvider";
+import {
+  applyEditPolicy,
+  inferTraceability,
+  readRGWBundle,
+  RGWBundle,
+  RGWStaleWriteError,
+  writeRGWBundle,
+} from "./requirements/rgwIo";
+import { generateRequirementsHtml } from "./requirements/webview/template";
+import type {
+  FromWebview,
+  ToWebview,
+} from "./requirements/webview/messages";
 
 import {
-  GENERATE_REQUIREMENTS_ENABLED,
+  exportRequirements,
   generateRequirements,
   generateTestsFromRequirements,
-  importRequirementsFromGateway,
+  importRequirements,
   initializeReqs2X,
-  populateRequirementsGateway,
 } from "./requirements/requirementsOperations";
+import { maybeOfferLegacyMigration } from "./requirements/legacyMigration";
 
 import {
   generateNewCodedTestFile,
@@ -165,10 +179,9 @@ import {
 import fs = require("fs");
 import {
   compilerTagList,
-  getNonce,
-  resolveWebviewBase,
   setCompilerList,
 } from "./manage/manageSrc/manageUtils";
+import { getNonce, resolveWebviewBase } from "./webviewUtils";
 
 const path = require("path");
 
@@ -292,6 +305,147 @@ async function getEnvironmentListIncludingUnbuilt(
   });
 }
 
+/**
+ * Pick the environment path to act on for a command. Right-click invocations
+ * pass `{ id }` from a tree node; command-palette invocations pass nothing,
+ * so we show a quick-pick of envs in the workspace. Returns null if the user
+ * dismisses the picker or the workspace has no env files.
+ */
+/**
+ * Open the source file backing a trace mapping. If `functionName` is given
+ * and the unit has a matching entry with a startLine, jump to that line;
+ * otherwise just open the file. Used by the requirements editor's "Open
+ * source" button.
+ */
+/**
+ * Resolve a source-file location from VectorCAST envData.  Returns the URI
+ * for the unit's source file and the line of the named function (or 0 if
+ * `functionName` is null or its `startLine` isn't known). Returns null if
+ * envData lacks unit info or the unit isn't present in the env.
+ *
+ * Shared by the test-pane "Open Source File" command and the requirements
+ * editor's per-card "Open source" button — same matching rule (unit name
+ * == source-file basename, sans extension).
+ */
+function resolveSourceLocation(
+  envData: any,
+  unitName: string,
+  functionName: string | null
+): { uri: vscode.Uri; lineNumber: number } | null {
+  const units = envData?.unitData;
+  if (!Array.isArray(units)) return null;
+  const unitInfo = units.find((u: any) => {
+    if (!u?.path) return false;
+    return path.basename(u.path, path.extname(u.path)) === unitName;
+  });
+  if (!unitInfo) return null;
+  let lineNumber = 0;
+  if (functionName && Array.isArray(unitInfo.functionList)) {
+    const fn = unitInfo.functionList.find(
+      (f: any) => f?.name === functionName && f?.startLine !== undefined
+    );
+    if (fn) lineNumber = fn.startLine;
+  }
+  return { uri: vscode.Uri.file(unitInfo.path), lineNumber };
+}
+
+async function openSourceForTrace(
+  enviroPath: string,
+  unitName: string,
+  functionName: string | null,
+  referenceColumn: vscode.ViewColumn | undefined
+): Promise<void> {
+  if (!unitName) return;
+  let envData: any;
+  try {
+    envData = await getEnvironmentData(enviroPath);
+  } catch {
+    vscode.window.showErrorMessage(
+      "Could not query the environment to resolve the source file."
+    );
+    return;
+  }
+  if (!envData?.unitData) {
+    vscode.window.showErrorMessage(
+      "Environment data has no unit information."
+    );
+    return;
+  }
+
+  const located = resolveSourceLocation(envData, unitName, functionName);
+  if (!located) {
+    vscode.window.showErrorMessage(
+      `Unit "${unitName}" not found in this environment.`
+    );
+    return;
+  }
+  const { uri, lineNumber } = located;
+  const position = new vscode.Position(Math.max(0, lineNumber - 1), 0);
+  const selection = new vscode.Range(position, position);
+
+  // If the file is already open in a tab in some *other* column, reveal
+  // that tab. Tabs in the webview's own column are ignored — switching to
+  // them would hide the requirements view. If no other-column tab exists,
+  // fall back to Beside so a new editor opens next to the webview.
+  let targetColumn: vscode.ViewColumn | undefined;
+  for (const group of vscode.window.tabGroups.all) {
+    if (group.viewColumn === referenceColumn) continue;
+    const hit = group.tabs.find(
+      (tab) =>
+        tab.input instanceof vscode.TabInputText &&
+        tab.input.uri.fsPath === uri.fsPath
+    );
+    if (hit) {
+      targetColumn = group.viewColumn;
+      break;
+    }
+  }
+  targetColumn ??= vscode.ViewColumn.Beside;
+
+  const document = await vscode.workspace.openTextDocument(uri);
+  await vscode.window.showTextDocument(document, {
+    preview: false,
+    preserveFocus: false,
+    selection,
+    viewColumn: targetColumn,
+  });
+}
+
+async function resolveEnviroPathForCommand(
+  args: any
+): Promise<string | null> {
+  if (args?.id) {
+    const testNode: testNodeType = getTestNode(args.id);
+    return testNode?.enviroPath ?? null;
+  }
+
+  const folders = workspace.workspaceFolders;
+  if (!folders || folders.length === 0) {
+    vscode.window.showErrorMessage("No workspace open.");
+    return null;
+  }
+
+  const envPaths = await getEnvironmentListIncludingUnbuilt(folders[0].uri.fsPath);
+  if (envPaths.length === 0) {
+    vscode.window.showErrorMessage(
+      "No VectorCAST environments found in the workspace."
+    );
+    return null;
+  }
+
+  if (envPaths.length === 1) return envPaths[0];
+
+  const picked = await vscode.window.showQuickPick(
+    envPaths.map((p) => ({
+      label: path.basename(p),
+      description: path.relative(folders[0].uri.fsPath, p),
+      envPath: p,
+    })),
+    { placeHolder: "Select environment" }
+  );
+  return picked ? picked.envPath : null;
+}
+
 async function activationLogic(context: vscode.ExtensionContext) {
   // remove developer env variables
   decodeAndRemoveDeveloperEnvs();
@@ -313,14 +467,9 @@ async function activationLogic(context: vscode.ExtensionContext) {
   // start the language server
   activateLanguageServerClient(context);
 
-  // Enable/disable the requirement generation component of the extension
-  vscode.commands.executeCommand(
-    "setContext",
-    "vectorcastTestExplorer.generateRequirementsEnabled",
-    GENERATE_REQUIREMENTS_ENABLED
-  );
-
-  // Initialize requirements availability for all environments
+  // Initialize requirements availability for all environments, then keep it
+  // in sync with out-of-band changes (RGW deleted in a terminal, CCAST_.CFG
+  // edited by hand, etc.).
   if (workspace.workspaceFolders && workspace.workspaceFolders.length > 0) {
     const envPaths = await getEnvironmentListIncludingUnbuilt(
       workspace.workspaceFolders[0].uri.fsPath
@@ -329,8 +478,15 @@ async function activationLogic(context: vscode.ExtensionContext) {
       updateRequirementsAvailability(envPath);
     }
   }
+  setupRequirementsFileWatchers(context);
 
   initializeReqs2X(context);
+
+  // One-shot prompt: legacy reqs.xlsx / reqs.csv → RGW. Runs after
+  // initializeReqs2X so the panreq executable path is resolved (no-op
+  // otherwise). Fire and forget — we don't want migration to block the
+  // rest of activation.
+  void maybeOfferLegacyMigration(context);
 }
 
 function configureExtension(context: vscode.ExtensionContext) {
@@ -512,29 +668,23 @@ function configureExtension(context: vscode.ExtensionContext) {
   );
   context.subscriptions.push(generateRequirementsTestsCommand);
 
-  let importRequirementsFromGatewayCommand = vscode.commands.registerCommand(
-    "vectorcastTestExplorer.importRequirementsFromGateway",
-    (args: any) => {
-      if (args) {
-        const testNode: testNodeType = getTestNode(args.id);
-        const enviroPath = testNode.enviroPath;
-        importRequirementsFromGateway(enviroPath);
-      }
+  let importRequirementsCommand = vscode.commands.registerCommand(
+    "vectorcastTestExplorer.importRequirements",
+    async (args: any) => {
+      const enviroPath = await resolveEnviroPathForCommand(args);
+      if (enviroPath) await importRequirements(enviroPath);
     }
   );
-  context.subscriptions.push(importRequirementsFromGatewayCommand);
+  context.subscriptions.push(importRequirementsCommand);
 
-  let populateRequirementsGatewayCommand = vscode.commands.registerCommand(
-    "vectorcastTestExplorer.populateRequirementsGateway",
+  let exportRequirementsCommand = vscode.commands.registerCommand(
+    "vectorcastTestExplorer.exportRequirements",
     async (args: any) => {
-      if (args) {
-        const testNode: testNodeType = getTestNode(args.id);
-        const enviroPath = testNode.enviroPath;
-        await populateRequirementsGateway(enviroPath);
-      }
+      const enviroPath = await resolveEnviroPathForCommand(args);
+      if (enviroPath) await exportRequirements(enviroPath);
     }
   );
-  context.subscriptions.push(populateRequirementsGatewayCommand);
+  context.subscriptions.push(exportRequirementsCommand);
 
   let testLLMConfigurationCommand = vscode.commands.registerCommand(
     "vectorcastTestExplorer.testLLMConfiguration",
@@ -915,7 +1065,7 @@ function configureExtension(context: vscode.ExtensionContext) {
   const addTestsuiteToCompiler = vscode.commands.registerCommand(
     "vectorcastTestExplorer.addTestsuiteToCompiler",
     async (node: any) => {
-      const manageWebviewSrcDir = resolveWebviewBase(context);
+      const manageWebviewSrcDir = resolveWebviewBase(context, "manage", "webviews");
       const panel = vscode.window.createWebviewPanel(
         "addTestsuiteToCompiler",
         "Add Testsuite to Compiler",
@@ -966,7 +1116,7 @@ function configureExtension(context: vscode.ExtensionContext) {
     context: vscode.ExtensionContext,
     panel: vscode.WebviewPanel
   ): Promise<string> {
-    const base = resolveWebviewBase(context);
+    const base = resolveWebviewBase(context, "manage", "webviews");
 
     // on-disk locations
     const cssOnDisk = vscode.Uri.file(
@@ -1240,70 +1390,41 @@ function configureExtension(context: vscode.ExtensionContext) {
   let openSourceFileFromTestpaneCommand = vscode.commands.registerCommand(
     "vectorcastTestExplorer.openSourceFileFromTestpaneCommand",
     async (args: any) => {
-      if (args) {
-        const testNode: testNodeType = getTestNode(args.id);
-        if (testNode) {
-          const enviroPath = testNode.enviroPath;
-          const unitName = testNode.unitName;
-          const functionName = testNode.functionName;
-          const envData = await getEnvironmentData(enviroPath);
-
-          if (envData.unitData) {
-            for (const unitInfo of envData.unitData) {
-              // Extract unit name from path to match against unitName
-              const pathBasename = path.basename(
-                unitInfo.path,
-                path.extname(unitInfo.path)
-              );
-
-              if (pathBasename === unitName) {
-                const sourcePath = unitInfo.path;
-                const uri = vscode.Uri.file(sourcePath);
-
-                // Determine the line number to open at (0 = top default)
-                let lineNumber = 0;
-
-                // If functionName is defined, try to find it in the function list
-                if (functionName && unitInfo.functionList) {
-                  for (const func of unitInfo.functionList) {
-                    if (
-                      func.name === functionName &&
-                      func.startLine !== undefined
-                    ) {
-                      lineNumber = func.startLine;
-                      break;
-                    }
-                  }
-                }
-
-                // Open the document at the specified line
-                const document = await vscode.workspace.openTextDocument(uri);
-                const position = new vscode.Position(
-                  Math.max(0, lineNumber - 1),
-                  0
-                );
-                const selection = new vscode.Range(position, position);
-
-                await vscode.window.showTextDocument(document, {
-                  preview: false, // open as a real tab
-                  preserveFocus: false,
-                  selection: selection,
-                });
+      if (!args) return;
+      const testNode: testNodeType = getTestNode(args.id);
+      if (!testNode) {
+        vscode.window.showErrorMessage(
+          `Unable to open Source File for Node: ${args.id}`
+        );
+        return;
+      }
 
-                break;
-              }
-            }
-          } else {
-            vscode.window.showErrorMessage(
-              `Could not find environment data for: ${enviroPath}`
-            );
-          }
-        } else {
-          vscode.window.showErrorMessage(
-            `Unable to open Source File for Node: ${args.id}`
-          );
-        }
+      const envData = await getEnvironmentData(testNode.enviroPath);
+      if (!envData?.unitData) {
+        vscode.window.showErrorMessage(
+          `Could not find environment data for: ${testNode.enviroPath}`
+        );
+        return;
       }
+
+      const located = resolveSourceLocation(
+        envData,
+        testNode.unitName,
+        testNode.functionName ?? null
+      );
+      if (!located) return;
+
+      const document = await vscode.workspace.openTextDocument(located.uri);
+      const position = new vscode.Position(
+        Math.max(0, located.lineNumber - 1),
+        0
+      );
+      const selection = new vscode.Range(position, position);
+      await vscode.window.showTextDocument(document, {
+        preview: false,
+        preserveFocus: false,
+        selection,
+      });
     }
   );
   context.subscriptions.push(openSourceFileFromTestpaneCommand);
@@ -1311,55 +1432,162 @@ function configureExtension(context: vscode.ExtensionContext) {
   let showRequirementsCommand = vscode.commands.registerCommand(
     "vectorcastTestExplorer.showRequirements",
     async (args: any) => {
-      if (args) {
-        const testNode: testNodeType = getTestNode(args.id);
-        const enviroPath = testNode.enviroPath;
+      if (!args) return;
+      const testNode: testNodeType = getTestNode(args.id);
+      const enviroPath = testNode.enviroPath;
+
+      let bundle: RGWBundle | null;
+      try {
+        bundle = readRGWBundle(enviroPath);
+      } catch (err) {
+        vscode.window.showErrorMessage(`Failed to load requirements: ${err}`);
+        return;
+      }
 
-        const parentDir = path.dirname(enviroPath);
-        const enviroNameWithExt = path.basename(enviroPath);
-        // remove ".env" if present
-        const enviroNameWithoutExt = enviroNameWithExt.replace(/\.env$/, "");
-        const envReqsFolderPath = path.join(
-          parentDir,
-          `reqs-${enviroNameWithoutExt}`
+      if (!bundle) {
+        vscode.window.showErrorMessage(
+          "No requirements gateway found. Generate requirements first."
         );
+        return;
+      }
 
-        const csvPath = path.join(envReqsFolderPath, "reqs.csv");
-        const xlsxPath = path.join(envReqsFolderPath, "reqs.xlsx");
-
-        let filePath = "";
-        let fileType = "";
-        if (fs.existsSync(xlsxPath)) {
-          filePath = xlsxPath;
-          fileType = "Excel";
-        } else if (fs.existsSync(csvPath)) {
-          filePath = csvPath;
-          fileType = "CSV";
-        } else {
-          vscode.window.showErrorMessage(
-            "Requirements file not found. Generate requirements first."
-          );
-          return;
+      const loaded: RGWBundle = bundle;
+
+      // Best-effort: pull units + their functions from the env so the
+      // traceability fields render as dropdowns. If the env can't be queried
+      // (unbuilt / data server down), fall back to free-text inputs.
+      let unitsToFunctions: Record<string, string[]> | null = null;
+      try {
+        const envData = await getEnvironmentData(enviroPath);
+        const testData = envData?.testData;
+        if (Array.isArray(testData)) {
+          unitsToFunctions = {};
+          for (const unit of testData) {
+            // Skip synthetic test-pane nodes ("Compound Tests",
+            // "Initialization Tests", etc.) — they have no source path.
+            if (!unit?.name || !unit.path) continue;
+            const fns: string[] = [];
+            if (Array.isArray(unit.functions)) {
+              for (const f of unit.functions) {
+                if (f?.name) fns.push(f.name);
+              }
+            }
+            unitsToFunctions[unit.name] = fns;
+          }
         }
+      } catch {
+        // ignore; webview will fall back to free-text inputs
+      }
 
-        try {
-          const panel = vscode.window.createWebviewPanel(
-            "requirementsReport",
-            "Requirements Report",
-            vscode.ViewColumn.One,
-            { enableScripts: true }
-          );
-
-          panel.webview.html = `<html><body><h1>Loading ${fileType} requirements...</h1></body></html>`;
-          const requirements = await parseRequirementsFromFile(filePath);
-          const htmlContent = generateRequirementsHtml(requirements);
-          panel.webview.html = htmlContent;
-        } catch (err) {
-          vscode.window.showErrorMessage(
-            `Error generating requirements report: ${err}`
-          );
+      const webviewBaseDir = resolveWebviewBase(context, "requirements", "webviews");
+      const panel = vscode.window.createWebviewPanel(
+        "requirementsReport",
+        "Requirements Report",
+        vscode.ViewColumn.One,
+        {
+          enableScripts: true,
+          enableFindWidget: true, // Ctrl+F text-find inside the webview
+          retainContextWhenHidden: true,
+          localResourceRoots: [vscode.Uri.file(webviewBaseDir)],
         }
-      }
+      );
+      const nonce = getNonce();
+      panel.webview.html = generateRequirementsHtml(
+        panel.webview,
+        webviewBaseDir,
+        nonce,
+        loaded,
+        unitsToFunctions
+      );
+
+      let currentBundle: RGWBundle = loaded;
+
+      // Save / infer can complete after the user closes the panel — let the
+      // underlying operation finish but skip the postMessage so we don't trip
+      // "Webview is disposed".
+      let disposed = false;
+      panel.onDidDispose(
+        () => {
+          disposed = true;
+        },
+        null,
+        context.subscriptions
+      );
+      const post = (msg: ToWebview) => {
+        if (disposed) return;
+        panel.webview.postMessage(msg);
+      };
+
+      panel.webview.onDidReceiveMessage(
+        async (msg: FromWebview) => {
+          if (msg?.type === "save") {
+            try {
+              // Single source of truth for the edit policy lives in
+              // applyEditPolicy: it redacts any field the loaded bundle
+              // reports as locked, so a tampered webview can't sneak edits
+              // through.
+              const safeUpdates = applyEditPolicy(currentBundle, msg.updates);
+              const newMtimes = await writeRGWBundle(
+                enviroPath,
+                currentBundle.gatewayPath,
+                safeUpdates,
+                msg.expectedMtimes
+              );
+              currentBundle = {
+                ...currentBundle,
+                requirements: safeUpdates.requirements,
+                traceability: safeUpdates.traceability,
+                mtimes: newMtimes,
+              };
+              post({
+                type: "saved",
+                mtimes: newMtimes,
+                requirements: safeUpdates.requirements,
+                traceability: safeUpdates.traceability,
+              });
+            } catch (err) {
+              const message =
+                err instanceof RGWStaleWriteError
+                  ? `${err.message} Reopen the requirements view to reload and re-apply your edits.`
+                  : `Failed to save requirements: ${err}`;
+              vscode.window.showErrorMessage(message);
+              post({ type: "save-failed", message });
+            }
+          } else if (msg?.type === "infer-traceability") {
+            try {
+              const refreshed = await inferTraceability(
+                enviroPath,
+                currentBundle.gatewayPath
+              );
+              if (!refreshed) {
+                // Cancelled by user — re-enable the webview buttons silently.
+                post({ type: "infer-cancelled" });
+                return;
+              }
+              currentBundle = refreshed;
+              post({
+                type: "inferred",
+                mtimes: refreshed.mtimes,
+                requirements: refreshed.requirements,
+                traceability: refreshed.traceability,
+              });
+            } catch (err) {
+              const message = `Failed to infer traceability: ${err}`;
+              vscode.window.showErrorMessage(message);
+              post({ type: "infer-failed", message });
+            }
+          } else if (msg?.type === "open-source") {
+            await openSourceForTrace(
+              enviroPath,
+              msg.unit,
+              msg.function,
+              panel.viewColumn
+            );
+          }
+        },
+        undefined,
+        context.subscriptions
+      );
     }
   );
   context.subscriptions.push(showRequirementsCommand);
@@ -1372,7 +1600,7 @@ function configureExtension(context: vscode.ExtensionContext) {
         const enviroPath = testNode.enviroPath;
 
         const message =
-          "This will remove all generated requirements files. This action cannot be undone.";
+          "This will delete the requirements gateway and clear VCAST_REPOSITORY from CCAST_.CFG. This action cannot be undone.";
         const choice = await vscode.window.showWarningMessage(
           message,
           "Remove",
@@ -1381,63 +1609,46 @@ function configureExtension(context: vscode.ExtensionContext) {
 
         if (choice === "Remove") {
           const parentDir = path.dirname(enviroPath);
-          const enviroNameWithExt = path.basename(enviroPath);
-          // remove ".env" if present
-          const enviroNameWithoutExt = enviroNameWithExt.replace(/\.env$/, "");
+          const enviroNameWithoutExt = path
+            .basename(enviroPath)
+            .replace(/\.env$/, "");
           const envReqsFolderPath = path.join(
             parentDir,
             `reqs-${enviroNameWithoutExt}`
           );
 
-          const filesToRemove = [
-            path.join(envReqsFolderPath, "reqs.csv"),
-            path.join(envReqsFolderPath, "reqs.xlsx"),
-            path.join(envReqsFolderPath, "reqs_converted.csv"),
-            path.join(envReqsFolderPath, "reqs.html"),
-            path.join(envReqsFolderPath, "reqs2tests.tst"),
-          ];
-
-          // Remove files
-          for (const file of filesToRemove) {
-            if (fs.existsSync(file)) {
-              try {
-                fs.unlinkSync(file);
-              } catch (err) {
-                vscode.window.showErrorMessage(
-                  `Failed to remove ${file}: ${err}`
-                );
-              }
+          const gatewayPath = findRelevantRequirementGateway(enviroPath);
+          if (gatewayPath && fs.existsSync(gatewayPath)) {
+            try {
+              fs.rmSync(gatewayPath, { recursive: true, force: true });
+            } catch (err) {
+              vscode.window.showErrorMessage(
+                `Failed to remove requirements gateway: ${err}`
+              );
             }
           }
 
-          const generatedRepositoryPath = path.join(
-            envReqsFolderPath,
-            "generated_requirement_repository"
-          );
-          const actualRepositoryPath =
-            findRelevantRequirementGateway(enviroPath);
+          clearVcastRepositoryInConfig(enviroPath);
+
+          const tstPath = path.join(parentDir, "reqs2tests.tst");
+          if (fs.existsSync(tstPath)) {
+            try {
+              fs.unlinkSync(tstPath);
+            } catch (err) {
+              vscode.window.showErrorMessage(
+                `Failed to remove ${tstPath}: ${err}`
+              );
+            }
+          }
 
-          // Separately prompt for repository directory removal
           if (
-            fs.existsSync(generatedRepositoryPath) &&
-            path.relative(generatedRepositoryPath, actualRepositoryPath) === ""
+            fs.existsSync(envReqsFolderPath) &&
+            fs.readdirSync(envReqsFolderPath).length === 0
           ) {
-            const repoMessage =
-              "Would you also like to remove the auto-generated requirements gateway too?";
-            const repoChoice = await vscode.window.showWarningMessage(
-              repoMessage,
-              "Yes",
-              "No"
-            );
-
-            if (repoChoice === "Yes") {
-              try {
-                fs.rmdirSync(generatedRepositoryPath, { recursive: true });
-              } catch (err) {
-                vscode.window.showErrorMessage(
-                  `Failed to remove repository directory: ${err}`
-                );
-              }
+            try {
+              fs.rmdirSync(envReqsFolderPath);
+            } catch {
+              // best-effort
             }
           }
 
@@ -1622,7 +1833,7 @@ async function installPreActivationEventHandlers(
   const importEnviroToProject = vscode.commands.registerCommand(
     "vectorcastTestExplorer.importEnviroToProject",
     async (_args: vscode.Uri, argList: vscode.Uri[]) => {
-      const manageWebviewSrcDir = resolveWebviewBase(context);
+      const manageWebviewSrcDir = resolveWebviewBase(context, "manage", "webviews");
       const panel = vscode.window.createWebviewPanel(
         "importEnviroToProject",
         "Import Environment to Project",
@@ -1708,7 +1919,7 @@ async function installPreActivationEventHandlers(
   const addEnviroToProject = vscode.commands.registerCommand(
     "vectorcastTestExplorer.addEnviroToProject",
     async (_projectNode: any) => {
-      const manageWebviewSrcDir = resolveWebviewBase(context);
+      const manageWebviewSrcDir = resolveWebviewBase(context, "manage", "webviews");
       const panel = vscode.window.createWebviewPanel(
         "addEnviroToProject",
         "Add Environment To Project",
@@ -1815,7 +2026,7 @@ async function installPreActivationEventHandlers(
     panel: vscode.WebviewPanel,
     argList: vscode.Uri[]
   ): Promise<string> {
-    const base = resolveWebviewBase(context);
+    const base = resolveWebviewBase(context, "manage", "webviews");
 
     // on-disk resource locations
     const cssOnDisk = vscode.Uri.file(path.join(base, "css", "importEnv.css"));
@@ -1868,7 +2079,7 @@ async function installPreActivationEventHandlers(
   const newEnviroInProjectVCASTCommand = vscode.commands.registerCommand(
     "vectorcastTestExplorer.newEnviroInProjectVCAST",
     async (_args: vscode.Uri, argList: vscode.Uri[]) => {
-      const manageWebviewSrcDir = resolveWebviewBase(context);
+      const manageWebviewSrcDir = resolveWebviewBase(context, "manage", "webviews");
       const panel = vscode.window.createWebviewPanel(
         "newEnvProject",
         "Create Environment in Project",
@@ -1948,7 +2159,7 @@ async function installPreActivationEventHandlers(
     panel: vscode.WebviewPanel,
     argList: vscode.Uri[]
   ): Promise<string> {
-    const base = resolveWebviewBase(context);
+    const base = resolveWebviewBase(context, "manage", "webviews");
     const cssOnDisk = vscode.Uri.file(
       path.join(base, "css", "newEnvProject.css")
     );
@@ -2003,7 +2214,7 @@ async function installPreActivationEventHandlers(
       }
       const workspaceRoot = workspaceFolders[0].uri.fsPath;
 
-      const baseDir = resolveWebviewBase(context);
+      const baseDir = resolveWebviewBase(context, "manage", "webviews");
       const panel = vscode.window.createWebviewPanel(
         "newProject",
         "Create New Project",
@@ -2093,7 +2304,7 @@ async function installPreActivationEventHandlers(
     panel: vscode.WebviewPanel,
     workspaceRoot: string
   ): Promise<string> {
-    const base = resolveWebviewBase(context);
+    const base = resolveWebviewBase(context, "manage", "webviews");
     const cssOnDisk = vscode.Uri.file(path.join(base, "css", "newProject.css"));
     const scriptOnDisk = vscode.Uri.file(
       path.join(base, "webviewScripts", "newProject.js")
@@ -2140,7 +2351,7 @@ async function installPreActivationEventHandlers(
       }
 
       // Create webview panel
-      const baseDir = resolveWebviewBase(context);
+      const baseDir = resolveWebviewBase(context, "manage", "webviews");
       const panel = vscode.window.createWebviewPanel(
         "newCompiler",
         "Create Compiler in Project",
@@ -2210,7 +2421,7 @@ async function installPreActivationEventHandlers(
     panel: vscode.WebviewPanel,
     projectPath: string
   ): Promise<string> {
-    const base = resolveWebviewBase(context);
+    const base = resolveWebviewBase(context, "manage", "webviews");
     const cssOnDisk = vscode.Uri.file(
       path.join(base, "css", "newCompiler.css")
     );
@@ -2257,10 +2468,6 @@ async function installPreActivationEventHandlers(
 
 // this method is called when your extension is deactivated
 export async function deactivate() {
-  if (requirementsFileWatcher) {
-    requirementsFileWatcher.dispose();
-  }
-
   await serverProcessController(serverStateType.stopped);
   // delete the server log if it exists
   await deleteServerLog();
diff --git a/src/manage/manageSrc/manageUtils.ts b/src/manage/manageSrc/manageUtils.ts
index bbcdac8f..61344e8a 100644
--- a/src/manage/manageSrc/manageUtils.ts
+++ b/src/manage/manageSrc/manageUtils.ts
@@ -101,73 +101,6 @@ function findTestItemRecursively(
   return found;
 }
 
-/**
- * Generates a cryptographically-strong random nonce string.
- *
- * We use this nonce to whitelist our injected <script> tags in the Webview's
- * Content-Security-Policy. By including a fresh, unpredictable nonce on each
- * load and referencing it both in the CSP header (`script-src 'nonce-…'`)
- * and in the `<script nonce="…">` attributes, we ensure:
- *   1. Only the scripts we explicitly ship and inject can execute.
- *   2. Inline scripts or any third-party code not bearing the correct nonce
- *      are blocked by the browser sandbox.
- *
- * @returns a 32-character alphanumeric nonce
- */
-export function getNonce(): string {
-  let text = "";
-  const chars =
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-  for (let i = 0; i < 32; i++) {
-    text += chars.charAt(Math.floor(Math.random() * chars.length));
-  }
-  return text;
-}
-
-/**
- * Resolves the on‐disk base directory for our `src/manage/webviews` folder.
- *
- * 1. Tries the normal location under the installed extension:
- *      <extensionPath>/src/manage/webviews
- * 2. If that doesn’t exist, checks if we're running in the E2E test harness
- *    under "<...>/tests/internal/e2e/test/extension". If so, strips off
- *    that suffix and uses the repo root to locate:
- *      <repoRoot>/src/manage/webviews
- * 3. If neither exists, throws an error.
- *
- * @param context The ExtensionContext, used to read `extensionPath`.
- * @returns The filesystem path to the `webviews` folder.
- * @throws If no valid `webviews` folder can be found.
- */
-export function resolveWebviewBase(context: vscode.ExtensionContext): string {
-  // 1) Normal installed extension layout
-  const normal = path.join(context.extensionPath, "src", "manage", "webviews");
-  if (fs1.existsSync(normal)) {
-    return normal;
-  }
-
-  // 2) Fallback for E2E tests under tests/internal/e2e/test/extension
-  const marker = path.join("tests", "internal", "e2e", "test", "extension");
-  const extPath = context.extensionPath;
-  const idx = extPath.indexOf(marker);
-  if (idx !== -1) {
-    const repoRoot = extPath.slice(0, idx);
-    const fallback = path.join(repoRoot, "src", "manage", "webviews");
-    if (fs1.existsSync(fallback)) {
-      return fallback;
-    }
-  }
-
-  throw new Error(
-    `Could not resolve webview base directory. Tried:\n` +
-      `  ${normal}\n` +
-      (marker && extPath.indexOf(marker) !== -1
-        ? `  ${path.join(extPath.slice(0, extPath.indexOf(marker)), "src/manage/webviews")}\n`
-        : "") +
-      `Please ensure that 'src/manage/webviews' exists either under the extension path or under the repo root.`
-  );
-}
-
 /**
  * Adds environments that are part of a managed project (from globalProjectDataCache).
  * @param globalProjectDataCache A Map containing project data.
diff --git a/src/requirements/availability.ts b/src/requirements/availability.ts
new file mode 100644
index 00000000..2467e279
--- /dev/null
+++ b/src/requirements/availability.ts
@@ -0,0 +1,135 @@
+import * as vscode from "vscode";
+import { normalizePath } from "../utilities";
+import { makeEnviroNodeID } from "../testPane";
+import { testNodeCache } from "../testData";
+import { hasCompleteAndUsableRGW } from "./rgwIo";
+import { logCliOperation } from "./requirementsLog";
+
+const path = require("path");
+
+// Tracks node IDs (env + descendants) currently flagged as having
+// requirements available. Sub-node IDs are included so the
+// `testId in vcastRequirementsAvailable` check on `Generate Tests from
+// Requirements` matches when the user right-clicks a unit / function / test
+// inside an env that has requirements.
+let availableNodeIds: string[] = [];
+
+/**
+ * Collect every node ID descended from `envNodeID` that's currently in
+ * the test cache. Sub-node IDs follow the convention
+ * `<envID>|<unit>[.<func>[.<test>]]`, so a prefix filter is enough.
+ */
+function descendantNodeIds(envNodeID: string): string[] {
+  const prefix = `${envNodeID}|`;
+  const out: string[] = [];
+  for (const id of testNodeCache.keys()) {
+    if (typeof id === "string" && id.startsWith(prefix)) {
+      out.push(id);
+    }
+  }
+  return out;
+}
+
+function setAvailableContext(ids: string[]) {
+  vscode.commands.executeCommand(
+    "setContext",
+    "vectorcastTestExplorer.vcastRequirementsAvailable",
+    ids
+  );
+  availableNodeIds = ids;
+}
+
+/**
+ * Update the `vectorcastTestExplorer.vcastRequirementsAvailable` context key
+ * for an environment. Includes descendants discovered in `testNodeCache` so
+ * sub-node menu enablements (Generate Tests from Requirements) work too.
+ *
+ * Call this after the env's tree has been processed (descendants exist in
+ * the cache); otherwise only the env ID gets added until the tree is built.
+ */
+export function updateRequirementsAvailability(enviroPath: string) {
+  const envNodeID = makeEnviroNodeID(normalizePath(enviroPath));
+  const hasRequirements = hasCompleteAndUsableRGW(enviroPath);
+  const idsForThisEnv = [envNodeID, ...descendantNodeIds(envNodeID)];
+
+  if (hasRequirements) {
+    let updated = availableNodeIds.slice();
+    let changed = false;
+    for (const id of idsForThisEnv) {
+      if (!updated.includes(id)) {
+        updated.push(id);
+        changed = true;
+      }
+    }
+    if (changed) setAvailableContext(updated);
+  } else {
+    const drop = new Set(idsForThisEnv);
+    const updated = availableNodeIds.filter((id) => !drop.has(id));
+    if (updated.length !== availableNodeIds.length) setAvailableContext(updated);
+  }
+}
+
+/**
+ * Re-evaluate availability for every environment in the workspace. Out-of-
+ * band edits (the user deletes the RGW from a terminal, edits CCAST_.CFG,
+ * etc.) don't tell us which env was affected, and the eval is cheap enough
+ * (a few `fs.existsSync` per env) to just do everything.
+ */
+async function refreshAllRequirementsAvailability(
+  reason: string
+): Promise<void> {
+  const envFiles = await vscode.workspace.findFiles("**/*.env");
+  logCliOperation(
+    `availability: refresh (${reason}); ${envFiles.length} env(s) found`
+  );
+  for (const uri of envFiles) {
+    const envDir = path.dirname(uri.fsPath);
+    const envName = path.basename(uri.fsPath, ".env");
+    updateRequirementsAvailability(path.join(envDir, envName));
+  }
+}
+
+/**
+ * Watch for out-of-band RGW changes so the menu enablement stays in sync
+ * with the filesystem:
+ *  - `requirements_gateway/requirements.json` create/delete: the RGW
+ *    appearing or disappearing.
+ *  - `CCAST_.CFG` create/change/delete: the user pointing VCAST_REPOSITORY
+ *    somewhere else (or unsetting it).
+ *  - VS Code window regains focus: catches everything else (`rm -rf` of the
+ *    parent dir, network FS, etc., where the file-level watcher can drop
+ *    events). The user typically returns to VS Code after terminal-side
+ *    work, so this is a near-zero-cost fallback that almost always fires.
+ *
+ * All disposables are registered on `context.subscriptions`.
+ */
+export function setupRequirementsFileWatchers(
+  context: vscode.ExtensionContext
+): void {
+  const refresh = (reason: string) => () => {
+    void refreshAllRequirementsAvailability(reason);
+  };
+
+  const rgwWatcher = vscode.workspace.createFileSystemWatcher(
+    "**/requirements_gateway/requirements.json"
+  );
+  rgwWatcher.onDidCreate(refresh("rgw create"), null, context.subscriptions);
+  rgwWatcher.onDidDelete(refresh("rgw delete"), null, context.subscriptions);
+  context.subscriptions.push(rgwWatcher);
+
+  const cfgWatcher = vscode.workspace.createFileSystemWatcher("**/CCAST_.CFG");
+  cfgWatcher.onDidChange(refresh("ccast change"), null, context.subscriptions);
+  cfgWatcher.onDidCreate(refresh("ccast create"), null, context.subscriptions);
+  cfgWatcher.onDidDelete(refresh("ccast delete"), null, context.subscriptions);
+  context.subscriptions.push(cfgWatcher);
+
+  // Fallback: VS Code regains focus. Cheap and catches the bulk-delete case
+  // where the file-level watcher drops events.
+  context.subscriptions.push(
+    vscode.window.onDidChangeWindowState((state) => {
+      if (state.focused) {
+        void refreshAllRequirementsAvailability("window focused");
+      }
+    })
+  );
+}
diff --git a/src/requirements/legacyMigration.ts b/src/requirements/legacyMigration.ts
new file mode 100644
index 00000000..54c3a2ce
--- /dev/null
+++ b/src/requirements/legacyMigration.ts
@@ -0,0 +1,122 @@
+import * as vscode from "vscode";
+import { findRelevantRequirementGateway } from "./rgwPath";
+import { PANREQ_EXECUTABLE_PATH } from "./requirementsExecutables";
+import { logCliOperation } from "./requirementsLog";
+import { importRequirementsFromPath } from "./requirementsOperations";
+
+const path = require("path");
+const fs = require("fs");
+
+// Persisted in workspaceState so a "Don't show again" choice survives
+// across VS Code sessions for this workspace.
+const SKIP_KEY = "vectorcastTestExplorer.reqs2x.skippedLegacyMigrationPrompt";
+
+interface LegacyEnv {
+  enviroPath: string;
+  legacySource: string;
+}
+
+/**
+ * Walk every `*.env` in the workspace looking for envs that have a legacy
+ * `reqs-<env>/reqs.xlsx` (or `reqs.csv`) file but no RGW configured yet.
+ * Those are the candidates for migration to the new RGW-based storage.
+ */
+async function findEnvsWithLegacyStorage(): Promise<LegacyEnv[]> {
+  const envFiles = await vscode.workspace.findFiles("**/*.env");
+  const out: LegacyEnv[] = [];
+  for (const uri of envFiles) {
+    const envDir = path.dirname(uri.fsPath);
+    const envName = path.basename(uri.fsPath, ".env");
+    const enviroPath = path.join(envDir, envName);
+
+    // Already migrated (or otherwise has a working gateway): skip.
+    if (findRelevantRequirementGateway(enviroPath)) continue;
+
+    const reqsDir = path.join(envDir, `reqs-${envName}`);
+    const xlsx = path.join(reqsDir, "reqs.xlsx");
+    const csv = path.join(reqsDir, "reqs.csv");
+    if (fs.existsSync(xlsx)) {
+      out.push({ enviroPath, legacySource: xlsx });
+    } else if (fs.existsSync(csv)) {
+      out.push({ enviroPath, legacySource: csv });
+    }
+  }
+  return out;
+}
+
+/**
+ * Migrate one env: import its legacy reqs.xlsx / reqs.csv into a fresh RGW
+ * under `reqs-<env>/rgw/`. Just a thin wrapper around the shared
+ * importRequirementsFromPath helper with a migration-flavoured progress
+ * title.
+ */
+async function migrateOne(env: LegacyEnv): Promise<boolean> {
+  return importRequirementsFromPath(env.enviroPath, env.legacySource, {
+    progressTitle: `Migrating requirements for ${path.basename(env.enviroPath)}`,
+  });
+}
+
+/**
+ * Offer a one-shot migration of legacy reqs.xlsx / reqs.csv files into the
+ * new RGW format. Shown at most once per workspace per "Don't show again"
+ * choice; otherwise the prompt re-appears the next session if any envs
+ * still have legacy files but no gateway. Skipped entirely when Reqs2X
+ * isn't enabled (the executables aren't resolved in that case).
+ */
+export async function maybeOfferLegacyMigration(
+  context: vscode.ExtensionContext
+): Promise<void> {
+  if (context.workspaceState.get<boolean>(SKIP_KEY)) return;
+
+  // Reqs2X feature must be on (so the panreq path is resolved).
+  const enabled = vscode.workspace
+    .getConfiguration("vectorcastTestExplorer.reqs2x")
+    .get<boolean>("enableReqs2xFeature");
+  if (!enabled || !PANREQ_EXECUTABLE_PATH) return;
+
+  const legacyEnvs = await findEnvsWithLegacyStorage();
+  if (legacyEnvs.length === 0) return;
+
+  logCliOperation(
+    `Legacy migration: ${legacyEnvs.length} env(s) have reqs.xlsx/reqs.csv but no RGW.`
+  );
+
+  const envWord = legacyEnvs.length === 1 ? "environment" : "environments";
+  const message =
+    `Found ${legacyEnvs.length} ${envWord} with legacy requirements files ` +
+    `(reqs.xlsx / reqs.csv). Requirements are now stored in a Requirements ` +
+    `Gateway (RGW). Migrate now?`;
+
+  const choice = await vscode.window.showInformationMessage(
+    message,
+    "Migrate",
+    "Not now",
+    "Don't show again"
+  );
+
+  if (choice === "Don't show again") {
+    await context.workspaceState.update(SKIP_KEY, true);
+    return;
+  }
+  if (choice !== "Migrate") return;
+
+  let succeeded = 0;
+  let failed = 0;
+  for (const env of legacyEnvs) {
+    const ok = await migrateOne(env);
+    if (ok) succeeded++;
+    else failed++;
+  }
+
+  if (failed === 0) {
+    vscode.window.showInformationMessage(
+      `Migrated ${succeeded} ${envWord} to the new RGW format. ` +
+      `The legacy reqs.xlsx / reqs.csv files were left in place as a backup.`
+    );
+  } else {
+    vscode.window.showWarningMessage(
+      `Migrated ${succeeded}; ${failed} failed. See the ` +
+      `"VectorCAST Requirement Test Generation Operations" output channel for details.`
+    );
+  }
+}
diff --git a/src/requirements/llmProvider.ts b/src/requirements/llmProvider.ts
new file mode 100644
index 00000000..9ecf0cf0
--- /dev/null
+++ b/src/requirements/llmProvider.ts
@@ -0,0 +1,329 @@
+import * as vscode from "vscode";
+import {
+  ChildProcessWithoutNullStreams,
+  spawn,
+} from "node:child_process";
+import { vcastInstallationDirectory } from "../vcastInstallation";
+import { showSettings } from "../utilities";
+import { extractJson } from "../../src-common/commonUtilities";
+import { LLM2CHECK_EXECUTABLE_PATH } from "./requirementsExecutables";
+
+export interface LLMProviderSettingsResult {
+  provider: string | null;
+  env: Record<string, string>;
+  missing: string[];
+}
+
+/**
+ * Project the user's LLM provider settings from VS Code config into the env
+ * variables Reqs2X tools expect. Returns a list of missing required fields
+ * for the chosen provider so the caller can show a useful error.
+ */
+export function gatherLLMProviderSettings(): LLMProviderSettingsResult {
+  const config = vscode.workspace.getConfiguration("vectorcastTestExplorer");
+
+  const provider = config.get<string>("reqs2x.provider");
+  const baseEnv: Record<string, string> = {};
+  const missing: string[] = [];
+
+  if (!provider) {
+    missing.push("Provider (reqs2x.provider)");
+    return { provider: null, env: baseEnv, missing };
+  }
+
+  function need(value: string | undefined, label: string, envVarName: string) {
+    if (!value) {
+      missing.push(label);
+      return;
+    }
+    baseEnv[envVarName] = value;
+  }
+
+  function optional(value: string | undefined, envVarName: string) {
+    if (value) {
+      baseEnv[envVarName] = value;
+    }
+  }
+
+  if (provider === "azure_openai") {
+    need(
+      config.get<string>("reqs2x.azure.baseUrl"),
+      "Azure Base URL",
+      "VCAST_REQS2X_AZURE_OPENAI_BASE_URL"
+    );
+    need(
+      config.get<string>("reqs2x.azure.apiKey"),
+      "Azure API Key",
+      "VCAST_REQS2X_AZURE_OPENAI_API_KEY"
+    );
+    need(
+      config.get<string>("reqs2x.azure.deployment"),
+      "Azure Deployment",
+      "VCAST_REQS2X_AZURE_OPENAI_DEPLOYMENT"
+    );
+    need(
+      config.get<string>("reqs2x.azure.modelName"),
+      "Azure Model Name",
+      "VCAST_REQS2X_AZURE_OPENAI_MODEL_NAME"
+    );
+    need(
+      config.get<string>("reqs2x.azure.apiVersion"),
+      "Azure API Version",
+      "VCAST_REQS2X_AZURE_OPENAI_API_VERSION"
+    );
+    optional(
+      config.get<string>("reqs2x.azure.reasoningModelName"),
+      "VCAST_REQS2X_REASONING_AZURE_OPENAI_MODEL_NAME"
+    );
+    optional(
+      config.get<string>("reqs2x.azure.reasoningDeployment"),
+      "VCAST_REQS2X_REASONING_AZURE_OPENAI_DEPLOYMENT"
+    );
+  } else if (provider === "openai") {
+    optional(
+      config.get<string>("reqs2x.openai.baseUrl"),
+      "VCAST_REQS2X_OPENAI_BASE_URL"
+    );
+    need(
+      config.get<string>("reqs2x.openai.apiKey"),
+      "OpenAI API Key",
+      "VCAST_REQS2X_OPENAI_API_KEY"
+    );
+    need(
+      config.get<string>("reqs2x.openai.modelName"),
+      "OpenAI Model Name",
+      "VCAST_REQS2X_OPENAI_MODEL_NAME"
+    );
+    optional(
+      config.get<string>("reqs2x.openai.reasoningModelName"),
+      "VCAST_REQS2X_REASONING_OPENAI_MODEL_NAME"
+    );
+  } else if (provider === "anthropic") {
+    need(
+      config.get<string>("reqs2x.anthropic.apiKey"),
+      "Anthropic API Key",
+      "VCAST_REQS2X_ANTHROPIC_API_KEY"
+    );
+    need(
+      config.get<string>("reqs2x.anthropic.modelName"),
+      "Anthropic Model Name",
+      "VCAST_REQS2X_ANTHROPIC_MODEL_NAME"
+    );
+    optional(
+      config.get<string>("reqs2x.anthropic.reasoningModelName"),
+      "VCAST_REQS2X_REASONING_ANTHROPIC_MODEL_NAME"
+    );
+  } else if (provider === "litellm") {
+    need(
+      config.get<string>("reqs2x.litellm.modelName"),
+      "LiteLLM Model Name",
+      "VCAST_REQS2X_LITELLM_MODEL_NAME"
+    );
+    optional(
+      config.get<string>("reqs2x.litellm.reasoningModelName"),
+      "VCAST_REQS2X_REASONING_LITELLM_MODEL_NAME"
+    );
+
+    const litellmProviderEnvVarsString = config.get<string>(
+      "reqs2x.litellm.providerEnvVars",
+      ""
+    );
+    const entries = litellmProviderEnvVarsString
+      .split(",")
+      .map((pair) => pair.split("="))
+      .filter((kv) => kv[0].trim().length);
+
+    if (entries.some((entryValues) => entryValues.length !== 2)) {
+      missing.push(
+        "LiteLLM Provider Environment Variables must be KEY=VALUE pairs"
+      );
+    } else {
+      for (const [key, value] of entries) {
+        baseEnv[key.trim()] = value.trim();
+      }
+    }
+  } else if (provider === "azure_apim") {
+    need(
+      config.get<string>("reqs2x.azureApim.subscriptionKey"),
+      "APIM Subscription Key",
+      "VCAST_REQS2X_AZURE_APIM_SUBSCRIPTION_KEY"
+    );
+    need(
+      config.get<string>("reqs2x.azureApim.baseUrl"),
+      "APIM Base URL",
+      "VCAST_REQS2X_AZURE_APIM_BASE_URL"
+    );
+    need(
+      config.get<string>("reqs2x.azureApim.modelName"),
+      "APIM Model Name",
+      "VCAST_REQS2X_AZURE_APIM_MODEL_NAME"
+    );
+    optional(
+      config.get<string>("reqs2x.azureApim.apiKey"),
+      "VCAST_REQS2X_AZURE_APIM_API_KEY"
+    );
+    optional(
+      config.get<string>("reqs2x.azureApim.reasoningModelName"),
+      "VCAST_REQS2X_REASONING_AZURE_APIM_MODEL_NAME"
+    );
+  } else if (provider === "openai_at") {
+    need(
+      config.get<string>("reqs2x.openaiAt.modelName"),
+      "OpenAI AT Model Name",
+      "VCAST_REQS2X_OPENAI_AT_MODEL_NAME"
+    );
+    need(
+      config.get<string>("reqs2x.openaiAt.modelUrl"),
+      "OpenAI AT Model URL",
+      "VCAST_REQS2X_OPENAI_AT_MODEL_URL"
+    );
+    need(
+      config.get<string>("reqs2x.openaiAt.authUrl"),
+      "OpenAI AT Auth URL",
+      "VCAST_REQS2X_OPENAI_AT_AUTH_URL"
+    );
+    need(
+      config.get<string>("reqs2x.openaiAt.appKey"),
+      "OpenAI AT App Key",
+      "VCAST_REQS2X_OPENAI_AT_APP_KEY"
+    );
+    need(
+      config.get<string>("reqs2x.openaiAt.appSecret"),
+      "OpenAI AT App Secret",
+      "VCAST_REQS2X_OPENAI_AT_APP_SECRET"
+    );
+    optional(
+      config.get<string>("reqs2x.openaiAt.reasoningModelName"),
+      "VCAST_REQS2X_REASONING_OPENAI_AT_MODEL_NAME"
+    );
+  } else {
+    missing.push("Unsupported provider value");
+  }
+
+  return { provider, env: baseEnv, missing };
+}
+
+/**
+ * Run llm2check to verify the configured provider is reachable. Used by both
+ * the explicit "Test LLM Configuration" command and as a precondition before
+ * invoking other Reqs2X tools.
+ */
+export function isLLMProviderEnvironmentUsable(): Promise<{
+  usable: boolean;
+  problem: string | null;
+}> {
+  const processEnv = { ...process.env };
+
+  const gatheredSettings = gatherLLMProviderSettings();
+  for (const [k, v] of Object.entries(gatheredSettings.env)) {
+    if (v) processEnv[k] = v;
+  }
+
+  if (
+    vscode.workspace
+      .getConfiguration("vectorcastTestExplorer.reqs2x")
+      .get<boolean>("modelCompatibilityMode", false)
+  ) {
+    processEnv.VCAST_REQS2X_MODEL_COMPATIBILITY_MODE = "1";
+  }
+
+  const proc = spawn(LLM2CHECK_EXECUTABLE_PATH, ["--json"], {
+    env: processEnv,
+  });
+
+  return new Promise((resolve) => {
+    let output = "";
+    proc.stdout.on("data", (data) => {
+      output += data.toString();
+    });
+
+    proc.on("close", () => {
+      const result = extractJson(output);
+      if (result && typeof result.usable === "boolean") {
+        resolve({ usable: result.usable, problem: result.problem || null });
+      } else {
+        console.error(`Failed to parse llm2check output: ${output}`);
+        resolve({ usable: false, problem: "Failed to parse llm2check output" });
+      }
+    });
+  });
+}
+
+/**
+ * Wraps `isLLMProviderEnvironmentUsable` with a user-facing error toast and
+ * "Open Settings" action. Returns true if the provider is usable, false
+ * otherwise (toast already shown).
+ */
+export async function performLLMProviderUsableCheck(): Promise<boolean> {
+  const { usable, problem } = await isLLMProviderEnvironmentUsable();
+  const gatheredSettings = gatherLLMProviderSettings();
+
+  if (!usable) {
+    const causedByMissing = problem?.includes(
+      "No provider configuration found"
+    );
+
+    const errorMessage = causedByMissing
+      ? `Required information to run Reqs2X with currently selected LLM provider (${gatheredSettings.provider}) is missing: ${gatheredSettings.missing.join(", ")}`
+      : `The current LLM provider settings for Reqs2X (either set in the extension or in the environment) are not usable: ${problem}`;
+
+    vscode.window
+      .showErrorMessage(errorMessage, "Open Settings")
+      .then((choice) => {
+        if (choice === "Open Settings") showSettings();
+      });
+
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Build the env block Reqs2X tools expect: provider creds + extras
+ * (generation language, debug logging, model-compatibility mode). Adds
+ * VSCODE_VECTORCAST_DIR so the tools can find the VC installation.
+ */
+export async function createProcessEnvironment(): Promise<NodeJS.ProcessEnv> {
+  const processEnv = { ...process.env };
+  processEnv.VSCODE_VECTORCAST_DIR = vcastInstallationDirectory;
+
+  const gatheredSettings = gatherLLMProviderSettings();
+  for (const [k, v] of Object.entries(gatheredSettings.env)) {
+    if (v) processEnv[k] = v;
+  }
+
+  const config = vscode.workspace.getConfiguration(
+    "vectorcastTestExplorer.reqs2x"
+  );
+  const languageCode = config.get<string>("generationLanguage", "en");
+  processEnv.VCAST_REQS2X_RESPONSE_LANGUAGE = languageCode;
+
+  if (config.get<boolean>("outputDebugInfo", false)) {
+    processEnv.VCAST_REQS2X_LOG_LEVEL = "debug";
+  }
+
+  if (config.get<boolean>("modelCompatibilityMode", false)) {
+    processEnv.VCAST_REQS2X_MODEL_COMPATIBILITY_MODE = "1";
+  }
+
+  return processEnv;
+}
+
+/**
+ * Spawn a Reqs2X tool with the LLM-aware env block. Performs the provider
+ * check up-front; throws if the user hasn't configured a usable provider.
+ */
+export async function spawnWithVcastEnv(
+  command: string,
+  args: string[],
+  options: any = {}
+): Promise<ChildProcessWithoutNullStreams> {
+  const checkSuccessful = await performLLMProviderUsableCheck();
+  if (!checkSuccessful) {
+    throw new Error("LLM provider settings are not usable");
+  }
+
+  const env = await createProcessEnvironment();
+  return spawn(command, args, { ...options, env });
+}
diff --git a/src/requirements/processRunner.ts b/src/requirements/processRunner.ts
new file mode 100644
index 00000000..bdf0e99c
--- /dev/null
+++ b/src/requirements/processRunner.ts
@@ -0,0 +1,191 @@
+import * as vscode from "vscode";
+import {
+  ChildProcessWithoutNullStreams,
+  spawn,
+} from "node:child_process";
+import { logCliError, logCliOperation } from "./requirementsLog";
+import { spawnWithVcastEnv } from "./llmProvider";
+
+/**
+ * Parses Reqs2X tool stdout for `--json-events` lines and drives a VS Code
+ * progress reporter from them. Plain (non-JSON) lines are forwarded to the
+ * operations output channel verbatim.
+ */
+export class ProgressTracker {
+  private lastProgress = 0.0;
+
+  constructor(
+    private progress: vscode.Progress<{ message?: string; increment?: number }>,
+    private logPrefix: string
+  ) {}
+
+  public processOutput(output: string) {
+    const lines = output.split("\n");
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const json = JSON.parse(line);
+        this.handleJson(json);
+      } catch {
+        logCliOperation(`${this.logPrefix}: ${line}`);
+      }
+    }
+  }
+
+  private handleJson(json: any) {
+    if (!json.event) {
+      throw new Error(
+        `Invalid JSON event: ${JSON.stringify(json)}. Missing 'event' field.`
+      );
+    }
+    if (!json.value) {
+      throw new Error(
+        `Invalid JSON event: ${JSON.stringify(json)}. Missing 'value' field.`
+      );
+    }
+    if (json.event === "progress") {
+      let step: string | undefined;
+      let newProgress: number | undefined;
+      if (typeof json.value === "object") {
+        step = json.value.step;
+        newProgress = json.value.progress;
+      } else if (typeof json.value === "number") {
+        newProgress = json.value; // legacy
+      }
+
+      if (newProgress === undefined) return;
+
+      const increment = (newProgress - this.lastProgress) * 100;
+      if (increment > 0) {
+        this.progress.report({ message: step, increment });
+        this.lastProgress = newProgress;
+        logCliOperation(
+          `${this.logPrefix} Progress: ${(newProgress * 100).toFixed(2)}% - ${step ?? ""}`
+        );
+      }
+    } else if (json.event === "problem") {
+      if (this.logPrefix === "reqs2tests" && json.value.includes("Individual")) {
+        return;
+      }
+      vscode.window.showWarningMessage(json.value);
+      logCliOperation(`Warning: ${json.value}`);
+    }
+  }
+}
+
+export interface RunReqs2xToolOptions {
+  /** Absolute path to the executable (panreq, code2reqs, reqs2tests, etc.). */
+  exe: string;
+  /** Arguments. */
+  args: string[];
+  /** Optional working directory. */
+  cwd?: string;
+  /**
+   * If true, the tool needs the LLM-aware env block (provider check + env
+   * vars). Use for code2reqs, reqs2tests, panreq --infer-traceability.
+   * Skip for plain panreq format conversions or other LLM-free operations.
+   */
+  llm?: boolean;
+  /**
+   * If provided, wraps the run in a VS Code progress notification and parses
+   * the tool's stdout via ProgressTracker. The notification is cancellable —
+   * cancel kills the subprocess and the runner returns `{ cancelled: true }`.
+   */
+  progress?: { title: string; logPrefix: string };
+}
+
+export interface RunReqs2xToolResult {
+  cancelled: boolean;
+}
+
+/**
+ * Single entry point for invoking a Reqs2X CLI tool. Replaces the previous
+ * mix of `spawnAndWait`, ad-hoc `spawn(...)` blocks, and inline progress
+ * wiring scattered across the requirements modules.
+ *
+ * - Logs the command, stdout, stderr and exit code to the operations output.
+ * - Honors `llm` to decide between plain `spawn` and LLM-checked
+ *   `spawnWithVcastEnv`.
+ * - With `progress` set, drives the standard notification + cancel button.
+ *
+ * Resolves on success, throws on non-zero exit, or returns
+ * `{ cancelled: true }` if the user cancelled a progress run.
+ */
+export async function runReqs2xTool(
+  opts: RunReqs2xToolOptions
+): Promise<RunReqs2xToolResult> {
+  logCliOperation(
+    `Running: ${opts.exe} ${opts.args.join(" ")}${opts.cwd ? `  (cwd=${opts.cwd})` : ""}`
+  );
+
+  const spawnOpts = opts.cwd ? { cwd: opts.cwd } : {};
+  const startProc = async (): Promise<ChildProcessWithoutNullStreams> =>
+    opts.llm
+      ? await spawnWithVcastEnv(opts.exe, opts.args, spawnOpts)
+      : spawn(opts.exe, opts.args, spawnOpts);
+
+  if (opts.progress) {
+    const progressOpts = opts.progress;
+    return vscode.window.withProgress(
+      {
+        location: vscode.ProgressLocation.Notification,
+        title: progressOpts.title,
+        cancellable: true,
+      },
+      async (progress, cancellationToken) => {
+        const proc = await startProc();
+        const tracker = new ProgressTracker(progress, progressOpts.logPrefix);
+
+        let cancelled = false;
+        cancellationToken.onCancellationRequested(() => {
+          cancelled = true;
+          proc.kill();
+          logCliOperation(`${progressOpts.logPrefix}: cancelled by user`);
+        });
+
+        await new Promise<void>((resolve, reject) => {
+          proc.stdout.on("data", (d) => {
+            if (!cancelled) tracker.processOutput(d.toString());
+          });
+          proc.stderr.on("data", (d) => {
+            const errOut = d.toString();
+            if (errOut.trim()) logCliError(`${progressOpts.logPrefix}: ${errOut.trim()}`);
+          });
+          proc.on("error", reject);
+          proc.on("close", (code) => {
+            logCliOperation(`${progressOpts.logPrefix} exit code: ${code}`);
+            if (cancelled) return resolve();
+            if (code === 0) resolve();
+            else reject(new Error(`${progressOpts.logPrefix} exited with code ${code}`));
+          });
+        });
+
+        return { cancelled };
+      }
+    );
+  }
+
+  // No progress notification: capture both streams and log them.
+  const proc = await startProc();
+  let stdout = "";
+  let stderr = "";
+
+  await new Promise<void>((resolve, reject) => {
+    proc.stdout.on("data", (d) => {
+      stdout += d.toString();
+    });
+    proc.stderr.on("data", (d) => {
+      stderr += d.toString();
+    });
+    proc.on("error", reject);
+    proc.on("close", (code) => {
+      if (stdout.trim()) logCliOperation(`stdout: ${stdout.trim()}`);
+      if (stderr.trim()) logCliOperation(`stderr: ${stderr.trim()}`);
+      logCliOperation(`exit code: ${code}`);
+      if (code === 0) resolve();
+      else reject(new Error(`${opts.exe} exited with code ${code}: ${stderr}`));
+    });
+  });
+
+  return { cancelled: false };
+}
diff --git a/src/requirements/requirementsExecutables.ts b/src/requirements/requirementsExecutables.ts
new file mode 100644
index 00000000..3805af0c
--- /dev/null
+++ b/src/requirements/requirementsExecutables.ts
@@ -0,0 +1,102 @@
+import * as vscode from "vscode";
+import { vcastInstallationDirectory } from "../vcastInstallation";
+import { exeFilename } from "../utilities";
+import { logCliError, logCliOperation } from "./requirementsLog";
+
+const fs = require("fs");
+
+const NECESSARY_REQS2X_EXECUTABLES = [
+  "code2reqs",
+  "reqs2tests",
+  "panreq",
+  "llm2check",
+];
+
+// Resolved at activation time via setupReqs2XExecutablePaths. Mutable
+// module-level state so the rest of the requirements modules can depend on
+// fixed names without each having to know how the binaries were located.
+export let CODE2REQS_EXECUTABLE_PATH: string = "";
+export let REQS2TESTS_EXECUTABLE_PATH: string = "";
+export let PANREQ_EXECUTABLE_PATH: string = "";
+export let LLM2CHECK_EXECUTABLE_PATH: string = "";
+
+/**
+ * Resolve the on-disk directory containing the Reqs2X executables. Priority:
+ *   1. `reqs2x.installationLocation` setting (if it has every binary).
+ *   2. The configured VectorCAST installation directory.
+ *   3. The bundled CI/VSIX resource path.
+ */
+export function getAutoreqExecutableDirectory(
+  context: vscode.ExtensionContext
+): vscode.Uri | undefined {
+  const pathHasAllExecutables = (dirPath: string): boolean => {
+    return NECESSARY_REQS2X_EXECUTABLES.every((exe) =>
+      fs.existsSync(
+        vscode.Uri.joinPath(vscode.Uri.file(dirPath), exeFilename(exe)).fsPath
+      )
+    );
+  };
+
+  const config = vscode.workspace.getConfiguration(
+    "vectorcastTestExplorer.reqs2x"
+  );
+  const installationLocation = config.get<string>("installationLocation");
+  if (installationLocation && pathHasAllExecutables(installationLocation)) {
+    return vscode.Uri.file(installationLocation);
+  }
+
+  if (pathHasAllExecutables(vcastInstallationDirectory)) {
+    return vscode.Uri.file(vcastInstallationDirectory);
+  }
+
+  const isCI = process.env.HOME?.startsWith("/github") ?? false;
+  const vsixResourceBasePath = `${process.env.GITHUB_WORKSPACE}/vsix`;
+
+  if (!fs.existsSync(vsixResourceBasePath)) {
+    logCliError(
+      `VSIX resource folder not found at expected path: ${vsixResourceBasePath}`
+    );
+  } else {
+    logCliOperation(`Found VSIX resource folder at: ${vsixResourceBasePath}`);
+  }
+
+  const vsixBaseURI = isCI
+    ? vscode.Uri.file(vsixResourceBasePath)
+    : context.extensionUri;
+
+  if (pathHasAllExecutables(vsixBaseURI.fsPath)) {
+    return vscode.Uri.joinPath(vsixBaseURI, "resources", "distribution");
+  }
+
+  return undefined;
+}
+
+/**
+ * Populate the four executable-path module bindings. Returns false if the
+ * binaries can't be located so the caller can disable the feature gracefully.
+ */
+export function setupReqs2XExecutablePaths(
+  context: vscode.ExtensionContext
+): boolean {
+  const baseUri = getAutoreqExecutableDirectory(context);
+  if (!baseUri) return false;
+
+  CODE2REQS_EXECUTABLE_PATH = vscode.Uri.joinPath(
+    baseUri,
+    exeFilename("code2reqs")
+  ).fsPath;
+  REQS2TESTS_EXECUTABLE_PATH = vscode.Uri.joinPath(
+    baseUri,
+    exeFilename("reqs2tests")
+  ).fsPath;
+  PANREQ_EXECUTABLE_PATH = vscode.Uri.joinPath(
+    baseUri,
+    exeFilename("panreq")
+  ).fsPath;
+  LLM2CHECK_EXECUTABLE_PATH = vscode.Uri.joinPath(
+    baseUri,
+    exeFilename("llm2check")
+  ).fsPath;
+
+  return true;
+}
diff --git a/src/requirements/requirementsLog.ts b/src/requirements/requirementsLog.ts
new file mode 100644
index 00000000..c407973e
--- /dev/null
+++ b/src/requirements/requirementsLog.ts
@@ -0,0 +1,25 @@
+import * as vscode from "vscode";
+
+// Output channel for all Reqs2X CLI invocations (code2reqs, reqs2tests,
+// panreq, llm2check). Lives in a leaf module so every other requirements
+// module can import the log helpers without pulling in requirementsOperations
+// — the dependency that previously forced lazy `require()` calls.
+const cliOutputChannel: vscode.OutputChannel = vscode.window.createOutputChannel(
+  "VectorCAST Requirement Test Generation Operations"
+);
+
+export function logCliOperation(message: string): void {
+  const timestamp = new Date().toLocaleTimeString();
+  cliOutputChannel.appendLine(`[${timestamp}] ${message}`);
+}
+
+export function logCliError(
+  message: string,
+  show: boolean | null = null
+): void {
+  const timestamp = new Date().toLocaleTimeString();
+  cliOutputChannel.appendLine(`[${timestamp}] ${message}`);
+  if (show) {
+    cliOutputChannel.show();
+  }
+}
diff --git a/src/requirements/requirementsOperations.ts b/src/requirements/requirementsOperations.ts
index 91451ecb..814a1e94 100644
--- a/src/requirements/requirementsOperations.ts
+++ b/src/requirements/requirementsOperations.ts
@@ -1,120 +1,32 @@
 import * as vscode from "vscode";
-import { exeFilename, showSettings } from "../utilities";
-import {
-  findRelevantRequirementGateway,
-  getAutoreqExecutableDirectory,
-  setupRequirementsFileWatchers,
-  spawnWithVcastEnv,
-  updateRequirementsAvailability,
-} from "./requirementsUtils";
+import { showSettings } from "../utilities";
 import { refreshAllExtensionData } from "../testPane";
 import { loadTestScriptIntoEnvironment } from "../vcastAdapter";
+import { updateRequirementsAvailability } from "./availability";
+import { logCliError } from "./requirementsLog";
+import {
+  CODE2REQS_EXECUTABLE_PATH,
+  PANREQ_EXECUTABLE_PATH,
+  REQS2TESTS_EXECUTABLE_PATH,
+  setupReqs2XExecutablePaths,
+} from "./requirementsExecutables";
+import { runReqs2xTool } from "./processRunner";
+import {
+  defaultRequirementGatewayPath,
+  findRelevantRequirementGateway,
+  setVcastRepositoryInConfig,
+} from "./rgwPath";
+import {
+  hasCompleteAndUsableRGW,
+  inferTraceability,
+  readRGWBundle,
+} from "./rgwIo";
 
 const path = require("path");
 const fs = require("fs");
 
 let reqs2XFeatureEnabled: boolean = false;
 
-export const GENERATE_REQUIREMENTS_ENABLED: boolean = true;
-
-// Setup the paths to the reqs2x executables
-let CODE2REQS_EXECUTABLE_PATH: string;
-let REQS2TESTS_EXECUTABLE_PATH: string;
-let PANREQ_EXECUTABLE_PATH: string;
-
-export let LLM2CHECK_EXECUTABLE_PATH: string;
-
-// Add a new output channel for CLI operations
-let cliOutputChannel: vscode.OutputChannel = vscode.window.createOutputChannel(
-  "VectorCAST Requirement Test Generation Operations"
-);
-
-export function logCliOperation(message: string): void {
-  const timestamp = new Date().toLocaleTimeString();
-  cliOutputChannel.appendLine(`[${timestamp}] ${message}`);
-}
-
-export function logCliError(
-  message: string,
-  show: boolean | null = null
-): void {
-  const timestamp = new Date().toLocaleTimeString();
-  cliOutputChannel.appendLine(`[${timestamp}] ${message}`);
-
-  if (show) {
-    cliOutputChannel.show();
-  }
-}
-
-class ProgressTracker {
-  private lastProgress = 0.0;
-
-  constructor(
-    private progress: vscode.Progress<{ message?: string; increment?: number }>,
-    private logPrefix: string
-  ) {}
-
-  public processOutput(output: string) {
-    const lines = output.split("\n");
-    for (const line of lines) {
-      if (!line.trim()) continue;
-      try {
-        const json = JSON.parse(line);
-        this.handleJson(json);
-      } catch (e) {
-        logCliOperation(`${this.logPrefix}: ${line}`);
-      }
-    }
-  }
-
-  private handleJson(json: any) {
-    if (!json.event) {
-      throw new Error(
-        `Invalid JSON event: ${JSON.stringify(json)}. Missing 'event' field.`
-      );
-    }
-    if (!json.value) {
-      throw new Error(
-        `Invalid JSON event: ${JSON.stringify(json)}. Missing 'value' field.`
-      );
-    }
-    if (json.event === "progress") {
-      let step: string | undefined;
-      let newProgress: number | undefined;
-      if (typeof json.value === "object") {
-        step = json.value.step;
-        newProgress = json.value.progress;
-      } else if (typeof json.value === "number") {
-        newProgress = json.value; // legacy
-      }
-
-      if (newProgress === undefined) {
-        return;
-      }
-
-      const increment = (newProgress - this.lastProgress) * 100;
-      if (increment > 0) {
-        this.progress.report({ message: step, increment });
-        this.lastProgress = newProgress;
-        logCliOperation(
-          `${this.logPrefix} Progress: ${(newProgress * 100).toFixed(
-            2
-          )}% - ${step ?? ""}`
-        );
-      }
-    } else if (json.event === "problem") {
-      if (
-        this.logPrefix === "reqs2tests" &&
-        json.value.includes("Individual")
-      ) {
-        return;
-      }
-      vscode.window.showWarningMessage(json.value);
-      logCliOperation(`Warning: ${json.value}`);
-    }
-  }
-}
-
 export function initializeReqs2X(context: vscode.ExtensionContext) {
   const config = vscode.workspace.getConfiguration(
     "vectorcastTestExplorer.reqs2x"
@@ -124,19 +36,15 @@ export function initializeReqs2X(context: vscode.ExtensionContext) {
   let featureEnabled: boolean = false;
 
   if (reqs2XFeatureEnabled) {
-    setupRequirementsFileWatchers(context);
     const successful = setupReqs2XExecutablePaths(context);
     if (!successful) {
-      // Tell the user that we couldn't find the executables as an error popup and offer to open settings
       vscode.window
         .showErrorMessage(
           "Could not find the reqs2X executables anywhere, disabling Reqs2X. Please check your settings.",
           "Open Settings"
         )
         .then((selection) => {
-          if (selection === "Open Settings") {
-            showSettings();
-          }
+          if (selection === "Open Settings") showSettings();
         });
     } else {
       featureEnabled = true;
@@ -150,86 +58,27 @@ export function initializeReqs2X(context: vscode.ExtensionContext) {
   );
 }
 
-function setupReqs2XExecutablePaths(context: vscode.ExtensionContext): boolean {
-  const baseUri = getAutoreqExecutableDirectory(context);
-
-  if (!baseUri) {
-    return false;
-  }
-
-  CODE2REQS_EXECUTABLE_PATH = vscode.Uri.joinPath(
-    baseUri,
-    exeFilename("code2reqs")
-  ).fsPath;
-  REQS2TESTS_EXECUTABLE_PATH = vscode.Uri.joinPath(
-    baseUri,
-    exeFilename("reqs2tests")
-  ).fsPath;
-  PANREQ_EXECUTABLE_PATH = vscode.Uri.joinPath(
-    baseUri,
-    exeFilename("panreq")
-  ).fsPath;
-  LLM2CHECK_EXECUTABLE_PATH = vscode.Uri.joinPath(
-    baseUri,
-    exeFilename("llm2check")
-  ).fsPath;
-
-  return true;
-}
-
 export async function generateRequirements(enviroPath: string) {
   const parentDir = path.dirname(enviroPath);
   const lowestDirname = path.basename(enviroPath);
   const envName = `${lowestDirname}.env`;
   const envPath = path.join(parentDir, envName);
 
-  // remove ".env" if present
-  const enviroNameWithoutExt = envName.replace(/\.env$/, "");
-  const envReqsFolderPath = path.join(
-    parentDir,
-    `reqs-${enviroNameWithoutExt}`
-  );
-
-  // Ensure the requirements folder exists
-  if (!fs.existsSync(envReqsFolderPath)) {
-    fs.mkdirSync(envReqsFolderPath, { recursive: true });
-  }
-
-  const xlsxPath = path.join(envReqsFolderPath, "reqs.xlsx");
-  const csvPath = path.join(envReqsFolderPath, "reqs.csv");
-  const repositoryDir = path.join(
-    envReqsFolderPath,
-    "generated_requirement_repository"
-  );
-
-  // Check for existing gateway
-  const existingGateway = findRelevantRequirementGateway(enviroPath);
-  if (existingGateway) {
-    const warningMessage = `Warning: An existing requirements gateway was found at ${existingGateway}. Generating requirements will switch the environment gateway to a new one.`;
+  // Resolve the RGW path: use an already-configured VCAST_REPOSITORY if set,
+  // otherwise fall back to the extension's default location and write it into
+  // CCAST_.CFG so subsequent operations find the same gateway.
+  let repositoryDir = findRelevantRequirementGateway(enviroPath);
+  if (repositoryDir) {
     const choice = await vscode.window.showWarningMessage(
-      warningMessage,
+      `Warning: An existing requirements gateway was found at ${repositoryDir}. Generating requirements will overwrite it.`,
       "Continue",
       "Cancel"
     );
-
-    if (choice !== "Continue") {
-      return;
-    }
-  }
-
-  // Check for existing reqs.csv or reqs.xlsx
-  if (fs.existsSync(xlsxPath) || fs.existsSync(csvPath)) {
-    const message =
-      "Existing requirements files found. Do you want to overwrite them?";
-    const choice = await vscode.window.showWarningMessage(
-      message,
-      "Overwrite",
-      "Cancel"
-    );
-
-    if (choice !== "Overwrite") {
-      return;
-    }
+    if (choice !== "Continue") return;
+  } else {
+    repositoryDir = defaultRequirementGatewayPath(enviroPath);
+    fs.mkdirSync(path.dirname(repositoryDir), { recursive: true });
+    setVcastRepositoryInConfig(enviroPath, repositoryDir);
   }
 
   const config = vscode.workspace.getConfiguration(
@@ -241,88 +90,43 @@ export async function generateRequirements(enviroPath: string) {
   );
   const reorder = config.get<boolean>("reorder", true);
 
-  const commandArgs = [
+  const args = [
     "-e",
     envPath,
-    "--export-excel",
-    xlsxPath,
     "--export-repository",
-    `${existingGateway ?? repositoryDir}`, // use existingGateway if not null/undefined, else repositoryDir. This would mean that the vcast env in the path is not defined.
+    repositoryDir,
     "--json-events",
-    //"--combine-related-requirements",
-    //"--extended-reasoning"
+    ...(generateHighLevelRequirements
+      ? ["--generate-high-level-requirements"]
+      : []),
+    ...(reorder ? [] : ["--no-reorder"]),
   ];
 
-  if (generateHighLevelRequirements) {
-    commandArgs.push("--generate-high-level-requirements");
-  }
-
-  if (!reorder) {
-    commandArgs.push("--no-reorder");
+  try {
+    const { cancelled } = await runReqs2xTool({
+      exe: CODE2REQS_EXECUTABLE_PATH,
+      args,
+      llm: true,
+      progress: {
+        title: `Generating Requirements for ${envName.split(".")[0]}`,
+        logPrefix: "code2reqs",
+      },
+    });
+    if (cancelled) return;
+
+    await refreshAllExtensionData();
+    updateRequirementsAvailability(enviroPath);
+    vscode.commands.executeCommand("vectorcastTestExplorer.showRequirements", {
+      id: enviroPath,
+    });
+    vscode.window.showInformationMessage(
+      "Successfully generated requirements for the environment!"
+    );
+  } catch (err) {
+    const message = `Error: ${err instanceof Error ? err.message : String(err)}`;
+    vscode.window.showErrorMessage(message);
+    logCliError(message, true);
   }
-
-  // Log the command being executed
-  const commandString = `${CODE2REQS_EXECUTABLE_PATH} ${commandArgs.join(" ")}`;
-  logCliOperation(`Executing command: ${commandString}`);
-
-  await vscode.window.withProgress(
-    {
-      location: vscode.ProgressLocation.Notification,
-      title: `Generating Requirements for ${envName.split(".")[0]}`,
-      cancellable: true,
-    },
-    async (progress, cancellationToken) => {
-      const process = await spawnWithVcastEnv(
-        CODE2REQS_EXECUTABLE_PATH,
-        commandArgs
-      );
-
-      return new Promise<void>((resolve, reject) => {
-        const tracker = new ProgressTracker(progress, "code2reqs");
-
-        cancellationToken.onCancellationRequested(() => {
-          process.kill();
-          logCliOperation("Operation cancelled by user");
-          resolve();
-        });
-
-        process.stdout.on("data", (data) => {
-          if (cancellationToken.isCancellationRequested) return;
-          tracker.processOutput(data.toString());
-        });
-
-        process.stderr.on("data", (data) => {
-          const errorOutput = data.toString();
-          logCliError(`code2reqs: ${errorOutput}`);
-          console.error(`Stderr: ${errorOutput}`);
-        });
-
-        process.on("close", async (code) => {
-          if (cancellationToken.isCancellationRequested) return;
-          if (code === 0) {
-            logCliOperation(
-              `code2reqs completed successfully with code ${code}`
-            );
-            await refreshAllExtensionData();
-            updateRequirementsAvailability(enviroPath);
-            vscode.commands.executeCommand(
-              "vectorcastTestExplorer.showRequirements",
-              { id: enviroPath }
-            );
-            vscode.window.showInformationMessage(
-              "Successfully generated requirements for the environment!"
-            );
-            resolve();
-          } else {
-            const errorMessage = `Error: code2reqs exited with code ${code}`;
-            vscode.window.showErrorMessage(errorMessage);
-            logCliError(errorMessage, true);
-            reject(new Error(errorMessage));
-          }
-        });
-      });
-    }
-  );
 }
 
 export async function generateTestsFromRequirements(
@@ -334,40 +138,29 @@ export async function generateTestsFromRequirements(
   const envName = `${lowestDirname}.env`;
   const envPath = path.join(parentDir, envName);
 
-  // remove ".env" if present
-  const enviroNameWithoutExt = envName.replace(/\.env$/, "");
-  const envReqsFolderPath = path.join(
-    parentDir,
-    `reqs-${enviroNameWithoutExt}`
-  );
-
-  // Ensure the requirements folder exists
-  if (!fs.existsSync(envReqsFolderPath)) {
-    fs.mkdirSync(envReqsFolderPath, { recursive: true });
-  }
-
-  const csvPath = path.join(envReqsFolderPath, "reqs.csv");
-  const xlsxPath = path.join(envReqsFolderPath, "reqs.xlsx");
-
-  // tstPath must be in the same parent directory as the .env.
-  // If the .tst is stored inside reqs-<envName>, VectorCAST treats the
-  // environment as read-only and refuses to load it. Therefore we place
-  // reqs2tests.tst directly under parentDir, alongside <envName>.env.
+  // tstPath must be in the same parent directory as the .env. If the .tst is
+  // stored inside reqs-<envName>, VectorCAST treats the environment as
+  // read-only and refuses to load it.
   const tstPath = path.join(parentDir, "reqs2tests.tst");
 
-  let reqsFile = "";
-  if (fs.existsSync(xlsxPath)) {
-    reqsFile = xlsxPath;
-  } else if (fs.existsSync(csvPath)) {
-    reqsFile = csvPath;
-  } else {
+  const gatewayPath = findRelevantRequirementGateway(enviroPath);
+  if (!gatewayPath) {
     vscode.window.showErrorMessage(
-      "No requirements file found. Please generate requirements first."
+      "No requirements gateway found. Please generate requirements first."
     );
     return;
   }
 
-  // Get the decompose setting from configuration
+  // Test generation needs per-requirement traceability — reqs2tests routes
+  // each requirement to its mapped function. If the RGW has none, offer to
+  // infer it now rather than letting reqs2tests no-op or fail downstream.
+  const proceed = await offerTraceabilityInferenceIfMissing(enviroPath, {
+    prompt:
+      "None of the requirements trace to a function. Test generation requires per-requirement traceability. Would you like to infer it automatically first?",
+    cancelMeansAbort: true,
+  });
+  if (!proceed) return;
+
   const config = vscode.workspace.getConfiguration(
     "vectorcastTestExplorer.reqs2x"
   );
@@ -375,7 +168,6 @@ export async function generateTestsFromRequirements(
     "decomposeRequirements",
     true
   );
-
   const noTestExamples = config.get<boolean>("noTestExamples", false);
   const reorder = config.get<boolean>("reorder", true);
   const funcDefs = config.get<boolean>("functionDefinitions", true);
@@ -389,14 +181,10 @@ export async function generateTestsFromRequirements(
     return;
   }
 
-  const enableRequirementKeys =
-    findRelevantRequirementGateway(enviroPath) !== null;
-  console.log(decomposeRequirements, enableRequirementKeys);
-
-  const commandArgs = [
+  const args = [
     "-e",
     envPath,
-    reqsFile, // use the chosen requirements file
+    gatewayPath,
     ...(unitOrFunctionName ? ["-f", unitOrFunctionName] : []),
     "--export-tst",
     tstPath,
@@ -410,319 +198,255 @@ export async function generateTestsFromRequirements(
     ...(allowUUTStubs ? [] : ["--no-allow-uut-stubs"]),
     "--allow-partial",
     "--json-events",
-    ...(enableRequirementKeys ? ["--requirement-keys"] : []),
+    "--requirement-keys",
   ];
 
-  // Log the command being executed
-  const commandString = `${REQS2TESTS_EXECUTABLE_PATH} ${commandArgs.join(
-    " "
-  )}`;
-  logCliOperation(`Executing command: ${commandString}`);
-
-  await vscode.window.withProgress(
-    {
-      location: vscode.ProgressLocation.Notification,
-      title: `Generating Requirement Tests for ${envName.split(".")[0]}`,
-      cancellable: true,
-    },
-    async (progress, cancellationToken) => {
-      const process = await spawnWithVcastEnv(
-        REQS2TESTS_EXECUTABLE_PATH,
-        commandArgs
-      );
+  try {
+    const { cancelled } = await runReqs2xTool({
+      exe: REQS2TESTS_EXECUTABLE_PATH,
+      args,
+      llm: true,
+      progress: {
+        title: `Generating Requirement Tests for ${envName.split(".")[0]}`,
+        logPrefix: "reqs2tests",
+      },
+    });
+    if (cancelled) return;
+
+    await loadTestScriptIntoEnvironment(envName.split(".")[0], tstPath);
+    await refreshAllExtensionData();
+    vscode.window.showInformationMessage(
+      "Successfully generated tests for the requirements!"
+    );
+  } catch (err) {
+    const message = `Error: ${err instanceof Error ? err.message : String(err)}`;
+    vscode.window.showErrorMessage(message);
+    logCliError(message, true);
+  }
+}
 
-      return new Promise<void>((resolve, reject) => {
-        const tracker = new ProgressTracker(progress, "reqs2tests");
+/**
+ * If the bundle has no traceability for any requirement, prompt the user to
+ * run --infer-traceability. Returns true if the caller should proceed (either
+ * we already had traceability, the user accepted and inference succeeded, or
+ * `cancelMeansAbort` is false and the user declined). Returns false to
+ * abort the caller's flow.
+ */
+async function offerTraceabilityInferenceIfMissing(
+  enviroPath: string,
+  options: { prompt: string; cancelMeansAbort: boolean }
+): Promise<boolean> {
+  const bundle = readRGWBundle(enviroPath);
+  if (!bundle) return true; // nothing to evaluate; let caller continue
 
-        cancellationToken.onCancellationRequested(() => {
-          process.kill();
-          logCliOperation("Operation cancelled by user");
-          resolve();
-        });
+  const hasAnyFunction = Object.values(bundle.traceability).some(
+    (entry) => entry?.function != null
+  );
+  if (hasAnyFunction) return true;
 
-        process.stdout.on("data", (data) => {
-          if (cancellationToken.isCancellationRequested) return;
-          tracker.processOutput(data.toString());
-        });
+  const choice = await vscode.window.showWarningMessage(
+    options.prompt,
+    "Infer traceability",
+    options.cancelMeansAbort ? "Cancel" : "Skip"
+  );
 
-        process.stderr.on("data", (data) => {
-          const errorOutput = data.toString();
-          logCliError(`reqs2tests: ${errorOutput}`);
-          console.error(`Stderr: ${errorOutput}`);
-        });
+  if (choice !== "Infer traceability") {
+    return !options.cancelMeansAbort;
+  }
 
-        process.on("close", async (code) => {
-          if (cancellationToken.isCancellationRequested) return;
-
-          if (code === 0) {
-            logCliOperation(
-              `reqs2tests completed successfully with code ${code}`
-            );
-            await loadTestScriptIntoEnvironment(envName.split(".")[0], tstPath);
-            await refreshAllExtensionData();
-
-            vscode.window.showInformationMessage(
-              "Successfully generated tests for the requirements!"
-            );
-            resolve();
-          } else {
-            const errorMessage = `Error: reqs2tests exited with code ${code}`;
-            vscode.window.showErrorMessage(errorMessage);
-            logCliError(errorMessage, true);
-            reject(new Error(errorMessage));
-          }
-        });
-      });
-    }
-  );
+  try {
+    const refreshed = await inferTraceability(enviroPath, bundle.gatewayPath);
+    if (!refreshed) return false; // user cancelled the inference progress
+    return true;
+  } catch (err) {
+    vscode.window.showErrorMessage(`Failed to infer traceability: ${err}`);
+    return false;
+  }
 }
 
-export async function importRequirementsFromGateway(enviroPath: string) {
+const EXT_TO_FORMAT: Record<string, string> = {
+  ".xlsx": "excel",
+  ".csv": "csv",
+  ".json": "json",
+};
+
+/**
+ * Import a requirements file (xlsx / csv / json) into the env's RGW.
+ * Sets up the default gateway location if VCAST_REPOSITORY is unset, runs
+ * panreq with the standard cancellable progress notification, then
+ * refreshes the test pane and the availability context key.
+ *
+ * Returns whether the import actually completed (false on user cancel of
+ * the progress, panreq failure, or other thrown errors). Does not show
+ * success messages — caller decides whether/how to celebrate.
+ */
+export async function importRequirementsFromPath(
+  enviroPath: string,
+  sourcePath: string,
+  options: { progressTitle: string }
+): Promise<boolean> {
   const parentDir = path.dirname(enviroPath);
-  const lowestDirname = path.basename(enviroPath);
-  const envName = `${lowestDirname}.env`;
-  const envPath = path.join(parentDir, envName);
+  const envPath = path.join(parentDir, `${path.basename(enviroPath)}.env`);
 
-  // Determine (or create) the requirements folder used elsewhere in the extension
-  const enviroNameWithoutExt = lowestDirname.replace(/\.env$/, "");
-  const envReqsFolderPath = path.join(
-    parentDir,
-    `reqs-${enviroNameWithoutExt}`
-  );
-  const repositoryDirExpandedEnv = path.join(
-    envReqsFolderPath,
-    "generated_requirement_repository"
-  );
-  if (!fs.existsSync(envReqsFolderPath)) {
-    fs.mkdirSync(envReqsFolderPath, { recursive: true });
+  let gatewayPath = findRelevantRequirementGateway(enviroPath);
+  if (!gatewayPath) {
+    gatewayPath = defaultRequirementGatewayPath(enviroPath);
+    fs.mkdirSync(path.dirname(gatewayPath), { recursive: true });
+    setVcastRepositoryInConfig(enviroPath, gatewayPath);
   }
 
-  // Look for requirement gateway
-  const repositoryPath = findRelevantRequirementGateway(enviroPath);
-  if (!repositoryPath) {
+  try {
+    const { cancelled } = await runReqs2xTool({
+      exe: PANREQ_EXECUTABLE_PATH,
+      args: [
+        sourcePath,
+        gatewayPath,
+        "--target-format",
+        "rgw",
+        "--target-env",
+        envPath,
+        "--json-events",
+      ],
+      progress: { title: options.progressTitle, logPrefix: "panreq" },
+    });
+    if (cancelled) return false;
+
+    await refreshAllExtensionData();
+    updateRequirementsAvailability(enviroPath);
+    return true;
+  } catch (err) {
+    const message = `Error: ${err instanceof Error ? err.message : String(err)}`;
+    vscode.window.showErrorMessage(message);
+    logCliError(message, true);
+    return false;
+  }
+}
+
+export async function importRequirements(enviroPath: string) {
+  const sourceUris = await vscode.window.showOpenDialog({
+    canSelectMany: false,
+    openLabel: "Import Requirements",
+    filters: {
+      "Requirements files": ["xlsx", "csv", "json"],
+      "Excel (*.xlsx)": ["xlsx"],
+      "CSV (*.csv)": ["csv"],
+      "JSON (*.json)": ["json"],
+    },
+  });
+  if (!sourceUris || sourceUris.length === 0) return;
+  const sourcePath = sourceUris[0].fsPath;
+
+  const ext = path.extname(sourcePath).toLowerCase();
+  if (!EXT_TO_FORMAT[ext]) {
     vscode.window.showErrorMessage(
-      "Requirements Gateway either is not specified or does not exist. Aborting."
+      `Unsupported import format: ${ext}. Use .xlsx, .csv, or .json.`
     );
     return;
   }
 
-  // Target files INSIDE the reqs-<env> folder (align with generate/remove logic)
-  const csvPath = path.join(envReqsFolderPath, "reqs.csv");
-  const xlsxPath = path.join(envReqsFolderPath, "reqs.xlsx");
-
-  // Check if requirements files already exist
-  const xlsxExists = fs.existsSync(xlsxPath);
-  const csvExists = fs.existsSync(csvPath);
-
-  if (xlsxExists || csvExists) {
-    let warningMessage = "Warning: ";
-    if (xlsxExists) {
-      warningMessage +=
-        "An existing Excel requirements file (reqs.xlsx) will be overwritten.";
-    }
-    if (csvExists) {
-      if (xlsxExists) warningMessage += " Additionally, ";
-      warningMessage +=
-        "An existing CSV requirements file (reqs.csv) will be ignored as the new Excel file takes precedence.";
-    }
-
+  // If a gateway already exists we ask first — the user may have come here
+  // by mistake. The actual setup-and-run happens in the shared helper.
+  const existingGateway = findRelevantRequirementGateway(enviroPath);
+  if (existingGateway) {
     const choice = await vscode.window.showWarningMessage(
-      warningMessage,
+      `Importing will overwrite the existing requirements gateway at ${existingGateway}.`,
       "Continue",
       "Cancel"
     );
     if (choice !== "Continue") return;
   }
 
-  const choice = await vscode.window.showInformationMessage(
-    "Would you like the system to automatically try to add traceability to the requirements?",
-    "Yes",
-    "No"
-  );
-  const addTraceability = choice === "Yes";
-
-  const commandArgs = [
-    `${repositoryPath ?? repositoryDirExpandedEnv}`, // repositoryPath should never be undefined here, as we return before but just to be sure
-    xlsxPath,
-    "--target-format",
-    "excel",
-    ...(addTraceability ? ["--infer-traceability"] : []),
-    "--target-env",
-    envPath,
-    "--json-events",
-  ];
-
-  const commandString = `${PANREQ_EXECUTABLE_PATH} ${commandArgs.join(" ")}`;
-  logCliOperation(`Executing command: ${commandString}`);
-
-  await vscode.window.withProgress(
-    {
-      location: vscode.ProgressLocation.Notification,
-      title: `Importing Requirements from Gateway`,
-      cancellable: true,
-    },
-    async (progress, cancellationToken) => {
-      const proc = await spawnWithVcastEnv(PANREQ_EXECUTABLE_PATH, commandArgs);
-
-      return new Promise<void>((resolve, reject) => {
-        const tracker = new ProgressTracker(progress, "panreq");
-
-        cancellationToken.onCancellationRequested(() => {
-          proc.kill();
-          logCliOperation("Operation cancelled by user");
-          resolve();
-        });
+  const enviroName = path.basename(enviroPath);
+  const ok = await importRequirementsFromPath(enviroPath, sourcePath, {
+    progressTitle: `Importing Requirements for ${enviroName}`,
+  });
+  if (!ok) return;
 
-        proc.stdout.on("data", (d) => {
-          if (cancellationToken.isCancellationRequested) return;
-          tracker.processOutput(d.toString());
-        });
-
-        proc.stderr.on("data", (d) => {
-          const errOut = d.toString();
-          logCliError(`panreq: ${errOut.trim()}`);
-        });
-
-        proc.on("close", async (code) => {
-          if (cancellationToken.isCancellationRequested) return;
-          if (code === 0) {
-            logCliOperation(
-              `reqs2excel completed successfully with code ${code}`
-            );
-            await refreshAllExtensionData();
-            updateRequirementsAvailability(enviroPath);
-            vscode.commands.executeCommand(
-              "vectorcastTestExplorer.showRequirements",
-              { id: enviroPath }
-            );
-            vscode.window.showInformationMessage(
-              "Successfully imported requirements from gateway"
-            );
-            resolve();
-          } else {
-            const msg = `Error: panreq exited with code ${code}`;
-            vscode.window.showErrorMessage(msg);
-            logCliError(msg, true);
-            reject(new Error(msg));
-          }
-        });
-      });
-    }
+  vscode.window.showInformationMessage(
+    `Successfully imported requirements from ${path.basename(sourcePath)}`
   );
+
+  // Same prompt as generateTestsFromRequirements: imported requirements
+  // typically lack code traceability. Skip-vs-infer; "Skip" leaves the user
+  // free to set traceability manually in the editor later.
+  await offerTraceabilityInferenceIfMissing(enviroPath, {
+    prompt:
+      "None of the imported requirements trace to a function. Would you like to infer traceability automatically?",
+    cancelMeansAbort: false,
+  });
 }
 
-export async function populateRequirementsGateway(enviroPath: string) {
+export async function exportRequirements(enviroPath: string) {
+  if (!hasCompleteAndUsableRGW(enviroPath)) {
+    vscode.window.showErrorMessage(
+      "No requirements available to export."
+    );
+    return;
+  }
+  const gatewayPath = findRelevantRequirementGateway(enviroPath)!;
+
   const parentDir = path.dirname(enviroPath);
-  const envName = path.basename(enviroPath);
+  const lowestDirname = path.basename(enviroPath);
+  const envName = `${lowestDirname}.env`;
   const envPath = path.join(parentDir, envName);
 
-  // remove ".env" if present
-  const enviroNameWithoutExt = envName.replace(/\.env$/, "");
-  const envReqsFolderPath = path.join(
-    parentDir,
-    `reqs-${enviroNameWithoutExt}`
-  );
-
-  const csvPath = path.join(envReqsFolderPath, "reqs.csv");
-  const xlsxPath = path.join(envReqsFolderPath, "reqs.xlsx");
+  const targetUri = await vscode.window.showSaveDialog({
+    saveLabel: "Export Requirements",
+    defaultUri: vscode.Uri.file(
+      path.join(parentDir, `${lowestDirname}-requirements.csv`)
+    ),
+    filters: {
+      "CSV (*.csv)": ["csv"],
+      "Excel (*.xlsx)": ["xlsx"],
+      "JSON (*.json)": ["json"],
+    },
+  });
+  if (!targetUri) return;
+  const targetPath = targetUri.fsPath;
 
-  // Check which requirements file exists
-  let requirementsFile = "";
-  if (fs.existsSync(xlsxPath)) {
-    requirementsFile = xlsxPath;
-  } else if (fs.existsSync(csvPath)) {
-    requirementsFile = csvPath;
-  } else {
+  const ext = path.extname(targetPath).toLowerCase();
+  const targetFormat = EXT_TO_FORMAT[ext];
+  if (!targetFormat) {
     vscode.window.showErrorMessage(
-      "No requirements file found. Generate requirements first."
+      `Unsupported export format: ${ext}. Use .xlsx, .csv, or .json.`
     );
     return;
   }
 
-  // Check if there is an existing requirements gateway
-  const existingGateway = findRelevantRequirementGateway(enviroPath);
-  if (existingGateway) {
-    const warningMessage = `Warning: An existing requirements gateway was found at ${existingGateway}. Generating requirements will switch the environment gateway to a new one.`;
-    const choice = await vscode.window.showWarningMessage(
-      warningMessage,
-      "Continue",
-      "Cancel"
-    );
-
-    if (choice !== "Continue") {
-      return;
-    }
-  }
-
-  const exportRepository = path.join(
-    envReqsFolderPath,
-    "generated_requirement_repository"
-  );
-
-  const commandArgs = [
-    requirementsFile,
-    `${existingGateway ?? exportRepository}`,
+  const args = [
+    gatewayPath,
+    targetPath,
     "--target-format",
-    "rgw",
+    targetFormat,
     "--target-env",
     envPath,
+    "--json-events",
   ];
 
-  // Log the command being executed
-  const commandString = `${PANREQ_EXECUTABLE_PATH} ${commandArgs.join(" ")}`;
-  logCliOperation(`Executing command: ${commandString}`);
-
-  // Show progress while running
-  await vscode.window.withProgress(
-    {
-      location: vscode.ProgressLocation.Notification,
-      title: "Populating Requirements Gateway...",
-      cancellable: false,
-    },
-    async (progress) => {
-      const process = await spawnWithVcastEnv(
-        PANREQ_EXECUTABLE_PATH,
-        commandArgs
+  try {
+    const { cancelled } = await runReqs2xTool({
+      exe: PANREQ_EXECUTABLE_PATH,
+      args,
+      progress: {
+        title: `Exporting Requirements for ${lowestDirname}`,
+        logPrefix: "panreq",
+      },
+    });
+    if (cancelled) return;
+
+    const choice = await vscode.window.showInformationMessage(
+      `Successfully exported requirements to ${path.basename(targetPath)}`,
+      "Reveal in File Explorer"
+    );
+    if (choice === "Reveal in File Explorer") {
+      vscode.commands.executeCommand(
+        "revealFileInOS",
+        vscode.Uri.file(targetPath)
       );
-
-      return new Promise<void>((resolve, reject) => {
-        process.stdout.on("data", (data) => {
-          const output = data.toString().trim();
-          logCliOperation(`panreq: ${output}`);
-        });
-
-        process.stderr.on("data", (data) => {
-          const errorOutput = data.toString().trim();
-          logCliError(`panreq: ${errorOutput}`);
-        });
-
-        process.on("close", async (code) => {
-          if (code === 0) {
-            logCliOperation(
-              `reqs2rgw completed successfully with code ${code}`
-            );
-
-            try {
-              await refreshAllExtensionData();
-              vscode.window.showInformationMessage(
-                `Successfully populated requirements gateway at ${exportRepository}`
-              );
-              resolve();
-            } catch (err) {
-              const error = err instanceof Error ? err : new Error(String(err));
-              vscode.window.showErrorMessage(
-                `Error updating environment configuration: ${error.message}`
-              );
-              reject(error);
-            }
-          } else {
-            const errorMessage = `Error: reqs2rgw exited with code ${code}`;
-            vscode.window.showErrorMessage(errorMessage);
-            logCliError(errorMessage, true);
-            reject(new Error(errorMessage));
-          }
-        });
-      });
     }
-  );
+  } catch (err) {
+    const message = `Error: ${err instanceof Error ? err.message : String(err)}`;
+    vscode.window.showErrorMessage(message);
+    logCliError(message, true);
+  }
 }
diff --git a/src/requirements/requirementsUtils.ts b/src/requirements/requirementsUtils.ts
deleted file mode 100644
index 7eb8d682..00000000
--- a/src/requirements/requirementsUtils.ts
+++ /dev/null
@@ -1,651 +0,0 @@
-import * as vscode from "vscode";
-import { workspace } from "vscode";
-import { ChildProcessWithoutNullStreams, spawn } from "node:child_process";
-import { parse as csvParse } from "csv-parse/sync";
-import { vcastInstallationDirectory } from "../vcastInstallation";
-import { exeFilename, normalizePath, showSettings } from "../utilities";
-import {
-  LLM2CHECK_EXECUTABLE_PATH,
-  logCliError,
-  logCliOperation,
-} from "./requirementsOperations";
-import { makeEnviroNodeID } from "../testPane";
-import { extractJson } from "../../src-common/commonUtilities";
-
-const path = require("path");
-const fs = require("fs");
-const excelToJson = require("convert-excel-to-json");
-
-const NECCESSARY_REQS2X_EXECUTABLES = [
-  "code2reqs",
-  "reqs2tests",
-  "panreq",
-  "llm2check",
-];
-
-export let alreadyInitializedFileWatchers: boolean = false;
-export let requirementsFileWatcher: vscode.FileSystemWatcher | undefined;
-
-let existingEnvs: string[] = [];
-
-/**
- * Find the most relevant requirement gateway for a given environment path
- * @param enviroPath The environment path
- * @returns The most relevant gateway path, or null if none found
- */
-export function findRelevantRequirementGateway(
-  enviroPath: string
-): string | null {
-  const parentDir = path.dirname(enviroPath);
-  const configPath = path.join(parentDir, "CCAST_.CFG");
-
-  const configContent = fs.readFileSync(configPath, "utf-8");
-
-  const gatewayMatch = configContent.match(/VCAST_REPOSITORY:\s*(.+)\s*/);
-
-  if (gatewayMatch == null) {
-    return null;
-  }
-
-  // Expand variables before checking existence
-  const rawGatewayPath = gatewayMatch[1].trim();
-  const gatewayPath = expandEnvVars(rawGatewayPath);
-
-  if (!fs.existsSync(gatewayPath)) {
-    return null;
-  }
-
-  return rawGatewayPath;
-}
-
-export async function parseRequirementsFromFile(
-  filePath: string
-): Promise<any[]> {
-  try {
-    if (filePath.endsWith(".xlsx")) {
-      const result = excelToJson({
-        sourceFile: filePath,
-      }).Requirements;
-
-      const columnNames: string[] = Object.values(result[0]);
-
-      const requirements = [];
-
-      console.log(columnNames, result);
-
-      for (const row of result.slice(1)) {
-        const requirement: Record<string, string> = {};
-        for (let i = 0; i < columnNames.length; i++) {
-          requirement[columnNames[i]] = Object.values(row)[i] as string;
-        }
-        requirements.push(requirement);
-      }
-
-      return requirements;
-    } else {
-      const fileContent = await fs.promises.readFile(filePath, "utf8");
-      return csvParse(fileContent, {
-        columns: true,
-        skip_empty_lines: true,
-        trim: true,
-        ltrim: true,
-        quote: '"',
-      });
-    }
-  } catch (error) {
-    logCliError(`Failed to parse requirements file: ${error}`, true);
-    throw error;
-  }
-}
-
-export function findEnvironmentInPath(dirPath: string): string | null {
-  // dirPath will be the path were the requirements are, but the env files are in the parent folder
-  const parentDir = path.dirname(dirPath);
-
-  // the folder is named reqs-<envName>, so we cut out the correct env name to find the corresponding env file
-  const baseFolder = path.basename(dirPath);
-  const envName = baseFolder.split("reqs-")[1];
-
-  // Check if the directory contains an environment file
-  const files = fs.readdirSync(parentDir);
-  const envFiles = files.filter((file: string) =>
-    file.endsWith(`${envName}.env`)
-  );
-
-  // Now see if there is a directory with the same name as the env file
-  for (const file of envFiles) {
-    // remove ".env"
-    const envName = file.slice(0, -4);
-    const envDirPath = path.join(parentDir, envName);
-    if (fs.existsSync(envDirPath) && fs.lstatSync(envDirPath).isDirectory()) {
-      return envDirPath;
-    }
-  }
-  return null;
-}
-
-export function setupRequirementsFileWatchers(
-  context: vscode.ExtensionContext
-) {
-  if (alreadyInitializedFileWatchers) {
-    return;
-  }
-  alreadyInitializedFileWatchers = true;
-
-  if (workspace.workspaceFolders && workspace.workspaceFolders.length > 0) {
-    // Create a file watcher that watches for requirements files changes
-    // using a glob pattern to match all reqs.csv and reqs.xlsx files in the workspace
-    requirementsFileWatcher = workspace.createFileSystemWatcher(
-      "**/reqs-*/reqs.{csv,xlsx}"
-    );
-
-    // When a requirements file is created
-    requirementsFileWatcher.onDidCreate(
-      async (uri) => {
-        logCliOperation(`Requirements file created: ${uri.fsPath}`);
-        const changeDir = path.dirname(uri.fsPath);
-        const envDirPath = findEnvironmentInPath(changeDir);
-        if (envDirPath) {
-          updateRequirementsAvailability(envDirPath);
-        }
-      },
-      null,
-      context.subscriptions
-    );
-
-    // When a requirements file is deleted
-    requirementsFileWatcher.onDidDelete(
-      async (uri) => {
-        logCliOperation(`Requirements file deleted: ${uri.fsPath}`);
-        const parentDir = path.dirname(uri.fsPath);
-        const envDirPath = findEnvironmentInPath(parentDir);
-        if (envDirPath) {
-          updateRequirementsAvailability(envDirPath);
-        }
-      },
-      null,
-      context.subscriptions
-    );
-
-    // Register the watcher to be disposed when the extension deactivates
-    context.subscriptions.push(requirementsFileWatcher);
-  }
-}
-
-export function updateRequirementsAvailability(enviroPath: string) {
-  const nodeID = makeEnviroNodeID(normalizePath(enviroPath));
-
-  // the vcast: prefix to allow package.json nodes to control
-  // when the VectorCAST context menu should be shown
-
-  // Check if this environment has requirements
-  const parentDir = path.dirname(enviroPath);
-  const enviroNameWithExt = path.basename(enviroPath);
-  // remove ".env" if present
-  const enviroNameWithoutExt = enviroNameWithExt.replace(/\.env$/, "");
-  const envReqsFolderPath = path.join(
-    parentDir,
-    `reqs-${enviroNameWithoutExt}`
-  );
-
-  const csvPath = path.join(envReqsFolderPath, "reqs.csv");
-  const xlsxPath = path.join(envReqsFolderPath, "reqs.xlsx");
-
-  const hasRequirementsFiles =
-    fs.existsSync(csvPath) || fs.existsSync(xlsxPath);
-
-  if (hasRequirementsFiles) {
-    // Add this environment to the list if not already present
-    if (!existingEnvs.includes(nodeID)) {
-      const updatedEnvs = [...existingEnvs, nodeID];
-      vscode.commands.executeCommand(
-        "setContext",
-        "vectorcastTestExplorer.vcastRequirementsAvailable",
-        updatedEnvs
-      );
-      existingEnvs = updatedEnvs;
-    }
-  } else {
-    // Remove this environment from the list if present
-    const updatedEnvs = existingEnvs.filter((env) => env !== nodeID);
-    vscode.commands.executeCommand(
-      "setContext",
-      "vectorcastTestExplorer.vcastRequirementsAvailable",
-      updatedEnvs
-    );
-    existingEnvs = updatedEnvs;
-  }
-}
-
-export function getAutoreqExecutableDirectory(
-  context: vscode.ExtensionContext
-): vscode.Uri | undefined {
-  const pathHasAllExecutables = (dirPath: string): boolean => {
-    return NECCESSARY_REQS2X_EXECUTABLES.every((exe) =>
-      fs.existsSync(
-        vscode.Uri.joinPath(vscode.Uri.file(dirPath), exeFilename(exe)).fsPath
-      )
-    );
-  };
-
-  // Resolve the location of the reqs2x executables according to the following priority:
-
-  // 1. Reqs2X path setting
-  const config = vscode.workspace.getConfiguration(
-    "vectorcastTestExplorer.reqs2x"
-  );
-  const installationLocation = config.get<string>("installationLocation");
-
-  if (installationLocation && pathHasAllExecutables(installationLocation)) {
-    return vscode.Uri.file(installationLocation);
-  }
-
-  // 2. VectorCAST installation path setting
-  if (pathHasAllExecutables(vcastInstallationDirectory)) {
-    return vscode.Uri.file(vcastInstallationDirectory);
-  }
-
-  // 3. Search in vsixResourceBasePath
-
-  // We need to check if we are on CI because in that case we have to use an alternate base dir to the resource files
-  const isCI = process.env.HOME?.startsWith("/github") ?? false;
-
-  // Base dir of the resource files should be here (see run-tests-workflow.yml/Pull latest reqs2tests release)
-  const vsixResourceBasePath = `${process.env.GITHUB_WORKSPACE}/vsix`;
-
-  // Check existence for debugging reasons
-  if (!fs.existsSync(vsixResourceBasePath)) {
-    logCliError(
-      `VSIX resource folder not found at expected path: ${vsixResourceBasePath}`
-    );
-  } else {
-    logCliOperation(`Found VSIX resource folder at: ${vsixResourceBasePath}`);
-  }
-
-  const vsixBaseURI = isCI
-    ? vscode.Uri.file(vsixResourceBasePath)
-    : context.extensionUri;
-
-  if (pathHasAllExecutables(vsixBaseURI.fsPath)) {
-    return vscode.Uri.joinPath(vsixBaseURI, "resources", "distribution");
-  }
-
-  return undefined;
-}
-
-/**
- * Generate HTML from requirements data
- */
-export function generateRequirementsHtml(requirements: any[]): string {
-  let htmlContent = `
-      <html>
-      <head>
-          <title>Requirements</title>
-          <style>
-              body { font-family: Arial, sans-serif; margin: 20px; background-color: #ffffff; color: #000000; }
-              h1 { color: #2c3e50; }
-              h2 { color: #34495e; margin-top: 30px; }
-              .requirement { background-color: #f7f7f7; padding: 15px; margin: 10px 0; border-radius: 5px; }
-              .req-id { font-weight: bold; color: #2980b9; }
-              .req-description { margin-top: 10px; color: #333333; }
-          </style>
-      </head>
-      <body>
-          <h1>Requirements</h1>
-    `;
-
-  // Group requirements by function
-  const requirementsByFunction: Record<string, any[]> = {};
-  for (const req of requirements) {
-    const funcName = req.Function || req.Module || "Unknown Function";
-    if (!requirementsByFunction[funcName]) {
-      requirementsByFunction[funcName] = [];
-    }
-    requirementsByFunction[funcName].push(req);
-  }
-
-  // Generate HTML content for each function
-  for (const [funcName, reqs] of Object.entries(requirementsByFunction)) {
-    htmlContent += `<h2>${funcName}</h2>`;
-    for (const req of reqs) {
-      htmlContent += `
-          <div class="requirement">
-              <div class="req-id">${req.ID || "No ID"}</div>
-              <div class="req-description">${
-                req.Description || "No Description"
-              }</div>
-          </div>
-        `;
-    }
-  }
-
-  htmlContent += "</body></html>";
-  return htmlContent;
-}
-
-export interface LLMProviderSettingsResult {
-  provider: string | null;
-  env: Record<string, string>;
-  missing: string[];
-}
-
-export function isLLMProviderEnvironmentUsable(): Promise<{
-  usable: boolean;
-  problem: string | null;
-}> {
-  const processEnv = { ...process.env };
-
-  const gatheredSettings = gatherLLMProviderSettings();
-  for (const [k, v] of Object.entries(gatheredSettings.env)) {
-    if (v) processEnv[k] = v;
-  }
-
-  if (
-    vscode.workspace
-      .getConfiguration("vectorcastTestExplorer.reqs2x")
-      .get<boolean>("modelCompatibilityMode", false)
-  ) {
-    processEnv.VCAST_REQS2X_MODEL_COMPATIBILITY_MODE = "1";
-  }
-
-  const proc = spawn(LLM2CHECK_EXECUTABLE_PATH, ["--json"], {
-    env: processEnv,
-  });
-
-  return new Promise((resolve) => {
-    let output = "";
-    proc.stdout.on("data", (data) => {
-      output += data.toString();
-    });
-
-    proc.on("close", () => {
-      const result = extractJson(output);
-      if (result && typeof result.usable === "boolean") {
-        resolve({ usable: result.usable, problem: result.problem || null });
-      } else {
-        console.error(`Failed to parse llm2check output: ${output}`);
-        resolve({ usable: false, problem: "Failed to parse llm2check output" });
-      }
-    });
-  });
-}
-
-export function gatherLLMProviderSettings(): LLMProviderSettingsResult {
-  const config = vscode.workspace.getConfiguration("vectorcastTestExplorer");
-
-  const provider = config.get<string>("reqs2x.provider");
-  const baseEnv: Record<string, string> = {};
-  const missing: string[] = [];
-
-  if (!provider) {
-    missing.push("Provider (reqs2x.provider)");
-    return { provider: null, env: baseEnv, missing };
-  }
-
-  function need(value: string | undefined, label: string, envVarName: string) {
-    if (!value) {
-      missing.push(label);
-      return;
-    }
-    baseEnv[envVarName] = value;
-  }
-
-  function optional(value: string | undefined, envVarName: string) {
-    if (value) {
-      baseEnv[envVarName] = value;
-    }
-  }
-
-  if (provider === "azure_openai") {
-    need(
-      config.get<string>("reqs2x.azure.baseUrl"),
-      "Azure Base URL",
-      "VCAST_REQS2X_AZURE_OPENAI_BASE_URL"
-    );
-    need(
-      config.get<string>("reqs2x.azure.apiKey"),
-      "Azure API Key",
-      "VCAST_REQS2X_AZURE_OPENAI_API_KEY"
-    );
-    need(
-      config.get<string>("reqs2x.azure.deployment"),
-      "Azure Deployment",
-      "VCAST_REQS2X_AZURE_OPENAI_DEPLOYMENT"
-    );
-    need(
-      config.get<string>("reqs2x.azure.modelName"),
-      "Azure Model Name",
-      "VCAST_REQS2X_AZURE_OPENAI_MODEL_NAME"
-    );
-    need(
-      config.get<string>("reqs2x.azure.apiVersion"),
-      "Azure API Version",
-      "VCAST_REQS2X_AZURE_OPENAI_API_VERSION"
-    );
-    optional(
-      config.get<string>("reqs2x.azure.reasoningModelName"),
-      "VCAST_REQS2X_REASONING_AZURE_OPENAI_MODEL_NAME"
-    );
-    optional(
-      config.get<string>("reqs2x.azure.reasoningDeployment"),
-      "VCAST_REQS2X_REASONING_AZURE_OPENAI_DEPLOYMENT"
-    );
-  } else if (provider === "openai") {
-    optional(
-      config.get<string>("reqs2x.openai.baseUrl"),
-      "VCAST_REQS2X_OPENAI_BASE_URL"
-    );
-    need(
-      config.get<string>("reqs2x.openai.apiKey"),
-      "OpenAI API Key",
-      "VCAST_REQS2X_OPENAI_API_KEY"
-    );
-    need(
-      config.get<string>("reqs2x.openai.modelName"),
-      "OpenAI Model Name",
-      "VCAST_REQS2X_OPENAI_MODEL_NAME"
-    );
-    optional(
-      config.get<string>("reqs2x.openai.reasoningModelName"),
-      "VCAST_REQS2X_REASONING_OPENAI_MODEL_NAME"
-    );
-  } else if (provider === "anthropic") {
-    need(
-      config.get<string>("reqs2x.anthropic.apiKey"),
-      "Anthropic API Key",
-      "VCAST_REQS2X_ANTHROPIC_API_KEY"
-    );
-    need(
-      config.get<string>("reqs2x.anthropic.modelName"),
-      "Anthropic Model Name",
-      "VCAST_REQS2X_ANTHROPIC_MODEL_NAME"
-    );
-    optional(
-      config.get<string>("reqs2x.anthropic.reasoningModelName"),
-      "VCAST_REQS2X_REASONING_ANTHROPIC_MODEL_NAME"
-    );
-  } else if (provider === "litellm") {
-    need(
-      config.get<string>("reqs2x.litellm.modelName"),
-      "LiteLLM Model Name",
-      "VCAST_REQS2X_LITELLM_MODEL_NAME"
-    );
-    optional(
-      config.get<string>("reqs2x.litellm.reasoningModelName"),
-      "VCAST_REQS2X_REASONING_LITELLM_MODEL_NAME"
-    );
-
-    const litellmProviderEnvVarsString = config.get<string>(
-      "reqs2x.litellm.providerEnvVars",
-      ""
-    );
-    const entries = litellmProviderEnvVarsString
-      .split(",")
-      .map((pair) => pair.split("="))
-      .filter((kv) => kv[0].trim().length);
-
-    if (entries.some((entryValues) => entryValues.length !== 2)) {
-      missing.push(
-        "LiteLLM Provider Environment Variables must be KEY=VALUE pairs"
-      );
-    } else {
-      for (const [key, value] of entries) {
-        baseEnv[key.trim()] = value.trim();
-      }
-    }
-  } else if (provider === "azure_apim") {
-    need(
-      config.get<string>("reqs2x.azureApim.subscriptionKey"),
-      "APIM Subscription Key",
-      "VCAST_REQS2X_AZURE_APIM_SUBSCRIPTION_KEY"
-    );
-    need(
-      config.get<string>("reqs2x.azureApim.baseUrl"),
-      "APIM Base URL",
-      "VCAST_REQS2X_AZURE_APIM_BASE_URL"
-    );
-    need(
-      config.get<string>("reqs2x.azureApim.modelName"),
-      "APIM Model Name",
-      "VCAST_REQS2X_AZURE_APIM_MODEL_NAME"
-    );
-    optional(
-      config.get<string>("reqs2x.azureApim.apiKey"),
-      "VCAST_REQS2X_AZURE_APIM_API_KEY"
-    );
-    optional(
-      config.get<string>("reqs2x.azureApim.reasoningModelName"),
-      "VCAST_REQS2X_REASONING_AZURE_APIM_MODEL_NAME"
-    );
-  } else if (provider === "openai_at") {
-    need(
-      config.get<string>("reqs2x.openaiAt.modelName"),
-      "OpenAI AT Model Name",
-      "VCAST_REQS2X_OPENAI_AT_MODEL_NAME"
-    );
-    need(
-      config.get<string>("reqs2x.openaiAt.modelUrl"),
-      "OpenAI AT Model URL",
-      "VCAST_REQS2X_OPENAI_AT_MODEL_URL"
-    );
-    need(
-      config.get<string>("reqs2x.openaiAt.authUrl"),
-      "OpenAI AT Auth URL",
-      "VCAST_REQS2X_OPENAI_AT_AUTH_URL"
-    );
-    need(
-      config.get<string>("reqs2x.openaiAt.appKey"),
-      "OpenAI AT App Key",
-      "VCAST_REQS2X_OPENAI_AT_APP_KEY"
-    );
-    need(
-      config.get<string>("reqs2x.openaiAt.appSecret"),
-      "OpenAI AT App Secret",
-      "VCAST_REQS2X_OPENAI_AT_APP_SECRET"
-    );
-    optional(
-      config.get<string>("reqs2x.openaiAt.reasoningModelName"),
-      "VCAST_REQS2X_REASONING_OPENAI_AT_MODEL_NAME"
-    );
-  } else {
-    missing.push("Unsupported provider value");
-  }
-
-  return { provider, env: baseEnv, missing };
-}
-
-export async function performLLMProviderUsableCheck(): Promise<boolean> {
-  const { usable, problem } = await isLLMProviderEnvironmentUsable();
-
-  const gatheredSettings = gatherLLMProviderSettings();
-
-  if (!usable) {
-    // TODO: Error based on what the problem was i.e. missing stuff or something else
-    const causedByMissing = problem?.includes(
-      "No provider configuration found"
-    );
-
-    let errorMessage: string;
-
-    if (causedByMissing) {
-      errorMessage = `Required information to run Reqs2X with currently selected LLM provider (${gatheredSettings.provider}) is missing: ${gatheredSettings.missing.join(", ")}`;
-    } else {
-      errorMessage = `The current LLM provider settings for Reqs2X (either set in the extension or in the environment) are not usable: ${problem}`;
-    }
-
-    vscode.window
-      .showErrorMessage(errorMessage, "Open Settings")
-      .then((choice) => {
-        if (choice === "Open Settings") {
-          showSettings();
-        }
-      });
-
-    return false;
-  }
-
-  return true;
-}
-
-export async function createProcessEnvironment(): Promise<NodeJS.ProcessEnv> {
-  const processEnv = { ...process.env };
-
-  // Setup correct VectorCAST directory variable
-  processEnv.VSCODE_VECTORCAST_DIR = vcastInstallationDirectory;
-
-  // Setup LLM provider settings
-  const gatheredSettings = gatherLLMProviderSettings();
-
-  for (const [k, v] of Object.entries(gatheredSettings.env)) {
-    if (v) processEnv[k] = v;
-  }
-
-  // Add non-provider specific settings (language, debug) here
-  const config = vscode.workspace.getConfiguration(
-    "vectorcastTestExplorer.reqs2x"
-  );
-  const languageCode = config.get<string>("generationLanguage", "en");
-  processEnv.VCAST_REQS2X_RESPONSE_LANGUAGE = languageCode;
-
-  if (config.get<boolean>("outputDebugInfo", false)) {
-    processEnv.VCAST_REQS2X_LOG_LEVEL = "debug";
-  }
-
-  if (config.get<boolean>("modelCompatibilityMode", false)) {
-    processEnv.VCAST_REQS2X_MODEL_COMPATIBILITY_MODE = "1";
-  }
-
-  // Return the constructed environment
-  return processEnv;
-}
-
-export async function spawnWithVcastEnv(
-  command: string,
-  args: string[],
-  options: any = {}
-): Promise<ChildProcessWithoutNullStreams> {
-  const checkSuccessful = await performLLMProviderUsableCheck(); // Check if the LLM provider settings are usable
-
-  if (!checkSuccessful) {
-    throw new Error("LLM provider settings are not usable");
-  }
-
-  const env = await createProcessEnvironment();
-  return spawn(command, args, { ...options, env });
-}
-
-export function expandEnvVars(inputPath: string): string {
-  return inputPath.replace(/\$\(([^)]+)\)/g, (match, varName) => {
-    const value = process.env[varName];
-
-    if (!value) {
-      vscode.window.showWarningMessage(
-        `Environment variable "${varName}" in VCAST_REPOSITORY is not defined.`
-      );
-      // leave it as-is
-      return match;
-    }
-
-    return value;
-  });
-}
diff --git a/src/requirements/rgwIo.ts b/src/requirements/rgwIo.ts
new file mode 100644
index 00000000..7c91d5af
--- /dev/null
+++ b/src/requirements/rgwIo.ts
@@ -0,0 +1,422 @@
+import * as os from "node:os";
+import {
+  expandEnvVars,
+  findRelevantRequirementGateway,
+  RGW_INNER_DIR,
+} from "./rgwPath";
+import { runReqs2xTool } from "./processRunner";
+import { PANREQ_EXECUTABLE_PATH } from "./requirementsExecutables";
+
+const path = require("path");
+const fs = require("fs");
+
+// ---------- Types -----------------------------------------------------------
+
+export interface RGWRequirement {
+  id: string;
+  title: string;
+  description: string;
+  last_modified?: string;
+  [key: string]: any;
+}
+
+// requirements.json: { "<source_bucket>": { "<req_id>": RGWRequirement } }
+export type RGWRequirementsFile = Record<
+  string,
+  Record<string, RGWRequirement>
+>;
+
+export interface RGWTraceabilityEntry {
+  unit: string | null;
+  function: string | null;
+  lines: number[] | null;
+}
+
+// traceability.json: { "<req_id>": RGWTraceabilityEntry }
+export type RGWTraceabilityFile = Record<string, RGWTraceabilityEntry>;
+
+export interface RGWOrigin {
+  generated_by_reqs2x: boolean;
+}
+
+export interface RGWFileMtimes {
+  requirements: number;
+  traceability: number;
+  origin: number;
+}
+
+export interface RGWBundle {
+  gatewayPath: string;
+  origin: RGWOrigin;
+  requirements: RGWRequirementsFile;
+  traceability: RGWTraceabilityFile;
+  mtimes: RGWFileMtimes;
+}
+
+export class RGWStaleWriteError extends Error {
+  constructor(public readonly file: "requirements" | "traceability") {
+    super(
+      `RGW ${file} file changed on disk since it was loaded; refusing to overwrite.`
+    );
+    this.name = "RGWStaleWriteError";
+  }
+}
+
+/**
+ * What the user is allowed to edit for a given bundle. Single source of
+ * truth for the rule "external-source RGWs lock requirement bodies": webview
+ * disables matching inputs, extension redacts matching fields out of the
+ * incoming patch on save.
+ */
+export interface RequirementsEditPolicy {
+  /** title and description editable iff true. */
+  bodiesEditable: boolean;
+}
+
+export function editPolicyFor(bundle: RGWBundle): RequirementsEditPolicy {
+  return { bodiesEditable: bundle.origin.generated_by_reqs2x };
+}
+
+/**
+ * Apply the policy to a webview-sourced patch. Substitutes the loaded copy of
+ * any field that's locked, so a tampered webview can't sneak edits through.
+ */
+export function applyEditPolicy(
+  bundle: RGWBundle,
+  incoming: {
+    requirements: RGWRequirementsFile;
+    traceability: RGWTraceabilityFile;
+  }
+): { requirements: RGWRequirementsFile; traceability: RGWTraceabilityFile } {
+  return editPolicyFor(bundle).bodiesEditable
+    ? incoming
+    : {
+        requirements: bundle.requirements,
+        traceability: incoming.traceability,
+      };
+}
+
+// ---------- Path / file helpers --------------------------------------------
+
+function rgwFilePaths(gatewayPath: string) {
+  const inner = path.join(gatewayPath, RGW_INNER_DIR);
+  return {
+    inner,
+    requirements: path.join(inner, "requirements.json"),
+    traceability: path.join(inner, "traceability.json"),
+    origin: path.join(inner, "origin.json"),
+    settings: path.join(inner, "settings.json"),
+  };
+}
+
+function mtimeMsOrZero(filePath: string): number {
+  try {
+    return fs.statSync(filePath).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+
+function writeAtomic(target: string, contents: string): void {
+  const tmp = `${target}.tmp-${process.pid}-${Date.now()}`;
+  fs.writeFileSync(tmp, contents, "utf-8");
+  fs.renameSync(tmp, target);
+}
+
+/**
+ * Read the source CSV path out of `settings.json`. Returns null when the
+ * gateway isn't CSV-backed (we don't yet know how to round-trip other
+ * source types) or when the field is missing.
+ */
+function readCsvSourcePath(gatewayPath: string): string | null {
+  const settingsPath = rgwFilePaths(gatewayPath).settings;
+  if (!fs.existsSync(settingsPath)) return null;
+  try {
+    const settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+    if (settings.current_gateway !== "csv") return null;
+    const csvPath = settings.csv?.csv_path;
+    return typeof csvPath === "string" && csvPath.length > 0 ? csvPath : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * True iff the configured gateway both exists *and* contains a
+ * `requirements.json` we can actually read. This is the predicate menu
+ * enablement and "is there anything to export" should consult — distinct
+ * from `findRelevantRequirementGateway` which only resolves the path.
+ *
+ * Without this distinction, deleting just `requirements.json` (leaving the
+ * gateway directory intact) leaves the UI claiming requirements are
+ * available while every reader downstream returns null.
+ */
+export function hasCompleteAndUsableRGW(enviroPath: string): boolean {
+  const rawGatewayPath = findRelevantRequirementGateway(enviroPath);
+  if (!rawGatewayPath) return false;
+
+  const gatewayPath = expandEnvVars(rawGatewayPath);
+  if (!fs.existsSync(gatewayPath)) return false;
+
+  return fs.existsSync(rgwFilePaths(gatewayPath).requirements);
+}
+
+/**
+ * True if `csvPath` looks like a Python-tempfile-generated CSV that's no
+ * longer on disk — i.e. the kind of artifact older Reqs2X CLIs left behind
+ * in `settings.json` after generating an RGW from a transient working CSV.
+ *
+ * Heuristic: file is gone, parent directory is the OS temp dir
+ * (`os.tmpdir()` matches Python's `tempfile.gettempdir()` on every platform
+ * we ship to), and the basename matches `tempfile.NamedTemporaryFile`'s
+ * default `tmp<random>` prefix with a `.csv` suffix.
+ */
+function looksLikeOrphanTempCsv(csvPath: string): boolean {
+  if (fs.existsSync(csvPath)) return false;
+
+  const tmpdir = os.tmpdir();
+  const isWindows = process.platform === "win32";
+  const inTempDir = isWindows
+    ? csvPath.toLowerCase().startsWith(tmpdir.toLowerCase())
+    : csvPath.startsWith(tmpdir);
+  if (!inTempDir) return false;
+
+  // Python's `tempfile._RandomNameSequence` yields 8 chars from
+  // [A-Za-z0-9_]; we're lenient with the length to cover Python-version
+  // drift and any custom prefixes that still start with "tmp".
+  return /^tmp[A-Za-z0-9_]{6,}\.csv$/i.test(path.basename(csvPath));
+}
+
+// ---------- Read ------------------------------------------------------------
+
+/**
+ * Read the RGW bundle from `<rgw>/requirements_gateway/`. Missing
+ * traceability/origin files are tolerated (treated as empty / external-source).
+ * Returns null when no gateway is configured, the gateway directory is absent,
+ * or there are no requirements yet to display.
+ */
+export function readRGWBundle(enviroPath: string): RGWBundle | null {
+  const rawGatewayPath = findRelevantRequirementGateway(enviroPath);
+  if (!rawGatewayPath) return null;
+
+  const gatewayPath = expandEnvVars(rawGatewayPath);
+  if (!fs.existsSync(gatewayPath)) return null;
+
+  const files = rgwFilePaths(gatewayPath);
+  if (!fs.existsSync(files.requirements)) return null;
+
+  const requirements: RGWRequirementsFile = JSON.parse(
+    fs.readFileSync(files.requirements, "utf-8")
+  );
+
+  const traceability: RGWTraceabilityFile = fs.existsSync(files.traceability)
+    ? JSON.parse(fs.readFileSync(files.traceability, "utf-8"))
+    : {};
+
+  let origin: RGWOrigin = { generated_by_reqs2x: false };
+  if (fs.existsSync(files.origin)) {
+    try {
+      const parsed = JSON.parse(fs.readFileSync(files.origin, "utf-8"));
+      origin = { generated_by_reqs2x: parsed.generated_by_reqs2x === true };
+    } catch {
+      // malformed origin.json → treat as external/read-only
+    }
+  } else {
+    // Backwards-compat for RGWs produced by older Reqs2X CLIs that didn't
+    // write origin.json: if the configured source CSV is gone *and* the
+    // path looks like a Python tempfile, the RGW was almost certainly
+    // generated by us (genuine external imports point at persistent files).
+    const csvPath = readCsvSourcePath(gatewayPath);
+    if (csvPath && looksLikeOrphanTempCsv(csvPath)) {
+      origin = { generated_by_reqs2x: true };
+    }
+  }
+
+  return {
+    gatewayPath,
+    origin,
+    requirements,
+    traceability,
+    mtimes: {
+      requirements: mtimeMsOrZero(files.requirements),
+      traceability: mtimeMsOrZero(files.traceability),
+      origin: mtimeMsOrZero(files.origin),
+    },
+  };
+}
+
+// ---------- Write -----------------------------------------------------------
+
+/**
+ * Persist edits back into the RGW.
+ *
+ * Requirement bodies travel via the source CSV (kept in sync as the durable
+ * external artifact): we serialize the updates to a temp JSON in panreq's
+ * input shape and run panreq to overwrite the CSV. We then mirror the same
+ * data into `requirements.json` ourselves — `clicast RGw Import` only adds
+ * *new* requirements (it deliberately doesn't overwrite existing bodies, and
+ * there's no `Reimport` subcommand).
+ *
+ * Traceability is written directly. Done last so a panreq failure leaves
+ * on-disk state consistent (no fresh trace pointing at stale requirements).
+ *
+ * Throws RGWStaleWriteError if either file's mtime has advanced since the
+ * bundle was loaded.
+ */
+export async function writeRGWBundle(
+  enviroPath: string,
+  gatewayPath: string,
+  updates: {
+    requirements: RGWRequirementsFile;
+    traceability: RGWTraceabilityFile;
+  },
+  expected: Pick<RGWFileMtimes, "requirements" | "traceability">
+): Promise<RGWFileMtimes> {
+  const files = rgwFilePaths(gatewayPath);
+
+  const currentReqMtime = mtimeMsOrZero(files.requirements);
+  if (currentReqMtime !== expected.requirements) {
+    throw new RGWStaleWriteError("requirements");
+  }
+  const currentTraceMtime = mtimeMsOrZero(files.traceability);
+  if (currentTraceMtime !== expected.traceability) {
+    throw new RGWStaleWriteError("traceability");
+  }
+
+  const csvPath = readCsvSourcePath(gatewayPath);
+  if (!csvPath) {
+    throw new Error(
+      "Cannot save: this RGW's source is not a CSV (or settings.json is missing). Only CSV-backed RGWs are editable."
+    );
+  }
+
+  // 1. Hand panreq the requirements as a temp JSON; have it write the CSV.
+  //    panreq's JSON *input* shape is a flat list, each entry carrying `key`,
+  //    `id`, `title`, `description` (plus any extras). This is asymmetric with
+  //    panreq's JSON *output* shape (nested `{bucket: {id: req}}`), so we
+  //    flatten + project here. The inner-mapping key is panreq's `key`,
+  //    distinct from `id` in general.
+  const flatList: Array<Record<string, any>> = [];
+  for (const bucket of Object.values(updates.requirements)) {
+    for (const [reqKey, req] of Object.entries(bucket)) {
+      const trace = updates.traceability[reqKey];
+      flatList.push({
+        ...req,
+        key: reqKey,
+        id: req.id ?? reqKey,
+        title: req.title ?? "",
+        description: req.description ?? "",
+        unit: trace?.unit ?? null,
+        function: trace?.function ?? null,
+      });
+    }
+  }
+
+  const tmpJson = path.join(
+    os.tmpdir(),
+    `vcast-reqs-${process.pid}-${Date.now()}.json`
+  );
+  fs.writeFileSync(tmpJson, JSON.stringify(flatList, null, 2), "utf-8");
+
+  try {
+    await runReqs2xTool({
+      exe: PANREQ_EXECUTABLE_PATH,
+      args: [
+        tmpJson,
+        csvPath,
+        "--target-format",
+        "csv",
+        "--target-env",
+        `${enviroPath}.env`,
+      ],
+    });
+  } finally {
+    try {
+      fs.unlinkSync(tmpJson);
+    } catch {
+      // best-effort cleanup
+    }
+  }
+
+  // 2. Mirror the same data into requirements.json. Bucket key is normalized
+  //    to the current csv_path so consumers see a consistent source path.
+  const consolidated: Record<string, RGWRequirement> = {};
+  for (const bucket of Object.values(updates.requirements)) {
+    for (const [reqKey, req] of Object.entries(bucket)) {
+      consolidated[reqKey] = req;
+    }
+  }
+  writeAtomic(
+    files.requirements,
+    JSON.stringify({ [`[CSV] [${csvPath}]`]: consolidated }, null, 4)
+  );
+
+  // 3. Write traceability.json directly. RGW's invariant is one-to-one with
+  //    requirements: every requirement key has an entry, even if it's all
+  //    null. Without this normalization a partial save would leave a sparse
+  //    traceability.json (or a stale one with entries for removed
+  //    requirements), which downstream tools mis-handle.
+  const normalizedTraceability: RGWTraceabilityFile = {};
+  for (const reqKey of Object.keys(consolidated)) {
+    normalizedTraceability[reqKey] = updates.traceability[reqKey] ?? {
+      unit: null,
+      function: null,
+      lines: null,
+    };
+  }
+  writeAtomic(
+    files.traceability,
+    JSON.stringify(normalizedTraceability, null, 4)
+  );
+
+  return {
+    requirements: mtimeMsOrZero(files.requirements),
+    traceability: mtimeMsOrZero(files.traceability),
+    origin: mtimeMsOrZero(files.origin),
+  };
+}
+
+// ---------- Infer traceability ---------------------------------------------
+
+/**
+ * Run panreq with `--infer-traceability` against the RGW's source CSV. The
+ * tool uses an LLM to populate unit/function for each requirement and writes
+ * the result back into the RGW. Wrapped in a cancellable progress
+ * notification (same UX as code2reqs/reqs2tests).
+ *
+ * Returns the freshly-read bundle on success, null if the user cancelled.
+ */
+export async function inferTraceability(
+  enviroPath: string,
+  gatewayPath: string
+): Promise<RGWBundle | null> {
+  const csvPath = readCsvSourcePath(gatewayPath);
+  if (!csvPath) {
+    throw new Error(
+      "Cannot infer traceability: this RGW's source is not a CSV (or settings.json is missing)."
+    );
+  }
+
+  const enviroName = path.basename(enviroPath);
+  const result = await runReqs2xTool({
+    exe: PANREQ_EXECUTABLE_PATH,
+    args: [
+      csvPath,
+      gatewayPath,
+      "--target-format",
+      "rgw",
+      "--infer-traceability",
+      "--target-env",
+      `${enviroPath}.env`,
+      "--json-events",
+    ],
+    llm: true,
+    progress: {
+      title: `Inferring Traceability for ${enviroName}`,
+      logPrefix: "panreq",
+    },
+  });
+
+  if (result.cancelled) return null;
+  return readRGWBundle(enviroPath);
+}
diff --git a/src/requirements/rgwPath.ts b/src/requirements/rgwPath.ts
new file mode 100644
index 00000000..c3f672ae
--- /dev/null
+++ b/src/requirements/rgwPath.ts
@@ -0,0 +1,108 @@
+import * as vscode from "vscode";
+
+const path = require("path");
+const fs = require("fs");
+
+export const DEFAULT_RGW_SUBDIR = "rgw";
+
+// The RGW directory contains a `requirements_gateway/` subdirectory which
+// holds the JSON files we read and write. code2reqs/panreq own this layout.
+export const RGW_INNER_DIR = "requirements_gateway";
+
+/**
+ * Expand $(VAR) tokens in the configured VCAST_REPOSITORY path against
+ * process.env. Unknown variables are left as-is and a one-time warning is
+ * surfaced to the user — better to leave the literal in place than silently
+ * resolve to "".
+ */
+export function expandEnvVars(inputPath: string): string {
+  return inputPath.replace(/\$\(([^)]+)\)/g, (match, varName) => {
+    const value = process.env[varName];
+
+    if (!value) {
+      vscode.window.showWarningMessage(
+        `Environment variable "${varName}" in VCAST_REPOSITORY is not defined.`
+      );
+      return match;
+    }
+
+    return value;
+  });
+}
+
+/**
+ * Read VCAST_REPOSITORY out of the CCAST_.CFG adjacent to `enviroPath`.
+ * Returns the *raw* (unexpanded) configured form so callers that want to
+ * write the value back to CCAST_.CFG can preserve the user's $(VAR) syntax.
+ * Returns null if the config is missing, the line isn't set, or the resolved
+ * directory doesn't exist.
+ */
+export function findRelevantRequirementGateway(
+  enviroPath: string
+): string | null {
+  const parentDir = path.dirname(enviroPath);
+  const configPath = path.join(parentDir, "CCAST_.CFG");
+
+  if (!fs.existsSync(configPath)) return null;
+
+  const configContent = fs.readFileSync(configPath, "utf-8");
+  const gatewayMatch = configContent.match(/VCAST_REPOSITORY:\s*(.+)\s*/);
+  if (gatewayMatch == null) return null;
+
+  const rawGatewayPath = gatewayMatch[1].trim();
+  const gatewayPath = expandEnvVars(rawGatewayPath);
+
+  if (!fs.existsSync(gatewayPath)) return null;
+  return rawGatewayPath;
+}
+
+/**
+ * Default on-disk location for a freshly created RGW. Used when the user
+ * runs Generate Requirements on an environment that has no VCAST_REPOSITORY
+ * configured yet.
+ */
+export function defaultRequirementGatewayPath(enviroPath: string): string {
+  const parentDir = path.dirname(enviroPath);
+  const enviroName = path.basename(enviroPath).replace(/\.env$/, "");
+  return path.join(parentDir, `reqs-${enviroName}`, DEFAULT_RGW_SUBDIR);
+}
+
+/**
+ * Set VCAST_REPOSITORY in the CCAST_.CFG adjacent to `enviroPath`. Replaces
+ * any existing line, otherwise appends a new one.
+ */
+export function setVcastRepositoryInConfig(
+  enviroPath: string,
+  gatewayPath: string
+): void {
+  const parentDir = path.dirname(enviroPath);
+  const configPath = path.join(parentDir, "CCAST_.CFG");
+  const line = `VCAST_REPOSITORY: ${gatewayPath}`;
+
+  let content = "";
+  if (fs.existsSync(configPath)) {
+    content = fs.readFileSync(configPath, "utf-8");
+  }
+
+  if (/^VCAST_REPOSITORY:.*$/m.test(content)) {
+    content = content.replace(/^VCAST_REPOSITORY:.*$/m, line);
+  } else {
+    if (content.length > 0 && !content.endsWith("\n")) content += "\n";
+    content += `${line}\n`;
+  }
+
+  fs.writeFileSync(configPath, content, "utf-8");
+}
+
+/** Remove the VCAST_REPOSITORY line from CCAST_.CFG if present. */
+export function clearVcastRepositoryInConfig(enviroPath: string): void {
+  const parentDir = path.dirname(enviroPath);
+  const configPath = path.join(parentDir, "CCAST_.CFG");
+  if (!fs.existsSync(configPath)) return;
+
+  const content = fs.readFileSync(configPath, "utf-8");
+  const stripped = content.replace(/^VCAST_REPOSITORY:.*\r?\n?/m, "");
+  if (stripped !== content) {
+    fs.writeFileSync(configPath, stripped, "utf-8");
+  }
+}
diff --git a/src/requirements/webview/messages.ts b/src/requirements/webview/messages.ts
new file mode 100644
index 00000000..99499e2b
--- /dev/null
+++ b/src/requirements/webview/messages.ts
@@ -0,0 +1,74 @@
+import type {
+  RGWFileMtimes,
+  RGWRequirementsFile,
+  RGWTraceabilityFile,
+} from "../rgwIo";
+
+// Wire protocol for the requirements webview ↔ extension.
+// Discriminated unions on `type`. The webview script and extension handler
+// both branch on these — keep them in sync.
+
+// --------- Webview → Extension ---------------------------------------------
+
+export interface SaveMessage {
+  type: "save";
+  updates: {
+    requirements: RGWRequirementsFile;
+    traceability: RGWTraceabilityFile;
+  };
+  expectedMtimes: Pick<RGWFileMtimes, "requirements" | "traceability">;
+}
+
+export interface InferTraceabilityMessage {
+  type: "infer-traceability";
+}
+
+export interface OpenSourceMessage {
+  type: "open-source";
+  /** Unit name as it appears in `envData.unitData[i]` (matches source basename). */
+  unit: string;
+  /** Function name within the unit, or null to just open the file. */
+  function: string | null;
+}
+
+export type FromWebview =
+  | SaveMessage
+  | InferTraceabilityMessage
+  | OpenSourceMessage;
+
+// --------- Extension → Webview ---------------------------------------------
+
+interface BundleRefreshPayload {
+  mtimes: RGWFileMtimes;
+  requirements: RGWRequirementsFile;
+  traceability: RGWTraceabilityFile;
+}
+
+export interface SavedMessage extends BundleRefreshPayload {
+  type: "saved";
+}
+
+export interface InferredMessage extends BundleRefreshPayload {
+  type: "inferred";
+}
+
+export interface SaveFailedMessage {
+  type: "save-failed";
+  message: string;
+}
+
+export interface InferFailedMessage {
+  type: "infer-failed";
+  message: string;
+}
+
+export interface InferCancelledMessage {
+  type: "infer-cancelled";
+}
+
+export type ToWebview =
+  | SavedMessage
+  | InferredMessage
+  | SaveFailedMessage
+  | InferFailedMessage
+  | InferCancelledMessage;
diff --git a/src/requirements/webview/template.ts b/src/requirements/webview/template.ts
new file mode 100644
index 00000000..53df159c
--- /dev/null
+++ b/src/requirements/webview/template.ts
@@ -0,0 +1,88 @@
+import * as vscode from "vscode";
+import { editPolicyFor, type RGWBundle } from "../rgwIo";
+
+const path = require("path");
+
+function escapeHtml(s: string): string {
+  return s
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#39;");
+}
+
+/**
+ * JSON-encode a state object for embedding inside `<script>...</script>`.
+ * Escapes `<`, `>`, and U+2028/U+2029 so the literal can't break out of the
+ * script tag (a requirement title containing `</script>` would otherwise
+ * terminate the block early). The output remains valid JSON.
+ */
+function serializeStateForScriptTag(state: unknown): string {
+  return JSON.stringify(state)
+    .replace(/</g, "\\u003c")
+    .replace(/>/g, "\\u003e")
+    .replace(/\u2028/g, "\\u2028")
+    .replace(/\u2029/g, "\\u2029");
+}
+
+/**
+ * Build the full webview HTML. Loads CSS + JS from the `webviews/` media
+ * folder via webview-relative URIs (a generated nonce gates `<script>`
+ * execution). Initial state is injected as a `window.__rgwState` blob the
+ * script picks up on load and renders into the empty `#reqs-body` via
+ * safe DOM APIs — there's no server-side card rendering anymore, so every
+ * concrete element comes from one place (the JS).
+ */
+export function generateRequirementsHtml(
+  webview: vscode.Webview,
+  webviewBaseDir: string,
+  nonce: string,
+  bundle: RGWBundle,
+  unitsToFunctions: Record<string, string[]> | null = null
+): string {
+  const policy = editPolicyFor(bundle);
+
+  const cssUri = webview.asWebviewUri(
+    vscode.Uri.file(path.join(webviewBaseDir, "css", "requirements.css"))
+  );
+  const scriptUri = webview.asWebviewUri(
+    vscode.Uri.file(
+      path.join(webviewBaseDir, "webviewScripts", "requirements.js")
+    )
+  );
+
+  const bannerHtml = policy.bodiesEditable
+    ? `<div class="banner banner-editable">Editable — these requirements were generated by Reqs2X. Changes are saved back into the RGW.</div>`
+    : `<div class="banner banner-readonly">Only traceability information can be updated with requirements exported from an external source (Polarion, DOORS, ...). Otherwise re-import could conflict with local changes.</div>`;
+
+  const initialState = {
+    gatewayPath: bundle.gatewayPath,
+    policy,
+    mtimes: bundle.mtimes,
+    requirements: bundle.requirements,
+    traceability: bundle.traceability,
+    unitsToFunctions,
+  };
+
+  const cspSource = webview.cspSource;
+  return `<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src ${cspSource}; script-src 'nonce-${nonce}' ${cspSource};">
+<title>Requirements</title>
+<link rel="stylesheet" href="${cssUri}">
+</head>
+<body>
+<h1>Requirements</h1>
+<div id="rgw-pill" title="${escapeHtml(bundle.gatewayPath)}">RGW: ${escapeHtml(bundle.gatewayPath)}</div>
+${bannerHtml}
+<div id="save-toolbar">${policy.bodiesEditable ? `<button id="add-btn" title="Add a new requirement to this RGW.">+ Add requirement</button>` : ""}<button id="infer-btn" title="Use the configured LLM to infer the unit/function each requirement traces to.">✨ Infer traceability</button><button id="save-btn" disabled>Save changes</button></div>
+<div id="search-bar"><input id="search-input" type="search" placeholder="Search…" /><select id="filter-unit" title="Filter by unit"></select><select id="filter-function" title="Filter by function"></select><span id="search-count"></span></div>
+<div id="reqs-body"></div>
+<script nonce="${nonce}">window.__rgwState = ${serializeStateForScriptTag(initialState)};</script>
+<script nonce="${nonce}" type="module" src="${scriptUri}"></script>
+</body>
+</html>`;
+}
diff --git a/src/requirements/webviews/css/requirements.css b/src/requirements/webviews/css/requirements.css
new file mode 100644
index 00000000..c60361fb
--- /dev/null
+++ b/src/requirements/webviews/css/requirements.css
@@ -0,0 +1,246 @@
+body {
+  font-family: -apple-system, Segoe UI, sans-serif;
+  margin: 20px;
+  padding-bottom: 80px;
+}
+
+h1 { margin-top: 0; }
+h2 {
+  margin-top: 24px;
+  border-bottom: 1px solid var(--vscode-panel-border, #ddd);
+  padding-bottom: 4px;
+}
+
+.banner {
+  padding: 10px 14px;
+  border-radius: 6px;
+  margin-bottom: 18px;
+  font-size: 0.95em;
+}
+.banner-editable {
+  background: var(--vscode-inputValidation-infoBackground, #eef5ff);
+  border: 1px solid var(--vscode-inputValidation-infoBorder, #9cc);
+}
+.banner-readonly {
+  background: var(--vscode-inputValidation-warningBackground, #fff5e6);
+  border: 1px solid var(--vscode-inputValidation-warningBorder, #d89);
+}
+
+.req {
+  border: 1px solid var(--vscode-panel-border, #ddd);
+  border-radius: 6px;
+  padding: 12px 14px;
+  margin: 10px 0;
+  background: var(--vscode-editor-background, #fff);
+  position: relative;
+}
+.req--pending-added {
+  border-color: var(--vscode-inputValidation-infoBorder, #4ec9b0);
+  border-style: dashed;
+}
+.req--pending-removal {
+  opacity: 0.45;
+}
+.req--pending-removal .req-id,
+.req--pending-removal .field input,
+.req--pending-removal .field textarea,
+.req--pending-removal .field select {
+  text-decoration: line-through;
+}
+.req-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: baseline;
+  gap: 12px;
+}
+.req-remove-btn,
+.req-restore-btn {
+  background: transparent;
+  border: 1px solid transparent;
+  color: var(--vscode-descriptionForeground, #888);
+  cursor: pointer;
+  border-radius: 4px;
+  padding: 2px 8px;
+  font: inherit;
+  line-height: 1;
+}
+.req-remove-btn:hover,
+.req-restore-btn:hover {
+  border-color: var(--vscode-input-border, #ccc);
+  color: var(--vscode-foreground, #000);
+}
+.field input.invalid {
+  outline: 2px solid var(--vscode-inputValidation-errorBorder, #be1100);
+}
+.field-error {
+  font-size: 0.8em;
+  color: var(--vscode-inputValidation-errorBorder, #be1100);
+  margin-top: 2px;
+}
+.open-source-row {
+  margin-top: 6px;
+  text-align: right;
+}
+.open-source-btn {
+  background: transparent;
+  border: 1px solid var(--vscode-input-border, #ccc);
+  color: var(--vscode-foreground, #000);
+  cursor: pointer;
+  border-radius: 4px;
+  padding: 2px 10px;
+  font-size: 0.85em;
+  font-family: inherit;
+}
+.open-source-btn:hover:not(:disabled) {
+  background: var(--vscode-button-secondaryBackground, var(--vscode-editorWidget-background, #eee));
+}
+.open-source-btn:disabled {
+  opacity: 0.4;
+  cursor: default;
+}
+.req-id {
+  font-weight: 600;
+  color: var(--vscode-textLink-foreground, #2980b9);
+}
+.req-meta {
+  font-size: 0.8em;
+  color: var(--vscode-descriptionForeground, #888);
+}
+
+.field { margin-top: 8px; }
+.field label {
+  display: block;
+  font-size: 0.8em;
+  color: var(--vscode-descriptionForeground, #666);
+  margin-bottom: 2px;
+}
+.field input,
+.field textarea,
+.field select {
+  width: 100%;
+  box-sizing: border-box;
+  background: var(--vscode-input-background, #fff);
+  color: var(--vscode-input-foreground, #000);
+  border: 1px solid var(--vscode-input-border, #ccc);
+  padding: 4px 6px;
+  font: inherit;
+}
+.field textarea {
+  resize: vertical;
+  min-height: 48px;
+}
+.field input:disabled,
+.field textarea:disabled,
+.field select:disabled {
+  opacity: 0.7;
+  cursor: default;
+}
+.trace-row {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 8px;
+}
+
+.dirty {
+  outline: 2px solid var(--vscode-inputValidation-infoBorder, #9cc);
+}
+
+#search-bar {
+  position: sticky;
+  top: 0;
+  z-index: 50;
+  background: var(--vscode-editor-background, #fff);
+  padding: 4px 0 6px;
+  margin-bottom: 4px;
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+  align-items: center;
+  font-size: 0.9em;
+}
+#search-input,
+#filter-unit,
+#filter-function {
+  background: var(--vscode-input-background, #fff);
+  color: var(--vscode-input-foreground, #000);
+  border: 1px solid var(--vscode-input-border, #ccc);
+  padding: 3px 8px;
+  font: inherit;
+  border-radius: 3px;
+}
+#search-input {
+  flex: 1;
+  min-width: 140px;
+}
+#search-input:focus,
+#filter-unit:focus,
+#filter-function:focus {
+  outline: 1px solid var(--vscode-focusBorder, #0078d4);
+}
+#filter-unit,
+#filter-function {
+  max-width: 180px;
+}
+#search-count {
+  font-size: 0.85em;
+  color: var(--vscode-descriptionForeground, #888);
+  white-space: nowrap;
+  margin-left: auto;
+}
+
+.req--hidden,
+.h2--hidden {
+  display: none;
+}
+
+#rgw-pill {
+  position: fixed;
+  bottom: 16px;
+  left: 16px;
+  max-width: 50vw;
+  padding: 5px 12px;
+  font-size: 0.8em;
+  color: var(--vscode-descriptionForeground, #666);
+  background: var(--vscode-editorWidget-background, var(--vscode-editor-background, #f3f3f3));
+  border: 1px solid var(--vscode-widget-border, var(--vscode-panel-border, #ddd));
+  border-radius: 999px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  opacity: 0.85;
+  z-index: 100;
+}
+
+#save-toolbar {
+  position: fixed;
+  bottom: 16px;
+  right: 16px;
+  background: var(--vscode-editorWidget-background, var(--vscode-editor-background, #fff));
+  border: 1px solid var(--vscode-widget-border, var(--vscode-panel-border, #ddd));
+  padding: 10px 14px;
+  border-radius: 8px;
+  box-shadow: 0 4px 14px rgba(0, 0, 0, 0.2);
+  display: flex;
+  gap: 12px;
+  align-items: center;
+  z-index: 100;
+}
+
+#save-btn,
+#infer-btn,
+#add-btn {
+  padding: 8px 18px;
+  font-size: 1em;
+  background: var(--vscode-button-background, #0078d4);
+  color: var(--vscode-button-foreground, #fff);
+  border: 0;
+  border-radius: 4px;
+  cursor: pointer;
+  font-family: inherit;
+}
+#save-btn[disabled],
+#infer-btn[disabled],
+#add-btn[disabled] {
+  opacity: 0.5;
+  cursor: default;
+}
diff --git a/src/requirements/webviews/webviewScripts/cards.js b/src/requirements/webviews/webviewScripts/cards.js
new file mode 100644
index 00000000..a3eb3a2d
--- /dev/null
+++ b/src/requirements/webviews/webviewScripts/cards.js
@@ -0,0 +1,500 @@
+// DOM construction + grouping + edit handling for requirement cards.
+
+import {
+  state,
+  dirty,
+  removed,
+  added,
+  reqsBody,
+  setDirty,
+  refreshButtonStates,
+  existingKeys,
+  nextTempIdValue,
+} from "./state.js";
+import { rebuildFilterDropdowns, applyFilter } from "./filter.js";
+
+// ---------- Low-level DOM builders ---------------------------------------
+
+function buildField(label, child) {
+  const div = document.createElement("div");
+  div.className = "field";
+  const lbl = document.createElement("label");
+  lbl.textContent = label;
+  div.appendChild(lbl);
+  div.appendChild(child);
+  return div;
+}
+
+function buildTraceField(field, current, options, refAttrs) {
+  let el;
+  if (!options) {
+    el = document.createElement("input");
+    el.type = "text";
+    el.value = current ?? "";
+  } else {
+    el = document.createElement("select");
+    const noneOpt = document.createElement("option");
+    noneOpt.value = "";
+    noneOpt.textContent = "(none)";
+    if (!current) noneOpt.selected = true;
+    el.appendChild(noneOpt);
+
+    let found = !current;
+    for (const o of options) {
+      const opt = document.createElement("option");
+      opt.value = o;
+      opt.textContent = o;
+      if (o === current) {
+        opt.selected = true;
+        found = true;
+      }
+      el.appendChild(opt);
+    }
+    if (!found) {
+      const opt = document.createElement("option");
+      opt.value = current;
+      opt.textContent = current + " (not in env)";
+      opt.selected = true;
+      el.appendChild(opt);
+    }
+  }
+  el.dataset.scope = "trace";
+  el.dataset.field = field;
+  Object.assign(el.dataset, refAttrs);
+  return el;
+}
+
+function buildTraceRow(currentUnit, currentFn, refAttrs) {
+  const traceRow = document.createElement("div");
+  traceRow.className = "field trace-row";
+
+  const unitOptions = state.unitsToFunctions
+    ? Object.keys(state.unitsToFunctions)
+    : null;
+  const unitField = buildTraceField(
+    "unit",
+    currentUnit ?? "",
+    unitOptions,
+    refAttrs
+  );
+  const fnOptions = state.unitsToFunctions
+    ? state.unitsToFunctions[currentUnit ?? ""] ?? []
+    : null;
+  const fnField = buildTraceField(
+    "function",
+    currentFn ?? "",
+    fnOptions,
+    refAttrs
+  );
+
+  const unitWrap = document.createElement("div");
+  const unitLabel = document.createElement("label");
+  unitLabel.textContent = "Traceability: unit";
+  unitWrap.appendChild(unitLabel);
+  unitWrap.appendChild(unitField);
+
+  const fnWrap = document.createElement("div");
+  const fnLabel = document.createElement("label");
+  fnLabel.textContent = "Traceability: function";
+  fnWrap.appendChild(fnLabel);
+  fnWrap.appendChild(fnField);
+
+  traceRow.appendChild(unitWrap);
+  traceRow.appendChild(fnWrap);
+  return traceRow;
+}
+
+function buildOpenSourceRow(unit) {
+  const row = document.createElement("div");
+  row.className = "open-source-row";
+  const btn = document.createElement("button");
+  btn.className = "open-source-btn";
+  btn.dataset.action = "open-source";
+  btn.textContent = "↗ Open source";
+  btn.title = "Open the unit's source file at the function definition.";
+  btn.disabled = !unit;
+  row.appendChild(btn);
+  return row;
+}
+
+function buildRemoveButton(reqId) {
+  const btn = document.createElement("button");
+  btn.className = "req-remove-btn";
+  btn.dataset.action = "remove";
+  btn.dataset.reqId = reqId;
+  btn.title = "Remove this requirement";
+  btn.textContent = "×";
+  return btn;
+}
+
+// ---------- Card builders ------------------------------------------------
+
+export function buildCard(entry) {
+  const policy = state.policy;
+  const lockedBodies = !policy.bodiesEditable;
+
+  const card = document.createElement("div");
+  card.className = "req";
+  card.dataset.reqId = entry.id;
+  if (removed.has(entry.id)) card.classList.add("req--pending-removal");
+
+  const header = document.createElement("div");
+  header.className = "req-header";
+
+  const id = document.createElement("div");
+  id.className = "req-id";
+  id.textContent = entry.id;
+  header.appendChild(id);
+
+  const meta = document.createElement("div");
+  meta.className = "req-meta";
+  const lastMod = entry.req.last_modified ?? "";
+  meta.textContent =
+    (lastMod ? "modified: " + lastMod + " · " : "") +
+    "source: " +
+    entry.source;
+  if (policy.bodiesEditable) {
+    meta.appendChild(document.createTextNode(" "));
+    meta.appendChild(buildRemoveButton(entry.id));
+  }
+  header.appendChild(meta);
+  card.appendChild(header);
+
+  const titleInput = document.createElement("input");
+  titleInput.type = "text";
+  titleInput.dataset.reqId = entry.id;
+  titleInput.dataset.scope = "req";
+  titleInput.dataset.field = "title";
+  titleInput.value = entry.req.title ?? "";
+  if (lockedBodies) titleInput.disabled = true;
+  card.appendChild(buildField("Title", titleInput));
+
+  const descArea = document.createElement("textarea");
+  descArea.dataset.reqId = entry.id;
+  descArea.dataset.scope = "req";
+  descArea.dataset.field = "description";
+  descArea.value = entry.req.description ?? "";
+  if (lockedBodies) descArea.disabled = true;
+  card.appendChild(buildField("Description", descArea));
+
+  card.appendChild(
+    buildTraceRow(entry.trace.unit, entry.trace.function, { reqId: entry.id })
+  );
+  card.appendChild(buildOpenSourceRow(entry.trace.unit ?? ""));
+  return card;
+}
+
+export function buildPendingAddCard(pending) {
+  const card = document.createElement("div");
+  card.className = "req req--pending-added";
+  card.dataset.tempId = pending.tempId;
+
+  const header = document.createElement("div");
+  header.className = "req-header";
+
+  const id = document.createElement("div");
+  id.className = "req-id";
+  id.textContent = "[New requirement]";
+  header.appendChild(id);
+
+  const meta = document.createElement("div");
+  meta.className = "req-meta";
+  const discardBtn = document.createElement("button");
+  discardBtn.className = "req-remove-btn";
+  discardBtn.dataset.action = "discard-added";
+  discardBtn.dataset.tempId = pending.tempId;
+  discardBtn.title = "Discard this new requirement";
+  discardBtn.textContent = "×";
+  meta.appendChild(discardBtn);
+  header.appendChild(meta);
+  card.appendChild(header);
+
+  const keyInput = document.createElement("input");
+  keyInput.type = "text";
+  keyInput.dataset.tempId = pending.tempId;
+  keyInput.dataset.field = "key";
+  keyInput.value = pending.key;
+  keyInput.placeholder = "Required: unique key under which this is stored";
+  const keyField = buildField("Key", keyInput);
+  const keyError = document.createElement("div");
+  keyError.className = "field-error";
+  keyError.dataset.tempId = pending.tempId;
+  keyError.dataset.role = "key-error";
+  keyField.appendChild(keyError);
+  card.appendChild(keyField);
+
+  const titleInput = document.createElement("input");
+  titleInput.type = "text";
+  titleInput.dataset.tempId = pending.tempId;
+  titleInput.dataset.field = "title";
+  titleInput.value = pending.title;
+  card.appendChild(buildField("Title", titleInput));
+
+  const descArea = document.createElement("textarea");
+  descArea.dataset.tempId = pending.tempId;
+  descArea.dataset.field = "description";
+  descArea.value = pending.description;
+  card.appendChild(buildField("Description", descArea));
+
+  card.appendChild(
+    buildTraceRow(pending.unit, pending.function, { tempId: pending.tempId })
+  );
+  card.appendChild(buildOpenSourceRow(pending.unit ?? ""));
+
+  validatePendingKey(pending, keyInput, keyError);
+  return card;
+}
+
+// ---------- Grouping + body rebuild --------------------------------------
+
+/**
+ * Flatten the bundle in `state` into ordered groups keyed by
+ * `function || unit || source`. Single source of truth for grouping —
+ * the wire protocol doesn't ship pre-grouped data, so this is what
+ * everyone (initial load + every saved/inferred refresh) uses.
+ */
+function groupRequirementsFromState() {
+  const flat = [];
+  for (const [source, bucket] of Object.entries(state.requirements)) {
+    for (const [id, req] of Object.entries(bucket)) {
+      flat.push({
+        source,
+        id,
+        req,
+        trace: state.traceability[id] || {
+          unit: null,
+          function: null,
+          lines: null,
+        },
+      });
+    }
+  }
+  const buckets = {};
+  const order = [];
+  for (const entry of flat) {
+    const key =
+      entry.trace.function ||
+      entry.trace.unit ||
+      entry.source ||
+      "Unknown";
+    if (!buckets[key]) {
+      buckets[key] = [];
+      order.push(key);
+    }
+    buckets[key].push(entry);
+  }
+  return order.map((name) => ({ name, entries: buckets[name] }));
+}
+
+export function rebuildBody() {
+  const groups = groupRequirementsFromState();
+  const frag = document.createDocumentFragment();
+  for (const group of groups) {
+    const h2 = document.createElement("h2");
+    h2.textContent = group.name;
+    frag.appendChild(h2);
+    for (const entry of group.entries) {
+      frag.appendChild(buildCard(entry));
+    }
+  }
+  // Pending-added cards live below the persisted groups so the user
+  // sees them clearly until they save.
+  for (const pending of added) {
+    frag.appendChild(buildPendingAddCard(pending));
+  }
+  reqsBody.replaceChildren(frag);
+  rebuildFilterDropdowns();
+  applyFilter();
+}
+
+// ---------- Pending-key validation ---------------------------------------
+
+export function validatePendingKey(pending, inputEl, errorEl) {
+  const key = pending.key.trim();
+  let problem = "";
+  if (!key) {
+    problem = "Key is required.";
+  } else if (existingKeys().has(key)) {
+    problem = "Collides with an existing requirement key.";
+  } else if (added.some((a) => a !== pending && a.key.trim() === key)) {
+    problem = "Two pending new requirements share this key.";
+  }
+  pending.keyValid = problem === "";
+  inputEl.classList.toggle("invalid", !pending.keyValid);
+  if (errorEl) errorEl.textContent = problem;
+}
+
+export function revalidateAllPendingKeys() {
+  for (const pending of added) {
+    const card = reqsBody.querySelector(
+      `.req--pending-added[data-temp-id="${pending.tempId}"]`
+    );
+    if (!card) continue;
+    const inputEl = card.querySelector('[data-field="key"]');
+    const errorEl = card.querySelector('[data-role="key-error"]');
+    if (inputEl) validatePendingKey(pending, inputEl, errorEl);
+  }
+}
+
+// ---------- Field-change handling ----------------------------------------
+
+function refreshFunctionOptions(card, selectedUnit, currentFunction) {
+  const fnSelect = card.querySelector(
+    '[data-scope="trace"][data-field="function"]'
+  );
+  if (!fnSelect || fnSelect.tagName !== "SELECT") return;
+  const map = state.unitsToFunctions || {};
+  const fns = selectedUnit && map[selectedUnit] ? map[selectedUnit] : [];
+  const desired = currentFunction != null ? String(currentFunction) : "";
+
+  while (fnSelect.firstChild) fnSelect.removeChild(fnSelect.firstChild);
+  const noneOpt = document.createElement("option");
+  noneOpt.value = "";
+  noneOpt.textContent = "(none)";
+  if (!desired) noneOpt.selected = true;
+  fnSelect.appendChild(noneOpt);
+
+  let found = !desired;
+  for (const fn of fns) {
+    const opt = document.createElement("option");
+    opt.value = fn;
+    opt.textContent = fn;
+    if (fn === desired) {
+      opt.selected = true;
+      found = true;
+    }
+    fnSelect.appendChild(opt);
+  }
+  if (!found) {
+    const opt = document.createElement("option");
+    opt.value = desired;
+    opt.textContent = desired + " (not in env)";
+    opt.selected = true;
+    fnSelect.appendChild(opt);
+  }
+}
+
+function pendingForTempId(tempId) {
+  return added.find((a) => a.tempId === tempId);
+}
+
+function updateOpenSourceForCard(card, unit) {
+  if (!card) return;
+  const btn = card.querySelector(".open-source-btn");
+  if (btn) btn.disabled = !unit;
+}
+
+export function handleFieldChange(el) {
+  // Pending-added card: route the edit into the `added` entry directly.
+  if (el.dataset.tempId) {
+    const pending = pendingForTempId(el.dataset.tempId);
+    if (!pending) return;
+    const field = el.dataset.field;
+    const value = el.value;
+    if (field === "key") {
+      pending.key = value;
+      const card = el.closest(".req");
+      const errorEl = card?.querySelector('[data-role="key-error"]');
+      validatePendingKey(pending, el, errorEl);
+    } else if (field === "title" || field === "description") {
+      pending[field] = value;
+    } else if (field === "unit" || field === "function") {
+      pending[field] = value === "" ? null : value;
+      if (field === "unit") {
+        // Drop the function when the unit changes — keeping a stale
+        // function would create mismatched traceability the user almost
+        // certainly didn't intend.
+        const card = el.closest(".req");
+        pending.function = null;
+        refreshFunctionOptions(card, pending.unit, null);
+        updateOpenSourceForCard(card, pending.unit);
+      }
+    }
+    refreshButtonStates();
+    return;
+  }
+
+  // Existing card edit.
+  const reqId = el.dataset.reqId;
+  if (removed.has(reqId)) return; // ignore edits to soft-deleted cards
+  const scope = el.dataset.scope;
+  const field = el.dataset.field;
+  let value = el.value;
+  if (field === "unit" || field === "function") {
+    value = value === "" ? null : value;
+  }
+  setDirty(reqId, scope, field, value);
+  el.classList.add("dirty");
+
+  if (field === "unit") {
+    // Same rule as for pending cards: drop the function on unit change.
+    const card = el.closest(".req");
+    refreshFunctionOptions(card, value, null);
+    setDirty(reqId, "trace", "function", null);
+    const fnSelect = card.querySelector(
+      '[data-scope="trace"][data-field="function"]'
+    );
+    if (fnSelect) fnSelect.classList.add("dirty");
+    updateOpenSourceForCard(card, value);
+  }
+
+  // The filter reads input values directly at apply time, so a fresh
+  // edit becomes searchable immediately without any per-edit bookkeeping
+  // here. We don't re-apply the filter on edit because doing so could
+  // yank a card the user is actively editing out from under them.
+}
+
+// ---------- Add / remove -------------------------------------------------
+
+export function appendPendingAdd() {
+  const pending = {
+    tempId: nextTempIdValue(),
+    key: "",
+    title: "",
+    description: "",
+    unit: null,
+    function: null,
+    keyValid: false,
+  };
+  added.push(pending);
+  reqsBody.appendChild(buildPendingAddCard(pending));
+  refreshButtonStates();
+}
+
+export function toggleRemoveExisting(reqId) {
+  const card = reqsBody.querySelector(`.req[data-req-id="${reqId}"]`);
+  if (!card) return;
+  if (removed.has(reqId)) {
+    removed.delete(reqId);
+    card.classList.remove("req--pending-removal");
+    const btn = card.querySelector(".req-remove-btn");
+    if (btn) {
+      btn.textContent = "×";
+      btn.title = "Remove this requirement";
+    }
+  } else {
+    removed.add(reqId);
+    card.classList.add("req--pending-removal");
+    const btn = card.querySelector(".req-remove-btn");
+    if (btn) {
+      btn.textContent = "↩";
+      btn.title = "Restore this requirement";
+    }
+  }
+  // A soft-delete or restore can flip the validity of pending-add keys
+  // that were colliding/uncolliding with the toggled requirement.
+  revalidateAllPendingKeys();
+  refreshButtonStates();
+}
+
+export function discardPendingAdd(tempId) {
+  const idx = added.findIndex((a) => a.tempId === tempId);
+  if (idx === -1) return;
+  added.splice(idx, 1);
+  const card = reqsBody.querySelector(
+    `.req--pending-added[data-temp-id="${tempId}"]`
+  );
+  if (card) card.remove();
+  revalidateAllPendingKeys();
+  refreshButtonStates();
+}
diff --git a/src/requirements/webviews/webviewScripts/filter.js b/src/requirements/webviews/webviewScripts/filter.js
new file mode 100644
index 00000000..d120cd4d
--- /dev/null
+++ b/src/requirements/webviews/webviewScripts/filter.js
@@ -0,0 +1,163 @@
+// Search + unit/function filter for the requirements editor.
+
+import {
+  state,
+  filterUnit,
+  filterFunction,
+  searchInput,
+  searchCount,
+  reqsBody,
+} from "./state.js";
+
+// Sentinel value for "(Not set)" in the unit/function dropdowns. Real
+// values are arbitrary strings; this one starts with NUL so it can't
+// collide with a legitimate identifier.
+export const NOT_SET = "\u0000not-set";
+
+/**
+ * Populate the unit and function dropdowns. Options come from the env's
+ * canonical list (so a brand-new unit shows up before anything traces to
+ * it — that's exactly when filtering down to "(Not set)" is most useful)
+ * plus any "(not in env)" stragglers that legitimately appear in current
+ * traceability. Both dropdowns also offer "(Any)" and "(Not set)" — the
+ * latter is what to pick when looking for requirements that still need
+ * traceability.
+ */
+export function rebuildFilterDropdowns() {
+  if (!filterUnit || !filterFunction) return;
+
+  const units = new Set();
+  const fns = new Set();
+
+  const map = state.unitsToFunctions || {};
+  for (const u of Object.keys(map)) {
+    units.add(u);
+    for (const f of map[u] || []) fns.add(f);
+  }
+  for (const trace of Object.values(state.traceability)) {
+    if (trace?.unit) units.add(trace.unit);
+    if (trace?.function) fns.add(trace.function);
+  }
+
+  const fillSelect = (sel, label, items) => {
+    const previous = sel.value;
+    while (sel.firstChild) sel.removeChild(sel.firstChild);
+
+    const any = document.createElement("option");
+    any.value = "";
+    any.textContent = `(Any ${label})`;
+    sel.appendChild(any);
+
+    const none = document.createElement("option");
+    none.value = NOT_SET;
+    none.textContent = "(Not set)";
+    sel.appendChild(none);
+
+    for (const v of [...items].sort()) {
+      const opt = document.createElement("option");
+      opt.value = v;
+      opt.textContent = v;
+      sel.appendChild(opt);
+    }
+
+    sel.value = [...sel.options].some((o) => o.value === previous)
+      ? previous
+      : "";
+  };
+
+  fillSelect(filterUnit, "unit", units);
+  fillSelect(filterFunction, "function", fns);
+}
+
+/**
+ * Hide cards that fail any of the active filters: the search text
+ * (substring AND on whitespace tokens, against the card's live inputs),
+ * the unit dropdown, and the function dropdown. "(Not set)" matches cards
+ * whose corresponding trace field is empty. Pending-add cards are always
+ * shown so a half-typed new requirement doesn't disappear under the user.
+ * Group headings collapse when all their cards are hidden.
+ */
+export function applyFilter() {
+  if (!searchInput) return;
+  const q = searchInput.value.trim().toLowerCase();
+  const tokens = q ? q.split(/\s+/) : [];
+  const matchesText = (haystack) =>
+    tokens.every((t) => haystack.includes(t));
+
+  const unitFilter = filterUnit ? filterUnit.value : "";
+  const fnFilter = filterFunction ? filterFunction.value : "";
+  const matchesField = (val, filter) => {
+    if (!filter) return true;
+    if (filter === NOT_SET) return !val;
+    return val === filter;
+  };
+
+  let currentHeader = null;
+  let currentHeaderHasVisible = false;
+  let totalReal = 0;
+  let visibleReal = 0;
+
+  for (const el of reqsBody.children) {
+    if (el.tagName === "H2") {
+      if (currentHeader) {
+        currentHeader.classList.toggle(
+          "h2--hidden",
+          !currentHeaderHasVisible
+        );
+      }
+      currentHeader = el;
+      currentHeaderHasVisible = false;
+    } else if (el.classList.contains("req")) {
+      if (el.classList.contains("req--pending-added")) {
+        el.classList.remove("req--hidden");
+        continue;
+      }
+      totalReal++;
+      // Pull the searchable fields off the live inputs — that way a
+      // mid-edit value is searchable immediately without an extra
+      // bookkeeping step in the field-change path.
+      const reqId = el.dataset.reqId || "";
+      const titleEl = el.querySelector('[data-field="title"]');
+      const descEl = el.querySelector('[data-field="description"]');
+      const unitEl = el.querySelector(
+        '[data-scope="trace"][data-field="unit"]'
+      );
+      const fnEl = el.querySelector(
+        '[data-scope="trace"][data-field="function"]'
+      );
+      const unitVal = unitEl ? unitEl.value : "";
+      const fnVal = fnEl ? fnEl.value : "";
+      const haystack = (
+        reqId +
+        " " +
+        (titleEl ? titleEl.value : "") +
+        " " +
+        (descEl ? descEl.value : "") +
+        " " +
+        unitVal +
+        " " +
+        fnVal
+      ).toLowerCase();
+      const visible =
+        (tokens.length === 0 || matchesText(haystack)) &&
+        matchesField(unitVal, unitFilter) &&
+        matchesField(fnVal, fnFilter);
+      el.classList.toggle("req--hidden", !visible);
+      if (visible) {
+        currentHeaderHasVisible = true;
+        visibleReal++;
+      }
+    }
+  }
+  if (currentHeader) {
+    currentHeader.classList.toggle("h2--hidden", !currentHeaderHasVisible);
+  }
+
+  if (searchCount) {
+    const filtersActive =
+      tokens.length > 0 || !!unitFilter || !!fnFilter;
+    searchCount.textContent = filtersActive
+      ? `${visibleReal} of ${totalReal}`
+      : "";
+  }
+}
diff --git a/src/requirements/webviews/webviewScripts/requirements.js b/src/requirements/webviews/webviewScripts/requirements.js
new file mode 100644
index 00000000..38aee619
--- /dev/null
+++ b/src/requirements/webviews/webviewScripts/requirements.js
@@ -0,0 +1,116 @@
+// Requirements editor webview entry. Wires DOM events to the four feature
+// modules:
+//
+//   state.js   — pending edits (dirty / removed / added) + DOM refs
+//   cards.js   — DOM building + grouping + edit handlers + add/remove
+//   filter.js  — search + unit/function dropdowns
+//   save.js    — save payload + refresh handler
+//
+// State (`window.__rgwState`) is injected as a JSON blob by the extension
+// at load time. The cards section is empty in the rendered HTML — every
+// element comes from the script via safe DOM APIs (createElement /
+// textContent).
+//
+// Wire protocol (see src/requirements/webview/messages.ts):
+//   FROM webview: { type: "save" | "infer-traceability" | "open-source" }
+//   TO   webview: { type: "saved" | "inferred" | "save-failed" | "infer-failed" | "infer-cancelled" }
+
+import {
+  vscode,
+  saveBtn,
+  inferBtn,
+  addBtn,
+  reqsBody,
+  searchInput,
+  filterUnit,
+  filterFunction,
+  refreshButtonStates,
+} from "./state.js";
+import {
+  appendPendingAdd,
+  toggleRemoveExisting,
+  discardPendingAdd,
+  handleFieldChange,
+  rebuildBody,
+} from "./cards.js";
+import { applyFilter } from "./filter.js";
+import { postSave, postInfer, applyRefreshedBundle } from "./save.js";
+
+// ---------- Event delegation on the cards container ----------------------
+
+reqsBody.addEventListener("input", (e) => {
+  const t = e.target;
+  if (t && t.matches && t.matches("[data-field]") && t.tagName !== "SELECT") {
+    handleFieldChange(t);
+  }
+});
+reqsBody.addEventListener("change", (e) => {
+  const t = e.target;
+  if (t && t.matches && t.matches("[data-field]") && t.tagName === "SELECT") {
+    handleFieldChange(t);
+  }
+});
+reqsBody.addEventListener("click", (e) => {
+  const t = e.target;
+  if (!t || !t.matches) return;
+
+  if (t.matches(".req-remove-btn")) {
+    const action = t.dataset.action;
+    if (action === "remove") {
+      toggleRemoveExisting(t.dataset.reqId);
+    } else if (action === "discard-added") {
+      discardPendingAdd(t.dataset.tempId);
+    }
+    return;
+  }
+
+  if (t.matches(".open-source-btn") && !t.disabled) {
+    const card = t.closest(".req");
+    if (!card) return;
+    const unitEl = card.querySelector(
+      '[data-scope="trace"][data-field="unit"]'
+    );
+    const fnEl = card.querySelector(
+      '[data-scope="trace"][data-field="function"]'
+    );
+    const unit = unitEl ? unitEl.value : "";
+    const fn = fnEl ? fnEl.value : "";
+    if (!unit) return;
+    vscode.postMessage({
+      type: "open-source",
+      unit,
+      function: fn === "" ? null : fn,
+    });
+  }
+});
+
+// ---------- Toolbar + filter listeners -----------------------------------
+
+if (addBtn) addBtn.addEventListener("click", appendPendingAdd);
+saveBtn.addEventListener("click", postSave);
+inferBtn.addEventListener("click", postInfer);
+
+if (searchInput) searchInput.addEventListener("input", applyFilter);
+if (filterUnit) filterUnit.addEventListener("change", applyFilter);
+if (filterFunction) filterFunction.addEventListener("change", applyFilter);
+
+// ---------- Extension → webview messages ---------------------------------
+
+window.addEventListener("message", (event) => {
+  const msg = event.data;
+  if (msg.type === "saved" || msg.type === "inferred") {
+    applyRefreshedBundle(msg);
+  } else if (
+    msg.type === "save-failed" ||
+    msg.type === "infer-failed" ||
+    msg.type === "infer-cancelled"
+  ) {
+    refreshButtonStates();
+  }
+});
+
+// ---------- Initial render -----------------------------------------------
+// rebuildBody() builds cards, populates filter dropdowns, and applies the
+// (empty) filter. Buttons start in their initial states.
+rebuildBody();
+refreshButtonStates();
diff --git a/src/requirements/webviews/webviewScripts/save.js b/src/requirements/webviews/webviewScripts/save.js
new file mode 100644
index 00000000..20101ff8
--- /dev/null
+++ b/src/requirements/webviews/webviewScripts/save.js
@@ -0,0 +1,108 @@
+// Save-payload assembly + handler for refresh messages from the extension.
+
+import {
+  state,
+  dirty,
+  removed,
+  added,
+  vscode,
+  saveBtn,
+  inferBtn,
+  addBtn,
+  refreshButtonStates,
+} from "./state.js";
+import { rebuildBody } from "./cards.js";
+
+export function buildSaveUpdates() {
+  const updates = {
+    requirements: JSON.parse(JSON.stringify(state.requirements)),
+    traceability: JSON.parse(JSON.stringify(state.traceability)),
+  };
+
+  // 1. Drop soft-removed entries from every bucket and the trace map.
+  for (const reqId of removed) {
+    for (const bucket of Object.keys(updates.requirements)) {
+      if (updates.requirements[bucket][reqId]) {
+        delete updates.requirements[bucket][reqId];
+      }
+    }
+    delete updates.traceability[reqId];
+  }
+
+  // 2. Apply in-place dirty patches (skipping any that are also removed).
+  for (const [reqId, patch] of dirty.entries()) {
+    if (removed.has(reqId)) continue;
+    if (state.policy.bodiesEditable && Object.keys(patch.req).length > 0) {
+      for (const bucket of Object.keys(updates.requirements)) {
+        if (updates.requirements[bucket][reqId]) {
+          Object.assign(updates.requirements[bucket][reqId], patch.req);
+          break;
+        }
+      }
+    }
+    if (Object.keys(patch.trace).length > 0) {
+      const existing = updates.traceability[reqId] || {
+        unit: null,
+        function: null,
+        lines: null,
+      };
+      updates.traceability[reqId] = { ...existing, ...patch.trace };
+    }
+  }
+
+  // 3. Append pending-added entries to the first bucket. The save flow on
+  //    the extension side normalizes everything into a single CSV-keyed
+  //    bucket anyway, so the choice here doesn't matter.
+  let bucketKey = Object.keys(updates.requirements)[0];
+  if (!bucketKey) {
+    bucketKey = "[CSV] [" + state.gatewayPath + "]";
+    updates.requirements[bucketKey] = {};
+  }
+  for (const pending of added) {
+    const key = pending.key.trim();
+    updates.requirements[bucketKey][key] = {
+      id: key,
+      title: pending.title,
+      description: pending.description,
+    };
+    if (pending.unit != null || pending.function != null) {
+      updates.traceability[key] = {
+        unit: pending.unit ?? null,
+        function: pending.function ?? null,
+        lines: null,
+      };
+    }
+  }
+
+  return updates;
+}
+
+export function postSave() {
+  const updates = buildSaveUpdates();
+  saveBtn.disabled = true;
+  inferBtn.disabled = true;
+  if (addBtn) addBtn.disabled = true;
+  vscode.postMessage({
+    type: "save",
+    updates,
+    expectedMtimes: state.mtimes,
+  });
+}
+
+export function postInfer() {
+  inferBtn.disabled = true;
+  saveBtn.disabled = true;
+  if (addBtn) addBtn.disabled = true;
+  vscode.postMessage({ type: "infer-traceability" });
+}
+
+export function applyRefreshedBundle(msg) {
+  dirty.clear();
+  removed.clear();
+  added.length = 0;
+  state.mtimes = msg.mtimes;
+  state.requirements = msg.requirements;
+  state.traceability = msg.traceability;
+  rebuildBody();
+  refreshButtonStates();
+}
diff --git a/src/requirements/webviews/webviewScripts/state.js b/src/requirements/webviews/webviewScripts/state.js
new file mode 100644
index 00000000..96a86d1a
--- /dev/null
+++ b/src/requirements/webviews/webviewScripts/state.js
@@ -0,0 +1,63 @@
+// Shared mutable state for the requirements editor webview.
+// Lives in one module so cards.js / filter.js / save.js / the entry script
+// all reference the same singletons via ES-module live bindings.
+
+export const vscode = acquireVsCodeApi();
+export const state = window.__rgwState;
+
+// Pending edits split three ways:
+//   dirty   — in-place edits to existing requirements (key -> {req, trace})
+//   removed — keys of existing requirements marked for soft-deletion
+//   added   — pending new requirements not yet on disk
+// All three flush on Save and reset on a successful saved/inferred.
+export const dirty = new Map();
+export const removed = new Set();
+export const added = []; // {tempId, key, title, description, unit, function, keyValid}
+
+let nextTempId = 1;
+export function nextTempIdValue() {
+  return "__pending_" + nextTempId++ + "__";
+}
+
+// DOM refs the rest of the modules rely on. Looked up once at module load —
+// `<script type="module">` is deferred, so the elements exist by the time
+// this evaluates.
+export const saveBtn = document.getElementById("save-btn");
+export const inferBtn = document.getElementById("infer-btn");
+// addBtn is null when bodies aren't editable (the template omits it).
+export const addBtn = document.getElementById("add-btn");
+export const reqsBody = document.getElementById("reqs-body");
+export const searchInput = document.getElementById("search-input");
+export const searchCount = document.getElementById("search-count");
+export const filterUnit = document.getElementById("filter-unit");
+export const filterFunction = document.getElementById("filter-function");
+
+/**
+ * Existing keys across all buckets, minus any soft-removed ones — those
+ * don't count, the user can add a fresh requirement with the same key in
+ * the same save (the Save flow drops the removed entry first).
+ */
+export function existingKeys() {
+  const keys = new Set();
+  for (const bucket of Object.values(state.requirements)) {
+    for (const k of Object.keys(bucket)) {
+      if (!removed.has(k)) keys.add(k);
+    }
+  }
+  return keys;
+}
+
+export function refreshButtonStates() {
+  const hasChanges = dirty.size > 0 || removed.size > 0 || added.length > 0;
+  const hasInvalid = added.some((a) => !a.keyValid);
+  saveBtn.disabled = !hasChanges || hasInvalid;
+  if (addBtn) addBtn.disabled = false;
+  // Don't clobber unsaved local edits with an inference.
+  inferBtn.disabled = hasChanges;
+}
+
+export function setDirty(reqId, scope, field, value) {
+  if (!dirty.has(reqId)) dirty.set(reqId, { req: {}, trace: {} });
+  dirty.get(reqId)[scope][field] = value;
+  refreshButtonStates();
+}
diff --git a/src/testPane.ts b/src/testPane.ts
index fe8dee68..5e601005 100644
--- a/src/testPane.ts
+++ b/src/testPane.ts
@@ -833,6 +833,16 @@ async function processSingleEnvData(
     );
   }
 
+  // Refresh the `vcastRequirementsAvailable` context key now that the env's
+  // descendants exist in the cache — without this, sub-node menu enablements
+  // (Generate Tests from Requirements) stay greyed even when the env has
+  // requirements. Lazy require to avoid an import cycle through
+  // requirements → testPane.
+  const {
+    updateRequirementsAvailability,
+  } = require("./requirements/availability") as typeof import("./requirements/availability");
+  updateRequirementsAvailability(enviroData.buildDirectory);
+
   // Instead of grouping, add the environment directly.
   globalController.items.delete(enviroNode.id);
   if (parentNode) {
diff --git a/src/webviewUtils.ts b/src/webviewUtils.ts
new file mode 100644
index 00000000..bfe37190
--- /dev/null
+++ b/src/webviewUtils.ts
@@ -0,0 +1,55 @@
+import * as vscode from "vscode";
+
+const path = require("path");
+const fs = require("fs");
+
+/**
+ * Generate a fresh 32-character alphanumeric nonce. Used to gate `<script>`
+ * execution in webview panels via `script-src 'nonce-…'`.
+ */
+export function getNonce(): string {
+  let text = "";
+  const chars =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  for (let i = 0; i < 32; i++) {
+    text += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return text;
+}
+
+/**
+ * Resolve the on-disk path to a webview-asset folder under `src/`.
+ *
+ * 1. Tries the normal installed-extension location: `<extensionPath>/src/<...subpath>`.
+ * 2. Falls back to the repo root when running under the E2E test harness
+ *    (`<...>/tests/internal/e2e/test/extension`): strips that suffix off
+ *    `extensionPath` and looks up `<repoRoot>/src/<...subpath>` instead.
+ * 3. Throws if neither exists.
+ *
+ * Example: `resolveWebviewBase(context, "manage", "webviews")` →
+ * `<root>/src/manage/webviews`.
+ */
+export function resolveWebviewBase(
+  context: vscode.ExtensionContext,
+  ...subpath: string[]
+): string {
+  const segments = ["src", ...subpath];
+  const normal = path.join(context.extensionPath, ...segments);
+  if (fs.existsSync(normal)) return normal;
+
+  const marker = path.join("tests", "internal", "e2e", "test", "extension");
+  const extPath = context.extensionPath;
+  const idx = extPath.indexOf(marker);
+  if (idx !== -1) {
+    const repoRoot = extPath.slice(0, idx);
+    const fallback = path.join(repoRoot, ...segments);
+    if (fs.existsSync(fallback)) return fallback;
+  }
+
+  throw new Error(
+    `Could not resolve webview base directory '${segments.join("/")}'. Tried:\n  ${normal}` +
+      (idx !== -1
+        ? `\n  ${path.join(extPath.slice(0, idx), ...segments)}`
+        : "")
+  );
+}