@contentful/experience-design-system-cli 2.34.5-dev-build-f6f44159.0 → 2.34.5-dev-build-ab8465d2.0

package/dist/src/index.js

@@ -110,41 +110,58 @@ var init_credentials_store = __esm({
 var render_with_goodbye_exports = {};
 __export(render_with_goodbye_exports, {
   GoodbyeBoundary: () => GoodbyeBoundary,
-  renderWithGoodbye: () => renderWithGoodbye
+  renderWithGoodbye: () => renderWithGoodbye,
+  useScreenTransitionClear: () => useScreenTransitionClear
 });
-import { useEffect, useRef, useState } from "react";
-import { render, Text } from "ink";
+import { createContext, useCallback, useContext, useEffect, useRef, useState } from "react";
+import { render, Text, useInput } from "ink";
 import { Fragment, jsx } from "react/jsx-runtime";
+function useScreenTransitionClear() {
+  return useContext(ScreenTransitionClearContext);
+}
 function GoodbyeBoundary({ children }) {
   const [isExiting, setIsExiting] = useState(false);
   const isExitingRef = useRef(false);
+  const exitTimerRef = useRef(void 0);
+  const requestExit = useCallback(() => {
+    if (isExitingRef.current) return;
+    isExitingRef.current = true;
+    setIsExiting(true);
+    exitTimerRef.current = setTimeout(() => process.exit(0), GOODBYE_RENDER_DELAY_MS);
+  }, []);
+  useInput((input, key) => {
+    if (key.ctrl && input === "c") requestExit();
+  });
   useEffect(() => {
-    let exitTimer;
-    const handleSigint = () => {
-      if (isExitingRef.current) return;
-      isExitingRef.current = true;
-      setIsExiting(true);
-      exitTimer = setTimeout(() => process.exit(0), GOODBYE_RENDER_DELAY_MS);
-    };
-    process.on("SIGINT", handleSigint);
+    process.on("SIGINT", requestExit);
     return () => {
-      process.off("SIGINT", handleSigint);
-      if (exitTimer) clearTimeout(exitTimer);
+      process.off("SIGINT", requestExit);
+      if (exitTimerRef.current) clearTimeout(exitTimerRef.current);
     };
-  }, []);
+  }, [requestExit]);
   return isExiting ? /* @__PURE__ */ jsx(Text, { children: "Goodbye!" }) : /* @__PURE__ */ jsx(Fragment, { children });
 }
 function renderWithGoodbye(element, options) {
-  return render(/* @__PURE__ */ jsx(GoodbyeBoundary, { children: element }), {
-    ...options,
-    exitOnCtrlC: false
-  });
+  const instanceRef = {};
+  const clearScreen = () => {
+    instanceRef.current?.clear();
+  };
+  const instance = render(
+    /* @__PURE__ */ jsx(ScreenTransitionClearContext.Provider, { value: clearScreen, children: /* @__PURE__ */ jsx(GoodbyeBoundary, { children: element }) }),
+    {
+      ...options,
+      exitOnCtrlC: false
+    }
+  );
+  instanceRef.current = instance;
+  return instance;
 }
-var GOODBYE_RENDER_DELAY_MS;
+var GOODBYE_RENDER_DELAY_MS, ScreenTransitionClearContext;
 var init_render_with_goodbye = __esm({
   "packages/experience-design-system-cli/src/tui/render-with-goodbye.tsx"() {
     "use strict";
     GOODBYE_RENDER_DELAY_MS = 50;
+    ScreenTransitionClearContext = createContext(() => void 0);
   }
 });
 
@@ -764,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:
@@ -776,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) {
@@ -918,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.`;
@@ -1952,8 +1976,7 @@ function hashComponentShape(component) {
     })),
     slots: component.slots.map((s) => ({
       name: s.name,
-      isDefault: s.isDefault,
-      allowedComponents: [...s.allowedComponents ?? []].sort()
+      isDefault: s.isDefault
     }))
   };
   return createHash2("sha256").update(JSON.stringify(payload)).digest("hex");
@@ -2498,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;
@@ -2633,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++;
       }
@@ -3185,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);
@@ -3543,15 +3573,38 @@ function lookupCacheByEntity(db, entityType, entityId) {
   };
 }
 function storeCache(db, inputHash, entityType, entityId, sourceSessionId, humanEdited, promptHash = "") {
+  storeCaches(db, [{ inputHash, entityType, entityId, sourceSessionId, humanEdited, promptHash }]);
+}
+function storeCaches(db, entries) {
+  if (entries.length === 0) return;
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  db.prepare(
+  const insert = db.prepare(
     `INSERT INTO generation_cache (input_hash, entity_type, entity_id, source_session_id, human_edited, created_at, updated_at, prompt_hash)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
      ON CONFLICT(input_hash, prompt_hash, entity_type, entity_id) DO UPDATE SET
        source_session_id = excluded.source_session_id,
        human_edited = CASE WHEN generation_cache.human_edited = 1 THEN 1 ELSE excluded.human_edited END,
        updated_at = excluded.updated_at`
-  ).run(inputHash, entityType, entityId, sourceSessionId, humanEdited ? 1 : 0, now, now, promptHash);
+  );
+  db.exec("BEGIN");
+  try {
+    for (const entry of entries) {
+      insert.run(
+        entry.inputHash,
+        entry.entityType,
+        entry.entityId,
+        entry.sourceSessionId,
+        entry.humanEdited ? 1 : 0,
+        now,
+        now,
+        entry.promptHash ?? ""
+      );
+    }
+    db.exec("COMMIT");
+  } catch (e) {
+    db.exec("ROLLBACK");
+    throw e;
+  }
 }
 function storeScannedFiles(db, sessionId2, filePaths) {
   db.exec("BEGIN");
@@ -3601,9 +3654,43 @@ function loadSlotCycles(db, sessionId2) {
     suggestedBreak: r.suggested_break_json ? JSON.parse(r.suggested_break_json) : null
   }));
 }
-function copyComponentFromCache(db, sourceSessionId, targetSessionId, componentId) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
+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 {
     const srcComp = db.prepare(
       `SELECT description, status, component_description_rationale, props_rationale, slots_rationale
@@ -3675,10 +3762,24 @@ 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);
+    if (manageTransaction) db.exec("COMMIT");
+  } catch (e) {
+    if (manageTransaction) db.exec("ROLLBACK");
+    throw e;
+  }
+}
+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, options);
+    }
     db.exec("COMMIT");
   } catch (e) {
     db.exec("ROLLBACK");
@@ -4821,43 +4922,85 @@ 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");
 }
