@contentful/experience-design-system-cli 2.34.5-dev-build-a95aeeba.0 → 2.34.5-dev-build-f8f0b1fa.0

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.34.5-dev-build-a95aeeba.0",
+  "version": "2.34.5-dev-build-f8f0b1fa.0",
   "description": "Contentful Experiences design system import CLI",
   "license": "MIT",
   "type": "module",

package/dist/src/index.js

@@ -781,7 +781,7 @@ function renderTokenCandidateSection(kind, entries) {
 ${formatTokenCandidateLines(entries)}`;
 }
 function buildPreamble(options) {
-  const { skill, rawComponentsInline, rawTokensInline, rawTokensFilename, tokensInline, tokenMapInline, generatedCdf, tokenTree, componentSourceRefs, existingComponentsInline, existingTokensInline } = options;
+  const { skill, rawComponentsInline, rawTokensInline, rawTokensFilename, tokensInline, tokenMapInline, generatedCdf, tokenTree, componentSourceRefs, existingComponentsInline, existingTokensInline, componentAllowlistInline } = options;
   const sections = [];
   if (existingComponentsInline) {
     sections.push(`Existing components in the target Contentful space (JSON) \u2014 use for alignment, not as a hard filter:
@@ -793,6 +793,12 @@ ${existingComponentsInline}
     sections.push(`Existing design tokens in the target Contentful space (JSON) \u2014 prefer binding to these paths over inventing new ones:
 \`\`\`json
 ${existingTokensInline}
+\`\`\``);
+  }
+  if (componentAllowlistInline) {
+    sections.push(`Known component names for slot allowed_components (hard allowlist; never use any other name):
+\`\`\`json
+${componentAllowlistInline}
 \`\`\``);
   }
   if (rawComponentsInline) {
@@ -935,6 +941,7 @@ Rules:
 - Q2: is the value written straight into a style or attribute (\`rx={radius}\`, \`padding: \${padding}\`)? no \u2192 not \`token\`, apply the type rules.
 - Q3: is there a design-token reference at that use \u2014 a \`tokens.*\` parameter default, a \`tokenReference\`, an inline \`tokens.*\` / \`var(--*)\`? yes \u2192 \`token\` (cite both lines in "reason"); no \u2192 \`string\`. "Ambiguity resolves to \`enum\`" applies only when Q1\u2013Q3 cannot be answered from the source shown.
 - CSS design props (className, style, styles, positional/geometric props: top, bottom, left, right, rotation, offset, etc.) \u2192 classify_prop, cdf_type: "string", cdf_category: "design".
+- For \`classify_slot.allowed_components\`, use only exact names from the hard allowlist provided below. Never invent a child from an import, JSX element, type name, icon name, or implementation helper; if a child is not listed, omit it.
 - On classify_component, "rationale" fields are operator-facing (read-only) but may surface in customer-facing exports. The "rationale.description" field is subject to the description content rules in the skill prompt (no internal initiative names). "rationale.props" and "rationale.slots" describe your reasoning about scope; "classify_slot.rationale" explains why each slot was kept.
 - On classify_prop, "reason" is REQUIRED and is the LLM's internal rationale \u2014 shown to the developer reviewing the import, never to end-users. "description" is the customer-facing copy and is subject to the description content rules in the skill prompt. Keep them distinct: "description" is short and customer-facing; "reason" explains your reasoning in detail.
 - You may emit prose lines (not starting with {) anywhere \u2014 they are ignored by the parser and serve as your reasoning log.`;
@@ -2514,7 +2521,7 @@ function loadComponentRationale(db, sessionId2, componentName) {
     }))
   };
 }
-function applyToolCalls(db, sessionId2, componentId, componentName, calls, incomingWarnings) {
+function applyToolCalls(db, sessionId2, componentId, componentName, calls, incomingWarnings, options = {}) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const warnings = [...incomingWarnings];
   let classified = 0;
@@ -2649,9 +2656,18 @@ function applyToolCalls(db, sessionId2, componentId, componentName, calls, incom
         }
         if (call.allowed_components !== void 0) {
           deleteAllowedComponents.run(sessionId2, componentId, call.slot);
-          call.allowed_components.forEach(
-            (ac, i) => insertAllowedComponent.run(sessionId2, componentId, call.slot, ac, i)
-          );
+          const allowedComponents = options.allowedComponentNames ? call.allowed_components.filter((allowedComponent) => options.allowedComponentNames.has(allowedComponent)) : call.allowed_components;
+          if (options.allowedComponentNames) {
+            const dropped = [
+              ...new Set(call.allowed_components.filter((ac) => !options.allowedComponentNames.has(ac)))
+            ];
+            for (const allowedComponent of dropped) {
+              warnings.push(
+                `${componentName}: classify_slot '${call.slot}' \u2014 dropped unknown allowed component '${allowedComponent}'`
+              );
+            }
+          }
+          allowedComponents.forEach((ac, i) => insertAllowedComponent.run(sessionId2, componentId, call.slot, ac, i));
         }
         slots++;
       }
@@ -3201,9 +3217,7 @@ function storeCDFComponents(db, sessionId2, components) {
           }
         }
         const existingDefaults = new Map(
-          readExistingSlotDefaults.all(sessionId2, componentId).map(
-            (r) => [r.name, r.is_default]
-          )
+          readExistingSlotDefaults.all(sessionId2, componentId).map((r) => [r.name, r.is_default])
         );
         deleteSlotAllowedComponents.run(sessionId2, componentId);
         deleteSlots.run(sessionId2, componentId);
@@ -3640,7 +3654,41 @@ function loadSlotCycles(db, sessionId2) {
     suggestedBreak: r.suggested_break_json ? JSON.parse(r.suggested_break_json) : null
   }));
 }
