@contentful/experience-design-system-cli 2.37.1-dev-build-5fe4d4be.0 → 2.37.1-dev-build-04545499.0

package/dist/app.js

@@ -772,7 +772,7 @@ async function runAgent(options) {
     promptLen: prompt.length,
     promptHead: prompt.slice(0, 500)
   });
-  return new Promise((resolve10) => {
+  return new Promise((resolve12) => {
     const bedrockEnv = bedrock ? BEDROCK_ENV_BY_AGENT[agent] : void 0;
     const child = spawn(binary, args, {
       stdio: ["pipe", "pipe", "pipe"],
@@ -821,7 +821,7 @@ async function runAgent(options) {
         stderrLen: stderr.length,
         stderrTail: stderr.slice(-1e3)
       });
-      resolve10(result);
+      resolve12(result);
     });
   });
 }
@@ -843,7 +843,7 @@ async function checkAgentAuth(agent) {
     return "not-found";
   if (agent !== "claude")
     return "ok";
-  return new Promise((resolve10) => {
+  return new Promise((resolve12) => {
     const child = spawn2(binary, ["auth", "status", "--json"], { stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let done = false;
@@ -852,7 +852,7 @@ async function checkAgentAuth(agent) {
         return;
       done = true;
       child.kill("SIGTERM");
-      resolve10("unauthenticated");
+      resolve12("unauthenticated");
     }, 5e3);
     child.stdout?.on("data", (chunk) => {
       stdout += chunk.toString();
@@ -863,14 +863,14 @@ async function checkAgentAuth(agent) {
       done = true;
       clearTimeout(timer);
       if (code !== 0) {
-        resolve10("unauthenticated");
+        resolve12("unauthenticated");
         return;
       }
       try {
         const status = JSON.parse(stdout);
-        resolve10(status.loggedIn ? "ok" : "unauthenticated");
+        resolve12(status.loggedIn ? "ok" : "unauthenticated");
       } catch {
-        resolve10("unauthenticated");
+        resolve12("unauthenticated");
       }
     });
   });
@@ -880,9 +880,9 @@ async function binaryIsOnPath(binary) {
     const fs = await import("node:fs/promises");
     return fs.access(binary).then(() => true, () => false);
   }
-  return new Promise((resolve10) => {
+  return new Promise((resolve12) => {
     const child = spawn2(process.platform === "win32" ? "where" : "which", [binary], { stdio: "ignore" });
-    child.on("close", (code) => resolve10(code === 0));
+    child.on("close", (code) => resolve12(code === 0));
   });
 }
 var init_check_agent_auth = __esm({
@@ -1356,6 +1356,23 @@ var init_flatten = __esm({
 });
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/shared/dtcg/helpers/validate.js
+function isDesignTokenType(value) {
+  return typeof value === "string" && TOKEN_TYPE_SET2.has(value);
+}
+function validateDTCG(obj) {
+  const errors = [];
+  const tokens = flattenDTCG(obj, "");
+  for (const token of tokens) {
+    if (!isDesignTokenType(token.$type)) {
+      errors.push({
+        path: token.path,
+        message: `Unknown $type "${token.$type}". Must be one of: ${DESIGN_TOKEN_TYPES.join(", ")}.`,
+        actual: token.$type
+      });
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
 var TOKEN_TYPE_SET2;
 var init_validate2 = __esm({
   "packages/experience-design-system-backend-pipeline/dist/src/steps/shared/dtcg/helpers/validate.js"() {
@@ -2000,8 +2017,8 @@ var init_cache_keys = __esm({
 });
 
 // packages/experience-design-system-cli/app.tsx
-import { join as join13 } from "node:path";
-import { useEffect as useEffect14, useState as useState20 } from "react";
+import { join as join14 } from "node:path";
+import { useEffect as useEffect15, useState as useState21 } from "react";
 
 // packages/experience-design-system-cli/src/tui/home/home.tsx
 import { useEffect as useEffect2, useState as useState2 } from "react";
@@ -2562,6 +2579,59 @@ function indexRowsByKey(items, key) {
   return map;
 }
 
+// packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/repositories/sessions/write.js
+function updateSessionTimestamp(db, sessionId, timestamp) {
+  db.prepare("UPDATE sessions SET updated_at = ? WHERE id = ?").run(timestamp, sessionId);
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/helpers/tokens/build-dtcg-groups.js
+function buildDtcgGroups(groupRows, tokenRows) {
+  return groupRows.map((r) => {
+    const prefix = `${r.path}.`;
+    const tokenIds = tokenRows.filter((t) => t.path.startsWith(prefix) && !t.path.slice(prefix.length).includes(".")).map((t) => t.path);
+    const g = { path: r.path, tokenIds };
+    if (r.description !== null)
+      g.$description = r.description;
+    return g;
+  });
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/helpers/tokens/build-dtcg-tokens.js
+function buildDtcgTokens(tokenRows) {
+  return tokenRows.map((r) => {
+    const t = {
+      path: r.path,
+      $type: r.type,
+      $value: JSON.parse(r.value)
+    };
+    if (r.description !== null)
+      t.$description = r.description;
+    return t;
+  });
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/repositories/tokens/read.js
+function getDtcgTokensForSession(db, sessionId) {
+  const groupRows = db.prepare("SELECT path, description FROM raw_token_groups WHERE session_id = ? ORDER BY path").all(sessionId).map((row) => ({
+    path: String(row.path),
+    description: row.description === null ? null : String(row.description)
+  }));
+  const tokenRows = db.prepare("SELECT path, type, value, description FROM raw_tokens WHERE session_id = ? ORDER BY path").all(sessionId).map((row) => ({
+    path: String(row.path),
+    type: String(row.type),
+    value: String(row.value),
+    description: row.description === null ? null : String(row.description)
+  }));
+  return {
+    groups: buildDtcgGroups(groupRows, tokenRows),
+    tokens: buildDtcgTokens(tokenRows)
+  };
+}
+function getRawTokenNamePaths(db, sessionId) {
+  const rows = db.prepare("SELECT raw_name, path FROM raw_token_name_paths WHERE session_id = ? ORDER BY raw_name").all(sessionId);
+  return Object.fromEntries(rows.map((row) => [String(row.raw_name), String(row.path)]));
+}
+
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/helpers/components/hash-component-shape.js
 import { createHash } from "node:crypto";
 function hashComponentShape(component) {
@@ -2581,6 +2651,48 @@ function hashComponentShape(component) {
   return createHash("sha256").update(JSON.stringify(payload)).digest("hex");
 }
 
+// packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/repositories/tokens/write.js
+function deleteRawTokensForSession(db, sessionId) {
+  db.prepare("DELETE FROM raw_token_groups WHERE session_id = ?").run(sessionId);
+  db.prepare("DELETE FROM raw_tokens WHERE session_id = ?").run(sessionId);
+}
+function createRawTokenGroups(db, sessionId, groups) {
+  const insertGroup = db.prepare(`INSERT INTO raw_token_groups (session_id, path, description) VALUES (?, ?, ?)`);
+  for (const group of groups) {
+    insertGroup.run(sessionId, group.path, group.$description ?? null);
+  }
+}
+function createRawTokens(db, sessionId, tokens) {
+  const insertToken = db.prepare(`INSERT INTO raw_tokens (session_id, path, type, value, description) VALUES (?, ?, ?, ?, ?)`);
+  for (const token of tokens) {
+    insertToken.run(sessionId, token.path, token.$type, JSON.stringify(token.$value), token.$description ?? null);
+  }
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/repositories/shared/with-transaction.js
+function withTransaction(db, fn) {
+  db.exec("BEGIN");
+  try {
+    const result = fn();
+    db.exec("COMMIT");
+    return result;
+  } catch (e) {
+    db.exec("ROLLBACK");
+    throw e;
+  }
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/services/tokens/store-dtcg-tokens.js
+function storeDtcgTokens(db, sessionId, groups, tokens) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  withTransaction(db, () => {
+    deleteRawTokensForSession(db, sessionId);
+    createRawTokenGroups(db, sessionId, groups);
+    createRawTokens(db, sessionId, tokens);
+    updateSessionTimestamp(db, sessionId, now);
+  });
+}
+
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/repositories/db.js
 var SCHEMA = `
 PRAGMA journal_mode = WAL;
@@ -3093,6 +3205,91 @@ function parseReviewReasons(raw) {
     return [];
   }
 }
+function loadCDFComponents(db, sessionId) {
+  const components = db.prepare(`SELECT component_id, name, description FROM raw_components
+       WHERE session_id = ? AND status = 'generated' ORDER BY rowid`).all(sessionId);
+  if (components.length === 0)
+    return [];
+  const props = db.prepare(`SELECT component_id, name, required, default_value, description,
+              cdf_type, cdf_category, cdf_token_kind, position
+       FROM raw_props
+       WHERE session_id = ? AND cdf_type IS NOT NULL
+       ORDER BY component_id, position`).all(sessionId);
+  const allowedValues = db.prepare(`SELECT component_id, prop_name, value, position
+       FROM raw_prop_allowed_values WHERE session_id = ? ORDER BY component_id, prop_name, position`).all(sessionId);
+  const slots = db.prepare(`SELECT component_id, name, description, required FROM raw_slots WHERE session_id = ? ORDER BY component_id, position`).all(sessionId);
+  const allowedComponents = db.prepare(`SELECT component_id, slot_name, allowed_component
+       FROM raw_slot_allowed_components WHERE session_id = ? ORDER BY component_id, slot_name, position`).all(sessionId);
+  const tokenPaths = db.prepare(`SELECT component_id, prop_name, position, path
+       FROM raw_prop_token_paths WHERE session_id = ? ORDER BY component_id, prop_name, position`).all(sessionId);
+  const resolvedDefaultPaths = getRawTokenNamePaths(db, sessionId);
+  const tokenTypeByPath = new Map(db.prepare("SELECT path, type FROM raw_tokens WHERE session_id = ?").all(sessionId).map((token) => [token.path, token.type]));
+  const propsByComponent = indexRowsByKey(props, (p) => p.component_id);
+  const allowedValuesByProp = indexRowsByKey(allowedValues, (av) => `${av.component_id}::${av.prop_name}`);
+  const slotsByComponent = indexRowsByKey(slots, (s) => s.component_id);
+  const allowedComponentsBySlot = indexRowsByKey(allowedComponents, (ac) => `${ac.component_id}::${ac.slot_name}`);
+  const tokenPathsByProp = indexRowsByKey(tokenPaths, (t) => `${t.component_id}::${t.prop_name}`);
+  const toTokenPaths = (rows) => rows === void 0 ? void 0 : rows.map((r) => r.path);
+  return components.map(({ component_id, name, description }) => {
+    const compProps = propsByComponent.get(component_id) ?? [];
+    const $properties = {};
+    for (const p of compProps) {
+      if (!p.name.trim())
+        continue;
+      const av = allowedValuesByProp.get(`${component_id}::${p.name}`);
+      const propDef = {
+        $type: p.cdf_type,
+        $category: p.cdf_category
+      };
+      if (p.required)
+        propDef.$required = true;
+      const isTokenProp = p.cdf_type === "token" && p.cdf_category === "design";
+      const defaultReference = p.default_value;
+      const resolvedDefault = isTokenProp && p.cdf_token_kind !== null && defaultReference !== null ? resolvedDefaultPaths[defaultReference] : void 0;
+      const compatibleResolvedDefault = resolvedDefault !== void 0 && tokenTypeByPath.get(resolvedDefault) === p.cdf_token_kind ? resolvedDefault : void 0;
+      if (p.default_value !== null) {
+        if (p.cdf_type === "boolean") {
+          propDef.$default = p.default_value === "true";
+        } else {
+          propDef.$default = compatibleResolvedDefault ?? p.default_value;
+        }
+      }
+      if (p.description !== null)
+        propDef.$description = p.description;
+      if (!isTokenProp && av && av.length > 0)
+        propDef.$values = av.map((v) => v.value);
+      if (p.cdf_token_kind !== null)
+        propDef["$token.kind"] = p.cdf_token_kind;
+      if (isTokenProp) {
+        const allowed = toTokenPaths(tokenPathsByProp.get(`${component_id}::${p.name}`));
+        if (allowed !== void 0 && allowed.length > 0)
+          propDef["$token.allowed"] = allowed;
+      }
+      $properties[p.name] = propDef;
+    }
+    const compSlots = slotsByComponent.get(component_id) ?? [];
+    const $slots = {};
+    for (const s of compSlots) {
+      if (!s.name.trim())
+        continue;
+      const ac = allowedComponentsBySlot.get(`${component_id}::${s.name}`);
+      const slotDef = {};
+      if (s.description !== null)
+        slotDef.$description = s.description;
+      if (s.required)
+        slotDef.$required = true;
+      if (ac && ac.length > 0)
+        slotDef.$allowedComponents = ac.map((v) => v.allowed_component);
+      $slots[s.name] = slotDef;
+    }
+    const entry = { $type: "component", $properties };
+    if (description !== null)
+      entry.$description = description;
+    if (Object.keys($slots).length > 0)
+      entry.$slots = $slots;
+    return { key: name, entry };
+  });
+}
 function loadScopeComponents(db, sessionId) {
   const rows = db.prepare(`SELECT name, component_id, status, reject_reason, review_reasons, needs_review FROM raw_components
        WHERE session_id = ? AND status IN ('extracted', 'accepted', 'rejected')
@@ -3121,6 +3318,38 @@ function loadScopeComponents(db, sessionId) {
     };
   });
 }
+function applyScopeDecisions(db, sessionId, decisions) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const acceptedSet = new Set(decisions.accepted);
+  const accepted = [...acceptedSet];
+  const rejected = [...new Set(decisions.rejected)].filter((n) => !acceptedSet.has(n));
+  if (rejected.length > 0) {
+    const placeholders = rejected.map(() => "?").join(",");
+    db.prepare(`UPDATE raw_components SET status = 'rejected' WHERE session_id = ? AND name IN (${placeholders})`).run(sessionId, ...rejected);
+  }
+  if (accepted.length > 0) {
+    const placeholders = accepted.map(() => "?").join(",");
+    db.prepare(`UPDATE raw_components SET status = 'generated' WHERE session_id = ? AND name IN (${placeholders})`).run(sessionId, ...accepted);
+  }
+  db.prepare("UPDATE sessions SET updated_at = ? WHERE id = ?").run(now, sessionId);
+}
+function copyTokensFromCache(db, sourceSessionId, targetSessionId) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.exec("BEGIN");
+  try {
+    db.prepare("DELETE FROM raw_tokens WHERE session_id = ?").run(targetSessionId);
+    db.prepare("DELETE FROM raw_token_groups WHERE session_id = ?").run(targetSessionId);
+    db.prepare(`INSERT INTO raw_token_groups (session_id, path, description)
+       SELECT ?, path, description FROM raw_token_groups WHERE session_id = ?`).run(targetSessionId, sourceSessionId);
+    db.prepare(`INSERT INTO raw_tokens (session_id, path, type, value, description)
+       SELECT ?, path, type, value, description FROM raw_tokens WHERE session_id = ?`).run(targetSessionId, sourceSessionId);
+    db.prepare("UPDATE sessions SET updated_at = ? WHERE id = ?").run(now, targetSessionId);
+    db.exec("COMMIT");
+  } catch (e) {
+    db.exec("ROLLBACK");
+    throw e;
+  }
+}
 var _cliCacheVersionCache = null;
 async function getCliCacheVersion() {
   if (_cliCacheVersionCache)
@@ -3373,6 +3602,32 @@ init_agents();
 init_agents();
 var DEFAULT_TIMEOUT_MS = Number(process.env.EDS_AGENT_TIMEOUT_MS ?? 5 * 60 * 1e3);
 
+// packages/experience-design-system-backend-pipeline/dist/src/persistence/src/review-session/repositories/review-session-paths.js
+import { resolve as resolve7 } from "node:path";
+async function getRefineSessionPaths(sessionId, artifactsRoot) {
+  const sessionDir = resolve7(artifactsRoot, sessionId);
+  return {
+    sessionDir,
+    eventsPath: resolve7(sessionDir, "events.jsonl"),
+    statePath: resolve7(sessionDir, "current-review-state.json")
+  };
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/persistence/src/review-session/repositories/review-artifacts-root.js
+import { resolve as resolve8 } from "node:path";
+function getRefineArtifactsRoot() {
+  if (process.env["EDS_REVIEW_ARTIFACTS_DIR"]) {
+    return resolve8(process.env["EDS_REVIEW_ARTIFACTS_DIR"]);
+  }
+  return resolve8(configRoot(), "reviews");
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/persistence/src/review-session/repositories/save-review-state.js
+import { writeFile } from "node:fs/promises";
+async function saveReviewState(statePath, session) {
+  await writeFile(statePath, JSON.stringify(session, null, 2), "utf8");
+}
+
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/helpers/collect-files/collect-files.js
 import { statSync as statSync2 } from "node:fs";
 import path4 from "node:path";
@@ -3559,15 +3814,15 @@ function walkProjectTree(dir, result, includeContent) {
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/helpers/collect-files/collect-files.js
 function collectFiles(root, options = {}) {
   const resolved = path4.resolve(root);
-  let stat2;
+  let stat4;
   try {
-    stat2 = statSync2(resolved);
+    stat4 = statSync2(resolved);
   } catch (err) {
     return { ok: false, failure: classifyStatError(err.code), rootPath: resolved };
   }
-  if (stat2.isFile())
+  if (stat4.isFile())
     return { ok: false, failure: "is-file", rootPath: resolved };
-  if (!stat2.isDirectory())
+  if (!stat4.isDirectory())
     return { ok: false, failure: "not-directory", rootPath: resolved };
   const result = {
     filePaths: [],
@@ -3585,6 +3840,38 @@ function collectFiles(root, options = {}) {
   return { ok: true, result };
 }
 
+// packages/experience-design-system-backend-pipeline/dist/src/persistence/src/review-session/services/write-scope-decisions-snapshot.js
+import { mkdir } from "node:fs/promises";
+async function writeScopeDecisionsSnapshot(db, sessionId, decisions) {
+  const acceptedSet = new Set(decisions.accepted);
+  const rawComponents = loadRawComponents(db, sessionId);
+  const records = rawComponents.map((c2) => {
+    const status = acceptedSet.has(c2.name) ? "accepted" : "rejected";
+    const proposal = {
+      name: c2.name,
+      source: c2.source,
+      framework: c2.framework,
+      props: c2.props,
+      slots: c2.slots,
+      ...c2.extractionConfidence !== void 0 ? { extractionConfidence: c2.extractionConfidence } : {},
+      ...c2.reviewReasons !== void 0 ? { reviewReasons: c2.reviewReasons } : {},
+      ...c2.needsReview !== void 0 ? { needsReview: c2.needsReview } : {}
+    };
+    return {
+      id: c2.component_id,
+      name: c2.name,
+      resolvedSourcePath: "",
+      sourceCode: null,
+      originalProposal: proposal,
+      editedProposal: proposal,
+      status
+    };
+  });
+  const paths = await getRefineSessionPaths(sessionId, getRefineArtifactsRoot());
+  await mkdir(paths.sessionDir, { recursive: true });
+  await saveReviewState(paths.statePath, { components: records });
+}
+
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/index.js
 import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
 
@@ -3794,7 +4081,7 @@ var defaultPathSerializer = ({ path: path5, url: _url }) => {
   }
   return url;
 };
-var createQuerySerializer = ({ allowReserved, array: array4, object: object2 } = {}) => {
+var createQuerySerializer = ({ allowReserved, array: array3, object: object2 } = {}) => {
   const querySerializer = (queryParams) => {
     const search = [];
     if (queryParams && typeof queryParams === "object") {
@@ -3810,7 +4097,7 @@ var createQuerySerializer = ({ allowReserved, array: array4, object: object2 } =
             name,
             style: "form",
             value,
-            ...array4
+            ...array3
           });
           if (serializedArray)
             search.push(serializedArray);
@@ -4218,7 +4505,7 @@ function errorMessage(error) {
   return error instanceof Error && error.message ? error.message : String(error);
 }
 function defaultSleep(delayMs) {
-  return new Promise((resolve10) => setTimeout(resolve10, delayMs));
+  return new Promise((resolve12) => setTimeout(resolve12, delayMs));
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/apply/src/helpers/sanitize-preview.js
@@ -4457,7 +4744,7 @@ var ApiClient = class {
         const progress = maxAttempts > 1 ? attempt / (maxAttempts - 1) : 0;
         const baseDelay = intervalMs + (maxIntervalMs - intervalMs) * progress;
         const jitter = Math.random() * baseDelay * 0.15;
-        await new Promise((resolve10) => setTimeout(resolve10, baseDelay + jitter));
+        await new Promise((resolve12) => setTimeout(resolve12, baseDelay + jitter));
       }
     }
     throw new Error(`Operation ${operationId} timed out after ${maxAttempts} attempts`);
@@ -4650,11 +4937,11 @@ function parseEdsiError(rawInput) {
       ...binding.diagnostics ? { diagnostics: binding.diagnostics } : {}
     };
   }
-  const literal3 = parseObjectLiteralTail(cleaned);
-  if (literal3 && (literal3.code || literal3.cycle)) {
+  const literal4 = parseObjectLiteralTail(cleaned);
+  if (literal4 && (literal4.code || literal4.cycle)) {
     const braceStart = cleaned.lastIndexOf("{");
     const head = braceStart === -1 ? cleaned : cleaned.slice(0, braceStart).trim();
-    return { code: literal3.code ?? null, message: head || cleaned, cycle: literal3.cycle ?? null, raw: false };
+    return { code: literal4.code ?? null, message: head || cleaned, cycle: literal4.cycle ?? null, raw: false };
   }
   return { code: null, message: cleaned || prefix || rawInput, cycle: null, raw: true };
 }
@@ -4735,6 +5022,99 @@ function formatApiError2(request) {
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/apply/src/helpers/tokens/read-tokens-from-path.js
 init_shared();
+import { readFile as readFile4, stat as stat2 } from "node:fs/promises";
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/apply/src/helpers/tokens/collect-json-files.js
+import { readdir, stat } from "node:fs/promises";
+import { join as join5 } from "node:path";
+var IGNORE_TOKEN_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", "build", ".next", ".nuxt", ".git"]);
+async function collectJsonFiles(dir) {
+  const results = [];
+  await walk(dir, results);
+  return results;
+}
+async function walk(current, results) {
+  let entries;
+  try {
+    entries = await readdir(current);
+  } catch {
+    return;
+  }
+  await Promise.all(entries.map(async (entry) => {
+    if (IGNORE_TOKEN_DIRS.has(entry))
+      return;
+    const full = join5(current, entry);
+    let s;
+    try {
+      s = await stat(full);
+    } catch {
+      return;
+    }
+    if (s.isDirectory()) {
+      await walk(full, results);
+    } else if (entry.endsWith(".json")) {
+      results.push(full);
+    }
+  }));
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/apply/src/helpers/tokens/read-tokens-from-path.js
+async function readTokensFromPath(flag, p) {
+  let s;
+  try {
+    s = await stat2(p);
+  } catch {
+    throw new Error(`file not found: ${p} (from ${flag})`);
+  }
+  const merged = s.isDirectory() ? await readMergedFromDir(flag, p) : await readSingleFile(flag, p);
+  const { valid, errors } = validateDTCG(merged);
+  if (!valid) {
+    throw new Error(`${flag} contains invalid token types:
+${errors.map((e) => `  ${e.path}: ${e.message}`).join("\n")}`);
+  }
+  return flattenDTCG(merged, "");
+}
+async function readMergedFromDir(flag, dir) {
+  const files = await collectJsonFiles(dir);
+  if (files.length === 0)
+    throw new Error(`no .json files found in directory: ${dir} (from ${flag})`);
+  const merged = {};
+  for (const file of files.sort()) {
+    try {
+      const text = await readFile4(file, "utf8");
+      const parsed = JSON.parse(text);
+      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+        Object.assign(merged, parsed);
+      }
+    } catch {
+      continue;
+    }
+  }
+  return merged;
+}
+async function readSingleFile(flag, p) {
+  let text;
+  try {
+    text = await readFile4(p, "utf8");
+  } catch {
+    throw new Error(`file not found: ${p} (from ${flag})`);
+  }
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch {
+    throw new Error(`${flag} is not valid JSON: ${p}`);
+  }
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new Error(`${flag} is not valid JSON: expected an object`);
+  }
+  return raw;
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/apply/src/controller/tokens/read-tokens-from-path.js
+function readTokensFromPath2(request) {
+  return readTokensFromPath(request.flag, request.path);
+}
 
 // packages/experience-design-system-backend-pipeline/dist/src/index.js
 init_agents();
@@ -4749,8 +5129,8 @@ function buildContentfulManagementClient(request) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/controller/existing-entities/fetch-and-persist.js
-import { writeFile } from "node:fs/promises";
-import { join as join5 } from "node:path";
+import { writeFile as writeFile2 } from "node:fs/promises";
+import { join as join6 } from "node:path";
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/helpers/existing-entities/fetch-from-contentful.js
 import { fetchAll } from "contentful-management";
@@ -4782,8 +5162,8 @@ async function fetchAndPersistExistingContentfulEntities(request) {
       spaceId: request.spaceId,
       environmentId: request.environmentId
     });
-    const path5 = join5(request.outDir, ".existing-entities.json");
-    await writeFile(path5, JSON.stringify(entities, null, 2), "utf8");
+    const path5 = join6(request.outDir, ".existing-entities.json");
+    await writeFile2(path5, JSON.stringify(entities, null, 2), "utf8");
     return { ok: true, path: path5, durationMs: Date.now() - t0, entities };
   } catch (error) {
     return {
@@ -5300,17 +5680,17 @@ function RunningStep({
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/05-token-reuse/logic.ts
-import { access, stat } from "node:fs/promises";
-import { join as join6 } from "node:path";
+import { access, stat as stat3 } from "node:fs/promises";
+import { join as join7 } from "node:path";
 async function inspectTokens({ rawTokensPath, outDir, cache }) {
   if (!cache) return { kind: "none" };
-  const tokensPath = join6(outDir, "tokens.json");
+  const tokensPath = join7(outDir, "tokens.json");
   try {
     await access(tokensPath);
   } catch {
     return { kind: "none" };
   }
-  const [generated, source] = await Promise.all([stat(tokensPath), stat(rawTokensPath).catch(() => null)]);
+  const [generated, source] = await Promise.all([stat3(tokensPath), stat3(rawTokensPath).catch(() => null)]);
   return { kind: "cached", tokensPath, sourceChanged: source ? source.mtimeMs > generated.mtimeMs : false };
 }
 function gateText({ tokensPath, sourceChanged }) {
@@ -5502,26 +5882,26 @@ function ExtractionScreen({
 
 // packages/experience-design-system-types/dist/src/config/index.js
 import { randomBytes } from "node:crypto";
-import { mkdir, readFile as readFile4, rename, writeFile as writeFile2 } from "node:fs/promises";
+import { mkdir as mkdir2, readFile as readFile5, rename, writeFile as writeFile3 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
-import { dirname as dirname5, join as join7 } from "node:path";
+import { dirname as dirname5, join as join8 } from "node:path";
 function configRoot2() {
-  return process.env["EDS_HOME"] || join7(homedir3(), ".contentful", "experience-design-system-cli");
+  return process.env["EDS_HOME"] || join8(homedir3(), ".contentful", "experience-design-system-cli");
 }
-var configFilePath2 = () => join7(configRoot2(), "config.json");
-var debugSessionsDir2 = () => join7(configRoot2(), "debug", "sessions");
+var configFilePath2 = () => join8(configRoot2(), "config.json");
+var debugSessionsDir2 = () => join8(configRoot2(), "debug", "sessions");
 async function readSettings2() {
   try {
-    return JSON.parse(await readFile4(configFilePath2(), "utf8"));
+    return JSON.parse(await readFile5(configFilePath2(), "utf8"));
   } catch {
     return {};
   }
 }
 async function writeSettings2(settings) {
   const path5 = configFilePath2();
-  await mkdir(dirname5(path5), { recursive: true });
+  await mkdir2(dirname5(path5), { recursive: true });
   const tmp = `${path5}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
-  await writeFile2(tmp, `${JSON.stringify(settings, null, 2)}
+  await writeFile3(tmp, `${JSON.stringify(settings, null, 2)}
 `, { mode: 384 });
   await rename(tmp, path5);
 }
@@ -5533,8 +5913,8 @@ async function updateSettings2(patch) {
 import { useEffect as useEffect5, useRef as useRef2, useState as useState8 } from "react";
 
 // packages/experience-design-system-cli/src/tui/import/steps/06-extraction/run.ts
-import { mkdir as mkdir2 } from "node:fs/promises";
-import { join as join11, resolve as resolve9 } from "node:path";
+import { mkdir as mkdir3 } from "node:fs/promises";
+import { join as join12, resolve as resolve11 } from "node:path";
 
 // packages/experience-design-system-generation/dist/src/agent-names.js
 var AGENT_BINARIES2 = {
@@ -5547,8 +5927,8 @@ var AGENT_BINARIES2 = {
 
 // packages/experience-design-system-generation/dist/src/services/prompts/helpers/resolve-skill-file.js
 import { existsSync as existsSync3 } from "node:fs";
-import { readFile as readFile5 } from "node:fs/promises";
-import { dirname as dirname6, join as join8, resolve as resolve7 } from "node:path";
+import { readFile as readFile6 } from "node:fs/promises";
+import { dirname as dirname6, join as join9, resolve as resolve9 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var SKILL_FILES2 = {
   components: "generate-components.md",
@@ -5562,10 +5942,10 @@ function resolveSkillPath2(skill) {
   const thisDir = dirname6(fileURLToPath3(import.meta.url));
   let dir = thisDir;
   for (; ; ) {
-    const candidate = join8(dir, "skills");
+    const candidate = join9(dir, "skills");
     if (existsSync3(candidate))
-      return join8(candidate, SKILL_FILES2[skill]);
-    const parent = resolve7(dir, "..");
+      return join9(candidate, SKILL_FILES2[skill]);
+    const parent = resolve9(dir, "..");
     if (parent === dir) {
       throw new Error(`skill file missing from CLI installation (could not locate skills/ directory from: ${thisDir})`);
     }
@@ -5574,16 +5954,16 @@ function resolveSkillPath2(skill) {
 }
 async function readSkillFile2(skill, override) {
   if (override) {
-    const skillPath2 = resolve7(override);
+    const skillPath2 = resolve9(override);
     try {
-      return await readFile5(skillPath2, "utf8");
+      return await readFile6(skillPath2, "utf8");
     } catch {
       throw new Error(`custom prompt file not found (skill: ${skill}, path: ${skillPath2})`);
     }
   }
   const skillPath = resolveSkillPath2(skill);
   try {
-    return await readFile5(skillPath, "utf8");
+    return await readFile6(skillPath, "utf8");
   } catch {
     throw new Error(`skill file missing from CLI installation \u2014 try reinstalling the CLI (looked for: ${skillPath})`);
   }
@@ -6180,7 +6560,7 @@ async function runAgent2(options) {
     promptLen: prompt.length,
     promptHead: prompt.slice(0, 500)
   });
-  return new Promise((resolve10) => {
+  return new Promise((resolve12) => {
     const bedrockEnv = bedrock ? BEDROCK_ENV_BY_AGENT2[agent] : void 0;
     const child = spawn3(binary, args, {
       stdio: ["pipe", "pipe", "pipe"],
@@ -6224,7 +6604,7 @@ async function runAgent2(options) {
         stderrLen: stderr.length,
         stderrTail: stderr.slice(-1e3)
       });
-      resolve10(result);
+      resolve12(result);
     });
   });
 }
@@ -6235,7 +6615,7 @@ import { spawn as spawn5 } from "node:child_process";
 // packages/experience-design-system-generation/dist/src/services/agent/helpers/check-claude-auth.js
 import { spawn as spawn4 } from "node:child_process";
 function checkClaudeAuth(binary) {
-  return new Promise((resolve10) => {
+  return new Promise((resolve12) => {
     const child = spawn4(binary, ["auth", "status", "--json"], {
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -6245,7 +6625,7 @@ function checkClaudeAuth(binary) {
       if (!done) {
         done = true;
         child.kill("SIGTERM");
-        resolve10("unauthenticated");
+        resolve12("unauthenticated");
       }
     }, 5e3);
     child.stdout?.on("data", (chunk) => {
@@ -6257,14 +6637,14 @@ function checkClaudeAuth(binary) {
       done = true;
       clearTimeout(timer);
       if (code !== 0) {
-        resolve10("unauthenticated");
+        resolve12("unauthenticated");
         return;
       }
       try {
         const status = JSON.parse(stdout);
-        resolve10(status.loggedIn ? "ok" : "unauthenticated");
+        resolve12(status.loggedIn ? "ok" : "unauthenticated");
       } catch {
-        resolve10("unauthenticated");
+        resolve12("unauthenticated");
       }
     });
   });
@@ -6273,13 +6653,13 @@ function checkClaudeAuth(binary) {
 // packages/experience-design-system-generation/dist/src/services/agent/helpers/check-agent-auth.js
 async function checkAgentAuth2(agent) {
   const binary = resolveAgentBinary(agent);
-  const binaryExists2 = await new Promise((resolve10) => {
+  const binaryExists2 = await new Promise((resolve12) => {
     if (binary.startsWith("/")) {
-      import("node:fs/promises").then((fs) => fs.access(binary).then(() => resolve10(true), () => resolve10(false)));
+      import("node:fs/promises").then((fs) => fs.access(binary).then(() => resolve12(true), () => resolve12(false)));
       return;
     }
     const child = spawn5(process.platform === "win32" ? "where" : "which", [binary], { stdio: "ignore" });
-    child.on("close", (code) => resolve10(code === 0));
+    child.on("close", (code) => resolve12(code === 0));
   });
   if (!binaryExists2)
     return "not-found";
@@ -6381,17 +6761,17 @@ function parseSelectToolCallLines(stdout) {
 
 // packages/experience-design-system-cli/src/tui/import/steps/06-extraction/processes.ts
 import { execFile as execFile2, spawn as spawn6 } from "node:child_process";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 
 // packages/experience-design-system-cli/src/legacy/legacy-cli-path.ts
 import { existsSync as existsSync4 } from "node:fs";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 var PACKAGE_NAME2 = "@contentful/experience-design-system-cli";
 function findLegacyCliPath() {
   const root = findPackageRoot(import.meta.url, PACKAGE_NAME2);
   const candidates = [
-    join9(root, "legacy", "bin", "cli.js"),
-    join9(root, "..", "experience-design-system-cli-legacy", "bin", "cli.js")
+    join10(root, "legacy", "bin", "cli.js"),
+    join10(root, "..", "experience-design-system-cli-legacy", "bin", "cli.js")
   ];
   const found = candidates.find((candidate) => existsSync4(candidate));
   if (!found) {
@@ -6429,7 +6809,7 @@ function buildPrintTokensArgs(tokensPath, tokenSessionId) {
   return ["print", "tokens", "--out", tokensPath, ...tokenSessionId ? ["--session", tokenSessionId] : []];
 }
 function run(args, handlers = {}) {
-  return new Promise((resolve10) => {
+  return new Promise((resolve12) => {
     const child = spawn6("node", args);
     let stdout = "";
     let stderr = "";
@@ -6445,17 +6825,17 @@ function run(args, handlers = {}) {
       stderr += chunk;
       stderrLines(chunk);
     });
-    child.on("error", (error) => resolve10({ exitCode: 1, stdout, stderr: stderr || error.message }));
-    child.on("exit", (code) => resolve10({ exitCode: code ?? 0, stdout, stderr }));
+    child.on("error", (error) => resolve12({ exitCode: 1, stdout, stderr: stderr || error.message }));
+    child.on("exit", (code) => resolve12({ exitCode: code ?? 0, stdout, stderr }));
   });
 }
 function spawnExtract(command, handlers) {
   return run(buildExtractArgs(findLegacyCliPath(), command), handlers);
 }
 function runBuffered(args) {
-  return new Promise((resolve10) => {
+  return new Promise((resolve12) => {
     execFile2("node", [findLegacyCliPath(), ...args], (error, stdout, stderr) => {
-      resolve10({ exitCode: error?.code ? Number(error.code) : 0, stdout, stderr });
+      resolve12({ exitCode: error?.code ? Number(error.code) : 0, stdout, stderr });
     });
   });
 }
@@ -6465,7 +6845,7 @@ async function runTokenGeneration(input) {
     return { ok: false, step: "generate tokens", message: generated.stderr.trim() || "Unknown error" };
   }
   const tokenSessionId = findSession(generated.stdout);
-  const tokensPath = join10(input.outDir, "tokens.json");
+  const tokensPath = join11(input.outDir, "tokens.json");
   const printed = await runBuffered(buildPrintTokensArgs(tokensPath, tokenSessionId));
   if (printed.exitCode !== 0) {
     return { ok: false, step: "print tokens", message: printed.stderr.trim() || "Unknown error" };
@@ -6474,10 +6854,10 @@ async function runTokenGeneration(input) {
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/06-extraction/selection.ts
-import { resolve as resolve8 } from "node:path";
+import { resolve as resolve10 } from "node:path";
 var DEFAULT_TIMEOUT_MS3 = Number(process.env.EDS_AGENT_TIMEOUT_MS ?? 5 * 60 * 1e3);
 async function hashSelectPrompt(options) {
-  const promptHash = options.promptText ? hashContent(options.promptText) : options.promptPath ? await hashFile(resolve8(options.promptPath)) : await hashFile(resolveSkillPath2("select"));
+  const promptHash = options.promptText ? hashContent(options.promptText) : options.promptPath ? await hashFile(resolve10(options.promptPath)) : await hashFile(resolveSkillPath2("select"));
   return hashContent(`${promptHash}|${options.agent}|${options.model ?? ""}`);
 }
 async function runSelection(options) {
@@ -6566,7 +6946,7 @@ var realDeps = { checkAgentAuth: checkAgentAuth2, fetchEntities, spawnExtract, r
 var fail = (step, message) => ({ ok: false, step, message });
 var errorMessage2 = (error) => error instanceof Error ? error.message : String(error);
 async function runExtraction(input, onProgress, deps = realDeps) {
-  const outDir = join11(resolve9(input.projectPath), ".contentful");
+  const outDir = join12(resolve11(input.projectPath), ".contentful");
   let progress = initialProgress({
     hasCredentials: input.credentials !== null,
     hasRawTokens: input.rawTokensPath !== "",
@@ -6651,10 +7031,11 @@ async function runExtraction(input, onProgress, deps = realDeps) {
   const tokens = await tokenGeneration;
   if (tokens && !tokens.ok) return fail(tokens.step, tokens.message);
   if (!sessionId) return fail("analyze extract", "The extract command did not report a session.");
+  const hasTokenSource = input.rawTokensPath !== "" || input.tokenStrategy === "reuse";
   const extraction = {
     sessionId,
     outDir,
-    tokensPath: tokens?.ok ? tokens.tokensPath : join11(outDir, "tokens.json"),
+    tokensPath: tokens?.ok ? tokens.tokensPath : hasTokenSource ? join12(outDir, "tokens.json") : "",
     tokenSessionId: tokens?.ok ? tokens.tokenSessionId : null,
     tokenCount: tokens?.ok ? tokens.tokenCount : 0,
     existingEntitiesPath,
@@ -6665,7 +7046,7 @@ async function runExtraction(input, onProgress, deps = realDeps) {
 }
 async function fetchEntities(credentials, outDir) {
   try {
-    await mkdir2(outDir, { recursive: true });
+    await mkdir3(outDir, { recursive: true });
     const result = await fetchAndPersistExistingContentfulEntities({
       spaceId: credentials.spaceId,
       environmentId: credentials.environmentId,
@@ -6685,7 +7066,7 @@ async function resolveSelectionPrompt(overrides) {
   if (select?.kind === "text") return { promptText: select.value };
   if (select?.kind === "path") {
     await resolvePromptOverride(select);
-    return { promptPath: resolve9(select.value) };
+    return { promptPath: resolve11(select.value) };
   }
   return {};
 }
@@ -7544,7 +7925,7 @@ function buildVisibleRows(props) {
         if (visited.has(target)) continue;
         visited.add(target);
         const isCycleMember = cycleParticipants.has(target);
-        out.push({ name: target, depth: cur.depth + 1, isCycleMember, parent: cur.name });
+        out.push({ name: target, depth: cur.depth + 1, isCycleMember });
         queue.push({ name: target, depth: cur.depth + 1 });
       }
     }
@@ -7591,8 +7972,7 @@ function buildVisibleRows(props) {
         sharedSuffix,
         cycleChild: child.isCycleMember || void 0,
         itemIdx: childRec?.idx ?? -1,
-        rootName: key,
-        parentName: child.parent
+        rootName: key
       });
     });
   }
@@ -7675,19 +8055,13 @@ function buildVisibleRows(props) {
         injectedChildren.push({
           name: target,
           depth: parentDepth + 1,
-          isCycleChild: true,
-          parent: parentName
+          isCycleChild: true
         });
       }
     };
     emitCycleChildrenOf(root, 0);
     for (const c2 of closureChildren) {
-      injectedChildren.push({
-        name: c2.name,
-        depth: c2.depth,
-        isCycleChild: false,
-        parent: c2.path[c2.path.length - 2] ?? root
-      });
+      injectedChildren.push({ name: c2.name, depth: c2.depth, isCycleChild: false });
       emitCycleChildrenOf(c2.name, c2.depth);
     }
     const isLastAtDepth = (idx) => {
@@ -7721,8 +8095,7 @@ function buildVisibleRows(props) {
         sharedSuffix,
         cycleChild: child.isCycleChild || void 0,
         itemIdx: childRec?.idx ?? -1,
-        rootName: root,
-        parentName: child.parent
+        rootName: root
       });
     });
   }
@@ -7875,7 +8248,7 @@ function GroupedSidebar(props) {
       const rs = itemName ? renderStatusByKey?.get(itemName) : void 0;
       const badge = itemName ? previewBadge(previewAnnotationByKey?.get(itemName)) : null;
       const showInheritance = rs !== void 0 && row.kind !== "cycle" && row.kind !== "empty" && row.kind !== "group-root";
-      const supportsSelectionGlyph = selectionStateByKey !== void 0 && itemName !== void 0 && (row.kind === "standalone" || row.kind === "group-root" || row.kind === "group-child" || row.kind === "flat" || row.kind === "empty" || row.kind === "cycle");
+      const supportsSelectionGlyph = selectionStateByKey !== void 0 && itemName !== void 0 && (row.kind === "standalone" || row.kind === "group-root" || row.kind === "group-child" || row.kind === "flat" || row.kind === "cycle");
       const selState = supportsSelectionGlyph ? selectionStateByKey.get(itemName) ?? "undecided" : void 0;
       const isCycleRow = row.kind === "cycle";
       const selStyle = selectionGlyphStyleFor(selState, isCycleRow);
@@ -7905,7 +8278,7 @@ function GroupedSidebar(props) {
             color: isSelected ? PALETTE2.info : labelStyle.dim ? PALETTE2.muted : labelStyle.color,
             bold: isSelected || labelStyle.bold,
             inverse: false,
-            underline: isSelected && focused,
+            underline: isSelected && !focused,
             wrap: wrapLabels ? "wrap" : "truncate",
             children: [
               " ",
@@ -8310,11 +8683,11 @@ function buildCycleUnits(slotCycles) {
     while (parent.get(cur) !== cur) {
       cur = parent.get(cur);
     }
-    let walk = x;
-    while (parent.get(walk) !== cur) {
-      const next = parent.get(walk);
-      parent.set(walk, cur);
-      walk = next;
+    let walk2 = x;
+    while (parent.get(walk2) !== cur) {
+      const next = parent.get(walk2);
+      parent.set(walk2, cur);
+      walk2 = next;
     }
     return cur;
   };
@@ -8549,7 +8922,6 @@ function resolveKey(mode, key, ctx) {
 function resolveMain(key, ctx) {
   const { input } = key;
   const inMain = ctx.focusedColumn === "main";
-  if (key.ctrl && input === "z") return { type: "undo" };
   if (input === "q" || key.escape) {
     if (key.escape && ctx.jumpFilterActive) return { type: "clear-jump-filter" };
     if (key.escape && ctx.searchActive) return { type: "clear-search" };
@@ -8808,42 +9180,21 @@ function rejectNeedsConfirmation(graph, name, state) {
   const ancestors = toReject.filter((n) => n !== name);
   return ancestors.length + toDeselect.length >= 2;
 }
-function removeSlotChild(components, edge) {
-  return components.map(
-    (component) => component.name === edge.parent ? {
-      ...component,
-      slots: component.slots?.map((slot) => ({
-        ...slot,
-        allowedComponents: slot.allowedComponents.filter((name) => name !== edge.child)
-      }))
-    } : component
-  );
-}
-function withoutSlotChildren(components, removedEdges) {
-  return removedEdges.reduce(removeSlotChild, components);
-}
-function partitionDecisions(components, state, removedEdges) {
+function partitionDecisions(components, state) {
   const accepted = [];
   const rejected = [];
   for (const c2 of components) {
     if (state.get(c2.name) === "accepted") accepted.push(c2.name);
     else rejected.push(c2.name);
   }
-  const rejectedNames = new Set(rejected);
-  const excludedSlotEdges = removedEdges.filter((e) => !rejectedNames.has(e.parent) && !rejectedNames.has(e.child));
-  return { accepted, rejected, excludedSlotEdges };
+  return { accepted, rejected };
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/use-scope-gate.ts
-function useScopeGate({ components: loadedComponents, onConfirm, onQuit }) {
+function useScopeGate({ components, onConfirm, onQuit }) {
   const { columns: totalWidth, rows: terminalRows } = useTerminalSize();
   const columnPlan = useMemo2(() => computeColumnWidths(totalWidth), [totalWidth]);
   const [decisions, setDecisions] = useState12(/* @__PURE__ */ new Map());
-  const [removedEdges, setRemovedEdges] = useState12([]);
-  const components = useMemo2(
-    () => withoutSlotChildren(loadedComponents, removedEdges),
-    [loadedComponents, removedEdges]
-  );
   const [nav, setNav] = useState12({ cursor: 0, scrollOffset: 0 });
   const [focusedColumn, setFocusedColumn] = useState12("main");
   const [addedComponentsCursor, setAddedComponentsCursor] = useState12(0);
@@ -9015,14 +9366,6 @@ function useScopeGate({ components: loadedComponents, onConfirm, onQuit }) {
         return void 0;
     }
   };
-  const focusedNestedEdge = () => {
-    const row = visibleRows[safeCursor];
-    if (row?.kind !== "group-child" || !row.parentName || row.itemIdx < 0) return void 0;
-    const child = groupedItems[row.itemIdx]?.key;
-    return child ? { parent: row.parentName, child } : void 0;
-  };
-  const removeFromParentSlot = (edge) => setRemovedEdges((edges) => [...edges, edge]);
-  const undoSlotRemoval = () => setRemovedEdges((edges) => edges.slice(0, -1));
   const jumpCursorTo = (name) => {
     let idx = -1;
     for (let i = 0; i < visibleRows.length; i++) {
@@ -9122,7 +9465,7 @@ function useScopeGate({ components: loadedComponents, onConfirm, onQuit }) {
         onQuit();
         return;
       case "confirm":
-        onConfirm(partitionDecisions(components, decisions, removedEdges));
+        onConfirm(partitionDecisions(components, decisions));
         return;
       case "close-help":
         setShowHelp(false);
@@ -9175,11 +9518,6 @@ function useScopeGate({ components: loadedComponents, onConfirm, onQuit }) {
         return;
       }
       case "reject": {
-        const edge = focusedColumn === "main" ? focusedNestedEdge() : void 0;
-        if (edge) {
-          removeFromParentSlot(edge);
-          return;
-        }
         const key = focusedColumn === "added-components" ? addedComponents[safeAddedComponentsCursor]?.name : focusedRowKey();
         if (key) requestReject(key);
         return;
@@ -9187,9 +9525,6 @@ function useScopeGate({ components: loadedComponents, onConfirm, onQuit }) {
       case "toggle-all":
         decide({ type: "toggle-all" });
         return;
-      case "undo":
-        undoSlotRemoval();
-        return;
       case "accept-unflagged":
         decide({ type: "accept-unflagged" });
         return;
@@ -9481,9 +9816,9 @@ function parseCacheComponents(stdout) {
     return [];
   }
 }
-var runLegacyCli = (args) => new Promise((resolve10) => {
+var runLegacyCli = (args) => new Promise((resolve12) => {
   execFile3("node", [findLegacyCliPath(), ...args], (error, stdout, stderr) => {
-    resolve10({ exitCode: error?.code ? Number(error.code) : 0, stdout, stderr });
+    resolve12({ exitCode: error?.code ? Number(error.code) : 0, stdout, stderr });
   });
 });
 async function checkGenerationCache(input, run2 = runLegacyCli) {
@@ -9525,31 +9860,320 @@ function useScopeGateFlow(input, deps = realDeps2) {
   const loaded = useMemo3(() => sessionId ? deps.load(sessionId) : void 0, [sessionId]);
   const cacheCheck = useRef5(void 0);
   const [confirmed, setConfirmed] = useState13();
-  const [scope, setScope] = useState13();
   useEffect8(() => {
     if (!input || !loaded?.ok || cacheCheck.current) return;
     cacheCheck.current = deps.checkCache(input.cache);
   }, [input, loaded]);
-  useEffect8(() => {
-    if (!confirmed || !cacheCheck.current) return;
-    let current = true;
-    void cacheCheck.current.then((cachedNames) => {
-      const accepted = new Set(confirmed.accepted);
-      if (current) setScope({ ...confirmed, cachedNames: cachedNames.filter((name) => accepted.has(name)) });
-    });
-    return () => {
-      current = false;
-    };
-  }, [confirmed]);
   if (!input || !loaded) return void 0;
   if (!loaded.ok) return { status: "failed", message: loaded.message };
-  if (scope) return { status: "confirmed", scope };
-  if (confirmed) return { status: "preparing" };
+  if (confirmed && cacheCheck.current)
+    return { status: "confirmed", decisions: confirmed, cachedNames: cacheCheck.current };
   return { status: "deciding", load: loaded, confirm: setConfirmed };
 }
 
+// packages/experience-design-system-cli/src/tui/import/steps/08-generation/logic.ts
+function initialProgress2() {
+  return { components: null, mapTokens: "idle", mapTokensEligible: null };
+}
+var PROGRESS_LINE = /^progress=generate:(\d+)\/(\d+):(.+)$/;
+var STARTED_LINE = /\[(\d+)\/(\d+)\]\s+(.+)/;
+function applyGenerateStderr(chunk, previous) {
+  let state = previous;
+  for (const line of chunk.split("\n")) {
+    const finished = PROGRESS_LINE.exec(line);
+    if (finished) {
+      state = { done: Number(finished[1]), total: Number(finished[2]), current: finished[3].trim() };
+      continue;
+    }
+    const started = STARTED_LINE.exec(line);
+    if (started) {
+      state = { done: state?.done ?? 0, total: Number(started[2]), current: started[3].trim() };
+    }
+  }
+  return state;
+}
+function parseGenerateResult(output, fallbackCount) {
+  const session = /^session=(.+)$/m.exec(output.stdout);
+  const count = /(\d+) components?/.exec(output.stderr);
+  const renamed = /^renamed-slots:\s*(\d+)$/m.exec(output.stdout);
+  return {
+    generateSessionId: session ? session[1].trim() : null,
+    generatedCount: count ? Number(count[1]) : fallbackCount,
+    renamedSlotsCount: renamed ? Number(renamed[1]) : 0
+  };
+}
+function shouldRunMapTokens(counts) {
+  return counts.mappablePropCount > 0 && counts.rawTokenCount > 0;
+}
+function formatAcceptanceSummary(counts) {
+  const accepted = `${counts.accepted} component${counts.accepted === 1 ? "" : "s"} accepted`;
+  if (counts.autoRejected === 0) return `${accepted}.`;
+  return `${accepted}, ${counts.autoRejected} excluded due to validation errors.`;
+}
+var capitalize = (name) => name.charAt(0).toUpperCase() + name.slice(1);
+function describeGeneration(input) {
+  const agent = capitalize(input.agent);
+  return `${formatAcceptanceSummary({ accepted: input.acceptedCount, autoRejected: 0 })}
+${agent} is mapping your selected components to Contentful's Component Definition Format (CDF).${input.hasTokens ? " Using your design tokens for prop resolution." : ""}`;
+}
+function progressRows2(progress, agent) {
+  const name = capitalize(agent);
+  const { components, mapTokens } = progress;
+  const rows = [
+    {
+      text: components ? components.current : `Starting up ${name}...`,
+      complete: false,
+      ...components ? { progress: { done: components.done, total: components.total } } : {}
+    }
+  ];
+  if (mapTokens !== "idle") {
+    rows.push({
+      text: mapTokens === "running" ? `Mapping token restrictions via ${name}...` : "Token restrictions ready",
+      complete: mapTokens === "complete"
+    });
+  }
+  return rows;
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/08-generation/screen.tsx
+import { jsx as jsx25 } from "react/jsx-runtime";
+function GenerationScreen({
+  progress,
+  agent,
+  acceptedCount,
+  hasTokens,
+  stepNumber,
+  totalSteps
+}) {
+  return /* @__PURE__ */ jsx25(
+    RunningStep,
+    {
+      stepNumber,
+      totalSteps,
+      title: "Generating definitions",
+      description: describeGeneration({ acceptedCount, agent, hasTokens }),
+      lines: progressRows2(progress, agent)
+    }
+  );
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/08-generation/use-generation.ts
+import { useEffect as useEffect9, useRef as useRef6, useState as useState14 } from "react";
+
+// packages/experience-design-system-cli/src/tui/import/steps/08-generation/map-tokens.ts
+async function prepareMapTokens(input, generatedSessionId) {
+  const db = openPipelineDb();
+  try {
+    if (input.tokenSessionId && input.tokenSessionId !== generatedSessionId) {
+      copyTokensFromCache(db, input.tokenSessionId, generatedSessionId);
+    } else if (!input.tokenSessionId && input.tokensPath) {
+      const tokens = await readTokensFromPath2({ flag: "tokens", path: input.tokensPath });
+      storeDtcgTokens(db, generatedSessionId, [], tokens);
+    }
+    const mappablePropCount = loadCDFComponents(db, generatedSessionId).reduce(
+      (count, { entry }) => count + Object.values(entry.$properties).filter((prop) => prop.$type === "token" && prop.$category === "design").length,
+      0
+    );
+    const rawTokenCount = getDtcgTokensForSession(db, generatedSessionId).tokens.length;
+    return {
+      eligible: shouldRunMapTokens({ mappablePropCount, rawTokenCount }),
+      mappablePropCount,
+      rawTokenCount
+    };
+  } finally {
+    db.close();
+  }
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/08-generation/processes.ts
+import { execFile as execFile4, spawn as spawn7 } from "node:child_process";
+function buildGenerateArgs(cliPath, command) {
+  const args = [cliPath, "__generate", "components", "--agent", command.agent, "--session", command.sessionId];
+  if (command.tokensPath) args.push("--tokens", command.tokensPath);
+  if (command.agentModel) args.push("--model", command.agentModel);
+  if (command.noCache) args.push("--no-cache");
+  if (command.generatePromptPath) args.push("--generate-prompt-path", command.generatePromptPath);
+  for (const prompt of command.promptOverrides) args.push("--prompt", prompt);
+  if (command.existingEntitiesPath) args.push("--existing-entities-path", command.existingEntitiesPath);
+  if (command.cachedComponents.length > 0) args.push("--cached-components", JSON.stringify(command.cachedComponents));
+  return args;
+}
+function buildMapTokensArgs(command) {
+  const args = ["map", "tokens", "--session", command.sessionId, "--agent", command.agent];
+  if (command.agentModel) args.push("--model", command.agentModel);
+  if (command.noCache) args.push("--no-cache");
+  for (const prompt of command.promptOverrides) args.push("--prompt", prompt);
+  if (command.existingEntitiesPath) args.push("--existing-entities-path", command.existingEntitiesPath);
+  return args;
+}
+function spawnGenerate(command, handlers) {
+  return new Promise((resolve12) => {
+    const child = spawn7("node", buildGenerateArgs(findLegacyCliPath(), command));
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (data) => {
+      stdout += String(data);
+    });
+    child.stderr.on("data", (data) => {
+      const chunk = String(data);
+      stderr += chunk;
+      handlers.onStderr(chunk);
+    });
+    child.on("error", (error) => resolve12({ exitCode: 1, stdout, stderr: stderr + error.message }));
+    child.on("close", (code) => resolve12({ exitCode: code ?? 0, stdout, stderr }));
+  });
+}
+function runMapTokens2(command) {
+  return new Promise((resolve12) => {
+    execFile4("node", [findLegacyCliPath(), ...buildMapTokensArgs(command)], (error, stdout, stderr) => {
+      resolve12({ exitCode: error?.code ? Number(error.code) : 0, stdout, stderr });
+    });
+  });
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/08-generation/save-decisions.ts
+async function saveDecisions(input) {
+  const db = openPipelineDb();
+  try {
+    applyScopeDecisions(db, input.sessionId, input.decisions);
+    await writeScopeDecisionsSnapshot(db, input.sessionId, input.decisions);
+  } finally {
+    db.close();
+  }
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/08-generation/run.ts
+var realDeps3 = {
+  checkAgentAuth: checkAgentAuth2,
+  saveDecisions,
+  checkCache: checkGenerationCache,
+  spawnGenerate,
+  prepareMapTokens,
+  runMapTokens: runMapTokens2
+};
+var fail2 = (step, message) => ({ ok: false, step, message });
+var errorMessage3 = (error) => error instanceof Error ? error.message : String(error);
+async function runGeneration(input, onProgress, deps = realDeps3) {
+  let progress = initialProgress2();
+  const update = (change) => {
+    progress = { ...progress, ...change };
+    onProgress(progress);
+  };
+  const accepted = input.decisions.accepted;
+  const handedOverNames = await input.cachedNames.catch(() => []);
+  try {
+    await deps.saveDecisions({ sessionId: input.sessionId, decisions: input.decisions });
+  } catch (error) {
+    return fail2("save decisions", errorMessage3(error));
+  }
+  if (accepted.length === 0) return { ok: true, generation: { route: "push", acceptedCount: 0 } };
+  const auth = await deps.checkAgentAuth(input.agent);
+  if (auth === "not-found" || auth === "unauthenticated") {
+    return fail2(`${input.agent} auth check`, agentAuthMessage(input.agent, auth));
+  }
+  const acceptedSet = new Set(accepted);
+  let cachedNames = handedOverNames;
+  let cacheHit = !input.noCache && accepted.length > 0 && accepted.every((name) => cachedNames.includes(name));
+  if (!cacheHit && !input.noCache && accepted.length > 0) {
+    const fresh = await deps.checkCache(cacheCheckFor(input));
+    cachedNames = fresh.filter((name) => acceptedSet.has(name));
+    cacheHit = accepted.every((name) => cachedNames.includes(name));
+  }
+  let generatedSessionId = input.sessionId;
+  let generatedCount = accepted.length;
+  if (!cacheHit) {
+    const result = await deps.spawnGenerate(
+      {
+        sessionId: input.sessionId,
+        tokensPath: input.tokensPath,
+        agent: input.agent,
+        ...input.agentModel ? { agentModel: input.agentModel } : {},
+        promptOverrides: input.promptOverrides,
+        ...input.generatePromptPath ? { generatePromptPath: input.generatePromptPath } : {},
+        noCache: input.noCache,
+        existingEntitiesPath: input.existingEntitiesPath,
+        cachedComponents: cachedNames
+      },
+      {
+        onStderr: (chunk) => {
+          const components = applyGenerateStderr(chunk, progress.components);
+          if (components !== progress.components) update({ components });
+        }
+      }
+    );
+    if (result.exitCode !== 0) return fail2("generate components", result.stderr.trim() || "Unknown error");
+    const parsed = parseGenerateResult(result, accepted.length);
+    generatedSessionId = parsed.generateSessionId ?? input.sessionId;
+    generatedCount = parsed.generatedCount;
+  }
+  let plan;
+  try {
+    plan = await deps.prepareMapTokens(input, generatedSessionId);
+  } catch (error) {
+    return fail2("map tokens", errorMessage3(error));
+  }
+  update({ mapTokensEligible: plan.eligible });
+  if (plan.eligible) {
+    update({ mapTokens: "running" });
+    const mapped = await deps.runMapTokens({
+      sessionId: generatedSessionId,
+      agent: input.agent,
+      ...input.agentModel ? { agentModel: input.agentModel } : {},
+      promptOverrides: input.promptOverrides,
+      noCache: input.noCache,
+      existingEntitiesPath: input.existingEntitiesPath
+    });
+    if (mapped.exitCode !== 0) return fail2("map tokens", mapped.stderr.trim() || "Unknown error");
+  }
+  update({ mapTokens: "complete" });
+  return {
+    ok: true,
+    generation: {
+      route: "review",
+      sessionId: generatedSessionId,
+      acceptedCount: accepted.length,
+      generatedCount,
+      mapTokensEligible: plan.eligible
+    }
+  };
+}
+function cacheCheckFor(input) {
+  return {
+    sessionId: input.sessionId,
+    tokensPath: input.tokensPath,
+    agent: input.agent,
+    ...input.agentModel ? { agentModel: input.agentModel } : {},
+    promptOverrides: input.promptOverrides,
+    existingEntitiesPath: input.existingEntitiesPath,
+    noCache: input.noCache
+  };
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/08-generation/use-generation.ts
+function useGeneration(input) {
+  const [state, setState] = useState14();
+  const current = useRef6();
+  useEffect9(() => {
+    current.current = input;
+    if (!input) {
+      setState(void 0);
+      return;
+    }
+    setState({ status: "running", progress: initialProgress2() });
+    void runGeneration(input, (progress) => {
+      if (current.current === input) setState({ status: "running", progress });
+    }).then((result) => {
+      if (current.current === input) setState({ status: "done", result });
+    });
+    return () => {
+      if (current.current === input) current.current = void 0;
+    };
+  }, [input]);
+  return state;
+}
+
 // packages/experience-design-system-cli/src/tui/import/spawn-v1-import.ts
-import { spawn as spawn7 } from "node:child_process";
+import { spawn as spawn8 } from "node:child_process";
 
 // packages/experience-design-system-cli/src/commands/import-options.ts
 function importOptionArgs(options) {
@@ -9583,27 +10207,36 @@ var ExtractionSchema = z5.object({
   /** The only phases the scope gate can start from. */
   compositionPhase: z5.enum(["done", "cache-hit"])
 });
-var ScopeSchema = z5.object({
-  /** The components the user kept at the scope gate. The wizard saves these, then generates them. */
-  accepted: z5.array(z5.string()),
-  /** Everything else at the gate, which counts as rejected. */
-  rejected: z5.array(z5.string()),
-  /** Slot edges the user removed at the gate. The child stays accepted; only that parent stops allowing it. */
-  excludedSlotEdges: z5._default(z5.array(z5.object({ parent: z5.string(), child: z5.string() })), []),
-  /**
-   * Components the generation cache already holds, found by the check that ran while the gate was open and which has
-   * finished (and restored them) before the wizard starts. Empty when the cache is off or the check failed.
-   */
-  cachedNames: z5.array(z5.string())
-});
+var GenerationSchema = z5.discriminatedUnion("route", [
+  /** At least one component was accepted: the definitions were generated and the wizard opens the review screen. */
+  z5.object({
+    route: z5.literal("review"),
+    /** The session the generated definitions are in. The review screen opens it, and saving and pushing read it. */
+    sessionId: NonEmpty,
+    /** How many components the user accepted at the scope gate. */
+    acceptedCount: z5.number(),
+    /** How many definitions were generated, which can differ from the accepted count. */
+    generatedCount: z5.number(),
+    /**
+     * Whether token mapping was worth running (there were design props that are tokens, and tokens to map them from).
+     * The step count the wizard shows depends on it.
+     */
+    mapTokensEligible: z5.boolean()
+  }),
+  /** Nothing was accepted: nothing is generated and the wizard goes straight to the push flow, as it always did. */
+  z5.object({ route: z5.literal("push"), acceptedCount: z5.literal(0) })
+]);
 var ImportHandoffSchema = z5.object({
   /** The user skipped the credentials screen, so nothing is fetched from or pushed to Contentful. */
   credentialsSkipped: z5.boolean(),
   tokens: TokensSchema,
   /** Present once the CLI has run the extraction stage; the wizard then starts at the scope gate. */
   extraction: z5.optional(ExtractionSchema),
-  /** Present once the user has confirmed the scope gate; the wizard then saves the decisions and starts generating. */
-  scope: z5.optional(ScopeSchema)
+  /**
+   * Present once the CLI has shown the scope gate, saved the decisions and generated the definitions; the wizard then
+   * starts at the review screen (or goes straight to pushing when nothing was accepted).
+   */
+  generation: z5.optional(GenerationSchema)
 });
 function serializeHandoff(handoff) {
   return JSON.stringify(handoff);
@@ -9628,7 +10261,7 @@ async function spawnV1Import(options = {}) {
   const cliPath = findLegacyCliPath();
   const args = buildArgs2(options);
   return new Promise((resolvePromise) => {
-    const child = spawn7("node", [cliPath, ...args], {
+    const child = spawn8("node", [cliPath, ...args], {
       stdio: "inherit",
       env: buildEnv(options)
     });
@@ -9646,7 +10279,7 @@ function getTerminalHandle() {
   return process.stdin._handle;
 }
 async function stopReadingTerminal() {
-  await new Promise((resolve10) => setImmediate(resolve10));
+  await new Promise((resolve12) => setImmediate(resolve12));
   const handle = getTerminalHandle();
   if (!handle?.readStop) return;
   handle.reading = false;
@@ -9660,13 +10293,13 @@ function startReadingTerminal() {
 }
 
 // packages/experience-design-system-cli/src/tui/help/PageContainer.tsx
-import { useEffect as useEffect9, useState as useState14 } from "react";
+import { useEffect as useEffect10, useState as useState15 } from "react";
 import { Box as Box21, Text as Text23, useInput as useInput9 } from "ink";
 
 // packages/experience-design-system-cli/src/tui/debug-store.ts
-import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
+import { mkdir as mkdir4, writeFile as writeFile4 } from "node:fs/promises";
 import { existsSync as existsSync5, readdirSync as readdirSync2 } from "node:fs";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 
 // packages/experience-design-system-cli/src/tui/settings/debug-mode/debug-mode-store.ts
 var DEFAULT_DEBUG_MODE_SETTING = {
@@ -9707,14 +10340,14 @@ function generateSessionId3() {
 }
 var SESSION_ID = generateSessionId3();
 function sessionDebugDir() {
-  return join12(debugSessionsDir2(), SESSION_ID);
+  return join13(debugSessionsDir2(), SESSION_ID);
 }
 function currentDebugSessionDir() {
   return sessionDebugDir();
 }
 void isDebugModeEnabled().then((enabled) => {
   if (!enabled) return void 0;
-  return mkdir3(sessionDebugDir(), { recursive: true });
+  return mkdir4(sessionDebugDir(), { recursive: true });
 });
 async function isDebugModeEnabled() {
   try {
@@ -9756,10 +10389,10 @@ async function finishDebugRun({
   const durationMs = Date.now() - run2.startedAt;
   const content = renderMarkdown(run2, { outputs: redact(outputs), status, exitMethod, durationMs });
   const flowSegments = run2.flow.split("/");
-  const dir = join12(sessionDebugDir(), ...flowSegments);
-  await mkdir3(dir, { recursive: true });
+  const dir = join13(sessionDebugDir(), ...flowSegments);
+  await mkdir4(dir, { recursive: true });
   const filename = nextAttemptFilename(dir, run2.menuOption);
-  await writeFile3(join12(dir, filename), content, { mode: 384 });
+  await writeFile4(join13(dir, filename), content, { mode: 384 });
 }
 function nextAttemptFilename(dir, menuOption) {
   const today = datePrefix();
@@ -9842,19 +10475,19 @@ async function readHelpInfo() {
 }
 
 // packages/experience-design-system-cli/src/tui/help/PageContainer.tsx
-import { Fragment as Fragment5, jsx as jsx25, jsxs as jsxs22 } from "react/jsx-runtime";
+import { Fragment as Fragment5, jsx as jsx26, jsxs as jsxs22 } from "react/jsx-runtime";
 function Section({ title, rows }) {
   return /* @__PURE__ */ jsxs22(Box21, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx25(Text23, { bold: true, color: PALETTE.accent, children: title }),
+    /* @__PURE__ */ jsx26(Text23, { bold: true, color: PALETTE.accent, children: title }),
     rows.map((row) => /* @__PURE__ */ jsxs22(Box21, { gap: 1, children: [
-      /* @__PURE__ */ jsx25(Box21, { width: 14, flexShrink: 0, children: /* @__PURE__ */ jsx25(Text23, { color: PALETTE.muted, children: row.label }) }),
-      /* @__PURE__ */ jsx25(Text23, { children: row.value })
+      /* @__PURE__ */ jsx26(Box21, { width: 14, flexShrink: 0, children: /* @__PURE__ */ jsx26(Text23, { color: PALETTE.muted, children: row.label }) }),
+      /* @__PURE__ */ jsx26(Text23, { children: row.value })
     ] }, row.label))
   ] });
 }
 function HelpScreen({ onDone }) {
-  const [info, setInfo] = useState14();
-  useEffect9(() => {
+  const [info, setInfo] = useState15();
+  useEffect10(() => {
     startDebugRun({ flow: "help", step: "01-help", menuOption: "Help", inputs: {} });
     void readHelpInfo().then(setInfo);
   }, []);
@@ -9873,13 +10506,13 @@ function HelpScreen({ onDone }) {
     }
   });
   return /* @__PURE__ */ jsxs22(Box21, { flexDirection: "column", paddingX: 2, paddingY: 1, gap: 1, children: [
-    /* @__PURE__ */ jsx25(Text23, { bold: true, children: "Help" }),
+    /* @__PURE__ */ jsx26(Text23, { bold: true, children: "Help" }),
     info ? /* @__PURE__ */ jsxs22(Fragment5, { children: [
-      /* @__PURE__ */ jsx25(Section, { title: "Where things are stored", rows: info.storage }),
-      /* @__PURE__ */ jsx25(Section, { title: "Troubleshooting", rows: info.troubleshooting }),
-      /* @__PURE__ */ jsx25(Text23, { color: PALETTE.muted, children: "Hit a problem? Turn on Debug Mode in Settings, reproduce it, then share the session folder above. The CMA token is redacted from those logs." })
-    ] }) : /* @__PURE__ */ jsx25(Text23, { color: PALETTE.accent, children: "Loading..." }),
-    /* @__PURE__ */ jsx25(
+      /* @__PURE__ */ jsx26(Section, { title: "Where things are stored", rows: info.storage }),
+      /* @__PURE__ */ jsx26(Section, { title: "Troubleshooting", rows: info.troubleshooting }),
+      /* @__PURE__ */ jsx26(Text23, { color: PALETTE.muted, children: "Hit a problem? Turn on Debug Mode in Settings, reproduce it, then share the session folder above. The CMA token is redacted from those logs." })
+    ] }) : /* @__PURE__ */ jsx26(Text23, { color: PALETTE.accent, children: "Loading..." }),
+    /* @__PURE__ */ jsx26(
       ControlHints,
       {
         hints: [
@@ -9892,14 +10525,14 @@ function HelpScreen({ onDone }) {
 }
 
 // packages/experience-design-system-cli/src/tui/settings/PageContainer.tsx
-import { useState as useState15 } from "react";
+import { useState as useState16 } from "react";
 import { Box as Box22, Text as Text24, useInput as useInput10 } from "ink";
-import { jsx as jsx26, jsxs as jsxs23 } from "react/jsx-runtime";
+import { jsx as jsx27, jsxs as jsxs23 } from "react/jsx-runtime";
 function SettingsScreen({
   onNavigate,
   onBack
 }) {
-  const [focusIdx, setFocusIdx] = useState15(0);
+  const [focusIdx, setFocusIdx] = useState16(0);
   const items = [
     { label: "Configuration", screen: "settings-configuration" },
     { label: "Opt-in Analytics", screen: "settings-opt-in-analytics" },
@@ -9926,14 +10559,14 @@ function SettingsScreen({
     }
   });
   return /* @__PURE__ */ jsxs23(Box22, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
-    /* @__PURE__ */ jsx26(Text24, { bold: true, children: "Settings" }),
-    /* @__PURE__ */ jsx26(Text24, { children: " " }),
+    /* @__PURE__ */ jsx27(Text24, { bold: true, children: "Settings" }),
+    /* @__PURE__ */ jsx27(Text24, { children: " " }),
     items.map((item, i) => /* @__PURE__ */ jsxs23(Text24, { color: i === focusIdx ? "cyan" : void 0, children: [
       i === focusIdx ? "> " : "  ",
       item.label
     ] }, item.label)),
-    /* @__PURE__ */ jsx26(Text24, { children: " " }),
-    /* @__PURE__ */ jsx26(
+    /* @__PURE__ */ jsx27(Text24, { children: " " }),
+    /* @__PURE__ */ jsx27(
       ControlHints,
       {
         hints: [
@@ -9947,7 +10580,7 @@ function SettingsScreen({
 }
 
 // packages/experience-design-system-cli/src/tui/settings/contentful-configuration/ContentfulConfigScreen.tsx
-import { useEffect as useEffect10, useState as useState16 } from "react";
+import { useEffect as useEffect11, useState as useState17 } from "react";
 import { Box as Box23, Text as Text25, useInput as useInput11 } from "ink";
 import TextInput4 from "ink-text-input";
 
@@ -9980,7 +10613,7 @@ async function writeCredentials(config) {
 }
 
 // packages/experience-design-system-cli/src/tui/settings/contentful-configuration/ContentfulConfigScreen.tsx
-import { Fragment as Fragment6, jsx as jsx27, jsxs as jsxs24 } from "react/jsx-runtime";
+import { Fragment as Fragment6, jsx as jsx28, jsxs as jsxs24 } from "react/jsx-runtime";
 var FIELD_ORDER = [
   "spaceId",
   "environmentId",
@@ -10008,14 +10641,14 @@ var FIELD_LABELS = {
   defaultTokenFile: "Default token file (optional)"
 };
 function ConfigurationScreen({ onDone }) {
-  const [stage, setStage] = useState16("loading");
-  const [config, setConfig] = useState16(null);
-  const [activeField, setActiveField] = useState16("spaceId");
-  const [notice, setNotice] = useState16(null);
-  const [lastSaved, setLastSaved] = useState16(null);
-  const [editing, setEditing] = useState16(false);
-  const [valueBeforeEdit, setValueBeforeEdit] = useState16("");
-  useEffect10(() => {
+  const [stage, setStage] = useState17("loading");
+  const [config, setConfig] = useState17(null);
+  const [activeField, setActiveField] = useState17("spaceId");
+  const [notice, setNotice] = useState17(null);
+  const [lastSaved, setLastSaved] = useState17(null);
+  const [editing, setEditing] = useState17(false);
+  const [valueBeforeEdit, setValueBeforeEdit] = useState17("");
+  useEffect11(() => {
     readCredentials().then((cfg) => {
       setConfig(cfg);
       setStage("form");
@@ -10093,25 +10726,25 @@ function ConfigurationScreen({ onDone }) {
   });
   if (stage === "loading") {
     return /* @__PURE__ */ jsxs24(Box23, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
-      /* @__PURE__ */ jsx27(Text25, { bold: true, children: "Configuration" }),
-      /* @__PURE__ */ jsx27(Text25, { children: " " }),
-      /* @__PURE__ */ jsx27(Text25, { color: PALETTE.accent, children: "Loading..." })
+      /* @__PURE__ */ jsx28(Text25, { bold: true, children: "Configuration" }),
+      /* @__PURE__ */ jsx28(Text25, { children: " " }),
+      /* @__PURE__ */ jsx28(Text25, { color: PALETTE.accent, children: "Loading..." })
     ] });
   }
   return /* @__PURE__ */ jsxs24(Box23, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
-    /* @__PURE__ */ jsx27(Text25, { bold: true, children: "Configuration" }),
-    /* @__PURE__ */ jsx27(Text25, { children: " " }),
-    /* @__PURE__ */ jsx27(Box23, { flexDirection: "column", children: FIELD_ORDER.map((field) => {
+    /* @__PURE__ */ jsx28(Text25, { bold: true, children: "Configuration" }),
+    /* @__PURE__ */ jsx28(Text25, { children: " " }),
+    /* @__PURE__ */ jsx28(Box23, { flexDirection: "column", children: FIELD_ORDER.map((field) => {
       const isActive = activeField === field;
       const value = fieldValue(field);
       const display = field === "cmaToken" ? "\u2022".repeat(value.length) : value;
       return /* @__PURE__ */ jsxs24(Box23, { gap: 1, children: [
-        /* @__PURE__ */ jsx27(Text25, { color: isActive ? PALETTE.accent : void 0, children: isActive ? "\u276F" : " " }),
+        /* @__PURE__ */ jsx28(Text25, { color: isActive ? PALETTE.accent : void 0, children: isActive ? "\u276F" : " " }),
         /* @__PURE__ */ jsxs24(Text25, { bold: isActive, children: [
           FIELD_LABELS[field],
           ":"
         ] }),
-        isActive && editing ? /* @__PURE__ */ jsx27(
+        isActive && editing ? /* @__PURE__ */ jsx28(
           TextInput4,
           {
             value,
@@ -10119,19 +10752,19 @@ function ConfigurationScreen({ onDone }) {
             onSubmit: () => setEditing(false),
             mask: field === "cmaToken" ? "\u2022" : void 0
           }
-        ) : /* @__PURE__ */ jsx27(Text25, { children: display || /* @__PURE__ */ jsx27(Text25, { color: PALETTE.muted, children: "(empty)" }) })
+        ) : /* @__PURE__ */ jsx28(Text25, { children: display || /* @__PURE__ */ jsx28(Text25, { color: PALETTE.muted, children: "(empty)" }) })
       ] }, field);
     }) }),
     notice && /* @__PURE__ */ jsxs24(Fragment6, { children: [
-      /* @__PURE__ */ jsx27(Text25, { children: " " }),
+      /* @__PURE__ */ jsx28(Text25, { children: " " }),
       /* @__PURE__ */ jsxs24(Text25, { color: notice.kind === "success" ? PALETTE.success : PALETTE.error, children: [
         notice.kind === "success" ? "\u2713" : "\u2717",
         " ",
         notice.text
       ] })
     ] }),
-    /* @__PURE__ */ jsx27(Text25, { children: " " }),
-    /* @__PURE__ */ jsx27(
+    /* @__PURE__ */ jsx28(Text25, { children: " " }),
+    /* @__PURE__ */ jsx28(
       ControlHints,
       {
         hints: editing ? [
@@ -10152,7 +10785,7 @@ function ConfigurationScreen({ onDone }) {
 }
 
 // packages/experience-design-system-cli/src/tui/settings/opt-in-analytics/screen.tsx
-import { useEffect as useEffect11, useState as useState17 } from "react";
+import { useEffect as useEffect12, useState as useState18 } from "react";
 import { Box as Box24, Text as Text26, useInput as useInput12 } from "ink";
 
 // packages/experience-design-system-cli/src/tui/settings/opt-in-analytics/analytics-store.ts
@@ -10171,11 +10804,11 @@ async function writeAnalyticsSetting(setting) {
 }
 
 // packages/experience-design-system-cli/src/tui/settings/opt-in-analytics/screen.tsx
-import { Fragment as Fragment7, jsx as jsx28, jsxs as jsxs25 } from "react/jsx-runtime";
+import { Fragment as Fragment7, jsx as jsx29, jsxs as jsxs25 } from "react/jsx-runtime";
 function OptInAnalyticsScreen({ onDone }) {
-  const [loading, setLoading] = useState17(true);
-  const [enabled, setEnabled] = useState17(true);
-  useEffect11(() => {
+  const [loading, setLoading] = useState18(true);
+  const [enabled, setEnabled] = useState18(true);
+  useEffect12(() => {
     readAnalyticsSetting().then((setting) => {
       setEnabled(setting.enabled);
       setLoading(false);
@@ -10203,20 +10836,20 @@ function OptInAnalyticsScreen({ onDone }) {
     }
   });
   return /* @__PURE__ */ jsxs25(Box24, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
-    /* @__PURE__ */ jsx28(Text26, { bold: true, children: "Settings \u203A Opt-in Analytics" }),
-    /* @__PURE__ */ jsx28(Text26, { children: " " }),
-    loading ? /* @__PURE__ */ jsx28(Text26, { color: PALETTE.muted, children: "Loading\u2026" }) : /* @__PURE__ */ jsxs25(Fragment7, { children: [
+    /* @__PURE__ */ jsx29(Text26, { bold: true, children: "Settings \u203A Opt-in Analytics" }),
+    /* @__PURE__ */ jsx29(Text26, { children: " " }),
+    loading ? /* @__PURE__ */ jsx29(Text26, { color: PALETTE.muted, children: "Loading\u2026" }) : /* @__PURE__ */ jsxs25(Fragment7, { children: [
       /* @__PURE__ */ jsxs25(Text26, { children: [
         "Share anonymous usage data:",
         " ",
-        /* @__PURE__ */ jsx28(Text26, { bold: true, color: enabled ? PALETTE.success : PALETTE.muted, children: enabled ? "On" : "Off" })
+        /* @__PURE__ */ jsx29(Text26, { bold: true, color: enabled ? PALETTE.success : PALETTE.muted, children: enabled ? "On" : "Off" })
       ] }),
-      /* @__PURE__ */ jsx28(Text26, { children: " " }),
-      /* @__PURE__ */ jsx28(Text26, { color: PALETTE.muted, children: "Shares which CLI commands are used and where imports succeed or fail." }),
-      /* @__PURE__ */ jsx28(Text26, { color: PALETTE.muted, children: "Never includes source code, file paths, credentials, or authored content." })
+      /* @__PURE__ */ jsx29(Text26, { children: " " }),
+      /* @__PURE__ */ jsx29(Text26, { color: PALETTE.muted, children: "Shares which CLI commands are used and where imports succeed or fail." }),
+      /* @__PURE__ */ jsx29(Text26, { color: PALETTE.muted, children: "Never includes source code, file paths, credentials, or authored content." })
     ] }),
-    /* @__PURE__ */ jsx28(Text26, { children: " " }),
-    /* @__PURE__ */ jsx28(
+    /* @__PURE__ */ jsx29(Text26, { children: " " }),
+    /* @__PURE__ */ jsx29(
       ControlHints,
       {
         hints: [
@@ -10229,13 +10862,13 @@ function OptInAnalyticsScreen({ onDone }) {
 }
 
 // packages/experience-design-system-cli/src/tui/upgrade/PageContainer.tsx
-import { useEffect as useEffect12, useState as useState18 } from "react";
+import { useEffect as useEffect13, useState as useState19 } from "react";
 import { Box as Box25, Text as Text27, useInput as useInput13 } from "ink";
-import { jsx as jsx29, jsxs as jsxs26 } from "react/jsx-runtime";
+import { jsx as jsx30, jsxs as jsxs26 } from "react/jsx-runtime";
 var UPGRADE_COMMANDS = ["git pull", "pnpm install", "pnpm build"];
 function UpgradeScreen({ onDone }) {
-  const [upgradeCheck, setUpgradeCheck] = useState18();
-  useEffect12(() => {
+  const [upgradeCheck, setUpgradeCheck] = useState19();
+  useEffect13(() => {
     startDebugRun({
       flow: "upgrade",
       step: "01-upgrade",
@@ -10256,10 +10889,10 @@ function UpgradeScreen({ onDone }) {
     }
   });
   return /* @__PURE__ */ jsxs26(Box25, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
-    /* @__PURE__ */ jsx29(Text27, { bold: true, children: "Upgrade" }),
-    /* @__PURE__ */ jsx29(Text27, { children: " " }),
+    /* @__PURE__ */ jsx30(Text27, { bold: true, children: "Upgrade" }),
+    /* @__PURE__ */ jsx30(Text27, { children: " " }),
     renderBody(upgradeCheck),
-    /* @__PURE__ */ jsx29(Text27, { children: " " }),
+    /* @__PURE__ */ jsx30(Text27, { children: " " }),
     /* @__PURE__ */ jsxs26(Text27, { bold: true, color: PALETTE.accent, children: [
       FOCUS_MARKER,
       " Go Back"
@@ -10268,10 +10901,10 @@ function UpgradeScreen({ onDone }) {
 }
 function renderBody(upgradeCheck) {
   if (!upgradeCheck) {
-    return /* @__PURE__ */ jsx29(Text27, { color: PALETTE.muted, children: "Checking for updates\u2026" });
+    return /* @__PURE__ */ jsx30(Text27, { color: PALETTE.muted, children: "Checking for updates\u2026" });
   }
   if (upgradeCheck.status === "error") {
-    return /* @__PURE__ */ jsx29(Text27, { color: PALETTE.warning, children: "Couldn't check for updates \u2014 check your network connection and try again." });
+    return /* @__PURE__ */ jsx30(Text27, { color: PALETTE.warning, children: "Couldn't check for updates \u2014 check your network connection and try again." });
   }
   if (upgradeCheck.status === "up-to-date") {
     return /* @__PURE__ */ jsxs26(Text27, { color: PALETTE.success, children: [
@@ -10294,19 +10927,19 @@ function renderBody(upgradeCheck) {
       ] }),
       "). Exit this program, cd into the root of your local clone of contentful/experience-design-system-sdk-public, then run:"
     ] }),
-    /* @__PURE__ */ jsx29(Text27, { children: " " }),
-    /* @__PURE__ */ jsx29(Box25, { flexDirection: "column", borderStyle: "round", borderColor: PALETTE.border, paddingX: 1, children: UPGRADE_COMMANDS.map((cmd) => /* @__PURE__ */ jsx29(Text27, { bold: true, children: cmd }, cmd)) })
+    /* @__PURE__ */ jsx30(Text27, { children: " " }),
+    /* @__PURE__ */ jsx30(Box25, { flexDirection: "column", borderStyle: "round", borderColor: PALETTE.border, paddingX: 1, children: UPGRADE_COMMANDS.map((cmd) => /* @__PURE__ */ jsx30(Text27, { bold: true, children: cmd }, cmd)) })
   ] });
 }
 
 // packages/experience-design-system-cli/src/tui/settings/debug-mode/screen.tsx
-import { useEffect as useEffect13, useState as useState19 } from "react";
+import { useEffect as useEffect14, useState as useState20 } from "react";
 import { Box as Box26, Text as Text28, useInput as useInput14 } from "ink";
-import { jsx as jsx30, jsxs as jsxs27 } from "react/jsx-runtime";
+import { jsx as jsx31, jsxs as jsxs27 } from "react/jsx-runtime";
 function DebugModeScreen({ onDone }) {
-  const [loading, setLoading] = useState19(true);
-  const [enabled, setEnabled] = useState19(true);
-  useEffect13(() => {
+  const [loading, setLoading] = useState20(true);
+  const [enabled, setEnabled] = useState20(true);
+  useEffect14(() => {
     readDebugModeSetting().then((setting) => {
       setEnabled(setting.enabled);
       setLoading(false);
@@ -10334,15 +10967,15 @@ function DebugModeScreen({ onDone }) {
     }
   });
   return /* @__PURE__ */ jsxs27(Box26, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
-    /* @__PURE__ */ jsx30(Text28, { bold: true, children: "Settings \u203A Debug Mode" }),
-    /* @__PURE__ */ jsx30(Text28, { children: " " }),
-    loading ? /* @__PURE__ */ jsx30(Text28, { color: PALETTE.muted, children: "Loading\u2026" }) : /* @__PURE__ */ jsxs27(Text28, { children: [
+    /* @__PURE__ */ jsx31(Text28, { bold: true, children: "Settings \u203A Debug Mode" }),
+    /* @__PURE__ */ jsx31(Text28, { children: " " }),
+    loading ? /* @__PURE__ */ jsx31(Text28, { color: PALETTE.muted, children: "Loading\u2026" }) : /* @__PURE__ */ jsxs27(Text28, { children: [
       "Debug logging:",
       " ",
-      /* @__PURE__ */ jsx30(Text28, { bold: true, color: enabled ? PALETTE.success : PALETTE.muted, children: enabled ? "On" : "Off" })
+      /* @__PURE__ */ jsx31(Text28, { bold: true, color: enabled ? PALETTE.success : PALETTE.muted, children: enabled ? "On" : "Off" })
     ] }),
-    /* @__PURE__ */ jsx30(Text28, { children: " " }),
-    /* @__PURE__ */ jsx30(
+    /* @__PURE__ */ jsx31(Text28, { children: " " }),
+    /* @__PURE__ */ jsx31(
       ControlHints,
       {
         hints: [
@@ -10355,18 +10988,18 @@ function DebugModeScreen({ onDone }) {
 }
 
 // packages/experience-design-system-cli/app.tsx
-import { Fragment as Fragment8, jsx as jsx31 } from "react/jsx-runtime";
+import { Fragment as Fragment8, jsx as jsx32 } from "react/jsx-runtime";
 function App({ importOptions, onLaunchImport, importExitCode }) {
   const returnedFromImport = importExitCode !== void 0;
-  const [screen, setScreen] = useState20(returnedFromImport ? "import" : "start");
-  const [showImportResult, setShowImportResult] = useState20(returnedFromImport);
-  const [projectPath, setProjectPath] = useState20();
-  const [tokensPath, setTokensPath] = useState20();
-  const [scannedFiles, setScannedFiles] = useState20();
-  const [pendingLaunch, setPendingLaunch] = useState20();
-  const [extractionRun, setExtractionRun] = useState20();
+  const [screen, setScreen] = useState21(returnedFromImport ? "import" : "start");
+  const [showImportResult, setShowImportResult] = useState21(returnedFromImport);
+  const [projectPath, setProjectPath] = useState21();
+  const [tokensPath, setTokensPath] = useState21();
+  const [scannedFiles, setScannedFiles] = useState21();
+  const [pendingLaunch, setPendingLaunch] = useState21();
+  const [extractionRun, setExtractionRun] = useState21();
   const extraction = useExtraction(extractionRun?.input);
-  const [scopeRun, setScopeRun] = useState20();
+  const [scopeRun, setScopeRun] = useState21();
   const scopeFlow = useScopeGateFlow(
     scopeRun && {
       sessionId: scopeRun.extraction.sessionId,
@@ -10381,8 +11014,10 @@ function App({ importOptions, onLaunchImport, importExitCode }) {
       }
     }
   );
-  const [importDefaults, setImportDefaults] = useState20();
-  useEffect14(() => {
+  const [generationInput, setGenerationInput] = useState21();
+  const generation = useGeneration(generationInput);
+  const [importDefaults, setImportDefaults] = useState21();
+  useEffect15(() => {
     if (screen !== "import") {
       setImportDefaults(void 0);
       return;
@@ -10400,7 +11035,7 @@ function App({ importOptions, onLaunchImport, importExitCode }) {
     const launch = { projectPath: projectPath2, tokens, filePaths, ...importOptions };
     const state = await inspectTokens({
       rawTokensPath: tokens,
-      outDir: join13(resolveUserPath(projectPath2), ".contentful"),
+      outDir: join14(resolveUserPath(projectPath2), ".contentful"),
       cache: importOptions.cache
     });
     if (state.kind === "cached") {
@@ -10418,8 +11053,11 @@ function App({ importOptions, onLaunchImport, importExitCode }) {
     void startExtraction(pending.launch, tokenStrategy, pending.credentials);
   };
   const startExtraction = async (launch, tokenStrategy, credentials) => {
-    const { agent, agentModel } = resolveAgentChoice(launch.agent, await readSettings2());
+    const settings = await readSettings2();
+    const { agent, agentModel } = resolveAgentChoice(launch.agent, settings);
+    const generatePromptPath = typeof settings.generatePromptPath === "string" ? settings.generatePromptPath : void 0;
     setExtractionRun({
+      ...generatePromptPath ? { generatePromptPath } : {},
       // the wizard gets the same agent, so its later steps use what the stage used
       launch: { ...launch, agent: agentModel ? `${agent}:${agentModel}` : agent },
       credentialsSkipped: credentials.skipped,
@@ -10436,25 +11074,44 @@ function App({ importOptions, onLaunchImport, importExitCode }) {
       }
     });
   };
-  useEffect14(() => {
+  useEffect15(() => {
     if (!extractionRun || extraction?.status !== "done" || !extraction.result.ok) return;
     setExtractionRun(void 0);
     setScopeRun({ ...extractionRun, extraction: extraction.result.extraction });
   }, [extraction, extractionRun]);
-  useEffect14(() => {
-    if (!scopeRun || scopeFlow?.status !== "confirmed") return;
+  useEffect15(() => {
+    if (!scopeRun || scopeFlow?.status !== "confirmed" || generationInput) return;
+    const { extraction: produced, input, generatePromptPath } = scopeRun;
+    setGenerationInput({
+      sessionId: produced.sessionId,
+      decisions: scopeFlow.decisions,
+      cachedNames: scopeFlow.cachedNames,
+      tokensPath: produced.tokensPath,
+      tokenSessionId: produced.tokenSessionId,
+      existingEntitiesPath: produced.existingEntitiesPath,
+      agent: input.agent,
+      ...input.agentModel ? { agentModel: input.agentModel } : {},
+      promptOverrides: input.promptOverrides,
+      noCache: input.noCache,
+      hasTokens: produced.tokensPath !== "",
+      ...generatePromptPath ? { generatePromptPath } : {}
+    });
+  }, [scopeFlow, scopeRun, generationInput]);
+  useEffect15(() => {
+    if (!scopeRun || generation?.status !== "done" || !generation.result.ok) return;
     const { launch, credentialsSkipped, tokenStrategy, extraction: produced } = scopeRun;
     setScopeRun(void 0);
+    setGenerationInput(void 0);
     onLaunchImport?.({
       ...launch,
       handoff: {
         credentialsSkipped,
         tokens: { strategy: tokenStrategy },
         extraction: produced,
-        scope: scopeFlow.scope
+        generation: generation.result.generation
       }
     });
-  }, [scopeFlow, scopeRun]);
+  }, [generation, scopeRun]);
   const goToStart = () => setScreen("start");
   const goToSettings = () => setScreen("settings");
   const resetImport = () => {
@@ -10464,6 +11121,7 @@ function App({ importOptions, onLaunchImport, importExitCode }) {
     setPendingLaunch(void 0);
     setExtractionRun(void 0);
     setScopeRun(void 0);
+    setGenerationInput(void 0);
   };
   const finishImportResult = () => {
     setShowImportResult(false);
@@ -10476,13 +11134,13 @@ function App({ importOptions, onLaunchImport, importExitCode }) {
   };
   switch (screen) {
     case "import":
-      if (showImportResult) return /* @__PURE__ */ jsx31(ImportScreen, { exitCode: importExitCode, onDone: finishImportResult });
-      if (importDefaults === void 0) return /* @__PURE__ */ jsx31(Fragment8, {});
+      if (showImportResult) return /* @__PURE__ */ jsx32(ImportScreen, { exitCode: importExitCode, onDone: finishImportResult });
+      if (importDefaults === void 0) return /* @__PURE__ */ jsx32(Fragment8, {});
       if (projectPath === void 0) {
-        return /* @__PURE__ */ jsx31(WelcomeScreen, { onContinue: setProjectPath, onQuit: leaveImport, initialPath: importDefaults.componentDir });
+        return /* @__PURE__ */ jsx32(WelcomeScreen, { onContinue: setProjectPath, onQuit: leaveImport, initialPath: importDefaults.componentDir });
       }
       if (tokensPath === void 0) {
-        return /* @__PURE__ */ jsx31(
+        return /* @__PURE__ */ jsx32(
           TokenInputScreen,
           {
             initialPath: importDefaults.tokenFile,
@@ -10492,7 +11150,7 @@ function App({ importOptions, onLaunchImport, importExitCode }) {
         );
       }
       if (scannedFiles === void 0) {
-        return /* @__PURE__ */ jsx31(
+        return /* @__PURE__ */ jsx32(
           PathValidationScreen,
           {
             projectPath,
@@ -10504,10 +11162,10 @@ function App({ importOptions, onLaunchImport, importExitCode }) {
       }
       if (extractionRun) {
         if (extraction?.status === "done" && !extraction.result.ok) {
-          return /* @__PURE__ */ jsx31(ErrorStep, { stepName: extraction.result.step, message: extraction.result.message, onExit: leaveImport });
+          return /* @__PURE__ */ jsx32(ErrorStep, { stepName: extraction.result.step, message: extraction.result.message, onExit: leaveImport });
         }
         if (extraction?.status === "running") {
-          return /* @__PURE__ */ jsx31(
+          return /* @__PURE__ */ jsx32(
             ExtractionScreen,
             {
               progress: extraction.progress,
@@ -10516,14 +11174,14 @@ function App({ importOptions, onLaunchImport, importExitCode }) {
             }
           );
         }
-        return /* @__PURE__ */ jsx31(Fragment8, {});
+        return /* @__PURE__ */ jsx32(Fragment8, {});
       }
       if (scopeRun && scopeFlow) {
         if (scopeFlow.status === "failed") {
-          return /* @__PURE__ */ jsx31(ErrorStep, { stepName: "scope gate", message: scopeFlow.message, onExit: leaveImport });
+          return /* @__PURE__ */ jsx32(ErrorStep, { stepName: "scope gate", message: scopeFlow.message, onExit: leaveImport });
         }
         if (scopeFlow.status === "deciding") {
-          return /* @__PURE__ */ jsx31(
+          return /* @__PURE__ */ jsx32(
             ScopeGateScreen,
             {
               components: scopeFlow.load.components,
@@ -10532,19 +11190,31 @@ function App({ importOptions, onLaunchImport, importExitCode }) {
             }
           );
         }
-        const numbers = stepNumbers({ hasRawTokens: scopeRun.input.rawTokensPath !== "" });
-        return /* @__PURE__ */ jsx31(
-          RunningStep,
-          {
-            stepNumber: numbers.stepNumber + 1,
-            totalSteps: numbers.totalSteps,
-            title: "Preparing",
-            description: "Checking which components are already generated..."
-          }
-        );
+        if (generation?.status === "done" && !generation.result.ok) {
+          return /* @__PURE__ */ jsx32(ErrorStep, { stepName: generation.result.step, message: generation.result.message, onExit: leaveImport });
+        }
+        if (generation?.status === "running") {
+          const hasRawTokens = scopeRun.input.rawTokensPath !== "";
+          const counted = stepNumbers({
+            hasRawTokens,
+            mapTokensEligible: generation.progress.mapTokensEligible
+          });
+          return /* @__PURE__ */ jsx32(
+            GenerationScreen,
+            {
+              progress: generation.progress,
+              agent: scopeRun.input.agent,
+              acceptedCount: scopeFlow.decisions.accepted.length,
+              hasTokens: scopeRun.extraction.tokensPath !== "",
+              stepNumber: hasRawTokens ? 4 : 3,
+              totalSteps: counted.totalSteps
+            }
+          );
+        }
+        return /* @__PURE__ */ jsx32(Fragment8, {});
       }
       if (pendingLaunch?.cached) {
-        return /* @__PURE__ */ jsx31(
+        return /* @__PURE__ */ jsx32(
           TokenReuseScreen,
           {
             tokensPath: pendingLaunch.cached.tokensPath,
@@ -10555,7 +11225,7 @@ function App({ importOptions, onLaunchImport, importExitCode }) {
           }
         );
       }
-      return /* @__PURE__ */ jsx31(
+      return /* @__PURE__ */ jsx32(
         CredentialsScreen,
         {
           initial: importDefaults.credentials,
@@ -10564,26 +11234,26 @@ function App({ importOptions, onLaunchImport, importExitCode }) {
         }
       );
     case "help":
-      return /* @__PURE__ */ jsx31(HelpScreen, { onDone: goToStart });
+      return /* @__PURE__ */ jsx32(HelpScreen, { onDone: goToStart });
     case "upgrade":
-      return /* @__PURE__ */ jsx31(UpgradeScreen, { onDone: goToStart });
+      return /* @__PURE__ */ jsx32(UpgradeScreen, { onDone: goToStart });
     case "settings":
-      return /* @__PURE__ */ jsx31(SettingsScreen, { onNavigate: setScreen, onBack: goToStart });
+      return /* @__PURE__ */ jsx32(SettingsScreen, { onNavigate: setScreen, onBack: goToStart });
     case "settings-configuration":
-      return /* @__PURE__ */ jsx31(ConfigurationScreen, { onDone: goToSettings });
+      return /* @__PURE__ */ jsx32(ConfigurationScreen, { onDone: goToSettings });
     case "settings-opt-in-analytics":
-      return /* @__PURE__ */ jsx31(OptInAnalyticsScreen, { onDone: goToSettings });
+      return /* @__PURE__ */ jsx32(OptInAnalyticsScreen, { onDone: goToSettings });
     case "settings-debug-mode":
-      return /* @__PURE__ */ jsx31(DebugModeScreen, { onDone: goToSettings });
+      return /* @__PURE__ */ jsx32(DebugModeScreen, { onDone: goToSettings });
     case "start":
-      return /* @__PURE__ */ jsx31(HomeScreen, { onNavigate: setScreen });
+      return /* @__PURE__ */ jsx32(HomeScreen, { onNavigate: setScreen });
   }
 }
 var CLEAR_SCREEN = "\x1B[2J\x1B[H";
 async function renderUntilImportRequestedOrExit(renderApp, importOptions, importExitCode) {
   let requestedImport;
   const instance = renderApp(
-    /* @__PURE__ */ jsx31(
+    /* @__PURE__ */ jsx32(
       App,
       {
         importOptions,