-async function runOneComponent(agent, model, db, sessionId2, component, tokensInline, tokenMapInline, index, total, verbose, noCache, skillPathOverride, skillContentOverride, promptHash, existingContentfulEntities, existingTokensInline) {
-  const pos = c.dim(`[${index + 1}/${total}]`);
-  if (!noCache) {
-    const inputHash = hashComponentShape(component);
-    const cached = lookupCache(db, inputHash, "component", component.component_id, promptHash);
-    if (cached) {
-      copyComponentFromCache(db, cached.sourceSessionId, sessionId2, component.component_id);
-      process.stderr.write(`  ${pos}  ${c.bold(component.name)}  ${c.green("cached")}
-`);
-      return {
-        componentName: component.name,
-        classified: 0,
-        excluded: 0,
-        slots: 0,
-        warnings: [],
-        failed: false,
-        cached: true,
-        renamedSlotsCount: 0
-      };
-    }
-    const pinned = lookupCacheByEntity(db, "component", component.component_id);
-    if (pinned?.humanEdited) {
-      copyComponentFromCache(db, pinned.sourceSessionId, sessionId2, component.component_id);
-      process.stderr.write(`  ${pos}  ${c.bold(component.name)}  ${c.cyan("pinned (human-edited)")}
+function createCachedComponentResult(componentName, warnings = []) {
+  return {
+    componentName,
+    classified: 0,
+    excluded: 0,
+    slots: 0,
+    warnings,
+    failed: false,
+    cached: true,
+    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}
 `);
-      return {
-        componentName: component.name,
-        classified: 0,
-        excluded: 0,
-        slots: 0,
-        warnings: [`${component.name}: source changed but human edits preserved`],
-        failed: false,
-        cached: true,
-        renamedSlotsCount: 0
-      };
-    }
+}
+function normalizeComponentForCache(component) {
+  const slots = component.slots.map((slot, index, allSlots) => ({
+    ...slot,
+    name: slot.name.trim() || (allSlots.length === 1 ? "children" : `slot_${index}`)
+  }));
+  return { ...component, slots };
+}
+function lookupComponentCache(db, component, promptHash) {
+  const normalized = normalizeComponentForCache(component);
+  const inputHash = hashComponentShape(normalized);
+  const cached = lookupCache(db, inputHash, "component", component.component_id, promptHash);
+  if (cached) return cached;
+  const legacyInputHash = hashComponentShape(component);
+  return legacyInputHash === inputHash ? null : lookupCache(db, legacyInputHash, "component", component.component_id, promptHash);
+}
+function resolveComponentCache(db, component, promptHash, allowedComponentNames2) {
+  const cached = lookupComponentCache(db, component, promptHash);
+  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 && findUnknownSlotAllowedComponents(db, pinned.sourceSessionId, allowedComponentNames2, component.component_id).length === 0 ? { entry: pinned, humanEdited: true } : null;
+}
+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,
     sessionId2,
@@ -4872,6 +5015,47 @@ 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)) {
+    writeCachedComponentStatus(pos, component.name, false);
+    return createCachedComponentResult(component.name);
+  }
+  if (!noCache) {
+    const inputHash = hashComponentShape(cacheComponent);
+    const resolution = resolveComponentCache(db, component, promptHash, allowedComponentNames2);
+    if (resolution && !resolution.humanEdited) {
+      copyComponentFromCache(db, resolution.entry.sourceSessionId, sessionId2, component.component_id, true, {
+        allowedComponentNames: allowedComponentNames2
+      });
+      storeCache(
+        db,
+        inputHash,
+        "component",
+        component.component_id,
+        resolution.entry.sourceSessionId,
+        resolution.entry.humanEdited,
+        promptHash
+      );
+      writeCachedComponentStatus(pos, component.name, false);
+      return createCachedComponentResult(component.name);
+    }
+    if (resolution?.humanEdited) {
+      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(
     [
       {
@@ -4904,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 = "";
@@ -4939,9 +5124,11 @@ ${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(component);
+      const inputHash = hashComponentShape(cacheComponent);
       storeCache(db, inputHash, "component", component.component_id, sessionId2, false, promptHash);
     }
     return {
@@ -4965,7 +5152,7 @@ ${outputBuf}`);
     renamedSlotsCount: renames.length
   };
 }
-async function runAllComponents(agent, model, db, sessionId2, components, tokensInline, tokenMapInline, verbose, noCache, skillPathOverride, skillContentOverride, promptHash, existingContentfulEntities, existingTokensInline) {
+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"
@@ -4976,24 +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
-      );
+      results[i] = await runOneComponent(options, components[i], i, components.length);
       completed += 1;
       process.stderr.write(`${formatGenerateProgressLine(completed, components.length, results[i].componentName)}
 `);
@@ -5021,6 +5191,15 @@ async function loadAcceptedNames(sessionId2) {
     return null;
   }
 }
+function parsePrecomputedCachedNames(value) {
+  if (!value) return /* @__PURE__ */ new Set();
+  try {
+    const parsed = JSON.parse(value);
+    return new Set(Array.isArray(parsed) ? parsed.filter((name) => typeof name === "string") : []);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
 async function runGenerateSkill(skill, opts, verbose = false) {
   const savedCreds = await readExperiencesCredentials();
   const agentName = opts.agent ?? savedCreds.agent;
@@ -5086,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);
@@ -5099,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
 `);
@@ -5158,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);
@@ -5175,6 +5377,7 @@ async function runGenerateSkill(skill, opts, verbose = false) {
   if (skill === "components" && allComponents && sessionId2) {
     const db = openPipelineDb();
     let componentResults;
+    const precomputedCachedNames = parsePrecomputedCachedNames(opts.cachedComponents);
     try {
       const existingContentfulEntitiesHashInputs = [];
       if (existingTokensInline) existingContentfulEntitiesHashInputs.push(hashContent(existingTokensInline));
@@ -5186,21 +5389,71 @@ async function runGenerateSkill(skill, opts, verbose = false) {
         existingContentfulEntitiesHashInputs,
         generatePrompt
       );
+      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, allowedComponentNames2);
+          return resolution ? [{ component, resolution }] : [];
+        }) : [];
+        if (cacheEnabled && opts.restoreCache) {
+          const restorations = [];
+          const rekeyed = [];
+          const componentStatus = db.prepare(
+            "SELECT status FROM raw_components WHERE session_id = ? AND component_id = ?"
+          );
+          for (const { component, resolution } of cachedComponents) {
+            const current = componentStatus.get(sessionId2, component.component_id);
+            if (current?.status === "generated") continue;
+            renameEmptySlots(db, sessionId2, component.component_id, component.name, component.slots.length);
+            restorations.push({
+              sourceSessionId: resolution.entry.sourceSessionId,
+              targetSessionId: sessionId2,
+              componentId: component.component_id
+            });
+            rekeyed.push({ component, cached: resolution.entry });
+          }
+          copyComponentsFromCache(db, restorations, { allowedComponentNames: allowedComponentNames2 });
+          storeCaches(
+            db,
+            rekeyed.map(({ component, cached }) => ({
+              inputHash: hashComponentShape(normalizeComponentForCache(component)),
+              entityType: "component",
+              entityId: component.component_id,
+              sourceSessionId: cached.sourceSessionId,
+              humanEdited: cached.humanEdited,
+              promptHash
+            }))
+          );
+        }
+        const fullyCached = cacheEnabled && cachedComponents.length === allComponents.length;
+        process.stdout.write(`cache-status=${fullyCached ? "hit" : "miss"}
+`);
+        process.stdout.write(
+          `cache-components=${JSON.stringify(cachedComponents.map(({ component }) => component.name))}
+`
+        );
+        await exitWithAnalytics(0);
+        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
+        {
+          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();
@@ -5275,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;
         }
       }
@@ -5344,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(
@@ -5386,6 +5606,12 @@ function registerInternalGenerateCommand(program) {
     "--existing-entities-path <path>",
     "Path to the .existing-entities.json file written after CMA credentials are supplied. When present, per-component prompts include a summary of the target space so classifications can align to existing prop names/tokens. Missing/malformed files are treated as no-op."
   );
+  componentsCmd.option("--cache-status", "Check whether all selected component definitions are cached");
+  componentsCmd.option("--restore-cache", "Restore cached component definitions into the current session");
+  componentsCmd.option(
+    "--cached-components <json>",
+    "Component names already restored by a prior cache-status lookup; skip per-component cache lookup"
+  );
   addAgentFlags(componentsCmd).action(async (opts) => {
     await runGenerateSkill("components", opts, opts.verbose ?? false);
   });
@@ -7145,7 +7371,7 @@ var init_contentful_urls = __esm({
 });
 
 // packages/experience-design-system-cli/src/apply/tui/ServerApplyView.tsx
-import { Box as Box3, Text as Text4, useInput } from "ink";
+import { Box as Box3, Text as Text4, useInput as useInput2 } from "ink";
 import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
 function ServerPreviewConfirm({
   preview,
@@ -7155,7 +7381,7 @@ function ServerPreviewConfirm({
   onConfirm,
   onCancel
 }) {
-  useInput((input, key) => {
+  useInput2((input, key) => {
     if (key.return) onConfirm(breakingWithImpact);
     else if (key.escape || input === "q") onCancel();
   });
@@ -7184,7 +7410,7 @@ function ServerApplyProgress({
   operationId,
   error
 }) {
-  useInput((_input, key) => {
+  useInput2((_input, key) => {
     if (status === "error" && (key.escape || _input === "q")) process.exit(1);
   });
   return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
@@ -7212,7 +7438,7 @@ function ServerApplyProgress({
   ] });
 }
 function ServerApplyDone({ operation, spaceId, environmentId, host }) {
-  useInput((input, key) => {
+  useInput2((input, key) => {
     if (key.escape || input === "q") {
       process.exit(operation.sys.status === "succeeded" ? 0 : 1);
     }
@@ -7326,7 +7552,6 @@ var init_terminal_capabilities = __esm({
 
 // packages/experience-design-system-cli/src/apply/command.ts
 import { createElement as createElement2 } from "react";
-import { render as render2 } from "ink";
 import { readFile as readFile9, readdir as readdir2, stat as stat2 } from "node:fs/promises";
 import { join as join8 } from "node:path";
 import {
@@ -7730,11 +7955,11 @@ function registerApplyCommand(program) {
           environmentId,
           host,
           acknowledgeBreakingChanges: acknowledge,
-          rerender: (element) => instance.rerender(element),
+          rerender: (element) => instance.rerender(createElement2(GoodbyeBoundary, null, element)),
           onDone: resolvePromise
         });
       };
-      const instance = render2(
+      const instance = renderWithGoodbye(
         createElement2(ServerPreviewConfirm, {
           preview,
           spaceId,
@@ -7756,6 +7981,7 @@ var IGNORE_TOKEN_DIRS;
 var init_command2 = __esm({
   "packages/experience-design-system-cli/src/apply/command.ts"() {
     "use strict";
+    init_render_with_goodbye();
     init_api_client();
     init_error_parser();
     init_cycle_detection();
@@ -10176,7 +10402,7 @@ var init_SpaceEnvironment = __esm({
 });
 
 // packages/experience-design-system-cli/src/import/tui/preview-confirmation-input.ts
-import { useCallback } from "react";
+import { useCallback as useCallback2 } from "react";
 function handlePreviewConfirmationInput(_input, key, options) {
   if (key.return) {
     options.onConfirm(options.breakingWithImpact);
@@ -10185,7 +10411,7 @@ function handlePreviewConfirmationInput(_input, key, options) {
   return false;
 }
 function usePreviewConfirmationInput(breakingWithImpact, onConfirm) {
-  return useCallback(
+  return useCallback2(
     (input, key) => handlePreviewConfirmationInput(input, key, {
       breakingWithImpact,
       onConfirm
@@ -19517,20 +19743,20 @@ var init_SearchMatchSummary = __esm({
 });
 
 // packages/experience-design-system-cli/src/import/tui/hooks/useOverlayPanel.ts
-import { useCallback as useCallback2, useState as useState13 } from "react";
+import { useCallback as useCallback3, useState as useState13 } from "react";
 function useOverlayPanel(opts) {
   const { toggleKey, onClose } = opts;
   const [isOpen, setIsOpen] = useState13(false);
-  const open = useCallback2(() => {
+  const open = useCallback3(() => {
     setIsOpen(true);
   }, []);
-  const close = useCallback2(() => {
+  const close = useCallback3(() => {
     setIsOpen((prev) => {
       if (prev && onClose) onClose();
       return false;
     });
   }, [onClose]);
-  const handleInput = useCallback2(
+  const handleInput = useCallback3(
     (input, key) => {
       if (!isOpen) return false;
       if (input === toggleKey || key.escape === true) {
@@ -24254,7 +24480,7 @@ var init_useFinalizePreview = __esm({
 });
 
 // packages/experience-design-system-cli/src/import/tui/hooks/useReviewSession.ts
-import { useCallback as useCallback3, useEffect as useEffect10, useRef as useRef6, useState as useState17 } from "react";
+import { useCallback as useCallback4, useEffect as useEffect10, useRef as useRef6, useState as useState17 } from "react";
 function loadReviewSessionState({
   extractSessionId,
   tokenSessionId,
@@ -24304,7 +24530,7 @@ function useReviewSession({
   const [loading, setLoading] = useState17(true);
   const [loadError, setLoadError] = useState17(null);
   const [availableTokens, setAvailableTokens] = useState17([]);
-  const loadInitialState = useCallback3(async () => {
+  const loadInitialState = useCallback4(async () => {
     const result = loadSession();
     if (result.error || !tokensPath) return { result, catalog: result.tokens };
     const catalog = (await readTokensFromPath("tokens", tokensPath)).map((token) => ({
@@ -25005,7 +25231,7 @@ var init_preview_annotations = __esm({
 });
 
 // packages/experience-design-system-cli/src/import/tui/useLivePreview.ts
-import { useCallback as useCallback4, useEffect as useEffect12, useRef as useRef8, useState as useState20 } from "react";
+import { useCallback as useCallback5, useEffect as useEffect12, useRef as useRef8, useState as useState20 } from "react";
 function useLivePreview(opts) {
   const debounceMs = opts.debounceMs ?? DEFAULT_DEBOUNCE_MS;
   const [status, setStatus] = useState20("idle");
@@ -25030,7 +25256,7 @@ function useLivePreview(opts) {
       }
     };
   }, []);
-  const trigger = useCallback4(() => {
+  const trigger = useCallback5(() => {
     const current = optsRef.current;
     if (!current.enabled) return;
     if (disabledRef.current) return;
@@ -25103,7 +25329,7 @@ var init_useLivePreview = __esm({
 });
 
 // packages/experience-design-system-cli/src/import/tui/hooks/useReviewPreview.ts
-import { useCallback as useCallback5, useEffect as useEffect13, useState as useState21 } from "react";
+import { useCallback as useCallback6, useEffect as useEffect13, useState as useState21 } from "react";
 function useReviewPreview({
   components,
   loading,
@@ -25119,7 +25345,7 @@ function useReviewPreview({
 }) {
   const [previewAnnotations, setPreviewAnnotations] = useState21(/* @__PURE__ */ new Map());
   const [removedComponents, setRemovedComponents] = useState21([]);
-  const handleResult = useCallback5(
+  const handleResult = useCallback6(
     (response) => {
       if (!response) return;
       setPreviewAnnotations(
@@ -25208,7 +25434,7 @@ var init_LivePreviewSummary = __esm({
 });
 
 // packages/experience-design-system-cli/src/import/tui/steps/GenerateReviewStep.tsx
-import { useCallback as useCallback6, useEffect as useEffect14, useMemo as useMemo3, useRef as useRef9, useState as useState22 } from "react";
+import { useCallback as useCallback7, useEffect as useEffect14, useMemo as useMemo3, useRef as useRef9, useState as useState22 } from "react";
 import figures6 from "figures";
 import { Box as Box41, Text as Text45 } from "ink";
 import { Fragment as Fragment18, jsx as jsx49, jsxs as jsxs42 } from "react/jsx-runtime";
@@ -25374,10 +25600,10 @@ function GenerateReviewStepView({
 }) {
   const { columns: terminalWidth, rows: terminalRows } = useTerminalSize();
   const [slotCycles, setSlotCycles] = useState22([]);
-  const setLoadedSlotCycles = useCallback6((cycles) => {
+  const setLoadedSlotCycles = useCallback7((cycles) => {
     setSlotCycles(cycles ?? []);
   }, []);
-  const loadSessionState = useCallback6(
+  const loadSessionState = useCallback7(
     () => loadReviewSessionState({
       extractSessionId,
       tokenSessionId,
@@ -25999,7 +26225,7 @@ function GenerateReviewStepView({
       }
       return;
     }
-    if (input === "c" && cycleRows.length > 0) {
+    if (input === "c" && !key.ctrl && !key.meta && cycleRows.length > 0) {
       cyclePanel.open();
       setCyclePanelScroll(0);
       setCyclesCursor(0);
@@ -26587,10 +26813,31 @@ var init_GenerateReviewStep = __esm({
 
 // packages/experience-design-system-cli/src/import/tui/runScopeGate.ts
 async function runScopeGate(opts) {
+  const startedAt = Date.now();
+  getDebugLogger().event("wizard", "scope-decision-persistence.start", {
+    sessionId: opts.sessionId,
+    acceptedCount: opts.decisions.accepted.length,
+    rejectedCount: opts.decisions.rejected.length
+  });
   const db = openPipelineDb();
   try {
     applyScopeDecisions(db, opts.sessionId, opts.decisions);
     await writeScopeDecisionsSnapshot(db, opts.sessionId, opts.decisions);
+    getDebugLogger().event("wizard", "scope-decision-persistence.complete", {
+      sessionId: opts.sessionId,
+      acceptedCount: opts.decisions.accepted.length,
+      rejectedCount: opts.decisions.rejected.length,
+      durationMs: Date.now() - startedAt
+    });
+  } catch (error) {
+    getDebugLogger().event("wizard", "scope-decision-persistence.error", {
+      sessionId: opts.sessionId,
+      acceptedCount: opts.decisions.accepted.length,
+      rejectedCount: opts.decisions.rejected.length,
+      durationMs: Date.now() - startedAt,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    throw error;
   } finally {
     db.close();
   }
@@ -26604,6 +26851,7 @@ var init_runScopeGate = __esm({
   "packages/experience-design-system-cli/src/import/tui/runScopeGate.ts"() {
     "use strict";
     init_persistence();
+    init_debug_logger();
     init_db();
   }
 });
@@ -26857,6 +27105,10 @@ function buildGenerateComponentsArgs(opts) {
   if (opts.generatePromptPath) args.push("--generate-prompt-path", opts.generatePromptPath);
   for (const prompt of opts.promptOverrides ?? []) args.push("--prompt", prompt);
   if (opts.existingEntitiesPath) args.push("--existing-entities-path", opts.existingEntitiesPath);
+  if (opts.restoreCache) args.push("--restore-cache");
+  if (opts.cachedComponents && opts.cachedComponents.length > 0) {
+    args.push("--cached-components", JSON.stringify(opts.cachedComponents));
+  }
   return args;
 }
 function buildGenerateTokensArgs(opts) {
@@ -26940,6 +27192,17 @@ function logStep(entry) {
   appendFileSync2(WIZARD_LOG, line);
   getDebugLogger().event("wizard", "step", entry);
 }
+function startWizardTimer(name, payload = {}) {
+  const startedAt = Date.now();
+  getDebugLogger().event("wizard", `${name}.start`, payload);
+  return startedAt;
+}
+function finishWizardTimer(name, startedAt, payload = {}) {
+  getDebugLogger().event("wizard", `${name}.complete`, {
+    ...payload,
+    durationMs: Date.now() - startedAt
+  });
+}
 function WizardApp({
   initialSpaceId = "",
   initialEnvironmentId = "master",
@@ -26962,6 +27225,7 @@ function WizardApp({
   const resolveWizardHost = (hostValue) => hostValue || defaultConfiguredHost;
   const credentialKey = (spaceId, environmentId, cmaToken, hostValue) => [spaceId.trim(), environmentId.trim(), cmaToken.trim(), resolveWizardHost(hostValue)].join("\0");
   const { columns: terminalWidth } = useTerminalSize();
+  const clearScreenOnTransition = useScreenTransitionClear();
   const logInit = useRef10(false);
   const initialAgentAuthRef = useRef10(initialAgentAuth ?? null);
   if (!logInit.current) {
@@ -26975,6 +27239,8 @@ function WizardApp({
   });
   const allowEmptyDeleteAllRef = useRef10(false);
   const generateChildRef = useRef10(null);
+  const generationCachePreflightRef = useRef10(null);
+  const selectionToReviewStartedAtRef = useRef10(null);
   const credentialsValidationIdRef = useRef10(0);
   const pendingCredentialValidationRef = useRef10(null);
   const validatedCredentialsKeyRef = useRef10(null);
@@ -26982,7 +27248,9 @@ function WizardApp({
   const extractPromiseRef = useRef10(null);
   const extractStartedRef = useRef10(false);
   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;
@@ -27052,7 +27320,10 @@ function WizardApp({
       tokensPath: state.tokensPath
     };
   }, [state.extractSessionId, state.tokensPath]);
-  const update = (partial) => {
+  const update = (partial, options = {}) => {
+    if (partial.step !== void 0 && partial.step !== state.step && options.clearScreen !== false) {
+      clearScreenOnTransition();
+    }
     const sanitized = { ...partial };
     if (sanitized.serverPreview) {
       const p = sanitized.serverPreview;
@@ -27099,12 +27370,41 @@ function WizardApp({
     logStep({ update: sanitized });
     setState((prev) => ({ ...prev, ...partial }));
   };
-  const runAgentAuthCheck = async (nextStep) => {
+  const finishSelectionToReviewTimer = (mode) => {
+    const startedAt = selectionToReviewStartedAtRef.current;
+    if (startedAt === null) return;
+    selectionToReviewStartedAtRef.current = null;
+    finishWizardTimer("selection-to-review", startedAt, { mode });
+  };
+  const runAgentAuthCheck = async (nextStep, deferStep = false) => {
+    const timer = startWizardTimer("agent-auth-validation", {
+      agent: state.agent,
+      deferred: deferStep,
+      nextStep
+    });
+    if (agentAuthVerifiedRef.current) {
+      finishWizardTimer("agent-auth-validation", timer, { status: "already-verified" });
+      if (!deferStep) update({ step: nextStep });
+      return true;
+    }
     const authCheckStepNumber = state.tokensPath ? 4 : 3;
     const prefetchedAuth = initialAgentAuthRef.current;
     initialAgentAuthRef.current = null;
-    if (!prefetchedAuth) update({ step: "checking-claude-auth", authCheckStepNumber });
-    const status = await (prefetchedAuth ?? checkAgentAuth(state.agent));
+    if (!prefetchedAuth && !deferStep) update({ step: "checking-claude-auth", authCheckStepNumber });
+    let status;
+    try {
+      status = await (prefetchedAuth ?? checkAgentAuth(state.agent));
+    } catch (error) {
+      finishWizardTimer("agent-auth-validation", timer, {
+        status: "error",
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+    finishWizardTimer("agent-auth-validation", timer, {
+      status,
+      prefetched: Boolean(prefetchedAuth)
+    });
     if (status === "not-found") {
       update({
         step: "error",
@@ -27128,7 +27428,8 @@ If you are using AWS Bedrock, run:
       });
       return false;
     }
-    update({ step: nextStep });
+    agentAuthVerifiedRef.current = true;
+    if (!deferStep) update({ step: nextStep });
     return true;
   };
   const runGenerateTokens = async (rawTokensPath, outDir, forceRegenerate = false) => {
@@ -27183,7 +27484,13 @@ If you are using AWS Bedrock, run:
     update({ tokensPath, tokenSessionId, tokenCount, tokenGenerationStatus: "complete" });
     return true;
   };
-  const runMapTokens2 = async (sessionId2) => {
+  const runMapTokens2 = async (sessionId2, silent = false) => {
+    const timer = startWizardTimer("token-mapping", {
+      sessionId: sessionId2,
+      silent,
+      noCache: effectiveNoCache,
+      skipAgent: skipMapTokens
+    });
     let mappablePropCount = 0;
     let rawTokenCount = 0;
     try {
@@ -27210,13 +27517,22 @@ If you are using AWS Bedrock, run:
         errorStep: "map tokens",
         errorMessage: error instanceof Error ? error.message : String(error)
       });
+      finishWizardTimer("token-mapping", timer, {
+        status: "error",
+        error: error instanceof Error ? error.message : String(error)
+      });
       return false;
     }
     if (!shouldRunMapTokens({ mappablePropCount, rawTokenCount })) {
-      update({ mapTokensEligible: false, mapTokensStatus: "complete" });
+      if (!silent) update({ mapTokensEligible: false, mapTokensStatus: "complete" });
+      finishWizardTimer("token-mapping", timer, {
+        status: "skipped",
+        mappablePropCount,
+        rawTokenCount
+      });
       return true;
     }
-    update({ mapTokensEligible: true, mapTokensStatus: "running" });
+    if (!silent) update({ mapTokensEligible: true, mapTokensStatus: "running", step: "generating" });
     const args = buildMapTokensArgs({
       sessionId: sessionId2,
       agent: state.agent,
@@ -27234,9 +27550,21 @@ If you are using AWS Bedrock, run:
         errorStep: "map tokens",
         errorMessage: result.stderr.trim() || "Unknown error"
       });
+      finishWizardTimer("token-mapping", timer, {
+        status: "error",
+        exitCode: result.exitCode,
+        mappablePropCount,
+        rawTokenCount
+      });
       return false;
     }
-    update({ mapTokensStatus: "complete" });
+    if (!silent) update({ mapTokensStatus: "complete" });
+    finishWizardTimer("token-mapping", timer, {
+      status: "complete",
+      exitCode: result.exitCode,
+      mappablePropCount,
+      rawTokenCount
+    });
     return true;
   };
   const startExistingEntitiesFetch = (projectPath, outDir) => {
@@ -27486,7 +27814,7 @@ Make sure this path contains TypeScript/React/Vue component files (.tsx, .ts, .v
       generateProgress: null
     }));
   };
-  const buildGenerateArgs = (extractSessionId, tokensPath, generatePromptPath2) => buildGenerateProcessArgs({
+  const buildGenerateOptions = (extractSessionId, tokensPath, generatePromptPath2, cachedComponents) => ({
     sessionId: extractSessionId,
     tokensPath,
     agent: state.agent,
@@ -27495,8 +27823,127 @@ Make sure this path contains TypeScript/React/Vue component files (.tsx, .ts, .v
     noCache: effectiveNoCache,
     ...state.existingEntitiesPath ? { existingEntitiesPath: state.existingEntitiesPath } : {},
     ...generatePromptPath2 ? { generatePromptPath: generatePromptPath2 } : {},
-    promptOverrides
+    promptOverrides,
+    ...cachedComponents && cachedComponents.length > 0 ? { cachedComponents } : {}
   });
+  const buildGenerateArgs = (extractSessionId, tokensPath, generatePromptPath2, cachedComponents) => buildGenerateProcessArgs(buildGenerateOptions(extractSessionId, tokensPath, generatePromptPath2, cachedComponents));
+  const buildGenerateCliArgs = (extractSessionId, tokensPath, generatePromptPath2, cachedComponents) => buildGenerateComponentsArgs(
+    buildGenerateOptions(extractSessionId, tokensPath, generatePromptPath2, cachedComponents)
+  );
+  const checkGenerateCache = async (extractSessionId, tokensPath) => {
+    const timer = startWizardTimer("generation-cache-status", {
+      sessionId: extractSessionId,
+      noCache: effectiveNoCache
+    });
+    if (effectiveNoCache) {
+      finishWizardTimer("generation-cache-status", timer, { status: "skipped" });
+      return false;
+    }
+    const result = await runCli([...buildGenerateCliArgs(extractSessionId, tokensPath), "--cache-status"]);
+    const hit = result.exitCode === 0 && /^cache-status=hit$/m.test(result.stdout);
+    finishWizardTimer("generation-cache-status", timer, {
+      status: hit ? "hit" : "miss",
+      exitCode: result.exitCode,
+      ...result.exitCode !== 0 ? { stderrTail: result.stderr.trim().slice(-500) } : {}
+    });
+    return hit;
+  };
+  const checkGenerateCacheComponents = async (extractSessionId, tokensPath, restoreCache = false) => {
+    const timer = startWizardTimer("generation-cache-components", {
+      sessionId: extractSessionId,
+      restoreCache,
+      noCache: effectiveNoCache
+    });
+    if (effectiveNoCache) {
+      finishWizardTimer("generation-cache-components", timer, { status: "skipped" });
+      return /* @__PURE__ */ new Set();
+    }
+    const args = [...buildGenerateCliArgs(extractSessionId, tokensPath), "--cache-status"];
+    if (restoreCache) args.push("--restore-cache");
+    const result = await runCli(args);
+    if (result.exitCode !== 0) {
+      finishWizardTimer("generation-cache-components", timer, {
+        status: "error",
+        exitCode: result.exitCode,
+        stderrTail: result.stderr.trim().slice(-500)
+      });
+      return /* @__PURE__ */ new Set();
+    }
+    const line = /^cache-components=(.+)$/m.exec(result.stdout)?.[1];
+    if (!line) {
+      finishWizardTimer("generation-cache-components", timer, {
+        status: "missing-output",
+        exitCode: result.exitCode,
+        cachedCount: 0
+      });
+      return /* @__PURE__ */ new Set();
+    }
+    try {
+      const names = JSON.parse(line);
+      const cachedNames = new Set(
+        Array.isArray(names) ? names.filter((name) => typeof name === "string") : []
+      );
+      finishWizardTimer("generation-cache-components", timer, {
+        status: "complete",
+        exitCode: result.exitCode,
+        cachedCount: cachedNames.size
+      });
+      return cachedNames;
+    } catch {
+      finishWizardTimer("generation-cache-components", timer, {
+        status: "invalid-output",
+        exitCode: result.exitCode,
+        cachedCount: 0
+      });
+      return /* @__PURE__ */ new Set();
+    }
+  };
+  useEffect15(() => {
+    if (state.step !== "extracting" && state.step !== "scope-gate" || !state.extractSessionId || state.existingEntitiesStatus === "running" || state.existingEntitiesStatus === "idle" || state.selectionAgentStatus !== "complete" || state.compositionPhase !== "done" && state.compositionPhase !== "cache-hit" || state.rawTokensPath && state.tokenGenerationStatus !== "complete" || effectiveNoCache) {
+      return;
+    }
+    const sessionId2 = state.extractSessionId;
+    if (generationCachePreflightRef.current?.sessionId === sessionId2) return;
+    const timer = startWizardTimer("generation-cache-preflight", { sessionId: sessionId2 });
+    const db = openPipelineDb();
+    let generatedNames = null;
+    try {
+      const rows = db.prepare("SELECT name, status FROM raw_components WHERE session_id = ?").all(sessionId2);
+      if (rows.length > 0 && rows.every((row) => row.status === "generated")) {
+        generatedNames = new Set(rows.map((row) => row.name));
+      }
+    } finally {
+      db.close();
+    }
+    if (generatedNames) {
+      generationCachePreflightRef.current = { sessionId: sessionId2, promise: Promise.resolve(generatedNames) };
+      finishWizardTimer("generation-cache-preflight", timer, {
+        status: "complete",
+        source: "session-db",
+        cachedCount: generatedNames.size
+      });
+      return;
+    }
+    const promise = checkGenerateCacheComponents(sessionId2, state.tokensPath, true);
+    generationCachePreflightRef.current = { sessionId: sessionId2, promise };
+    void promise.then((cachedNames) => {
+      finishWizardTimer("generation-cache-preflight", timer, {
+        status: "complete",
+        source: "cache-status",
+        cachedCount: cachedNames.size
+      });
+    });
+  }, [
+    state.step,
+    state.extractSessionId,
+    state.tokensPath,
+    state.rawTokensPath,
+    state.tokenGenerationStatus,
+    state.selectionAgentStatus,
+    state.compositionPhase,
+    state.existingEntitiesStatus,
+    state.existingEntitiesPath
+  ]);
   const startGeneratePrefetch = (extractSessionId, tokensPath) => {
     const args = buildGenerateArgs(extractSessionId, tokensPath);
     let progressCursor = null;
@@ -27551,8 +27998,14 @@ Make sure this path contains TypeScript/React/Vue component files (.tsx, .ts, .v
     });
     return donePromise;
   };
-  const runGenerate = async (extractSessionId, tokensPath, acceptedCount) => {
-    const args = buildGenerateArgs(extractSessionId, tokensPath, generatePromptPath);
+  const runGenerate = async (extractSessionId, tokensPath, acceptedCount, suppressScreen = false, cachedComponents = []) => {
+    const timer = startWizardTimer("component-generation", {
+      sessionId: extractSessionId,
+      acceptedCount,
+      suppressScreen,
+      noCache: effectiveNoCache
+    });
+    const args = buildGenerateArgs(extractSessionId, tokensPath, generatePromptPath, cachedComponents);
     let progressCursor = state.generateProgress;
     const { donePromise } = spawnGenerateChild({
       command: "node",
@@ -27561,12 +28014,17 @@ Make sure this path contains TypeScript/React/Vue component files (.tsx, .ts, .v
         const nextProgress = parseGenerateStderrChunk(chunk, progressCursor);
         if (nextProgress !== progressCursor) {
           progressCursor = nextProgress;
-          update({ generateProgress: nextProgress });
+          if (!suppressScreen) update({ generateProgress: nextProgress });
         }
       }
     });
     const result = await donePromise;
     if (result.exitCode !== 0) {
+      finishWizardTimer("component-generation", timer, {
+        status: "error",
+        exitCode: result.exitCode
+      });
+      finishSelectionToReviewTimer("error");
       update({
         step: "error",
         errorStep: "generate components",
@@ -27574,14 +28032,67 @@ Make sure this path contains TypeScript/React/Vue component files (.tsx, .ts, .v
       });
       return;
     }
-    const { generateSessionId: generateSessionId2, generatedCount } = parseGenerateResult(result, acceptedCount);
+    const { generateSessionId: generateSessionId2, generatedCount, renamedSlotsCount } = parseGenerateResult(result, acceptedCount);
     const mappedSessionId = generateSessionId2 ?? extractSessionId;
-    update({
-      generateSessionId: mappedSessionId,
+    finishWizardTimer("component-generation", timer, {
+      status: "complete",
+      exitCode: result.exitCode,
       generatedCount,
-      generateProgress: null
+      renamedSlotsCount
     });
-    if (await runMapTokens2(mappedSessionId)) update({ step: "final-review" });
+    if (!suppressScreen) {
+      update({
+        acceptedCount,
+        autoRejectedCount: 0,
+        generateSessionId: mappedSessionId,
+        generatedCount,
+        generateProgress: null
+      });
+      if (await runMapTokens2(mappedSessionId)) {
+        finishSelectionToReviewTimer("generated");
+        update({ step: "final-review" });
+      } else {
+        finishSelectionToReviewTimer("error");
+      }
+      return;
+    }
+    const mapped = await runMapTokens2(mappedSessionId, true);
+    if (mapped) {
+      finishSelectionToReviewTimer("generated");
+      update(
+        {
+          acceptedCount,
+          autoRejectedCount: 0,
+          generateSessionId: mappedSessionId,
+          generatedCount,
+          generateProgress: null,
+          mapTokensStatus: "complete",
+          step: "final-review"
+        },
+        { clearScreen: false }
+      );
+    } else {
+      finishSelectionToReviewTimer("error");
+    }
+  };
+  const finishCachedGeneration = async (sessionId2, acceptedCount) => {
+    if (await runMapTokens2(sessionId2, true)) {
+      finishSelectionToReviewTimer("cached");
+      update(
+        {
+          acceptedCount,
+          autoRejectedCount: 0,
+          generateSessionId: sessionId2,
+          generatedCount: acceptedCount,
+          generateProgress: null,
+          mapTokensStatus: "complete",
+          step: "final-review"
+        },
+        { clearScreen: false }
+      );
+    } else {
+      finishSelectionToReviewTimer("error");
+    }
   };
   const advanceToPushFlow = (generatedAcceptedCount) => {
     update({ generatedAcceptedCount });
@@ -27766,8 +28277,15 @@ Make sure this path contains TypeScript/React/Vue component files (.tsx, .ts, .v
           return;
         }
       }
-      if (await runAgentAuthCheck("generating")) {
-        void runGenerate(sid, state.tokensPath, state.acceptedCount);
+      if (await runAgentAuthCheck("generating", true)) {
+        const cacheHit = await checkGenerateCache(sid, state.tokensPath);
+        if (cacheHit) {
+          update({ step: "generating" });
+          void finishCachedGeneration(sid, state.acceptedCount);
+        } else {
+          update({ step: "generating" });
+          void runGenerate(sid, state.tokensPath, state.acceptedCount);
+        }
       }
       return;
     }
@@ -28135,13 +28653,13 @@ If using a custom host configuration, make sure the space exists on that host.`
     update(nextStateAfterPrint({ skipGate: opts.skipGate, componentsPath }));
     return { ok: true };
   };
-  const runSaveAndPush = async () => {
-    await startSaveFlow({ skipGate: true, andPush: true });
+  const runSaveAndPush = async (statePatch = {}) => {
+    await startSaveFlow({ skipGate: true, andPush: true }, statePatch);
   };
   const pendingSaveOptionsRef = useRef10({});
-  const startSaveFlow = async (opts = {}) => {
+  const startSaveFlow = async (opts = {}, statePatch = {}) => {
     pendingSaveOptionsRef.current = opts;
-    setState((prev) => ({ ...prev, step: "path-prompt" }));
+    update({ ...statePatch, step: "path-prompt" });
   };
   const proceedToWrite = async (path) => {
     setState((prev) => ({ ...prev, outDir: path }));
@@ -28373,42 +28891,103 @@ 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,
           {
             components,
             onConfirm: (decisions) => {
-              void runScopeGate({
-                sessionId: sessionId2,
-                decisions,
-                onAdvanceToGenerate: async ({ sessionId: sid, acceptedCount }) => {
-                  scopeGateCompletedRef.current = true;
-                  if (shouldGenerateAfterScopeGate({ acceptedCount })) {
-                    update({
-                      acceptedCount,
-                      autoRejectedCount: 0,
-                      step: "checking-claude-auth",
-                      authCheckStepNumber: state.tokensPath ? 4 : 3
-                    });
-                    if (await runAgentAuthCheck("generating")) {
-                      void runGenerate(sid, state.tokensPath, acceptedCount);
+              void (async () => {
+                selectionToReviewStartedAtRef.current = decisions.accepted.length > 0 ? startWizardTimer("selection-to-review", {
+                  sessionId: sessionId2,
+                  acceptedCount: decisions.accepted.length,
+                  rejectedCount: decisions.rejected.length
+                }) : null;
+                const preflight = generationCachePreflightRef.current;
+                const cachePromise = preflight?.sessionId === sessionId2 ? preflight.promise : checkGenerateCacheComponents(sessionId2, state.tokensPath, true);
+                if (!preflight || preflight.sessionId !== sessionId2) {
+                  generationCachePreflightRef.current = { sessionId: sessionId2, promise: cachePromise };
+                }
+                const cacheWaitStartedAt = startWizardTimer("selection-cache-restoration-wait", {
+                  sessionId: sessionId2,
+                  preflight: Boolean(preflight?.sessionId === sessionId2)
+                });
+                try {
+                  const cachedNames = await cachePromise;
+                  finishWizardTimer("selection-cache-restoration-wait", cacheWaitStartedAt, {
+                    status: "complete",
+                    cachedCount: cachedNames.size
+                  });
+                } catch (error) {
+                  finishWizardTimer("selection-cache-restoration-wait", cacheWaitStartedAt, {
+                    status: "error",
+                    error: error instanceof Error ? error.message : String(error)
+                  });
+                  finishSelectionToReviewTimer("error");
+                  throw error;
+                }
+                await runScopeGate({
+                  sessionId: sessionId2,
+                  decisions,
+                  onAdvanceToGenerate: async ({ sessionId: sid, acceptedCount }) => {
+                    scopeGateCompletedRef.current = true;
+                    if (shouldGenerateAfterScopeGate({ acceptedCount })) {
+                      const authPromise = runAgentAuthCheck("generating", true);
+                      if (await authPromise) {
+                        const comparisonStartedAt = startWizardTimer("generation-cache-set-comparison", {
+                          sessionId: sid,
+                          acceptedCount: decisions?.accepted.length ?? 0
+                        });
+                        let cachedNames = await cachePromise;
+                        const acceptedNames = decisions?.accepted ?? [];
+                        let cacheHit = !effectiveNoCache && acceptedNames.length > 0 && acceptedNames.every((name) => cachedNames.has(name));
+                        if (!cacheHit && !effectiveNoCache && acceptedNames.length > 0) {
+                          cachedNames = await checkGenerateCacheComponents(sid, state.tokensPath, true);
+                          cacheHit = acceptedNames.every((name) => cachedNames.has(name));
+                        }
+                        finishWizardTimer("generation-cache-set-comparison", comparisonStartedAt, {
+                          status: "complete",
+                          cacheHit,
+                          cachedCount: cachedNames.size,
+                          acceptedCount: acceptedNames.length
+                        });
+                        if (cacheHit) {
+                          void finishCachedGeneration(sid, acceptedCount);
+                        } else {
+                          const acceptedNameSet = new Set(acceptedNames);
+                          const restoredCachedNames = [...cachedNames].filter((name) => acceptedNameSet.has(name));
+                          update({
+                            step: "generating",
+                            generateProgress: null,
+                            acceptedCount
+                          });
+                          void runGenerate(sid, state.tokensPath, acceptedCount, false, restoredCachedNames);
+                        }
+                      } else {
+                        finishSelectionToReviewTimer("error");
+                      }
+                      return;
                     }
-                    return;
+                    void runSaveAndPush();
+                  },
+                  onAdvanceToPushFlow: (count) => {
+                    scopeGateCompletedRef.current = true;
+                    update({ acceptedCount: count, autoRejectedCount: 0 });
+                    advanceToPushFlow(count);
                   }
-                  void runSaveAndPush();
-                },
-                onAdvanceToPushFlow: (count) => {
-                  scopeGateCompletedRef.current = true;
-                  update({ acceptedCount: count, autoRejectedCount: 0 });
-                  advanceToPushFlow(count);
-                }
-              });
+                });
+              })();
             },
             onQuit: () => process.exit(0)
           }
@@ -28495,8 +29074,10 @@ If using a custom host configuration, make sure the space exists on that host.`
               }
               const allowEmptyDeleteAll = acceptedCount === 0;
               allowEmptyDeleteAllRef.current = allowEmptyDeleteAll;
-              update({ finalReviewPassed: true, generatedAcceptedCount: acceptedCount });
-              void runSaveAndPush();
+              void runSaveAndPush({
+                finalReviewPassed: true,
+                generatedAcceptedCount: acceptedCount
+              });
             },
             onQuit: () => process.exit(0)
           }
@@ -28735,6 +29316,7 @@ var init_WizardApp = __esm({
     init_prompt_overrides();
     init_run_selection_agent();
     init_use_terminal_size();
+    init_render_with_goodbye();
     SAVE_CONFIRMATION_DELAY_MS = 1e3;
     WIZARD_LOG = join20(tmpdir(), "experiences-import-wizard.log");
   }