-function copyComponentFromCache(db, sourceSessionId, targetSessionId, componentId, manageTransaction = true) {
+function findUnknownSlotAllowedComponents(db, sessionId2, allowedComponentNames2, componentId) {
+  const rows = db.prepare(
+    `SELECT a.component_id, c.name AS component_name, a.slot_name, a.allowed_component
+       FROM raw_slot_allowed_components a
+       JOIN raw_components c ON c.session_id = a.session_id AND c.component_id = a.component_id
+       WHERE a.session_id = ? AND (? IS NULL OR a.component_id = ?)
+       ORDER BY a.component_id, a.slot_name, a.position`
+  ).all(sessionId2, componentId ?? null, componentId ?? null);
+  return rows.filter((row) => !allowedComponentNames2.has(row.allowed_component)).map((row) => ({
+    componentId: row.component_id,
+    componentName: row.component_name,
+    slotName: row.slot_name,
+    allowedComponent: row.allowed_component
+  }));
+}
+function filterUnknownSlotAllowedComponents(db, sessionId2, allowedComponentNames2) {
+  const unknown = findUnknownSlotAllowedComponents(db, sessionId2, allowedComponentNames2);
+  if (unknown.length === 0) return unknown;
+  db.exec("BEGIN");
+  try {
+    const remove = db.prepare(
+      `DELETE FROM raw_slot_allowed_components
+       WHERE session_id = ? AND component_id = ? AND slot_name = ? AND allowed_component = ?`
+    );
+    for (const row of unknown) {
+      remove.run(sessionId2, row.componentId, row.slotName, row.allowedComponent);
+    }
+    db.exec("COMMIT");
+  } catch (e) {
+    db.exec("ROLLBACK");
+    throw e;
+  }
+  return unknown;
+}
+function copyComponentFromCache(db, sourceSessionId, targetSessionId, componentId, manageTransaction = true, options = {}) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   if (manageTransaction) db.exec("BEGIN");
   try {
@@ -3714,7 +3762,8 @@ function copyComponentFromCache(db, sourceSessionId, targetSessionId, componentI
     const insertSAC = db.prepare(
       `INSERT INTO raw_slot_allowed_components (session_id, component_id, slot_name, allowed_component, position) VALUES (?, ?, ?, ?, ?)`
     );
-    for (const sac of srcSAC) {
+    const allowedSAC = options.allowedComponentNames ? srcSAC.filter((sac) => options.allowedComponentNames.has(sac.allowed_component)) : srcSAC;
+    for (const sac of allowedSAC) {
       insertSAC.run(targetSessionId, componentId, sac.slot_name, sac.allowed_component, sac.position);
     }
     db.prepare("UPDATE sessions SET updated_at = ? WHERE id = ?").run(now, targetSessionId);
@@ -3724,12 +3773,12 @@ function copyComponentFromCache(db, sourceSessionId, targetSessionId, componentI
     throw e;
   }
 }
-function copyComponentsFromCache(db, entries) {
+function copyComponentsFromCache(db, entries, options = {}) {
   if (entries.length === 0) return;
   db.exec("BEGIN");
   try {
     for (const entry of entries) {
-      copyComponentFromCache(db, entry.sourceSessionId, entry.targetSessionId, entry.componentId, false);
+      copyComponentFromCache(db, entry.sourceSessionId, entry.targetSessionId, entry.componentId, false, options);
     }
     db.exec("COMMIT");
   } catch (e) {
@@ -4873,7 +4922,7 @@ function printFallbackInstructions(options) {
   lines.push(`  Re-run the generate command with the agent available, or use --dry-run to inspect the prompt.`);
   process.stderr.write(lines.join("\n") + "\n");
 }
-function cachedComponentResult(componentName, warnings = []) {
+function createCachedComponentResult(componentName, warnings = []) {
   return {
     componentName,
     classified: 0,
@@ -4885,6 +4934,31 @@ function cachedComponentResult(componentName, warnings = []) {
     renamedSlotsCount: 0
   };
 }
+async function showGenerateView(result) {
+  if (process.stdout.isTTY) {
+    const { waitUntilExit } = renderWithGoodbye(
+      createElement(GenerateView, {
+        result,
+        onExit: () => void exitWithAnalytics(0)
+      })
+    );
+    await waitUntilExit();
+    return;
+  }
+  process.stdout.write(
+    `generate complete
+skill: ${result.skill}
+agent: ${result.agent}
+session=${result.sessionId}
+`
+  );
+  await exitWithAnalytics(0);
+}
+function writeCachedComponentStatus(position, componentName, pinned) {
+  const status = pinned ? c.cyan("pinned (human-edited)") : c.green("cached");
+  process.stderr.write(`  ${position}  ${c.bold(componentName)}  ${status}
+`);
+}
 function normalizeComponentForCache(component) {
   const slots = component.slots.map((slot, index, allSlots) => ({
     ...slot,
@@ -4900,13 +4974,32 @@ function lookupComponentCache(db, component, promptHash) {
   const legacyInputHash = hashComponentShape(component);
   return legacyInputHash === inputHash ? null : lookupCache(db, legacyInputHash, "component", component.component_id, promptHash);
 }
-function resolveComponentCache(db, component, promptHash) {
+function resolveComponentCache(db, component, promptHash, allowedComponentNames2) {
   const cached = lookupComponentCache(db, component, promptHash);
-  if (cached) return { entry: cached, humanEdited: cached.humanEdited };
+  if (cached && findUnknownSlotAllowedComponents(db, cached.sourceSessionId, allowedComponentNames2, component.component_id).length === 0) {
+    return { entry: cached, humanEdited: cached.humanEdited };
+  }
   const pinned = lookupCacheByEntity(db, "component", component.component_id);
-  return pinned?.humanEdited ? { entry: pinned, humanEdited: true } : null;
+  return pinned?.humanEdited && findUnknownSlotAllowedComponents(db, pinned.sourceSessionId, allowedComponentNames2, component.component_id).length === 0 ? { entry: pinned, humanEdited: true } : null;
 }
-async function runOneComponent(agent, model, db, sessionId2, component, tokensInline, tokenMapInline, index, total, verbose, noCache, skillPathOverride, skillContentOverride, promptHash, existingContentfulEntities, existingTokensInline, precomputedCachedNames) {
+async function runOneComponent(options, component, index, total) {
+  const {
+    agent,
+    model,
+    db,
+    sessionId: sessionId2,
+    tokensInline,
+    tokenMapInline,
+    verbose,
+    noCache,
+    skillPathOverride,
+    skillContentOverride,
+    promptHash,
+    existingContentfulEntities,
+    existingTokensInline,
+    precomputedCachedNames,
+    allowedComponentNames: allowedComponentNames2
+  } = options;
   const pos = c.dim(`[${index + 1}/${total}]`);
   const { renames, warnings: renameWarnings } = renameEmptySlots(
     db,
@@ -4922,17 +5015,25 @@ async function runOneComponent(agent, model, db, sessionId2, component, tokensIn
     for (const w of renameWarnings) process.stderr.write(`  ${c.yellow("\u26A0")}  ${w}
 `);
   }
+  effectiveSlots = effectiveSlots.map((slot) => {
+    if (!slot.allowedComponents) return slot;
+    return {
+      ...slot,
+      allowedComponents: slot.allowedComponents.filter((name) => allowedComponentNames2.has(name))
+    };
+  });
   const cacheComponent = normalizeComponentForCache(component);
   if (!noCache && precomputedCachedNames.has(component.name)) {
-    process.stderr.write(`  ${pos}  ${c.bold(component.name)}  ${c.green("cached")}
-`);
-    return cachedComponentResult(component.name);
+    writeCachedComponentStatus(pos, component.name, false);
+    return createCachedComponentResult(component.name);
   }
   if (!noCache) {
     const inputHash = hashComponentShape(cacheComponent);
-    const resolution = resolveComponentCache(db, component, promptHash);
+    const resolution = resolveComponentCache(db, component, promptHash, allowedComponentNames2);
     if (resolution && !resolution.humanEdited) {
-      copyComponentFromCache(db, resolution.entry.sourceSessionId, sessionId2, component.component_id);
+      copyComponentFromCache(db, resolution.entry.sourceSessionId, sessionId2, component.component_id, true, {
+        allowedComponentNames: allowedComponentNames2
+      });
       storeCache(
         db,
         inputHash,
@@ -4942,15 +5043,17 @@ async function runOneComponent(agent, model, db, sessionId2, component, tokensIn
         resolution.entry.humanEdited,
         promptHash
       );
-      process.stderr.write(`  ${pos}  ${c.bold(component.name)}  ${c.green("cached")}
-`);
-      return cachedComponentResult(component.name);
+      writeCachedComponentStatus(pos, component.name, false);
+      return createCachedComponentResult(component.name);
     }
     if (resolution?.humanEdited) {
-      copyComponentFromCache(db, resolution.entry.sourceSessionId, sessionId2, component.component_id);
-      process.stderr.write(`  ${pos}  ${c.bold(component.name)}  ${c.cyan("pinned (human-edited)")}
-`);
-      return cachedComponentResult(component.name, [`${component.name}: source changed but human edits preserved`]);
+      copyComponentFromCache(db, resolution.entry.sourceSessionId, sessionId2, component.component_id, true, {
+        allowedComponentNames: allowedComponentNames2
+      });
+      writeCachedComponentStatus(pos, component.name, true);
+      return createCachedComponentResult(component.name, [
+        `${component.name}: source changed but human edits preserved`
+      ]);
     }
   }
   const rawComponentsInline = JSON.stringify(
@@ -4985,7 +5088,8 @@ async function runOneComponent(agent, model, db, sessionId2, component, tokensIn
     skillPathOverride,
     skillContentOverride,
     existingComponentsInline,
-    existingTokensInline
+    existingTokensInline,
+    componentAllowlistInline: JSON.stringify([...allowedComponentNames2].sort())
   });
   const maxAttempts = 2;
   let lastError = "";
@@ -5020,7 +5124,9 @@ ${outputBuf}`);
       lastError = describeAgentFailure(result);
       continue;
     }
-    const applied = applyToolCalls(db, sessionId2, component.component_id, component.name, calls, warnings);
+    const applied = applyToolCalls(db, sessionId2, component.component_id, component.name, calls, warnings, {
+      allowedComponentNames: allowedComponentNames2
+    });
     if (!noCache) {
       const inputHash = hashComponentShape(cacheComponent);
       storeCache(db, inputHash, "component", component.component_id, sessionId2, false, promptHash);
@@ -5046,7 +5152,7 @@ ${outputBuf}`);
     renamedSlotsCount: renames.length
   };
 }
-async function runAllComponents(agent, model, db, sessionId2, components, tokensInline, tokenMapInline, verbose, noCache, skillPathOverride, skillContentOverride, promptHash, existingContentfulEntities, existingTokensInline, precomputedCachedNames) {
+async function runAllComponents(options, components) {
   const concurrency = Number(process.env.EDS_GENERATE_CONCURRENCY ?? DEFAULT_COMPONENT_CONCURRENCY);
   process.stderr.write(
     `Categorizing ${c.bold(String(components.length))} component${components.length === 1 ? "" : "s"}` + c.dim(`  (concurrency: ${concurrency})`) + "\n"
@@ -5057,25 +5163,7 @@ async function runAllComponents(agent, model, db, sessionId2, components, tokens
   async function worker() {
     while (next < components.length) {
       const i = next++;
-      results[i] = await runOneComponent(
-        agent,
-        model,
-        db,
-        sessionId2,
-        components[i],
-        tokensInline,
-        tokenMapInline,
-        i,
-        components.length,
-        verbose,
-        noCache,
-        skillPathOverride,
-        skillContentOverride,
-        promptHash,
-        existingContentfulEntities,
-        existingTokensInline,
-        precomputedCachedNames
-      );
+      results[i] = await runOneComponent(options, components[i], i, components.length);
       completed += 1;
       process.stderr.write(`${formatGenerateProgressLine(completed, components.length, results[i].componentName)}
 `);
@@ -5177,6 +5265,7 @@ async function runGenerateSkill(skill, opts, verbose = false) {
   }
   let sessionId2;
   let allComponents;
+  let allowedComponentNames2;
   if (skill === "components") {
     sessionId2 = await resolveSessionId(opts.session);
     await bindAnalyticsSessionId(sessionId2);
@@ -5190,6 +5279,27 @@ async function runGenerateSkill(skill, opts, verbose = false) {
     if (allComponents.length === 0) {
       die(`Error: session '${sessionId2}' has no raw components. Run analyze extract first.`);
     }
+    allowedComponentNames2 = /* @__PURE__ */ new Set([
+      ...allComponents.map((component) => component.name),
+      ...(existingContentfulEntities?.components ?? []).map((component) => component.name)
+    ]);
+    if (!opts.dryRun) {
+      const dbForReferences = openPipelineDb();
+      try {
+        const dropped = filterUnknownSlotAllowedComponents(dbForReferences, sessionId2, allowedComponentNames2);
+        for (const reference of dropped) {
+          process.stderr.write(
+            `Warning: ${reference.componentName}: slot '${reference.slotName}' \u2014 dropped unknown allowed component '${reference.allowedComponent}'
+`
+          );
+        }
+        if (dropped.length > 0) {
+          allComponents = loadRawComponents(dbForReferences, sessionId2, acceptedNames ?? void 0);
+        }
+      } finally {
+        dbForReferences.close();
+      }
+    }
     if (acceptedNames) {
       process.stderr.write(`Scope: ${allComponents.length} accepted component(s) from analyze select
 `);
@@ -5249,7 +5359,8 @@ async function runGenerateSkill(skill, opts, verbose = false) {
       skillPathOverride: generatePromptPath,
       skillContentOverride: generatePrompt,
       existingComponentsInline: dryRunExistingComponentsInline,
-      existingTokensInline: skill === "components" ? existingTokensInline : void 0
+      existingTokensInline: skill === "components" ? existingTokensInline : void 0,
+      componentAllowlistInline: skill === "components" && allowedComponentNames2 ? JSON.stringify([...allowedComponentNames2].sort()) : void 0
     });
     process.stdout.write(prompt + "\n");
     await exitWithAnalytics(0);
@@ -5281,7 +5392,7 @@ async function runGenerateSkill(skill, opts, verbose = false) {
       if (opts.cacheStatus) {
         const cacheEnabled = opts.cache !== false && process.env.EDS_NO_CACHE !== "1";
         const cachedComponents = cacheEnabled ? allComponents.flatMap((component) => {
-          const resolution = resolveComponentCache(db, component, promptHash);
+          const resolution = resolveComponentCache(db, component, promptHash, allowedComponentNames2);
           return resolution ? [{ component, resolution }] : [];
         }) : [];
         if (cacheEnabled && opts.restoreCache) {
@@ -5301,7 +5412,7 @@ async function runGenerateSkill(skill, opts, verbose = false) {
             });
             rekeyed.push({ component, cached: resolution.entry });
           }
-          copyComponentsFromCache(db, restorations);
+          copyComponentsFromCache(db, restorations, { allowedComponentNames: allowedComponentNames2 });
           storeCaches(
             db,
             rekeyed.map(({ component, cached }) => ({
@@ -5325,21 +5436,24 @@ async function runGenerateSkill(skill, opts, verbose = false) {
         return;
       }
       componentResults = await runAllComponents(
-        agent,
-        model,
-        db,
-        sessionId2,
-        allComponents,
-        tokensInline,
-        tokenMapInline,
-        verbose,
-        opts.cache === false || process.env.EDS_NO_CACHE === "1",
-        generatePromptPath,
-        generatePrompt,
-        promptHash,
-        existingContentfulEntities,
-        existingTokensInline,
-        precomputedCachedNames
+        {
+          agent,
+          model,
+          db,
+          sessionId: sessionId2,
+          tokensInline,
+          tokenMapInline,
+          verbose,
+          noCache: opts.cache === false || process.env.EDS_NO_CACHE === "1",
+          skillPathOverride: generatePromptPath,
+          skillContentOverride: generatePrompt,
+          promptHash,
+          existingContentfulEntities,
+          existingTokensInline,
+          precomputedCachedNames,
+          allowedComponentNames: allowedComponentNames2
+        },
+        allComponents
       );
     } finally {
       db.close();
@@ -5414,20 +5528,7 @@ async function runGenerateSkill(skill, opts, verbose = false) {
 `
           );
           db.close();
-          const viewResult2 = { skill, agent, sessionId: sessionId2 ?? "" };
-          if (process.stdout.isTTY) {
-            const { waitUntilExit } = renderWithGoodbye(
-              createElement(GenerateView, { result: viewResult2, onExit: () => void exitWithAnalytics(0) })
-            );
-            await waitUntilExit();
-          } else {
-            process.stdout.write(`generate complete
-skill: ${skill}
-agent: ${agent}
-session=${sessionId2}
-`);
-            await exitWithAnalytics(0);
-          }
+          await showGenerateView({ skill, agent, sessionId: sessionId2 ?? "" });
           return;
         }
       }
@@ -5483,27 +5584,7 @@ ${tokenWarnings.map((w) => `  ${w}`).join("\n")}
       db.close();
     }
   }
-  const viewResult = {
-    skill,
-    agent,
-    sessionId: sessionId2 ?? ""
-  };
-  if (process.stdout.isTTY) {
-    const { waitUntilExit } = renderWithGoodbye(
-      createElement(GenerateView, {
-        result: viewResult,
-        onExit: () => void exitWithAnalytics(0)
-      })
-    );
-    await waitUntilExit();
-  } else {
-    process.stdout.write(`generate complete
-skill: ${skill}
-agent: ${agent}
-session=${sessionId2 ?? ""}
-`);
-    await exitWithAnalytics(0);
-  }
+  await showGenerateView({ skill, agent, sessionId: sessionId2 ?? "" });
 }
 function addAgentFlags(cmd) {
   return addAgentModelOptions(cmd).option("--verbose", "Show full agent output including reasoning text").option("--dry-run", "Print the prompt without invoking the agent").option(
@@ -11253,30 +11334,26 @@ function getTsxExtractionContext(filePaths, componentFilePattern) {
     project: createTsxProject(getTsxProjectFiles(filePaths))
   };
 }
-function extractTsxComponents(filePaths, componentFilePattern, extractSourceFile) {
+function extractTsxComponents(filePaths, componentFilePattern, extract) {
   const extractionContext = getTsxExtractionContext(filePaths, componentFilePattern);
-  if (!extractionContext)
-    return void 0;
-  const warnings = [];
+  if (!extractionContext) {
+    return { components: [], warnings: [], exclusions: [] };
+  }
+  const { componentFiles, project } = extractionContext;
   const components = [];
-  for (const filePath of extractionContext.componentFiles) {
+  const warnings = [];
+  const exclusions = [];
+  for (const filePath of componentFiles) {
     try {
-      const sourceFile = extractionContext.project.getSourceFile(filePath);
+      const sourceFile = project.getSourceFile(filePath);
       if (!sourceFile)
         continue;
-      components.push(...extractSourceFile(sourceFile));
+      components.push(...extract(sourceFile, exclusions));
     } catch (e) {
       warnings.push(`Failed to extract from ${filePath}: ${e instanceof Error ? e.message : String(e)}`);
     }
   }
-  return { ...extractionContext, components, warnings };
-}
-function resolveComponentExportName(exportKey, declarations, exported, allowVariableDeclaration = false) {
-  const name = exportKey === "default" ? resolveDefaultExportName(declarations, exported, allowVariableDeclaration) : exportKey;
-  return name && /^[A-Z]/.test(name) ? name : void 0;
-}
-function isCompositionHookName(name) {
-  return name.startsWith("use");
+  return { components, warnings, exclusions, project };
 }
 function resolveDefaultExportName(declarations, exported, allowVariableDeclaration = false) {
   const declaration = declarations[0];
@@ -11285,6 +11362,27 @@ function resolveDefaultExportName(declarations, exported, allowVariableDeclarati
     return void 0;
   return name;
 }
+function getRenderableExports(sourceFile, exclusions, options) {
+  const renderable = [];
+  const exported = sourceFile.getExportedDeclarations();
+  for (const [exportKey, declarations] of exported) {
+    const name = exportKey === "default" ? resolveDefaultExportName(declarations, exported, options.allowVariableDeclaration) : exportKey;
+    if (!name || !/^[A-Z]/.test(name))
+      continue;
+    if (name.startsWith("use")) {
+      exclusions.push({
+        itemType: "component",
+        name,
+        source: sourceFile.getFilePath(),
+        reason: options.hookReason,
+        stage: "component-filter"
+      });
+      continue;
+    }
+    renderable.push({ name, declarations });
+  }
+  return renderable;
+}
 function kebabToPascal(input) {
   return input.split("-").filter(Boolean).map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
 }
@@ -13568,18 +13666,13 @@ function hasImplementationChildrenHint(funcNode, param) {
   return body.getDescendantsOfKind(SyntaxKind4.JsxSpreadAttribute).some((attr) => isComponentSpreadAttribute(attr, /* @__PURE__ */ new Set([paramName])));
 }
 async function extractReactComponents(filePaths) {
-  const exclusions = [];
-  const extractionContext = extractTsxComponents(filePaths, /\.[jt]sx$/, (sourceFile) => {
+  const { components, warnings, exclusions, project } = extractTsxComponents(filePaths, /\.[jt]sx$/, (sourceFile, exclusions2) => {
     if (isStencilFile2(sourceFile))
       return [];
     const fileExports = [...sourceFile.getExportedDeclarations().keys()];
     const isNext = isNextJsComponent(sourceFile.getFilePath(), fileExports);
-    return extractFromSourceFile2(sourceFile, isNext, exclusions);
+    return extractFromSourceFile2(sourceFile, isNext, exclusions2);
   });
-  if (!extractionContext) {
-    return { components: [], warnings: [] };
-  }
-  const { project, components, warnings } = extractionContext;
   const propsToComponent = /* @__PURE__ */ new Map();
   const componentNames = /* @__PURE__ */ new Set();
   for (const c2 of components) {
@@ -13615,7 +13708,7 @@ async function extractReactComponents(filePaths) {
     const cached = structuralByFile.get(filePath);
     if (cached)
       return cached;
-    const sourceFile = project.getSourceFile(filePath);
+    const sourceFile = project?.getSourceFile(filePath);
     if (!sourceFile)
       return [];
     const ctx = { propsToComponent, componentNames };
@@ -13677,22 +13770,11 @@ async function extractReactComponents(filePaths) {
 }
 function extractFromSourceFile2(sourceFile, isNext, exclusions) {
   const components = [];
-  const exported = sourceFile.getExportedDeclarations();
   const usesCreateContext = sourceFileUsesCreateContext(sourceFile);
-  for (const [exportKey, declarations] of exported) {
-    const name = resolveComponentExportName(exportKey, declarations, exported, true);
-    if (!name)
-      continue;
-    if (isCompositionHookName(name)) {
-      exclusions.push({
-        itemType: "component",
-        name,
-        source: sourceFile.getFilePath(),
-        reason: "React hook names are not renderable components",
-        stage: "component-filter"
-      });
-      continue;
-    }
+  for (const { name, declarations } of getRenderableExports(sourceFile, exclusions, {
+    allowVariableDeclaration: true,
+    hookReason: "React hook names are not renderable components"
+  })) {
     const funcNode = resolveBestFunctionNode(declarations);
     if (!funcNode)
       continue;
@@ -14170,12 +14252,7 @@ var init_react = __esm({
 // packages/experience-design-system-extraction/dist/src/extract/vue-tsx.js
 import { Node as Node5, SyntaxKind as SyntaxKind5 } from "ts-morph";
 async function extractVueTsxComponents(filePaths) {
-  const exclusions = [];
-  const extractionContext = extractTsxComponents(filePaths, /\.tsx$/, (sourceFile) => extractFromSourceFile3(sourceFile, exclusions));
-  if (!extractionContext) {
-    return { components: [], warnings: [] };
-  }
-  const { components, warnings } = extractionContext;
+  const { components, warnings, exclusions } = extractTsxComponents(filePaths, /\.tsx$/, extractFromSourceFile3);
   return {
     components: components.sort((a, b) => a.name.localeCompare(b.name)),
     warnings,
@@ -14184,21 +14261,9 @@ async function extractVueTsxComponents(filePaths) {
 }
 function extractFromSourceFile3(sourceFile, exclusions) {
   const components = [];
-  const exported = sourceFile.getExportedDeclarations();
-  for (const [exportKey, declarations] of exported) {
-    const name = resolveComponentExportName(exportKey, declarations, exported);
-    if (!name)
-      continue;
-    if (isCompositionHookName(name)) {
-      exclusions.push({
-        itemType: "component",
-        name,
-        source: sourceFile.getFilePath(),
-        reason: "Vue composition hook names are not renderable components",
-        stage: "component-filter"
-      });
-      continue;
-    }
+  for (const { name, declarations } of getRenderableExports(sourceFile, exclusions, {
+    hookReason: "Vue composition hook names are not renderable components"
+  })) {
     const component = extractVueTsxComponent(declarations, name, sourceFile);
     if (component) {
       components.push(component);
@@ -27169,6 +27234,7 @@ function WizardApp({
   const credentialsReadyRef = useRef10(false);
   const agentAuthVerifiedRef = useRef10(false);
   const scopeGateCompletedRef = useRef10(false);
+  const scopeComponentsRef = useRef10(null);
   const existingEntitiesPromiseRef = useRef10(null);
   const generatePromiseRef = useRef10(null);
   const rawTokensEntryReady = !!initialRawTokensPath;
@@ -28809,12 +28875,18 @@ If using a custom host configuration, make sure the space exists on that host.`
         }
         const sessionId2 = state.extractSessionId;
         const db = openPipelineDb();
-        let components;
+        let loadedComponents;
         try {
-          components = loadScopeComponents(db, sessionId2);
+          loadedComponents = loadScopeComponents(db, sessionId2);
         } finally {
           db.close();
         }
+        const remembered = scopeComponentsRef.current;
+        if (loadedComponents.length > 0 && remembered?.sessionId !== sessionId2) {
+          scopeComponentsRef.current = { sessionId: sessionId2, components: loadedComponents };
+        }
+        const rememberedForSession = scopeComponentsRef.current?.sessionId === sessionId2 ? scopeComponentsRef.current.components : null;
+        const components = scopeGateCompletedRef.current && rememberedForSession ? rememberedForSession : loadedComponents.length > 0 ? loadedComponents : rememberedForSession ?? [];
         return /* @__PURE__ */ jsx50(
           ScopeGateStep,
           {

package/dist/src/session/db.d.ts

@@ -22,6 +22,10 @@ export interface ApplyToolCallsResult {
     slots: number;
     warnings: string[];
 }
+export interface ApplyToolCallsOptions {
+    /** Component names that may appear in generated slot allowed-components lists. */
+    allowedComponentNames?: ReadonlySet<string>;
+}
 export interface ComponentReviewMetadata {
     sourcePath: string | null;
     componentSource: string | null;
@@ -51,7 +55,7 @@ export interface ComponentRationale {
     }>;
 }
 export declare function loadComponentRationale(db: DatabaseSync, sessionId: string, componentName: string): ComponentRationale | null;
-export declare function applyToolCalls(db: DatabaseSync, sessionId: string, componentId: string, componentName: string, calls: ToolCall[], incomingWarnings: string[]): ApplyToolCallsResult;
+export declare function applyToolCalls(db: DatabaseSync, sessionId: string, componentId: string, componentName: string, calls: ToolCall[], incomingWarnings: string[], options?: ApplyToolCallsOptions): ApplyToolCallsResult;
 export type MatchHints = SessionMatchHints;
 export type { SessionResolution };
 export declare function getOrCreateSession(db: DatabaseSync, sessionFlag: string | undefined, sessionName: string | undefined, hints: MatchHints): SessionResolution;
@@ -141,12 +145,24 @@ export interface StoredSlotCycle extends SlotCycle {
 export declare function loadSlotCycles(db: DatabaseSync, sessionId: string): StoredSlotCycle[];
 export declare function clearSlotCycles(db: DatabaseSync, sessionId: string): void;
 export declare function markCacheHumanEdited(db: DatabaseSync, entityType: 'component' | 'token_set', entityId: string): void;
-export declare function copyComponentFromCache(db: DatabaseSync, sourceSessionId: string, targetSessionId: string, componentId: string, manageTransaction?: boolean): void;
+export interface UnknownSlotAllowedComponent {
+    componentId: string;
+    componentName: string;
+    slotName: string;
+    allowedComponent: string;
+}
+export declare function findUnknownSlotAllowedComponents(db: DatabaseSync, sessionId: string, allowedComponentNames: ReadonlySet<string>, componentId?: string): UnknownSlotAllowedComponent[];
+/** Remove slot references that cannot resolve in the current manifest or target space. */
+export declare function filterUnknownSlotAllowedComponents(db: DatabaseSync, sessionId: string, allowedComponentNames: ReadonlySet<string>): UnknownSlotAllowedComponent[];
+export interface CopyComponentFromCacheOptions {
+    allowedComponentNames?: ReadonlySet<string>;
+}
+export declare function copyComponentFromCache(db: DatabaseSync, sourceSessionId: string, targetSessionId: string, componentId: string, manageTransaction?: boolean, options?: CopyComponentFromCacheOptions): void;
 export declare function copyComponentsFromCache(db: DatabaseSync, entries: Array<{
     sourceSessionId: string;
     targetSessionId: string;
     componentId: string;
-}>): void;
+}>, options?: CopyComponentFromCacheOptions): void;
 export declare function copyTokensFromCache(db: DatabaseSync, sourceSessionId: string, targetSessionId: string): void;
 export declare function copyMapTokensFromCache(db: DatabaseSync, sourceSessionId: string, targetSessionId: string): number;
 export declare function getCliCacheVersion(): Promise<string>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.34.5-dev-build-a95aeeba.0",
+  "version": "2.34.5-dev-build-f8f0b1fa.0",
   "description": "Contentful Experiences design system import CLI",
   "license": "MIT",
   "type": "module",
@@ -41,8 +41,8 @@
     "svelte": "^5.56.4",
     "ts-morph": "^27.0.2",
     "typescript": "^5.9.3",
-    "@contentful/experience-design-system-types": "2.34.5-dev-build-a95aeeba.0",
-    "@contentful/experience-design-system-cli-v2": "2.34.5-dev-build-a95aeeba.0"
+    "@contentful/experience-design-system-cli-v2": "2.34.5-dev-build-f8f0b1fa.0",
+    "@contentful/experience-design-system-types": "2.34.5-dev-build-f8f0b1fa.0"
   },
   "devDependencies": {
     "@tsconfig/node24": "^24.0.4",
@@ -54,9 +54,9 @@
     "ink-testing-library": "^4.0.0",
     "typescript-eslint": "^8.67.0",
     "vitest": "^4.0.16",
-    "@contentful/experience-design-system-extraction": "2.34.5-dev-build-a95aeeba.0",
-    "@contentful/experience-design-system-client": "2.34.5-dev-build-a95aeeba.0",
-    "@contentful/experience-design-system-generation": "2.34.5-dev-build-a95aeeba.0"
+    "@contentful/experience-design-system-extraction": "2.34.5-dev-build-f8f0b1fa.0",
+    "@contentful/experience-design-system-client": "2.34.5-dev-build-f8f0b1fa.0",
+    "@contentful/experience-design-system-generation": "2.34.5-dev-build-f8f0b1fa.0"
   },
   "repository": {
     "type": "git",

package/skills/generate-components.md

@@ -12,11 +12,12 @@ Contentful Experience Orchestration is a Contentful product that enables **marke
 
 A Component Type has two kinds of configurable properties:
 
-- **Design Properties** — values that control *how the component looks*: color scheme, visual variant (primary/secondary/ghost), size (sm/md/lg), spacing, layout orientation, background color, font style, border style, any visual toggle that changes appearance. These are the values a designer sets once and a marketer may override. Think: "what would a designer put in a design token or a style guide?"
-- **Content Properties** — values that are *data the component displays*: labels, headings, body text, rich text, images, media, URLs, counts, IDs used for CMS lookups, locales. These are filled by editors with real CMS content. Think: "what does a copywriter or content editor fill in?"
+- **Design Properties** — values that control _how the component looks_: color scheme, visual variant (primary/secondary/ghost), size (sm/md/lg), spacing, layout orientation, background color, font style, border style, any visual toggle that changes appearance. These are the values a designer sets once and a marketer may override. Think: "what would a designer put in a design token or a style guide?"
+- **Content Properties** — values that are _data the component displays_: labels, headings, body text, rich text, images, media, URLs, counts, IDs used for CMS lookups, locales. These are filled by editors with real CMS content. Think: "what does a copywriter or content editor fill in?"
 
 The third category:
-- **State Properties** — values that control *interactive or behavioral state*: disabled, loading, expanded, isOpen, isSearchVisible. These are runtime behavioral flags, not visual design nor content.
+
+- **State Properties** — values that control _interactive or behavioral state_: disabled, loading, expanded, isOpen, isSearchVisible. These are runtime behavioral flags, not visual design nor content.
 
 Getting this right matters: Contentful uses the category to decide where a property appears in the editor UI. Design properties appear in the design panel, content properties appear in the content panel.
 
@@ -35,13 +36,13 @@ All input is embedded inline in the prompt before this file:
 ```typescript
 interface RawPropDefinition {
   name: string;
-  type: string;            // raw TypeScript type, e.g. "'primary' | 'secondary'"
+  type: string; // raw TypeScript type, e.g. "'primary' | 'secondary'"
   required: boolean;
-  category?: 'content' | 'design' | 'state';  // pre-classified — verify, do not blindly trust
+  category?: 'content' | 'design' | 'state'; // pre-classified — verify, do not blindly trust
   allowedValues?: string[];
   defaultValue?: string;
   description?: string;
-  tokenReference?: string;  // raw token name — shape varies by design system, e.g. "--brand-primary" (CSS custom property) or "tokens.blue500" (flat/dotted JS reference)
+  tokenReference?: string; // raw token name — shape varies by design system, e.g. "--brand-primary" (CSS custom property) or "tokens.blue500" (flat/dotted JS reference)
 }
 
 interface RawSlotDefinition {
@@ -60,6 +61,7 @@ interface RawComponentDefinition {
 
 The `category` field on each prop is a pre-classification hint from static analysis heuristics.
 It is correct approximately 80% of the time for simple props. You should:
+
 - Trust it for obvious cases (event handlers excluded, text labels as content)
 - Override it when your domain knowledge indicates otherwise
 - NEVER produce zero output — if you disagree with all hints, explain why in descriptions
@@ -87,12 +89,13 @@ Emit one JSON object per line. The CLI parses lines starting with `{`. Lines not
 ```
 
 **Rules:**
+
 - Emit exactly one JSON object per line. No multi-line JSON.
 - Every prop in the input must produce exactly one call: `classify_prop` OR `exclude_prop`.
 - Every slot must produce exactly one `classify_slot` call.
 - Emit `classify_component` once at the start (required). The `description` field is **required** — always provide a brief description of the component's purpose.
 - `values` is required for `cdf_type: "enum"` — must be a non-empty string array of the variant names the prop accepts. **There is no legal `enum` with a guessed list.** If the value set is shown to you anywhere in the material below — the type's own declaration, an `allowedValues` list on the raw prop, a variant/lookup map, a default, a sibling excerpt — copy it and emit `enum`. If it is shown nowhere, emit `cdf_type: "string"` and leave `values` off. `string` is an unrestricted enum: the author can still pass the real value. A guessed list silently rejects it.
-- **Do NOT include `values` for `cdf_type: "token"`.** The two property types carry different kinds of list. An `enum` prop's list holds *variant names* the component accepts (`"primary"`, `"secondary"`). A `token` prop's list holds *design token paths* (`"color.brand.primary"`), produced by the separate token-mapping step (`$token.allowed`) — never by you. Emitting `values` on a token prop makes the definition invalid.
+- **Do NOT include `values` for `cdf_type: "token"`.** The two property types carry different kinds of list. An `enum` prop's list holds _variant names_ the component accepts (`"primary"`, `"secondary"`). A `token` prop's list holds _design token paths_ (`"color.brand.primary"`), produced by the separate token-mapping step (`$token.allowed`) — never by you. Emitting `values` on a token prop makes the definition invalid.
 - `token_kind` is required for `cdf_type: "token"` — must be a DTCG `$type` string, e.g. `"color"`.
 - `required` must be a JSON boolean (`true`/`false`), not a string.
 - `description` on `classify_prop` is customer-facing — keep it short and subject to the description content rules below.
@@ -117,14 +120,14 @@ Emit one JSON object per line. The CLI parses lines starting with `{`. Lines not
 
 Exactly **6** valid types:
 
-| cdf_type | Use case |
-|---|---|
-| `string` | Plain text, URLs, href props, numbers (as string), any string-shaped value |
-| `richtext` | Formatted text, HTML, ReactNode used as markup |
-| `media` | Images, videos, media assets |
-| `enum` | Fixed set of string choices — requires `values` |
-| `token` | Design-token-linked prop — requires `token_kind` |
-| `boolean` | Boolean toggle props (visible, disabled, enabled, etc.) |
+| cdf_type   | Use case                                                                   |
+| ---------- | -------------------------------------------------------------------------- |
+| `string`   | Plain text, URLs, href props, numbers (as string), any string-shaped value |
+| `richtext` | Formatted text, HTML, ReactNode used as markup                             |
+| `media`    | Images, videos, media assets                                               |
+| `enum`     | Fixed set of string choices — requires `values`                            |
+| `token`    | Design-token-linked prop — requires `token_kind`                           |
+| `boolean`  | Boolean toggle props (visible, disabled, enabled, etc.)                    |
 
 > **IMPORTANT: No `number` type.** The design-systems API only supports the `String` design property variant for numeric values. All numeric props must use `cdf_type: "string"` with the number as a string default (e.g. `"0"`, `"100"`). Boolean props can now use `cdf_type: "boolean"` directly.
 
@@ -134,11 +137,11 @@ Exactly **6** valid types:
 
 ### `enum` versus `token`
 
-Both describe a closed set of choices, but the *contents* differ, and that is the whole distinction:
+Both describe a closed set of choices, but the _contents_ differ, and that is the whole distinction:
 
-| | What the list holds | Example |
-|---|---|---|
-| `enum` | Variant names the component accepts | `["primary", "secondary", "ghost"]` |
+|         | What the list holds                     | Example                                          |
+| ------- | --------------------------------------- | ------------------------------------------------ |
+| `enum`  | Variant names the component accepts     | `["primary", "secondary", "ghost"]`              |
 | `token` | Design token paths the prop may bind to | `["color.brand.primary", "color.brand.neutral"]` |
 
 The distinction is **what the component does with the value it receives**. That
@@ -147,7 +150,7 @@ component's role, or from the property's TypeScript type.
 
 An `enum` design property is delivered as a plain string, so the component
 receives `variant="primary"` — the value its own code branches on. A `token`
-property is resolved to the token's value *before* it reaches the component, so
+property is resolved to the token's value _before_ it reaches the component, so
 that same component would receive `variant="#0059c8"` and match no branch.
 
 #### The three-question procedure (closed, ordered)
@@ -160,7 +163,7 @@ that decides. There is no fourth question.
   An indexed access (`tokens[fontColor]`, `SPACING[padding]`, a `Record<Variant, Token>`),
   a `switch (variant)` / `if (variant === 'x')` chain, a `styles[variant]` class lookup,
   or a vocabulary of its own (`allowedValues`, a literal union) — any of these means
-  the component needs the *name*. A presence check (`if (width)`) or arithmetic on
+  the component needs the _name_. A presence check (`if (width)`) or arithmetic on
   the value is not a lookup.
   **Yes → `enum`, names in `values`, stop.** No → Q2.
 - **Q2 — Is the value written straight into a style or attribute?**
@@ -170,7 +173,7 @@ that decides. There is no fourth question.
 - **Q3 — Is there a design-token reference at that use?** Any one of:
   the parameter default is a token (`radius = tokens.borderRadiusSmall`), the raw prop
   carries a `tokenReference`, or an inline `tokens.*` / `var(--*)` sits in the same
-  expression. The reference must belong to *this* prop — a `tokens.*` on some other
+  expression. The reference must belong to _this_ prop — a `tokens.*` on some other
   line of the file, or in a sibling's style object, is not one.
   **Yes → `token`, stop; resolve `token_kind` from that reference. No → `string`, stop.**
 
@@ -178,7 +181,7 @@ that decides. There is no fourth question.
 `string | number`, `stringOrNumber` — none of these answers any question above;
 they say what the compiler accepts, not what the component does with the value.
 "The type accepts any value, the default just happens to be a token reference" is
-a Q3-yes described as a no: a token parameter default *is* the design-token
+a Q3-yes described as a no: a token parameter default _is_ the design-token
 reference Q3 asks for, and the prop is `token`. Equally, a prop named `color` with
 no lookup and no token reference is `string`, however token-like the name.
 
@@ -216,7 +219,7 @@ the source is truncated at the point of use (the "uses not shown" line). In thos
 cases emit `enum` if a value set is citable from the source shown, else `cdf_type:
 "string"` per "no legal `enum` with a guessed list" — either way, record the
 ambiguity in `reason`. When the three
-questions *can* be answered from the source shown, they are answered and the
+questions _can_ be answered from the source shown, they are answered and the
 tie-break does not apply: a clear Q1-yes is `enum`, a clear Q2-yes + Q3-yes is
 `token`, and a type annotation does not create ambiguity. An `enum` is delivered
 as the plain string the component was written to receive and remains reachable
@@ -229,11 +232,11 @@ reason to call a decided case a tie.
 
 ## Valid cdf_category values
 
-| cdf_category | Use case |
-|---|---|
-| `content` | Data the component *displays* — what a copywriter or editor fills in: text, labels, headings, body copy, rich text, images, media, URLs, link targets, counts, locale |
-| `design` | Values that control *how the component looks* — what a designer sets: color, size (sm/md/lg), variant (primary/secondary/ghost), layout orientation, alignment, background, visual toggles (imageOnLeft, enableEffect), design tokens |
-| `state` | Runtime behavioral or interactive flags — not visible in the editor's design or content panel: disabled, loading, expanded, isOpen, isSearchVisible, preview, identifiers used for analytics/tracking (componentId, sectionKey, componentName) |
+| cdf_category | Use case                                                                                                                                                                                                                                       |
+| ------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `content`    | Data the component _displays_ — what a copywriter or editor fills in: text, labels, headings, body copy, rich text, images, media, URLs, link targets, counts, locale                                                                          |
+| `design`     | Values that control _how the component looks_ — what a designer sets: color, size (sm/md/lg), variant (primary/secondary/ghost), layout orientation, alignment, background, visual toggles (imageOnLeft, enableEffect), design tokens          |
+| `state`      | Runtime behavioral or interactive flags — not visible in the editor's design or content panel: disabled, loading, expanded, isOpen, isSearchVisible, preview, identifiers used for analytics/tracking (componentId, sectionKey, componentName) |
 
 The pre-classified `category` in the raw input is a starting point — correct it when it is wrong. Contentful uses this category to decide where the property appears in the editor UI, so accuracy matters.
 
@@ -254,7 +257,8 @@ For each `RawPropDefinition`, apply in order:
    - Data attributes: any `data-*` prop
    - **Polymorphic component props**: `as`, `element`, `component` (when typed as an HTML tag string or component reference) — these change rendered HTML, not marketer-visible behavior
    - **Framework theming / pass-through escape hatches**: PrimeVue's `dt` / `pt` / `ptOptions` / `unstyled`, MUI/Chakra-style `sx`, anything explicitly typed as a developer "override" / "passthrough" object
-   - **Important caveat**: only exclude when the prop is inherited/universal *and unredeclared*. Compound names like `fileName`, `displayName`, `dataset`, `dataSource`, `roleDescription`, `idLabel` are not pass-through — classify them normally. Likewise, a `title` (or any other inherited-attribute name) that the component redeclares with its own type or doc comment is component-specific content, not pass-through — classify it per rule 2 onward, do not exclude it and do not route it through the `title` → `content` correction below.
+   - **Important caveat**: only exclude when the prop is inherited/universal _and unredeclared_. Compound names like `fileName`, `displayName`, `dataset`, `dataSource`, `roleDescription`, `idLabel` are not pass-through — classify them normally. Likewise, a `title` (or any other inherited-attribute name) that the component redeclares with its own type or doc comment is component-specific content, not pass-through — classify it per rule 2 onward, do not exclude it and do not route it through the `title` → `content` correction below.
+
 2. **Common semantic props — DO classify, do not exclude.** The LLM has been over-excluding these because they sound like framework internals; they are not. Classify each per the rest of this tree:
    - `icon` / `leftIcon` / `rightIcon` / `prefixIcon` / `suffixIcon` — slot or `string` (icon name); see slot guidance below
    - `items` / `options` / `actions` / `links` — usually array content; if the element shape is simple, classify as `string` (comma-separated names/IDs) and note in `description`. Only exclude when elements are deep nested objects with no flat representation.
@@ -266,21 +270,21 @@ For each `RawPropDefinition`, apply in order:
    - `eventDetails` / similar telemetry props — `cdf_category: "state"`.
 3. **Positional/geometric design prop?** (`top`, `bottom`, `left`, `right`, `rotation`, `offset`, `zIndex`) → `classify_prop`, `cdf_type: "string"`, `cdf_category: "design"`.
 4. **`enum` or `token`? — run the three-question procedure first.** Before any type-based rule, for every design prop that carries a value, answer Q1–Q3 from "`enum` versus `token`" above, in order, from the source shown:
+   - **Q1** looked up / switched on / compared / has its own vocabulary → `cdf_type: "enum"`, names in `values`, no `token_kind`. This holds even when every name maps 1:1 to a design token; the map is the component resolving a name it was given.
+   - **Q2** not written straight into a style or attribute → not `token`; continue to rules 5–7.
+   - **Q3** written straight into a style or attribute **and** a token reference at that use (a `tokens.*` parameter default, a `tokenReference`, an inline `tokens.*` / `var(--*)`) → `cdf_type: "token"`, `token_kind` from that reference via the sidecar, no `values`. Interpolated with no token reference at that use → `cdf_type: "string"`.
+   - Q1–Q3 **cannot be answered** from the source shown (unread, truncated, in a file you cannot see, evidence pointing both ways) → `cdf_type: "enum"` (or `string`). See "Ambiguity resolves to `enum`" above.
 
-   * **Q1** looked up / switched on / compared / has its own vocabulary → `cdf_type: "enum"`, names in `values`, no `token_kind`. This holds even when every name maps 1:1 to a design token; the map is the component resolving a name it was given.
-   * **Q2** not written straight into a style or attribute → not `token`; continue to rules 5–7.
-   * **Q3** written straight into a style or attribute **and** a token reference at that use (a `tokens.*` parameter default, a `tokenReference`, an inline `tokens.*` / `var(--*)`) → `cdf_type: "token"`, `token_kind` from that reference via the sidecar, no `values`. Interpolated with no token reference at that use → `cdf_type: "string"`.
-   * Q1–Q3 **cannot be answered** from the source shown (unread, truncated, in a file you cannot see, evidence pointing both ways) → `cdf_type: "enum"` (or `string`). See "Ambiguity resolves to `enum`" above.
-
-   **Do not classify on the component's role.** A layout primitive is not automatically a token consumer. Design systems routinely key their primitives on token *names*, and those props are `enum` — the component needs the name to perform its own lookup:
+   **Do not classify on the component's role.** A layout primitive is not automatically a token consumer. Design systems routinely key their primitives on token _names_, and those props are `enum` — the component needs the name to perform its own lookup:
 
    ```ts
    // Box.tsx — padding is an enum, despite Box being a layout primitive
-   const { padding } = props;                  // "spacingXs"
-   getSpacingStyles({ padding });               // → SpacingTable["spacingXs"] → "0.5rem"
+   const { padding } = props; // "spacingXs"
+   getSpacingStyles({ padding }); // → SpacingTable["spacingXs"] → "0.5rem"
    ```
 
    Classify that `padding` as `token` and the platform delivers `"0.5rem"`, so `SpacingTable["0.5rem"]` is `undefined` and the spacing silently disappears. A value that is spelled like a token name is still a lookup key (Q1 yes). Curated components with named variant APIs (`Button`, `Tag`, `Badge`, `Avatar`, `Notification`) are `enum` for the same reason. A design system may legitimately produce **zero** token-typed props.
+
 5. **Union of string literals** (e.g. `'a' | 'b' | 'c'`)? → `cdf_type: "enum"`, extract literals into `values`. (Rule 4's Q1 will normally have decided this already — a literal union is the prop's own vocabulary.) This applies even when Component source references show each literal resolving to a design token internally — a resolved token map is evidence about the component's internals, not its interface.
 6. **Raw type is `string`** and prop name is `href`, `url`, or clearly a URL? → `cdf_type: "string"`, `cdf_category: "content"`.
 7. **Raw type is `string` / `number` / `boolean`?** → For `boolean`, use `cdf_type: "boolean"` with `default: true` or `false` (native boolean). For `number`, use `cdf_type: "string"` with `default` as the numeric value as a string (e.g. `"0"`). For `string`, use `cdf_type: "string"`. **A design prop reaches this rule only after leaving rule 4 at Q2 (not written into a style) or Q3 (written into a style with no token reference at that use).** A prop that answered Q3 yes is already `token` and never arrives here — a `string`, `number`, or `string | number` annotation on it does not bring it back to this rule.
@@ -292,27 +296,28 @@ For each `RawPropDefinition`, apply in order:
 
 ## Resolving complex types — do not exclude without reasoning
 
-A prop with a complex TypeScript type is **not automatically excluded**. Many props that appear complex carry real marketer-configurable information. Before excluding, ask: *"Could a marketer set this value in Contentful?"* If yes, classify it.
+A prop with a complex TypeScript type is **not automatically excluded**. Many props that appear complex carry real marketer-configurable information. Before excluding, ask: _"Could a marketer set this value in Contentful?"_ If yes, classify it.
 
 **Common resolvable patterns:**
 
-| Raw type pattern | How to resolve |
-|---|---|
-| `'primary' \| 'secondary' \| 'ghost'` (union of literals) | → `enum`, extract `values` |
+| Raw type pattern                                                                                | How to resolve                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| ----------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `'primary' \| 'secondary' \| 'ghost'` (union of literals)                                       | → `enum`, extract `values`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
 | `HeadingSize` / `ButtonVariant` / any named type that is clearly a finite set of visual options | → `enum` if you can cite its values from the source shown (the type's own declaration, a lookup table, a default) — copy them, never invent them. If the source shown does not enumerate the values, this is not the Q1–Q3 ambiguity tie-break — it is the "no legal `enum` with a guessed list" rule: emit `cdf_type: "string"` instead, with the missing evidence noted in `reason`. Do not default to a generic guess like `['sm', 'md', 'lg']` or `['primary', 'secondary']` — those are one design system's vocabulary, not a fallback for missing evidence. |
-| `Variant` / `variant` prop | Usually a visual design variant. → `enum`, `cdf_category: "design"`. Same evidence rule as above — cite values from the source shown; do not invent them. |
-| `Section[]` / array of custom items where the structure is unclear | → `exclude_prop` only if the array elements are complex objects with no obvious flat representation. If items are simple (title, label, id), consider representing as `string` (a comma-separated IDs or keys) or note in `description` why. |
-| `ExperienceConfiguration<Variant>` / deep generic | Personalization config — → `exclude_prop`, reason: `"personalization configuration — framework internal"` |
-| `React.Dispatch<...>` / setter | State setter — → `exclude_prop`, reason: `"React state setter — framework internal"` |
-| `React.RefObject<...>` / `ref` | → `exclude_prop`, reason: `"ref — framework internal"` |
-| `() => void` / callback | → `exclude_prop`, reason: `"callback function — framework internal"` |
-| `ReactNode` used as a slot-like prop (children, `icon`, `footer`) | → classify as a `slot` if it represents an injectable area, or `richtext` if it is inline markup content |
-| `boolean` with a name like `hideChevron`, `imageOnLeft`, `enableBackgroundColorEffect` | → `boolean`, `cdf_category: "design"`, `default: true` or `false` — these control visual appearance |
-| `boolean` with a name like `preview`, `hideContentForPersonalization` | → `boolean`, `cdf_category: "state"`, `default: false` — these control behavior |
-| `string` used as a `componentId`, `sectionKey`, `componentName` | → `string`, `cdf_category: "state"` — these are identifiers for tracking/lookup |
-| `string` locale (e.g. `locale: string`) | → `string`, `cdf_category: "state"` — locale is a behavioral/routing value |
+| `Variant` / `variant` prop                                                                      | Usually a visual design variant. → `enum`, `cdf_category: "design"`. Same evidence rule as above — cite values from the source shown; do not invent them.                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `Section[]` / array of custom items where the structure is unclear                              | → `exclude_prop` only if the array elements are complex objects with no obvious flat representation. If items are simple (title, label, id), consider representing as `string` (a comma-separated IDs or keys) or note in `description` why.                                                                                                                                                                                                                                                                                                                      |
+| `ExperienceConfiguration<Variant>` / deep generic                                               | Personalization config — → `exclude_prop`, reason: `"personalization configuration — framework internal"`                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `React.Dispatch<...>` / setter                                                                  | State setter — → `exclude_prop`, reason: `"React state setter — framework internal"`                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| `React.RefObject<...>` / `ref`                                                                  | → `exclude_prop`, reason: `"ref — framework internal"`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| `() => void` / callback                                                                         | → `exclude_prop`, reason: `"callback function — framework internal"`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| `ReactNode` used as a slot-like prop (children, `icon`, `footer`)                               | → classify as a `slot` if it represents an injectable area, or `richtext` if it is inline markup content                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `boolean` with a name like `hideChevron`, `imageOnLeft`, `enableBackgroundColorEffect`          | → `boolean`, `cdf_category: "design"`, `default: true` or `false` — these control visual appearance                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| `boolean` with a name like `preview`, `hideContentForPersonalization`                           | → `boolean`, `cdf_category: "state"`, `default: false` — these control behavior                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `string` used as a `componentId`, `sectionKey`, `componentName`                                 | → `string`, `cdf_category: "state"` — these are identifiers for tracking/lookup                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `string` locale (e.g. `locale: string`)                                                         | → `string`, `cdf_category: "state"` — locale is a behavioral/routing value                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
 
 **When to finally exclude:**
+
 - The type is a callback signature or event handler
 - The type is a React ref
 - The type is a React state setter (`Dispatch`)
@@ -342,6 +347,7 @@ function splits on `.` and takes only the last segment, producing poor display n
 produces display names like "Item Url", "Item Alt" which are more readable in the ExO editor.
 
 Rules for nested objects:
+
 - Flatten to max depth 2 (e.g., `item_nested_deep` is acceptable, deeper is not)
 - Each leaf field gets its own classify_prop call with underscore-joined name
 - Apply the same classification rules as top-level props
@@ -384,9 +390,11 @@ The pre-classified `category` is wrong in predictable ways. Correct silently (do
 The `classify_slot` tool call maps to CDF's `$slots` object. Each slot you classify becomes a `$slots` entry; the `allowed_components` field maps to `$allowedComponents` in the output CDF.
 
 For each `RawSlotDefinition`:
+
 - `name` → `slot` field
 - `description` → `description` field
 - `allowedComponents` → `allowed_components` (pass through)
+- `allowed_components` must contain only exact names from the hard allowlist supplied in the prompt; never invent a child from an import, JSX element, type name, icon name, or implementation helper, and omit any child that is not listed.
 - `required`:
   - `true` if the component does not render correctly without content in this slot (primary content area of a Card, Dialog body, etc.)
   - `false` if clearly optional (icon slot, footer slot with a default, decorative slot)
@@ -401,21 +409,33 @@ For each `RawSlotDefinition`:
 ### Simple component
 
 Input:
+
 ```json
 {
   "name": "Button",
   "props": [
-    {"name":"label","type":"string","category":"content","required":true},
-    {"name":"variant","type":"'primary'|'secondary'|'ghost'","category":"design","defaultValue":"'primary'"},
-    {"name":"disabled","type":"boolean","category":"design"},
-    {"name":"onClick","type":"()=>void","category":"state"},
-    {"name":"className","type":"string"}
+    {
+      "name": "label",
+      "type": "string",
+      "category": "content",
+      "required": true
+    },
+    {
+      "name": "variant",
+      "type": "'primary'|'secondary'|'ghost'",
+      "category": "design",
+      "defaultValue": "'primary'"
+    },
+    { "name": "disabled", "type": "boolean", "category": "design" },
+    { "name": "onClick", "type": "()=>void", "category": "state" },
+    { "name": "className", "type": "string" }
   ],
-  "slots": [{"name":"icon","description":"Optional leading icon"}]
+  "slots": [{ "name": "icon", "description": "Optional leading icon" }]
 }
 ```
 
 Output:
+
 ```
 Starting Button classification — 5 props, 1 slot
 {"tool":"classify_component","description":"Primary action button with variant and state support","rationale":{"description":"Button is an atom — a single interactive control that triggers an action. It carries a label, a small set of visual variants, and a disabled flag, which is the minimal surface a marketer needs to configure a call-to-action.","props":"Kept label (content), variant (enum, design), disabled (boolean, state), and className (string, design escape hatch). Excluded onClick because it is an event handler — framework-internal and not configurable in Contentful.","slots":"Kept the icon slot as optional because the button renders correctly without it and the icon is purely decorative."}}
@@ -436,21 +456,33 @@ icon slot is clearly optional (decorative leading icon)
 ### Component with multiple slots (Card)
 
 Input:
+
 ```json
 {
   "name": "Card",
   "props": [
-    {"name":"title","type":"string","category":"content","required":true},
-    {"name":"elevation","type":"'flat'|'raised'|'floating'","category":"design","defaultValue":"'raised'"}
+    {
+      "name": "title",
+      "type": "string",
+      "category": "content",
+      "required": true
+    },
+    {
+      "name": "elevation",
+      "type": "'flat'|'raised'|'floating'",
+      "category": "design",
+      "defaultValue": "'raised'"
+    }
   ],
   "slots": [
-    {"name":"body","description":"Main card body"},
-    {"name":"footer","description":"Optional footer area"}
+    { "name": "body", "description": "Main card body" },
+    { "name": "footer", "description": "Optional footer area" }
   ]
 }
 ```
 
 Output:
+
 ```
 Starting Card classification — 2 props, 2 slots
 {"tool":"classify_component","description":"Container that groups related content with a title, body, and optional footer","rationale":{"description":"Card is a molecule — it composes a title with body and footer slots into a single visual container. Useful as a building block for lists and grids of related content.","props":"Kept title (string, content) as the customer-facing label and elevation (enum, design) for the three visual depth variants. Nothing was excluded — both raw props map cleanly to CDF.","slots":"Kept both body (required, primary content area) and footer (optional, supplementary area). Body is required because a card with no body renders empty; footer is optional because many cards do not need one."}}
@@ -467,7 +499,7 @@ footer is supplementary and optional
 ### Named type (HeadingSize, ButtonVariant, etc.) — do NOT infer the values
 
 When a prop has a named TypeScript type that is not inlined as a union literal,
-the value set is whatever that type's declaration says. A type *name* is not
+the value set is whatever that type's declaration says. A type _name_ is not
 evidence of its members: `HeadingSize` could be `h1`–`h6`, `sm|md|lg`, or
 `s|m|l|xl`. Guessing picks one design system's vocabulary and is wrong more
 often than it is right, and a wrong name matches no style rule — the author's
@@ -478,12 +510,14 @@ is not, **emit `string`** — `string` is an unrestricted enum, so the author st
 unrestricted but correct.
 
 Members visible in the source shown — copy them, do not paraphrase:
+
 ```
 titleSize has type HeadingSize; HeadingSize is declared in the excerpt as 'sm' | 'md' | 'lg'
 {"tool":"classify_prop","prop":"titleSize","cdf_type":"enum","cdf_category":"design","required":false,"values":["sm","md","lg"],"description":"Heading size","reason":"Copied from the HeadingSize declaration shown in the excerpt."}
 ```
 
 Members NOT visible in the source shown — degrade to `string`:
+
 ```
 titleSize has type HeadingSize; HeadingSize is not declared anywhere in the source shown
 no evidence for its members, so no values list — string, not a guess
@@ -517,7 +551,7 @@ Before emitting any tool calls, verify:
 5. Every `cdf_type: "token"` has `token_kind` (or a warning in `description` if lookup failed) and does **not** have `values` set
 6. No `cdf_type: "link"` — all href/url props use `string`
 7. `required` values are JSON booleans, not strings
-8. Framework, DOM, accessibility, and data-* pass-through props are excluded per the inheritance principle (rule 1) — any prop inherited from an HTML-attributes base interface and not redeclared by the component, plus `aria-*` (and bare `aria`), `data-*`, polymorphic `as`/`element`/`component`, framework theming `dt`/`pt`/`ptOptions`/`unstyled`/`sx`. A prop matching an inherited-attribute name (including `title`) that the component redeclares with its own type or meaning is NOT excluded. Discrete positional/geometric props (`top`, `bottom`, `left`, `right`, `rotation`, etc.) ARE classified as `string` design props. Common semantic props (`icon`, `items`, `actions`, `options`, `value`, `name`, `form`, `inputId`, `componentId`) are NOT excluded — classify them per their content/design/state nature.
+8. Framework, DOM, accessibility, and data-_ pass-through props are excluded per the inheritance principle (rule 1) — any prop inherited from an HTML-attributes base interface and not redeclared by the component, plus `aria-_`(and bare`aria`), `data-\*`, polymorphic `as`/`element`/`component`, framework theming `dt`/`pt`/`ptOptions`/`unstyled`/`sx`. A prop matching an inherited-attribute name (including `title`) that the component redeclares with its own type or meaning is NOT excluded. Discrete positional/geometric props (`top`, `bottom`, `left`, `right`, `rotation`, etc.) ARE classified as `string` design props. Common semantic props (`icon`, `items`, `actions`, `options`, `value`, `name`, `form`, `inputId`, `componentId`) are NOT excluded — classify them per their content/design/state nature.
 9. No `cdf_type: "link"` used — `link` is reserved and rejected by the CLI parser
 10. No `cdf_type: "number"` used — this is not a supported type; use `"string"` with numeric defaults. `cdf_type: "boolean"` IS valid — use it for boolean toggle props.
 11. `classify_component` includes a `rationale` object with all three sub-fields (`rationale.description`, `rationale.props`, `rationale.slots`) populated as non-empty strings.