@codeyam/codeyam-cli 0.1.0-staging.7c30edc → 0.1.0-staging.80e493d

package/analyzer-template/.build-info.json

@@ -1,10 +1,10 @@
 {
-  "buildTimestamp": "2026-02-12T15:28:10.920Z",
-  "buildTime": 1770910090920,
-  "gitCommit": "7c30edc8b3c3c3d584502dd7762988219e5dabbb",
+  "buildTimestamp": "2026-02-23T19:24:41.178Z",
+  "buildTime": 1771874681178,
+  "gitCommit": "80e493d2d23413dae7c1ee02edb59828263fb98f",
   "nodeVersion": "v20.20.0",
-  "contentHash": "1614bacb94f772727a12f702e776ac1fe8e99792dd6cf286ea389f7c8026f245",
-  "buildNumber": 617,
-  "semanticVersion": "0.1.617",
-  "version": "0.1.617 (2026-02-12T15:28+1614bac)"
+  "contentHash": "2ecaac9a4db618717f2df27f667eaab3b8630093f73966eff1cec34d3899aca6",
+  "buildNumber": 646,
+  "semanticVersion": "0.1.646",
+  "version": "0.1.646 (2026-02-23T19:24+2ecaac9)"
 }

package/analyzer-template/log.txt

@@ -1,7 +1,7 @@
 
-[2/12/2026, 3:28:10 PM] > codeyam-combo@1.0.0 mergeDependencies
-[2/12/2026, 3:28:10 PM] > node ./scripts/mergePackageJsonFiles.cjs
+[2/23/2026, 7:24:41 PM] > codeyam-combo@1.0.0 mergeDependencies
+[2/23/2026, 7:24:41 PM] > node ./scripts/mergePackageJsonFiles.cjs
 
 
-[2/12/2026, 3:28:10 PM] Merged dependencies into root package.json
+[2/23/2026, 7:24:41 PM] Merged dependencies into root package.json
 

package/analyzer-template/package.json

@@ -7,17 +7,17 @@
     "build": "tsc && node ./scripts/postbuild.cjs"
   },
   "dependencies": {
-    "@aws-sdk/client-cloudwatch-logs": "^3.980.0",
-    "@aws-sdk/client-cloudfront": "^3.966.0",
-    "@aws-sdk/client-codebuild": "^3.948.0",
-    "@aws-sdk/client-dynamodb": "^3.956.0",
-    "@aws-sdk/client-ec2": "^3.899.0",
-    "@aws-sdk/client-ecr": "^3.948.0",
-    "@aws-sdk/client-ecs": "^3.956.0",
-    "@aws-sdk/client-s3": "^3.940.0",
-    "@aws-sdk/client-sqs": "^3.956.0",
-    "@aws-sdk/lib-storage": "^3.975.0",
-    "@aws-sdk/util-dynamodb": "^3.971.0",
+    "@aws-sdk/client-cloudwatch-logs": "^3.990.0",
+    "@aws-sdk/client-cloudfront": "^3.990.0",
+    "@aws-sdk/client-codebuild": "^3.990.0",
+    "@aws-sdk/client-dynamodb": "^3.990.0",
+    "@aws-sdk/client-ec2": "^3.990.0",
+    "@aws-sdk/client-ecr": "^3.990.0",
+    "@aws-sdk/client-ecs": "^3.990.0",
+    "@aws-sdk/client-s3": "^3.990.0",
+    "@aws-sdk/client-sqs": "^3.990.0",
+    "@aws-sdk/lib-storage": "^3.990.0",
+    "@aws-sdk/util-dynamodb": "^3.990.0",
     "@octokit/auth-app": "^8.1.0",
     "@octokit/rest": "^22.0.0",
     "@sendgrid/mail": "^8.1.4",
@@ -26,7 +26,7 @@
     "dotenv": "^17.2.3",
     "express": "^5.2.1",
     "get-port": "^7.1.0",
-    "htmlparser2": "^10.0.0",
+    "htmlparser2": "^10.1.0",
     "jest": "^30.2.0",
     "jsdom": "^27.4.0",
     "jsonc-parser": "^3.2.1",
@@ -45,7 +45,7 @@
     "yargs": "^18.0.0",
     "json5": "^2.2.3",
     "@anthropic-ai/sdk": "^0.74.0",
-    "@aws-sdk/s3-request-presigner": "^3.940.0",
+    "@aws-sdk/s3-request-presigner": "^3.990.0",
     "better-sqlite3": "^12.4.1",
     "fetch-retry": "^6.0.0",
     "kysely": "^0.28.11",

package/analyzer-template/packages/ai/index.ts

@@ -43,6 +43,7 @@ export { default as isolateScopes } from './src/lib/isolateScopes';
 export {
   default as analyzeScope,
   destroyWorkerPool,
+  skipWorkerPool,
 } from './src/lib/analyzeScope';
 export { default as logOrderedMap } from './src/lib/logOrderedMap';
 export {

package/analyzer-template/packages/ai/src/lib/analyzeScope.ts

@@ -50,6 +50,19 @@ let workerPool: Piscina<
   AnalyzeScopeWorkerOutput
 > | null = null;
 let workerPoolDestroyed = false;
+let workerPoolSkipped = false;
+
+/**
+ * Skip worker pool initialization for the current session.
+ *
+ * The worker thread creates its own ProjectAnalyzer (ts.Program), which takes
+ * 50-70s — far longer than the actual entity processing (<2s for typical batches).
+ * When the entity count is small, running analyzeScopeLocal on the main thread
+ * reuses the existing ProjectAnalyzer and avoids this overhead entirely.
+ */
+export function skipWorkerPool() {
+  workerPoolSkipped = true;
+}
 
 /**
  * Check if we're in Node.js main thread
@@ -108,6 +121,7 @@ function ensureWorkerPool() {
         'analyzeScope should not be called after data structure preparation completes.',
     );
   }
+  if (workerPoolSkipped) return;
   if (workerPool !== null) return;
 
   // Only initialize worker pool in Node.js environment

package/analyzer-template/packages/ai/src/lib/dataStructure/ScopeDataStructure.ts

@@ -3360,6 +3360,22 @@ export class ScopeDataStructure {
    * ensure all sub-paths of that variable are reflected under signature[N].
    */
   private propagateParameterToSignaturePaths(scopeNode: ScopeNode) {
+    // Helper: check if a type is a concrete scalar that cannot have sub-properties.
+    const SCALAR_TYPES = new Set([
+      'string',
+      'number',
+      'boolean',
+      'bigint',
+      'symbol',
+      'void',
+      'never',
+    ]);
+    const isDefinitelyScalar = (type: string): boolean => {
+      const parts = type.split('|').map((s) => s.trim());
+      const base = parts.filter((s) => s !== 'undefined' && s !== 'null');
+      return base.length > 0 && base.every((b) => SCALAR_TYPES.has(b));
+    };
+
     // Find variable → signature[N] equivalencies
     for (const [varName, equivalencies] of Object.entries(
       scopeNode.equivalencies,
@@ -3390,7 +3406,38 @@ export class ScopeDataStructure {
 
               // Only add if the signature path doesn't already exist
               if (!scopeNode.schema[sigKey]) {
-                scopeNode.schema[sigKey] = scopeNode.schema[key];
+                // Check if this path represents variable conflation:
+                // When a standalone variable (e.g., showWorkoutForm from useState)
+                // appears as a sub-property of a scalar-typed ancestor (e.g.,
+                // activity_type = "string"), it's from scope conflation, not real
+                // property access. Block these while allowing legitimate built-in
+                // accesses like string.length or string.slice.
+                let isConflatedPath = false;
+                let checkPos = signaturePath.length;
+                while (true) {
+                  checkPos = sigKey.indexOf('.', checkPos + 1);
+                  if (checkPos === -1) break;
+                  const ancestorPath = sigKey.substring(0, checkPos);
+                  const ancestorType = scopeNode.schema[ancestorPath];
+                  if (ancestorType && isDefinitelyScalar(ancestorType)) {
+                    // Ancestor is scalar — check if the immediate sub-property
+                    // is also a standalone variable (indicating conflation)
+                    const afterDot = sigKey.substring(checkPos + 1);
+                    const nextSep = afterDot.search(/[.\[]/);
+                    const subPropName =
+                      nextSep === -1
+                        ? afterDot
+                        : afterDot.substring(0, nextSep);
+                    if (scopeNode.schema[subPropName] !== undefined) {
+                      isConflatedPath = true;
+                      break;
+                    }
+                  }
+                }
+
+                if (!isConflatedPath) {
+                  scopeNode.schema[sigKey] = scopeNode.schema[key];
+                }
               }
             }
           }
@@ -4165,6 +4212,24 @@ export class ScopeDataStructure {
       }
     }
 
+    // Helper: check if a type is a concrete scalar that cannot have sub-properties.
+    // e.g., "string", "number | undefined", "boolean | null" are scalar.
+    // "object", "array", "function", "unknown", "Workout", etc. are NOT scalar.
+    const SCALAR_TYPES = new Set([
+      'string',
+      'number',
+      'boolean',
+      'bigint',
+      'symbol',
+      'void',
+      'never',
+    ]);
+    const isDefinitelyScalarType = (type: string): boolean => {
+      const parts = type.split('|').map((s) => s.trim());
+      const base = parts.filter((s) => s !== 'undefined' && s !== 'null');
+      return base.length > 0 && base.every((b) => SCALAR_TYPES.has(b));
+    };
+
     // Propagate nested paths from variables to their signature equivalents
     // e.g., if workouts = signature[0].workouts, then workouts[].title becomes
     // signature[0].workouts[].title
@@ -4189,7 +4254,69 @@ export class ScopeDataStructure {
 
           // Add to schema if not already present
           if (!tempScopeNode.schema[signatureKey]) {
-            tempScopeNode.schema[signatureKey] = schema[schemaKey];
+            // Check if this path represents variable conflation:
+            // When a standalone variable (e.g., showWorkoutForm from useState)
+            // appears as a sub-property of a scalar-typed ancestor (e.g.,
+            // activity_type = "string"), it's from scope conflation, not real
+            // property access. Block these while allowing legitimate built-in
+            // accesses like string.length or string.slice.
+            let isConflatedPath = false;
+            let checkPos = signaturePath.length;
+            while (true) {
+              checkPos = signatureKey.indexOf('.', checkPos + 1);
+              if (checkPos === -1) break;
+              const ancestorPath = signatureKey.substring(0, checkPos);
+              const ancestorType = tempScopeNode.schema[ancestorPath];
+              if (ancestorType && isDefinitelyScalarType(ancestorType)) {
+                // Ancestor is scalar — check if the immediate sub-property
+                // is also a standalone variable (indicating conflation)
+                const afterDot = signatureKey.substring(checkPos + 1);
+                const nextSep = afterDot.search(/[.\[]/);
+                const subPropName =
+                  nextSep === -1 ? afterDot : afterDot.substring(0, nextSep);
+                if (schema[subPropName] !== undefined) {
+                  isConflatedPath = true;
+                  break;
+                }
+              }
+            }
+
+            if (!isConflatedPath) {
+              tempScopeNode.schema[signatureKey] = schema[schemaKey];
+            }
+          }
+        }
+      }
+    }
+
+    // Post-process: filter out conflated signature paths.
+    // During phase 2 scope analysis, useState(false) conflation can create
+    // bad paths like signature[0].mockWorkouts[].activity_type.showWorkoutForm
+    // directly in scopeNode.schema. These flow through signatureInSchema into
+    // tempScopeNode.schema without any guard. Filter them out here by checking:
+    //   1. An ancestor in the path has a concrete scalar type (string, number, boolean, etc.)
+    //   2. The immediate sub-property of that scalar ancestor is also a standalone
+    //      variable in the schema (indicating conflation, not a real property access)
+    for (const key of Object.keys(tempScopeNode.schema)) {
+      if (!key.startsWith('signature[')) continue;
+
+      // Walk through the path looking for scalar-typed ancestors
+      let pos = 0;
+      while (true) {
+        pos = key.indexOf('.', pos + 1);
+        if (pos === -1) break;
+        const ancestorPath = key.substring(0, pos);
+        const ancestorType = tempScopeNode.schema[ancestorPath];
+        if (ancestorType && isDefinitelyScalarType(ancestorType)) {
+          // Found a scalar ancestor — check if the sub-property name
+          // is a standalone variable in the getSchema() result
+          const afterDot = key.substring(pos + 1);
+          const nextSep = afterDot.search(/[.\[]/);
+          const subPropName =
+            nextSep === -1 ? afterDot : afterDot.substring(0, nextSep);
+          if (schema[subPropName] !== undefined) {
+            delete tempScopeNode.schema[key];
+            break;
           }
         }
       }
@@ -4929,9 +5056,109 @@ export class ScopeDataStructure {
     // Replace cyScope placeholders in all external function call data
     // This ensures call signatures and schema paths use actual callback text
     // instead of internal cyScope names, preventing mock data merge conflicts.
-    return this.externalFunctionCalls.map((efc) =>
-      this.cleanCyScopeFromFunctionCallInfo(efc),
-    );
+    const rootScopeName = this.scopeTreeManager.getRootName();
+    const rootSchema = this.scopeNodes[rootScopeName]?.schema ?? {};
+
+    return this.externalFunctionCalls.map((efc) => {
+      const cleaned = this.cleanCyScopeFromFunctionCallInfo(efc);
+      return this.filterConflatedExternalPaths(cleaned, rootSchema);
+    });
+  }
+
+  /**
+   * Filters out conflated paths from external function call schemas.
+   *
+   * When multiple useState(false) calls create equivalency conflation during
+   * Phase 1 analysis, standalone boolean state variables (like showWorkoutForm,
+   * showGoalForm) can bleed into external function call schemas as sub-properties
+   * of unrelated data fields (like data[].activity_type.showWorkoutForm).
+   *
+   * Detection: group sub-properties by parent path. If 2+ sub-properties of
+   * the same parent all match standalone root scope variable names, treat them
+   * as conflation artifacts and remove them.
+   */
+  private filterConflatedExternalPaths(
+    efc: FunctionCallInfo,
+    rootSchema: Record<string, string>,
+  ): FunctionCallInfo {
+    // Build a set of top-level root scope variable names (simple names, no dots/brackets)
+    const topLevelRootVars = new Set<string>();
+    for (const key of Object.keys(rootSchema)) {
+      if (!key.includes('.') && !key.includes('[')) {
+        topLevelRootVars.add(key);
+      }
+    }
+
+    if (topLevelRootVars.size === 0) return efc;
+
+    // Group sub-property matches by their parent path.
+    // For a path like "...data[].activity_type.showWorkoutForm",
+    // parent = "...data[].activity_type", child = "showWorkoutForm"
+    const parentToConflatedKeys = new Map<string, string[]>();
+
+    for (const key of Object.keys(efc.schema)) {
+      const lastDot = key.lastIndexOf('.');
+      if (lastDot === -1) continue;
+
+      const parent = key.substring(0, lastDot);
+      const child = key.substring(lastDot + 1);
+
+      // Skip array access or function call patterns
+      if (child.includes('[') || child.includes('(')) continue;
+
+      // Only consider paths inside array element chains (contains []).
+      // Direct children of functionCallReturnValue are legitimate destructured
+      // return values, not conflation. Conflation happens deeper in the chain
+      // when array element fields get corrupted sub-properties.
+      if (!parent.includes('[')) continue;
+
+      if (topLevelRootVars.has(child)) {
+        if (!parentToConflatedKeys.has(parent)) {
+          parentToConflatedKeys.set(parent, []);
+        }
+        parentToConflatedKeys.get(parent)!.push(key);
+      }
+    }
+
+    // Only filter when 2+ sub-properties of the same parent match root scope vars.
+    // This threshold avoids false positives from coincidental name matches.
+    const keysToRemove = new Set<string>();
+    const parentsToRestore = new Set<string>();
+
+    for (const [parent, conflatedKeys] of parentToConflatedKeys) {
+      if (conflatedKeys.length >= 2) {
+        for (const key of conflatedKeys) {
+          keysToRemove.add(key);
+        }
+        parentsToRestore.add(parent);
+      }
+    }
+
+    if (keysToRemove.size === 0) return efc;
+
+    // Create a new schema without the conflated paths
+    const newSchema: Record<string, string> = {};
+    for (const [key, value] of Object.entries(efc.schema)) {
+      if (keysToRemove.has(key)) continue;
+
+      // Restore parent type: if it was changed to "object" because of conflated
+      // sub-properties, and now all those sub-properties are removed, change it
+      // back to "unknown" (we don't know the original type)
+      if (parentsToRestore.has(key) && value === 'object') {
+        // Check if there are any remaining sub-properties
+        const hasRemainingSubProps = Object.keys(efc.schema).some(
+          (k) =>
+            !keysToRemove.has(k) &&
+            k !== key &&
+            (k.startsWith(key + '.') || k.startsWith(key + '[')),
+        );
+        newSchema[key] = hasRemainingSubProps ? value : 'unknown';
+      } else {
+        newSchema[key] = value;
+      }
+    }
+
+    return { ...efc, schema: newSchema };
   }
 
   /**

package/analyzer-template/packages/ai/src/lib/dataStructure/helpers/convertDotNotation.ts

@@ -14,35 +14,46 @@ const isStandaloneIndex = (s?: string) => !!s && STANDALONE_INDEX_RE.test(s);
 // The regex matches any path ending with .length that has [] somewhere before it
 const DYNAMIC_LENGTH_RE = /\[\].*\.length$/;
 
-// Treat these as structural placeholders (don't commit them as concrete leaves)
-function isSkippableLeafType(t: string) {
-  // 'unknown' by itself is a placeholder (but 'boolean | unknown' is not)
-  // Also handles optional variants like 'object | undefined', 'object | null',
-  // 'array | undefined', etc. — these are still structural placeholders that
-  // should not overwrite already-populated structures.
+// Cache for type string analysis to avoid repeated split/filter operations.
+// These functions are called multiple times per path segment across thousands of paths.
+const typeAnalysisCache = new Map<
+  string,
+  { isSkippable: boolean; baseType: string; isNullable: boolean }
+>();
+
+function getTypeAnalysis(t: string) {
+  const cached = typeAnalysisCache.get(t);
+  if (cached) return cached;
   const parts = t.split('|').map((s) => s.trim());
   const base = parts.filter((s) => s !== 'undefined' && s !== 'null');
-  return (
-    base.length === 1 &&
-    (base[0] === 'object' ||
-      base[0] === 'array' ||
-      base[0] === 'function' ||
-      base[0] === 'unknown')
-  );
+  const result = {
+    isSkippable:
+      base.length === 1 &&
+      (base[0] === 'object' ||
+        base[0] === 'array' ||
+        base[0] === 'function' ||
+        base[0] === 'unknown'),
+    baseType: base[0],
+    isNullable: parts.includes('undefined') || parts.includes('null'),
+  };
+  typeAnalysisCache.set(t, result);
+  return result;
+}
+
+// Treat these as structural placeholders (don't commit them as concrete leaves)
+function isSkippableLeafType(t: string) {
+  return getTypeAnalysis(t).isSkippable;
 }
 
 // Extract the base structural type from a potentially nullable type string.
 // e.g., 'object | undefined' → 'object', 'array | null' → 'array'
 function getBaseSkippableType(t: string): string {
-  const parts = t.split('|').map((s) => s.trim());
-  const base = parts.filter((s) => s !== 'undefined' && s !== 'null');
-  return base[0];
+  return getTypeAnalysis(t).baseType;
 }
 
 // Check if a type string has nullable annotations (| undefined or | null)
 function isNullableType(t: string): boolean {
-  const parts = t.split('|').map((s) => s.trim());
-  return parts.includes('undefined') || parts.includes('null');
+  return getTypeAnalysis(t).isNullable;
 }
 
 // Matches paths containing [][] — e.g., "items[][]" or "items[][].text"

package/analyzer-template/packages/ai/src/lib/dataStructure/helpers/stripNullableMarkers.ts

@@ -0,0 +1,35 @@
+/**
+ * Recursively strips `_nullable` keys from LLM-generated mock data.
+ *
+ * The `_nullable` marker is an internal CodeYam concept used in type definitions
+ * to indicate that a field can be null/undefined. The LLM sometimes includes
+ * these markers in its generated scenario data, which causes runtime errors
+ * when code iterates over object keys (e.g., `Object.keys(importedBy)` picks
+ * up `_nullable` as a key alongside real data).
+ *
+ * This function mutates the input object in-place, consistent with other
+ * post-processing helpers like `convertNullToUndefinedBySchema`.
+ */
+export default function stripNullableMarkers(
+  data: Record<string, unknown>,
+): void {
+  if (data == null || typeof data !== 'object') return;
+
+  // Delete _nullable from this level
+  if ('_nullable' in data) {
+    delete data._nullable;
+  }
+
+  // Recurse into nested objects and arrays
+  for (const value of Object.values(data)) {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item !== null && typeof item === 'object' && !Array.isArray(item)) {
+          stripNullableMarkers(item as Record<string, unknown>);
+        }
+      }
+    } else if (value !== null && typeof value === 'object') {
+      stripNullableMarkers(value as Record<string, unknown>);
+    }
+  }
+}

package/analyzer-template/packages/ai/src/lib/dataStructureChunking.ts

@@ -4,10 +4,10 @@ import type { ExecutionFlow, ScenariosDataStructure } from '~codeyam/types';
 type RequiredValue = NonNullable<ExecutionFlow['requiredValues']>[number];
 
 const DEFAULT_MAX_CHUNK_SIZE = 10_000; // ~10K chars per chunk
+const DEFAULT_MAX_KEYS_PER_CHUNK = 20;
 
 export interface ChunkOptions {
   maxChunkSize?: number;
-  /** @deprecated Use maxChunkSize instead. Kept for backward compatibility in tests. */
   maxKeysPerChunk?: number;
 }
 
@@ -33,16 +33,19 @@ export function chunkDataStructure(
     return [dataForMocks];
   }
 
-  const { maxChunkSize = DEFAULT_MAX_CHUNK_SIZE } = options;
+  const {
+    maxChunkSize = DEFAULT_MAX_CHUNK_SIZE,
+    maxKeysPerChunk = DEFAULT_MAX_KEYS_PER_CHUNK,
+  } = options;
   const keys = Object.keys(dataForMocks);
 
   // Calculate total size to see if chunking is needed
   const totalSize = JSON.stringify(dataForMocks).length;
-  if (totalSize <= maxChunkSize) {
+  if (totalSize <= maxChunkSize && keys.length <= maxKeysPerChunk) {
     return [dataForMocks];
   }
 
-  // Greedily pack keys into chunks by cumulative size
+  // Greedily pack keys into chunks by cumulative size and key count
   const chunks: Array<ScenariosDataStructure['dataForMocks']> = [];
   let currentChunk: Record<string, unknown> = {};
   let currentSize = 0;
@@ -52,8 +55,14 @@ export function chunkDataStructure(
       (dataForMocks as Record<string, unknown>)[key],
     ).length;
 
-    // If adding this key would exceed the limit AND chunk isn't empty, start a new chunk
-    if (currentSize > 0 && currentSize + keySize > maxChunkSize) {
+    const currentKeyCount = Object.keys(currentChunk).length;
+
+    // If adding this key would exceed size or key count limit AND chunk isn't empty, start a new chunk
+    if (
+      currentSize > 0 &&
+      (currentSize + keySize > maxChunkSize ||
+        currentKeyCount >= maxKeysPerChunk)
+    ) {
       chunks.push(currentChunk as ScenariosDataStructure['dataForMocks']);
       currentChunk = {};
       currentSize = 0;

package/analyzer-template/packages/ai/src/lib/generateExecutionFlows.ts

@@ -32,6 +32,30 @@ import resolvePathToControllable from './resolvePathToControllable';
 import { AI } from '~codeyam/ai';
 import type { JsxRenderingUsage, ConditionalUsage } from './astScopes/types';
 
+/**
+ * Patterns that indicate a child component is a modal/overlay/blocking element.
+ * Same patterns used in generateExecutionFlowsFromConditionalEffects.ts for
+ * state variable names — here applied to child component names.
+ */
+const BLOCKING_CHILD_PATTERNS = [
+  /modal/i,
+  /overlay/i,
+  /dialog/i,
+  /popup/i,
+  /drawer/i,
+  /sheet/i,
+  /lightbox/i,
+  /backdrop/i,
+];
+
+/**
+ * Check if a child component name suggests it's a blocking/modal element.
+ * Exported for testing.
+ */
+export function isBlockingChildComponent(componentName: string): boolean {
+  return BLOCKING_CHILD_PATTERNS.some((pattern) => pattern.test(componentName));
+}
+
 interface GenerateExecutionFlowsArgs {
   entity: Pick<Entity, 'sha' | 'name' | 'filePath' | 'code' | 'metadata'>;
   mergedDataStructure: Omit<DataStructure, 'equivalentSignatureVariables'>;
@@ -273,6 +297,11 @@ export default function generateExecutionFlows({
     calculateFlowPriority(flow, gatingPathToChildren);
   }
 
+  // Assign exclusiveGroup for truthy/falsy flow pairs that control child components.
+  // When the same gating path produces both a truthy flow (show component) and a
+  // falsy flow (hide component), they are mutually exclusive and should be grouped.
+  assignExclusiveGroupsForGatingPairs(allFlows);
+
   // Sort flows by priority (highest first)
   allFlows.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
 
@@ -361,6 +390,60 @@ function buildGatingPathToChildrenMap(
   return gatingPathToChildren;
 }
 
+/**
+ * Assign exclusiveGroup for truthy/falsy flow pairs that control child components.
+ *
+ * When the same attribute path produces both a truthy and falsy flow (e.g.,
+ * {diffView && <DiffModal/>}), they are mutually exclusive — only one can be
+ * active at a time. Grouping them ensures the scenario generator treats them
+ * as alternative states rather than combining them.
+ */
+function assignExclusiveGroupsForGatingPairs(flows: ExecutionFlow[]): void {
+  // Build a map: attributePath -> flows with truthy or falsy comparison for that path
+  const pathToFlows = new Map<
+    string,
+    { truthy: ExecutionFlow[]; falsy: ExecutionFlow[] }
+  >();
+
+  for (const flow of flows) {
+    // Only consider flows that control child components
+    if (!flow.childComponentsControlled?.length) continue;
+
+    for (const rv of flow.requiredValues) {
+      if (rv.comparison === 'truthy' || rv.comparison === 'falsy') {
+        if (!pathToFlows.has(rv.attributePath)) {
+          pathToFlows.set(rv.attributePath, { truthy: [], falsy: [] });
+        }
+        pathToFlows.get(rv.attributePath)![rv.comparison].push(flow);
+      }
+    }
+  }
+
+  // Also check falsy flows that DON'T have childComponentsControlled —
+  // they still pair with truthy flows that do
+  for (const flow of flows) {
+    if (flow.childComponentsControlled?.length) continue; // Already processed
+
+    for (const rv of flow.requiredValues) {
+      if (rv.comparison === 'falsy' && pathToFlows.has(rv.attributePath)) {
+        pathToFlows.get(rv.attributePath)!.falsy.push(flow);
+      }
+    }
+  }
+
+  // Assign exclusiveGroup where both truthy and falsy flows exist
+  for (const [attributePath, { truthy, falsy }] of pathToFlows) {
+    if (truthy.length > 0 && falsy.length > 0) {
+      const groupName = `gating:${attributePath}`;
+      for (const flow of [...truthy, ...falsy]) {
+        if (!flow.exclusiveGroup) {
+          flow.exclusiveGroup = groupName;
+        }
+      }
+    }
+  }
+}
+
 /**
  * Calculate priority and childComponentsControlled for a flow.
  *
@@ -415,6 +498,19 @@ function calculateFlowPriority(
     if (flow.impact !== 'high') {
       flow.impact = 'high';
     }
+
+    // Check if any controlled child component is a modal/dialog/overlay.
+    // Only truthy flows (which SHOW the component) should be marked as blocking.
+    // Falsy flows (which HIDE the component) should not be blocking.
+    const isTruthyFlow = flow.requiredValues.some(
+      (rv) => rv.comparison === 'truthy' || rv.comparison === 'equals',
+    );
+    if (
+      isTruthyFlow &&
+      Array.from(childComponentsControlled).some(isBlockingChildComponent)
+    ) {
+      flow.blocksOtherFlows = true;
+    }
   }
 
   // Calculate priority score