@contentful/experience-design-system-cli 2.37.1-dev-build-a029dc0a.0 → 2.37.1-dev-build-1c5cd11a.0

package/dist/app.js

@@ -772,7 +772,7 @@ async function runAgent(options) {
     promptLen: prompt.length,
     promptHead: prompt.slice(0, 500)
   });
-  return new Promise((resolve22) => {
+  return new Promise((resolve25) => {
     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)
       });
-      resolve22(result);
+      resolve25(result);
     });
   });
 }
@@ -843,7 +843,7 @@ async function checkAgentAuth(agent) {
     return "not-found";
   if (agent !== "claude")
     return "ok";
-  return new Promise((resolve22) => {
+  return new Promise((resolve25) => {
     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");
-      resolve22("unauthenticated");
+      resolve25("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) {
-        resolve22("unauthenticated");
+        resolve25("unauthenticated");
         return;
       }
       try {
         const status = JSON.parse(stdout);
-        resolve22(status.loggedIn ? "ok" : "unauthenticated");
+        resolve25(status.loggedIn ? "ok" : "unauthenticated");
       } catch {
-        resolve22("unauthenticated");
+        resolve25("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((resolve22) => {
+  return new Promise((resolve25) => {
     const child = spawn2(process.platform === "win32" ? "where" : "which", [binary], { stdio: "ignore" });
-    child.on("close", (code) => resolve22(code === 0));
+    child.on("close", (code) => resolve25(code === 0));
   });
 }
 var init_check_agent_auth = __esm({
@@ -2017,7 +2017,7 @@ var init_cache_keys = __esm({
 });
 
 // packages/experience-design-system-cli/app.tsx
-import { join as join26 } from "node:path";
+import { join as join25 } from "node:path";
 import { useEffect as useEffect26, useState as useState33 } from "react";
 
 // packages/experience-design-system-cli/src/tui/home/home.tsx
@@ -2553,6 +2553,8 @@ function usePathValidationControls(phase, handlers) {
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/repositories/db.js
 import { DatabaseSync } from "node:sqlite";
 import { mkdirSync, readFileSync as readFileSync3 } from "node:fs";
+import { readFile as readFile4 } from "node:fs/promises";
+import { createHash as createHash5 } from "node:crypto";
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/helpers/config-root.js
 import { homedir as homedir2 } from "node:os";
@@ -2565,6 +2567,81 @@ var runsFilePath = () => join3(configRoot(), "state", "runs.json");
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/repositories/db.js
 import { dirname as dirname4, resolve as resolve6 } from "node:path";
 
+// packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/helpers/source-excerpt.js
+var ELLIPSIS_MARKER = "/* \u2026 */";
+var TRUNCATED_MARKER = "/* truncated */";
+function escapeForRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function identifierPattern(name) {
+  return new RegExp(`(?<![A-Za-z0-9_$])${escapeForRegExp(name)}(?![A-Za-z0-9_$])`);
+}
+function excerptAroundNames(text, names, maxChars, contextLines = 6) {
+  if (text.length <= maxChars)
+    return { content: text, usesNotShown: [] };
+  const patterns = names.filter((name) => name.length > 0).map((name) => ({ name, pattern: identifierPattern(name) }));
+  const lines = text.split("\n");
+  const windows = [];
+  lines.forEach((line, index) => {
+    const mentioned = patterns.filter(({ pattern }) => pattern.test(line)).map(({ name }) => name);
+    if (mentioned.length === 0)
+      return;
+    const start = Math.max(0, index - contextLines);
+    const end = Math.min(lines.length - 1, index + contextLines);
+    const last = windows[windows.length - 1];
+    if (last && start <= last.end + 1) {
+      last.end = Math.max(last.end, end);
+      for (const name of mentioned)
+        last.names.add(name);
+    } else {
+      windows.push({ start, end, names: new Set(mentioned) });
+    }
+  });
+  if (windows.length === 0) {
+    return { content: `${text.slice(0, maxChars)}
+${TRUNCATED_MARKER}`, usesNotShown: [] };
+  }
+  const lastWindowFor = /* @__PURE__ */ new Map();
+  for (const window of windows)
+    for (const name of window.names)
+      lastWindowFor.set(name, window);
+  const kept = [];
+  const cut = /* @__PURE__ */ new Set();
+  let used = 0;
+  for (const window of [...windows].reverse()) {
+    const chunk = lines.slice(window.start, window.end + 1).join("\n");
+    const separator = kept.length > 0 ? `
+${ELLIPSIS_MARKER}
+` : "";
+    if (used + separator.length + chunk.length > maxChars) {
+      if (kept.length === 0) {
+        const head = chunk.slice(0, maxChars);
+        kept.push({ window, text: head });
+        used += head.length;
+        for (const name of window.names) {
+          if (lastWindowFor.get(name) === window && !identifierPattern(name).test(head))
+            cut.add(name);
+        }
+        continue;
+      }
+      for (const name of window.names) {
+        if (lastWindowFor.get(name) === window)
+          cut.add(name);
+      }
+      continue;
+    }
+    kept.push({ window, text: chunk });
+    used += separator.length + chunk.length;
+  }
+  kept.sort((a, b) => a.window.start - b.window.start);
+  const parts = kept.map((entry, index) => (index > 0 ? `
+${ELLIPSIS_MARKER}
+` : "") + entry.text);
+  const usesNotShown = names.filter((name, index) => cut.has(name) && names.indexOf(name) === index);
+  return { content: `${parts.join("")}
+${TRUNCATED_MARKER}`, usesNotShown };
+}
+
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/helpers/components/derive-component-id.js
 import { createHash } from "node:crypto";
 function deriveComponentId(name, source) {
@@ -2626,6 +2703,14 @@ function getSessionById(db, sessionId) {
   const row = db.prepare("SELECT id FROM sessions WHERE id = ?").get(sessionId);
   return row ?? null;
 }
+function getLatestCompletedSessionForCommand(db, command) {
+  const row = db.prepare(`SELECT s.id FROM sessions s
+       JOIN steps st ON st.session_id = s.id
+       WHERE st.command = ? AND st.status = 'complete'
+       ORDER BY st.started_at DESC, st.id DESC
+       LIMIT 1`).get(command);
+  return row?.id ?? null;
+}
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/repositories/sessions/write.js
 function createSession(db, id, name, timestamp) {
@@ -2930,6 +3015,13 @@ 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)]));
 }
+function getRawTokenNamePathRows(db, sessionId) {
+  return db.prepare("SELECT raw_name, path, source FROM raw_token_name_paths WHERE session_id = ? ORDER BY raw_name").all(sessionId).map((row) => ({
+    rawName: String(row.raw_name),
+    path: String(row.path),
+    source: String(row.source)
+  }));
+}
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/helpers/components/hash-component-shape.js
 import { createHash as createHash2 } from "node:crypto";
@@ -2981,6 +3073,27 @@ function upsertRawTokenGroup(db, sessionId, call) {
   db.prepare(`INSERT INTO raw_token_groups (session_id, path, description) VALUES (?, ?, ?)
      ON CONFLICT(session_id, path) DO UPDATE SET description = excluded.description`).run(sessionId, call.path, call.description ?? null);
 }
+function updateRawTokenNamePaths(db, sessionId, tokenNamePaths, source) {
+  const entries = Object.entries(tokenNamePaths);
+  const deletePaths = db.prepare("DELETE FROM raw_token_name_paths WHERE session_id = ? AND source = ?");
+  const insertPath = db.prepare("INSERT OR IGNORE INTO raw_token_name_paths (session_id, raw_name, path, source) VALUES (?, ?, ?, ?)");
+  const deleteAutomaticByName = db.prepare("DELETE FROM raw_token_name_paths WHERE session_id = ? AND raw_name = ? AND source = 'automatic'");
+  deletePaths.run(sessionId, source);
+  for (const [rawName, path5] of entries) {
+    if (source === "manual")
+      deleteAutomaticByName.run(sessionId, rawName);
+    insertPath.run(sessionId, rawName, path5, source);
+  }
+}
+function updateRawPropTokenPaths(db, sessionId, componentId, propName, paths, source) {
+  db.prepare(`DELETE FROM raw_prop_token_paths
+     WHERE session_id = ? AND component_id = ? AND prop_name = ?`).run(sessionId, componentId, propName);
+  const insertPath = db.prepare(`INSERT INTO raw_prop_token_paths (session_id, component_id, prop_name, source, position, path)
+     VALUES (?, ?, ?, ?, ?, ?)`);
+  paths.forEach((path5, position) => {
+    insertPath.run(sessionId, componentId, propName, source, position, path5);
+  });
+}
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/repositories/shared/with-transaction.js
 function withTransaction(db, fn) {
@@ -3027,6 +3140,22 @@ function applyTokenToolCalls(db, sessionId, calls, incomingWarnings) {
   return { tokens, groups, warnings };
 }
 
+// packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/services/tokens/replace-raw-token-name-paths.js
+function replaceRawTokenNamePaths(db, sessionId, tokenNamePaths, source = "automatic") {
+  withTransaction(db, () => {
+    updateRawTokenNamePaths(db, sessionId, tokenNamePaths, source);
+    updateSessionTimestamp(db, sessionId, (/* @__PURE__ */ new Date()).toISOString());
+  });
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/services/tokens/replace-raw-prop-token-paths.js
+function replaceRawPropTokenPaths(db, sessionId, componentId, propName, paths, source) {
+  withTransaction(db, () => {
+    updateRawPropTokenPaths(db, sessionId, componentId, propName, paths, source);
+    updateSessionTimestamp(db, sessionId, (/* @__PURE__ */ new Date()).toISOString());
+  });
+}
+
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/repositories/db.js
 var SCHEMA = `
 PRAGMA journal_mode = WAL;
@@ -3521,6 +3650,109 @@ function loadComponentRationale(db, sessionId, componentName) {
     }))
   };
 }
+function applyToolCalls(db, sessionId, componentId, componentName, calls, incomingWarnings, options = {}) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const warnings = [...incomingWarnings];
+  let classified = 0;
+  let excluded = 0;
+  let slots = 0;
+  const updateProp = db.prepare(`UPDATE raw_props SET cdf_type = ?, cdf_category = ?, cdf_token_kind = ?, required = ?, description = ?, rationale = ?
+     WHERE session_id = ? AND component_id = ? AND name = ?`);
+  const clearProp = db.prepare(`UPDATE raw_props
+     SET cdf_type = CASE WHEN type = 'boolean' THEN 'boolean' ELSE 'string' END,
+         cdf_category = 'unattached',
+         cdf_token_kind = NULL,
+         required = 0,
+         rationale = ?
+     WHERE session_id = ? AND component_id = ? AND name = ?`);
+  const deleteAllowedValues = db.prepare(`DELETE FROM raw_prop_allowed_values WHERE session_id = ? AND component_id = ? AND prop_name = ?`);
+  const deleteTokenPaths = db.prepare(`DELETE FROM raw_prop_token_paths WHERE session_id = ? AND component_id = ? AND prop_name = ?`);
+  const insertAllowedValue = db.prepare(`INSERT OR IGNORE INTO raw_prop_allowed_values (session_id, component_id, prop_name, value, position)
+     VALUES (?, ?, ?, ?, ?)`);
+  const deleteAllowedComponents = db.prepare(`DELETE FROM raw_slot_allowed_components WHERE session_id = ? AND component_id = ? AND slot_name = ?`);
+  const insertAllowedComponent = db.prepare(`INSERT OR IGNORE INTO raw_slot_allowed_components (session_id, component_id, slot_name, allowed_component, position)
+     VALUES (?, ?, ?, ?, ?)`);
+  const updateSlot = db.prepare(`UPDATE raw_slots SET required = ?, description = ? WHERE session_id = ? AND component_id = ? AND name = ?`);
+  db.exec("BEGIN");
+  try {
+    for (const call of calls) {
+      if (call.tool === "classify_component") {
+        if (call.description !== void 0) {
+          db.prepare("UPDATE raw_components SET description = ? WHERE session_id = ? AND component_id = ?").run(call.description, sessionId, componentId);
+        }
+        if (call.rationale) {
+          if (call.rationale.description !== void 0) {
+            db.prepare("UPDATE raw_components SET component_description_rationale = ? WHERE session_id = ? AND component_id = ?").run(call.rationale.description, sessionId, componentId);
+          }
+          if (call.rationale.props !== void 0) {
+            db.prepare("UPDATE raw_components SET props_rationale = ? WHERE session_id = ? AND component_id = ?").run(call.rationale.props, sessionId, componentId);
+          }
+          if (call.rationale.slots !== void 0) {
+            db.prepare("UPDATE raw_components SET slots_rationale = ? WHERE session_id = ? AND component_id = ?").run(call.rationale.slots, sessionId, componentId);
+          }
+        }
+      } else if (call.tool === "classify_prop") {
+        const changes = updateProp.run(call.cdf_type, call.cdf_category, call.token_kind ?? null, call.required !== void 0 ? call.required ? 1 : 0 : 0, call.description ?? null, call.reason ?? null, sessionId, componentId, call.prop);
+        if (changes.changes === 0) {
+          warnings.push(`${componentName}: classify_prop '${call.prop}' \u2014 prop not found, skipped`);
+          continue;
+        }
+        if (call.cdf_type === "token") {
+          deleteAllowedValues.run(sessionId, componentId, call.prop);
+          if (call.values && call.values.length > 0) {
+            const count = call.values.length;
+            warnings.push(`${componentName}: classify_prop '${call.prop}' \u2014 dropped ${count} value${count === 1 ? "" : "s"} on a token property; its options list is $token.allowed, not $values`);
+          }
+        } else {
+          deleteTokenPaths.run(sessionId, componentId, call.prop);
+          if (call.values && call.values.length > 0) {
+            deleteAllowedValues.run(sessionId, componentId, call.prop);
+            call.values.forEach((v, i) => insertAllowedValue.run(sessionId, componentId, call.prop, v, i));
+          }
+        }
+        if (call.default !== void 0) {
+          const storedDefault = typeof call.default === "boolean" ? String(call.default) : call.default;
+          db.prepare(`UPDATE raw_props SET default_value = ? WHERE session_id = ? AND component_id = ? AND name = ?`).run(storedDefault, sessionId, componentId, call.prop);
+        }
+        classified++;
+      } else if (call.tool === "exclude_prop") {
+        clearProp.run(call.reason || null, sessionId, componentId, call.prop);
+        excluded++;
+      } else if (call.tool === "classify_slot") {
+        const slotRequired = call.required !== void 0 ? call.required ? 1 : 0 : 1;
+        const slotChanges = updateSlot.run(slotRequired, call.description ?? null, sessionId, componentId, call.slot);
+        if (slotChanges.changes === 0) {
+          warnings.push(`${componentName}: classify_slot '${call.slot}' \u2014 slot not found, skipped`);
+          continue;
+        }
+        if (call.rationale !== void 0) {
+          db.prepare("UPDATE raw_slots SET rationale = ? WHERE session_id = ? AND component_id = ? AND name = ?").run(call.rationale, sessionId, componentId, call.slot);
+        }
+        if (call.allowed_components !== void 0) {
+          deleteAllowedComponents.run(sessionId, componentId, call.slot);
+          const allowedComponents = options.allowedComponentNames ? call.allowed_components.filter((allowedComponent) => options.allowedComponentNames.has(allowedComponent)) : call.allowed_components;
+          if (options.allowedComponentNames) {
+            const dropped = [
+              ...new Set(call.allowed_components.filter((ac) => !options.allowedComponentNames.has(ac)))
+            ];
+            for (const allowedComponent of dropped) {
+              warnings.push(`${componentName}: classify_slot '${call.slot}' \u2014 dropped unknown allowed component '${allowedComponent}'`);
+            }
+          }
+          allowedComponents.forEach((ac, i) => insertAllowedComponent.run(sessionId, componentId, call.slot, ac, i));
+        }
+        slots++;
+      }
+    }
+    db.prepare(`UPDATE raw_components SET status = 'generated', extracted_at = ? WHERE session_id = ? AND component_id = ?`).run(now, sessionId, componentId);
+    db.prepare("UPDATE sessions SET updated_at = ? WHERE id = ?").run(now, sessionId);
+    db.exec("COMMIT");
+  } catch (e) {
+    db.exec("ROLLBACK");
+    throw e;
+  }
+  return { classified, excluded, slots, warnings };
+}
 function getOrCreateSession(db, sessionFlag, sessionName, hints) {
   return getOrCreateSessionForCommand(db, sessionFlag, sessionName, hints);
 }
@@ -3730,6 +3962,192 @@ function loadRawComponents(db, sessionId, allowedNames) {
     })
   }));
 }
+var MAX_COMPONENT_SOURCE_CHARS = 8e3;
+var MAX_SIBLING_FILES = 5;
+var MAX_SIBLING_SNIPPET_CHARS = 1200;
+var MAX_TYPE_DECLARING_SIBLING_CHARS = 4e3;
+var MAX_ENLARGED_SIBLINGS = 2;
+var MAX_SIBLING_DEPTH = 2;
+var MAX_SIBLING_CANDIDATES_EXPLORED = 25;
+var RELATIVE_IMPORT_PATTERN = /from\s+['"](\.[^'"]+)['"]/g;
+var SIBLING_FILE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"];
+var TS_ESM_EXTENSION_REWRITES = [
+  [".js", [".ts", ".tsx", ".js", ".jsx"]],
+  [".jsx", [".tsx", ".jsx"]],
+  [".mjs", [".mts", ".mjs"]],
+  [".cjs", [".cts", ".cjs"]]
+];
+function rewrittenSourcePaths(basePath) {
+  for (const [emitted, sources] of TS_ESM_EXTENSION_REWRITES) {
+    if (!basePath.endsWith(emitted))
+      continue;
+    const stem = basePath.slice(0, -emitted.length);
+    return sources.map((ext) => `${stem}${ext}`);
+  }
+  return [];
+}
+var IDENTIFIER_PATTERN = /[A-Za-z_$][A-Za-z0-9_$]*/g;
+function identifiersIn(propTypes) {
+  const names = /* @__PURE__ */ new Set();
+  for (const propType of propTypes) {
+    for (const match2 of propType.matchAll(IDENTIFIER_PATTERN))
+      names.add(match2[0]);
+  }
+  return [...names];
+}
+function declaresAnyType(text, typeNames) {
+  return typeNames.some((name) => new RegExp(`\\b(?:type|interface|enum|const|class)\\s+${escapeForRegExp(name)}\\b`).test(text));
+}
+function extractRelativeImportPaths(sourceText) {
+  const specifiers = /* @__PURE__ */ new Set();
+  for (const match2 of sourceText.matchAll(RELATIVE_IMPORT_PATTERN)) {
+    if (match2[1])
+      specifiers.add(match2[1]);
+  }
+  return [...specifiers];
+}
+async function resolveRelativeImport(specifier, fromDir) {
+  const basePath = resolve6(fromDir, specifier);
+  const candidates = [
+    basePath,
+    ...rewrittenSourcePaths(basePath),
+    ...SIBLING_FILE_EXTENSIONS.map((ext) => `${basePath}${ext}`),
+    ...SIBLING_FILE_EXTENSIONS.map((ext) => resolve6(basePath, `index${ext}`))
+  ];
+  for (const candidate of candidates) {
+    try {
+      await readFile4(candidate, "utf8");
+      return candidate;
+    } catch {
+    }
+  }
+  return void 0;
+}
+async function resolveImportSpecifiers(sourceText, fromDir) {
+  const resolvedPaths = [];
+  for (const specifier of extractRelativeImportPaths(sourceText)) {
+    const resolvedPath = await resolveRelativeImport(specifier, fromDir);
+    if (resolvedPath)
+      resolvedPaths.push(resolvedPath);
+  }
+  return resolvedPaths;
+}
+async function loadSiblingFiles(sourceText, sourcePath, propNames, candidateTypeNames = []) {
+  const visited = /* @__PURE__ */ new Set([resolve6(sourcePath)]);
+  const discovered = [];
+  let frontier = [{ text: sourceText, dir: dirname4(sourcePath) }];
+  for (let hop = 0; hop < MAX_SIBLING_DEPTH && discovered.length < MAX_SIBLING_CANDIDATES_EXPLORED; hop++) {
+    const nextFrontier = [];
+    for (const node of frontier) {
+      if (discovered.length >= MAX_SIBLING_CANDIDATES_EXPLORED)
+        break;
+      const resolvedPaths = await resolveImportSpecifiers(node.text, node.dir);
+      for (const resolvedPath of resolvedPaths) {
+        if (visited.has(resolvedPath))
+          continue;
+        visited.add(resolvedPath);
+        if (discovered.length >= MAX_SIBLING_CANDIDATES_EXPLORED)
+          break;
+        let content;
+        try {
+          content = await readFile4(resolvedPath, "utf8");
+        } catch {
+          continue;
+        }
+        discovered.push({ path: resolvedPath, content });
+        nextFrontier.push({ text: content, dir: dirname4(resolvedPath) });
+      }
+    }
+    frontier = nextFrontier;
+  }
+  const inHand = [sourceText, ...discovered.map((d) => d.content)];
+  const declaredTypeNames = candidateTypeNames.filter((name) => inHand.some((text) => declaresAnyType(text, [name])));
+  const usesNotShown = /* @__PURE__ */ new Set();
+  const searchNames = [.../* @__PURE__ */ new Set([...propNames, ...declaredTypeNames])];
+  let enlarged = 0;
+  const siblings = discovered.slice(0, MAX_SIBLING_FILES).map((d) => {
+    const enlarge = enlarged < MAX_ENLARGED_SIBLINGS && declaresAnyType(d.content, declaredTypeNames);
+    if (enlarge)
+      enlarged++;
+    const budget = enlarge ? MAX_TYPE_DECLARING_SIBLING_CHARS : MAX_SIBLING_SNIPPET_CHARS;
+    const excerpt = excerptAroundNames(d.content, searchNames, budget);
+    for (const name of excerpt.usesNotShown)
+      usesNotShown.add(name);
+    return { path: d.path, content: excerpt.content };
+  });
+  const truncatedCount = Math.max(0, discovered.length - MAX_SIBLING_FILES);
+  return {
+    siblings,
+    truncatedCount,
+    usesNotShown: propNames.filter((name) => usesNotShown.has(name)),
+    declaredTypeNames
+  };
+}
+async function loadComponentSourceRef(name, sourcePath, propNames = [], propTypes = []) {
+  let content = null;
+  let siblingFiles = [];
+  let truncatedSiblingCount = 0;
+  const usesNotShown = /* @__PURE__ */ new Set();
+  try {
+    const rawText = await readFile4(sourcePath, "utf8");
+    let siblingUsesNotShown;
+    let declaredTypeNames;
+    ({
+      siblings: siblingFiles,
+      truncatedCount: truncatedSiblingCount,
+      usesNotShown: siblingUsesNotShown,
+      declaredTypeNames
+    } = await loadSiblingFiles(rawText, sourcePath, propNames, identifiersIn(propTypes)));
+    const mainExcerpt = excerptAroundNames(rawText, [.../* @__PURE__ */ new Set([...propNames, ...declaredTypeNames])], MAX_COMPONENT_SOURCE_CHARS);
+    content = mainExcerpt.content;
+    for (const name2 of mainExcerpt.usesNotShown)
+      usesNotShown.add(name2);
+    for (const name2 of siblingUsesNotShown)
+      usesNotShown.add(name2);
+  } catch {
+  }
+  const ref = { component: name, sourcePath, content };
+  if (siblingFiles.length > 0)
+    ref.siblingFiles = siblingFiles;
+  if (truncatedSiblingCount > 0)
+    ref.truncatedSiblingCount = truncatedSiblingCount;
+  const notShown = propNames.filter((name2) => usesNotShown.has(name2));
+  if (notShown.length > 0)
+    ref.usesNotShown = notShown;
+  return ref;
+}
+async function loadComponentSourceRefs(db, sessionId) {
+  const rows = db.prepare(`SELECT component_id, name, source, source_path FROM raw_components WHERE session_id = ? AND status = 'generated' ORDER BY rowid`).all(sessionId);
+  const propsFor = db.prepare(`SELECT name, type FROM raw_props WHERE session_id = ? AND component_id = ? ORDER BY position`);
+  return Promise.all(rows.map((r) => {
+    const props = propsFor.all(sessionId, r.component_id);
+    return loadComponentSourceRef(r.name, r.source_path ?? r.source, props.map((p) => p.name), props.map((p) => p.type));
+  }));
+}
+function renameEmptySlots(db, sessionId, componentId, componentName, slotCount) {
+  const emptySlots = db.prepare(`SELECT name, position FROM raw_slots
+       WHERE session_id = ? AND component_id = ? AND trim(name) = ''
+       ORDER BY position`).all(sessionId, componentId);
+  if (emptySlots.length === 0)
+    return { renames: [], warnings: [] };
+  const renames = [];
+  const warnings = [];
+  const rename3 = db.prepare(`UPDATE raw_slots SET name = ? WHERE session_id = ? AND component_id = ? AND name = ? AND position = ?`);
+  db.exec("BEGIN");
+  try {
+    for (const slot of emptySlots) {
+      const newName = slotCount === 1 ? "children" : `slot_${slot.position}`;
+      rename3.run(newName, sessionId, componentId, slot.name, slot.position);
+      renames.push({ oldName: slot.name, newName });
+      warnings.push(`${componentName}: slot at position ${slot.position} had empty name \u2014 renamed to "${newName}" for classification`);
+    }
+    db.exec("COMMIT");
+  } catch (e) {
+    db.exec("ROLLBACK");
+    throw e;
+  }
+  return { renames, warnings };
+}
 function parseReviewReasons(raw) {
   try {
     const parsed = JSON.parse(raw ?? "[]");
@@ -3947,29 +4365,10 @@ function applyScopeDecisions(db, sessionId, decisions) {
     const placeholders = accepted.map(() => "?").join(",");
     db.prepare(`UPDATE raw_components SET status = 'generated' WHERE session_id = ? AND name IN (${placeholders})`).run(sessionId, ...accepted);
   }
-  removeSlotAllowedComponents(db, sessionId, decisions.excludedSlotEdges ?? [], rejected);
   db.prepare("UPDATE sessions SET updated_at = ? WHERE id = ?").run(now, sessionId);
 }
-function removeSlotAllowedComponents(db, sessionId, edges, rejectedNames) {
-  if (edges.length === 0 && rejectedNames.length === 0)
-    return;
-  const componentId = db.prepare("SELECT component_id FROM raw_components WHERE session_id = ? AND name = ?");
-  const removeEdge = db.prepare("DELETE FROM raw_slot_allowed_components WHERE session_id = ? AND component_id = ? AND allowed_component = ?");
-  const removeEverywhere = db.prepare("DELETE FROM raw_slot_allowed_components WHERE session_id = ? AND allowed_component = ?");
-  db.exec("BEGIN");
-  try {
-    for (const edge of edges) {
-      const row = componentId.get(sessionId, edge.parent);
-      if (row)
-        removeEdge.run(sessionId, row.component_id, edge.child);
-    }
-    for (const name of rejectedNames)
-      removeEverywhere.run(sessionId, name);
-    db.exec("COMMIT");
-  } catch (e) {
-    db.exec("ROLLBACK");
-    throw e;
-  }
+function findLatestSessionForCommand(db, command) {
+  return getLatestCompletedSessionForCommand(db, command);
 }
 function seedCDFFromPreviewResponse(db, sessionId, removedItems) {
   if (removedItems.length === 0)
@@ -4038,6 +4437,35 @@ function backfillUnclassifiedProps(db, sessionId) {
        )`).run(sessionId, sessionId);
   return Number(withCategory.changes) + Number(withoutCategory.changes);
 }
+function computeMapTokensInputHash(db, sessionId, componentSourceRefs = []) {
+  const props = db.prepare(`SELECT rc.name AS component_name, rp.name AS prop_name, rp.cdf_token_kind, rp.default_value
+       FROM raw_props rp
+       JOIN raw_components rc ON rc.session_id = rp.session_id AND rc.component_id = rp.component_id
+       WHERE rp.session_id = ? AND rp.cdf_type = 'token' AND rp.cdf_category = 'design'
+       ORDER BY rc.name, rp.name`).all(sessionId);
+  const tokens = db.prepare(`SELECT path, type FROM raw_tokens WHERE session_id = ? ORDER BY path`).all(sessionId);
+  const defaultMappings = db.prepare("SELECT raw_name, path, source FROM raw_token_name_paths WHERE session_id = ? ORDER BY raw_name").all(sessionId);
+  const payload = {
+    props: props.map((p) => ({
+      component: p.component_name,
+      prop: p.prop_name,
+      tokenKind: p.cdf_token_kind,
+      rawDefault: p.default_value
+    })),
+    tokens,
+    defaultMappings,
+    // The agent's evidence, not just its inputs: a comment or allowlist edit
+    // in a source file (or a sibling it reads) changes the correct answer
+    // without touching props or tokens, so it must invalidate the cache too.
+    sourceRefs: [...componentSourceRefs].sort((a, b) => a.component.localeCompare(b.component)).map((ref) => ({
+      component: ref.component,
+      content: ref.content,
+      siblingFiles: (ref.siblingFiles ?? []).map((s) => ({ path: s.path, content: s.content })).sort((a, b) => a.path.localeCompare(b.path)),
+      usesNotShown: [...ref.usesNotShown ?? []].sort()
+    }))
+  };
+  return createHash5("sha256").update(JSON.stringify(payload)).digest("hex");
+}
 function lookupCache(db, inputHash, entityType, entityId, promptHash = "") {
   const row = db.prepare(`SELECT input_hash, entity_type, entity_id, source_session_id, human_edited, created_at, updated_at, prompt_hash
        FROM generation_cache
@@ -4055,6 +4483,24 @@ function lookupCache(db, inputHash, entityType, entityId, promptHash = "") {
     updatedAt: row.updated_at
   };
 }
+function lookupCacheByEntity(db, entityType, entityId) {
+  const row = db.prepare(`SELECT input_hash, entity_type, entity_id, source_session_id, human_edited, created_at, updated_at, prompt_hash
+       FROM generation_cache
+       WHERE entity_type = ? AND entity_id = ?
+       ORDER BY updated_at DESC LIMIT 1`).get(entityType, entityId);
+  if (!row)
+    return null;
+  return {
+    inputHash: row.input_hash,
+    entityType: row.entity_type,
+    entityId: row.entity_id,
+    sourceSessionId: row.source_session_id,
+    humanEdited: row.human_edited === 1,
+    promptHash: row.prompt_hash,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
 function storeCache(db, inputHash, entityType, entityId, sourceSessionId, humanEdited, promptHash = "") {
   storeCaches(db, [{ inputHash, entityType, entityId, sourceSessionId, humanEdited, promptHash }]);
 }
@@ -4117,6 +4563,95 @@ function loadSlotCycles(db, sessionId) {
     suggestedBreak: r.suggested_break_json ? JSON.parse(r.suggested_break_json) : null
   }));
 }
+function findUnknownSlotAllowedComponents(db, sessionId, allowedComponentNames2, componentId) {
+  const rows = db.prepare(`SELECT a.component_id, c.name AS component_name, a.slot_name, a.allowed_component
+       FROM raw_slot_allowed_components a
+       JOIN raw_components c ON c.session_id = a.session_id AND c.component_id = a.component_id
+       WHERE a.session_id = ? AND (? IS NULL OR a.component_id = ?)
+       ORDER BY a.component_id, a.slot_name, a.position`).all(sessionId, componentId ?? null, componentId ?? null);
+  return rows.filter((row) => !allowedComponentNames2.has(row.allowed_component)).map((row) => ({
+    componentId: row.component_id,
+    componentName: row.component_name,
+    slotName: row.slot_name,
+    allowedComponent: row.allowed_component
+  }));
+}
+function filterUnknownSlotAllowedComponents(db, sessionId, allowedComponentNames2) {
+  const unknown5 = findUnknownSlotAllowedComponents(db, sessionId, allowedComponentNames2);
+  if (unknown5.length === 0)
+    return unknown5;
+  db.exec("BEGIN");
+  try {
+    const remove = db.prepare(`DELETE FROM raw_slot_allowed_components
+       WHERE session_id = ? AND component_id = ? AND slot_name = ? AND allowed_component = ?`);
+    for (const row of unknown5) {
+      remove.run(sessionId, row.componentId, row.slotName, row.allowedComponent);
+    }
+    db.exec("COMMIT");
+  } catch (e) {
+    db.exec("ROLLBACK");
+    throw e;
+  }
+  return unknown5;
+}
+function copyComponentFromCache(db, sourceSessionId, targetSessionId, componentId, manageTransaction = true, options = {}) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (manageTransaction)
+    db.exec("BEGIN");
+  try {
+    const srcComp = db.prepare(`SELECT description, status, component_description_rationale, props_rationale, slots_rationale
+         FROM raw_components WHERE session_id = ? AND component_id = ?`).get(sourceSessionId, componentId);
+    if (srcComp) {
+      db.prepare(`UPDATE raw_components
+         SET description = ?, status = ?, component_description_rationale = ?, props_rationale = ?, slots_rationale = ?, extracted_at = ?
+         WHERE session_id = ? AND component_id = ?`).run(srcComp.description, srcComp.status, srcComp.component_description_rationale, srcComp.props_rationale, srcComp.slots_rationale, now, targetSessionId, componentId);
+    }
+    const srcProps = db.prepare(`SELECT name, cdf_type, cdf_category, cdf_token_kind, required, description, default_value, rationale
+         FROM raw_props WHERE session_id = ? AND component_id = ?`).all(sourceSessionId, componentId);
+    for (const p of srcProps) {
+      db.prepare(`UPDATE raw_props SET cdf_type = ?, cdf_category = ?, cdf_token_kind = ?, required = ?, description = ?, default_value = ?, rationale = ?
+         WHERE session_id = ? AND component_id = ? AND name = ?`).run(p.cdf_type, p.cdf_category, p.cdf_token_kind, p.required, p.description, p.default_value, p.rationale, targetSessionId, componentId, p.name);
+    }
+    db.prepare(`DELETE FROM raw_prop_allowed_values WHERE session_id = ? AND component_id = ?`).run(targetSessionId, componentId);
+    const srcAV = db.prepare(`SELECT prop_name, position, value FROM raw_prop_allowed_values WHERE session_id = ? AND component_id = ?`).all(sourceSessionId, componentId);
+    const insertAV = db.prepare(`INSERT INTO raw_prop_allowed_values (session_id, component_id, prop_name, position, value) VALUES (?, ?, ?, ?, ?)`);
+    for (const av of srcAV) {
+      insertAV.run(targetSessionId, componentId, av.prop_name, av.position, av.value);
+    }
+    const srcSlots = db.prepare(`SELECT name, required, description, rationale FROM raw_slots WHERE session_id = ? AND component_id = ?`).all(sourceSessionId, componentId);
+    for (const s of srcSlots) {
+      db.prepare(`UPDATE raw_slots SET required = ?, description = ?, rationale = ? WHERE session_id = ? AND component_id = ? AND name = ?`).run(s.required, s.description, s.rationale, targetSessionId, componentId, s.name);
+    }
+    db.prepare(`DELETE FROM raw_slot_allowed_components WHERE session_id = ? AND component_id = ?`).run(targetSessionId, componentId);
+    const srcSAC = db.prepare(`SELECT slot_name, position, allowed_component FROM raw_slot_allowed_components WHERE session_id = ? AND component_id = ?`).all(sourceSessionId, componentId);
+    const insertSAC = db.prepare(`INSERT INTO raw_slot_allowed_components (session_id, component_id, slot_name, allowed_component, position) VALUES (?, ?, ?, ?, ?)`);
+    const allowedSAC = options.allowedComponentNames ? srcSAC.filter((sac) => options.allowedComponentNames.has(sac.allowed_component)) : srcSAC;
+    for (const sac of allowedSAC) {
+      insertSAC.run(targetSessionId, componentId, sac.slot_name, sac.allowed_component, sac.position);
+    }
+    db.prepare("UPDATE sessions SET updated_at = ? WHERE id = ?").run(now, targetSessionId);
+    if (manageTransaction)
+      db.exec("COMMIT");
+  } catch (e) {
+    if (manageTransaction)
+      db.exec("ROLLBACK");
+    throw e;
+  }
+}
+function copyComponentsFromCache(db, entries, options = {}) {
+  if (entries.length === 0)
+    return;
+  db.exec("BEGIN");
+  try {
+    for (const entry of entries) {
+      copyComponentFromCache(db, entry.sourceSessionId, entry.targetSessionId, entry.componentId, false, options);
+    }
+    db.exec("COMMIT");
+  } catch (e) {
+    db.exec("ROLLBACK");
+    throw e;
+  }
+}
 function copyTokensFromCache(db, sourceSessionId, targetSessionId) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   db.exec("BEGIN");
@@ -4134,18 +4669,58 @@ function copyTokensFromCache(db, sourceSessionId, targetSessionId) {
     throw e;
   }
 }
+function copyMapTokensFromCache(db, sourceSessionId, targetSessionId) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let copiedCount = 0;
+  db.exec("BEGIN");
+  try {
+    const sourceRows = db.prepare(`SELECT rc.name AS component_name, rptp.prop_name, rptp.source, rptp.position, rptp.path
+         FROM raw_prop_token_paths rptp
+         JOIN raw_components rc ON rc.session_id = rptp.session_id AND rc.component_id = rptp.component_id
+         WHERE rptp.session_id = ?
+         ORDER BY rc.name, rptp.prop_name, rptp.position`).all(sourceSessionId);
+    const targetComponents = db.prepare(`SELECT component_id, name FROM raw_components WHERE session_id = ?`).all(targetSessionId);
+    const targetIdByName = new Map(targetComponents.map((c2) => [c2.name, c2.component_id]));
+    const targetProps = new Set(db.prepare(`SELECT component_id, name FROM raw_props WHERE session_id = ?`).all(targetSessionId).map((p) => `${p.component_id}::${p.name}`));
+    const insertPath = db.prepare(`INSERT INTO raw_prop_token_paths (session_id, component_id, prop_name, source, position, path)
+       VALUES (?, ?, ?, ?, ?, ?)`);
+    const clearedProps = /* @__PURE__ */ new Set();
+    const copiedProps = /* @__PURE__ */ new Set();
+    for (const row of sourceRows) {
+      const targetComponentId = targetIdByName.get(row.component_name);
+      if (!targetComponentId)
+        continue;
+      if (!targetProps.has(`${targetComponentId}::${row.prop_name}`))
+        continue;
+      const propKey = `${targetComponentId}::${row.prop_name}`;
+      if (!clearedProps.has(propKey)) {
+        clearedProps.add(propKey);
+        db.prepare(`DELETE FROM raw_prop_token_paths WHERE session_id = ? AND component_id = ? AND prop_name = ?`).run(targetSessionId, targetComponentId, row.prop_name);
+      }
+      insertPath.run(targetSessionId, targetComponentId, row.prop_name, row.source, row.position, row.path);
+      copiedProps.add(propKey);
+    }
+    copiedCount = copiedProps.size;
+    db.prepare("UPDATE sessions SET updated_at = ? WHERE id = ?").run(now, targetSessionId);
+    db.exec("COMMIT");
+  } catch (e) {
+    db.exec("ROLLBACK");
+    throw e;
+  }
+  return copiedCount;
+}
 var _cliCacheVersionCache = null;
 async function getCliCacheVersion() {
   if (_cliCacheVersionCache)
     return _cliCacheVersionCache;
   try {
     const { hashContent: hashContent3 } = await Promise.resolve().then(() => (init_cache_keys(), cache_keys_exports));
-    const { resolveSkillPath: resolveSkillPath3 } = await Promise.resolve().then(() => (init_agents(), agents_exports));
+    const { resolveSkillPath: resolveSkillPath2 } = await Promise.resolve().then(() => (init_agents(), agents_exports));
     const skills = ["components", "tokens", "select"];
     const parts = [];
     for (const s of skills) {
       try {
-        const p = resolveSkillPath3(s);
+        const p = resolveSkillPath2(s);
         parts.push(readFileSync3(p, "utf8"));
       } catch {
         parts.push(`<missing:${s}>`);
@@ -4625,7 +5200,7 @@ function findNearestPackageRootDir(filePath) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/shared/file-extraction-workers.js
-import { readFile as readFile4 } from "node:fs/promises";
+import { readFile as readFile5 } from "node:fs/promises";
 async function runFileExtractionWorkers(filePaths, concurrency, extractFile, formatError, onProgress, onResult) {
   const warnings = [];
   const items = [];
@@ -4637,7 +5212,7 @@ async function runFileExtractionWorkers(filePaths, concurrency, extractFile, for
       if (!filePath)
         break;
       try {
-        const source = await readFile4(filePath, "utf-8");
+        const source = await readFile5(filePath, "utf-8");
         const outcome = await extractFile(filePath, source);
         warnings.push(...outcome.warnings ?? []);
         if (outcome.item)
@@ -7613,7 +8188,7 @@ function extractVueSlotsFromSetup(options) {
 // packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/vue/extract-vue-components.js
 import os from "node:os";
 import { basename, dirname as dirname7, resolve as resolve9, join as join7 } from "node:path";
-import { readFile as readFile5 } from "node:fs/promises";
+import { readFile as readFile6 } from "node:fs/promises";
 import { existsSync as existsSync5, readFileSync as readFileSync5, readdirSync, statSync as statSync3 } from "node:fs";
 import { parse as parseSFC } from "@vue/compiler-sfc";
 import { Project as Project3, Node as Node6 } from "ts-morph";
@@ -7855,7 +8430,7 @@ async function extractNamedObjectExportProps(importedRef, visitedImports) {
   if (visitedImports.has(visitKey))
     return [];
   visitedImports.add(visitKey);
-  const source = await readFile5(importedRef.filePath, "utf-8");
+  const source = await readFile6(importedRef.filePath, "utf-8");
   const project = new Project3({
     compilerOptions: {
       strict: false,
@@ -8086,7 +8661,7 @@ async function extractOptionsProps(filePath, scriptContent, visited = /* @__PURE
   return [];
 }
 async function extractInheritedVueProps(filePath, visited) {
-  const source = await readFile5(filePath, "utf-8");
+  const source = await readFile6(filePath, "utf-8");
   const { descriptor } = parseSFC(source);
   if (!descriptor.script) {
     return [];
@@ -11252,9 +11827,9 @@ function capCandidatesToPromptBudget(files, budget = PROMPT_CANDIDATE_TOKEN_BUDG
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/composition/src/helpers/candidates/composition-cache-key.js
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 function hashContent2(content) {
-  return createHash5("sha256").update(content).digest("hex");
+  return createHash6("sha256").update(content).digest("hex");
 }
 function buildCompositionInputHash(input) {
   const fileDigest = input.files.map((f) => `${f.path} ${hashContent2(f.content)}`).sort().join("");
@@ -11656,9 +12231,9 @@ function validateExtractedComponents(components) {
 import { resolve as resolve14 } from "node:path";
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/review-session/helpers/create-component-id.js
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 function createComponentId(name, resolvedSourcePath) {
-  const sourceHash = createHash6("sha256").update(`${name}:${resolvedSourcePath}`).digest("hex").slice(0, 12);
+  const sourceHash = createHash7("sha256").update(`${name}:${resolvedSourcePath}`).digest("hex").slice(0, 12);
   return `${name}-${sourceHash}`;
 }
 
@@ -11724,10 +12299,10 @@ async function loadAndValidateForReview(sessionId, projectRoot) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/selection/src/controller/review/merge-preview-validation-errors-into-review-session.js
-import { access as access3, readFile as readFile7 } from "node:fs/promises";
+import { access as access3, readFile as readFile8 } from "node:fs/promises";
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/review-session/repositories/ensure-review-session.js
-import { access as access2, mkdir, readFile as readFile6, writeFile } from "node:fs/promises";
+import { access as access2, mkdir, readFile as readFile7, writeFile } from "node:fs/promises";
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/review-session/repositories/review-session-paths.js
 import { resolve as resolve15 } from "node:path";
@@ -11746,7 +12321,7 @@ async function ensureRefineSession(sessionId, artifactsRoot, initialSnapshot) {
   await mkdir(paths.sessionDir, { recursive: true });
   try {
     await access2(paths.statePath);
-    const savedState = await readFile6(paths.statePath, "utf8");
+    const savedState = await readFile7(paths.statePath, "utf8");
     return JSON.parse(savedState);
   } catch {
     await writeFile(paths.statePath, JSON.stringify(initialSnapshot, null, 2), "utf8");
@@ -11777,7 +12352,7 @@ async function mergePreviewValidationErrorsIntoReviewSession(sessionId, errors,
   let snapshot;
   try {
     await access3(paths.statePath);
-    snapshot = JSON.parse(await readFile7(paths.statePath, "utf8"));
+    snapshot = JSON.parse(await readFile8(paths.statePath, "utf8"));
   } catch {
     snapshot = await loadAndValidateForReview(sessionId, void 0);
     snapshot = await ensureRefineSession(sessionId, artifactsRoot, snapshot);
@@ -11815,7 +12390,7 @@ async function mergePreviewValidationErrorsIntoReviewSession(sessionId, errors,
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/selection/src/controller/review/reject-components-by-name.js
-import { readFile as readFile8 } from "node:fs/promises";
+import { readFile as readFile9 } from "node:fs/promises";
 async function rejectComponentsByName(sessionId, names, opts = {}) {
   if (names.length === 0)
     return;
@@ -11831,7 +12406,7 @@ async function rejectComponentsByName(sessionId, names, opts = {}) {
   const nameSet = new Set(names);
   let snapshot;
   try {
-    snapshot = JSON.parse(await readFile8(paths.statePath, "utf8"));
+    snapshot = JSON.parse(await readFile9(paths.statePath, "utf8"));
   } catch {
     return;
   }
@@ -12083,7 +12658,7 @@ function generateUlid(now = Date.now()) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/runs/repositories/read-runs-file.js
-import { readFile as readFile9 } from "node:fs/promises";
+import { readFile as readFile10 } from "node:fs/promises";
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/runs/helpers/migrate-record.js
 function migrateRecord(rec) {
@@ -12102,7 +12677,7 @@ var READABLE_VERSIONS = /* @__PURE__ */ new Set([1, 2, 3]);
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/runs/repositories/read-runs-file.js
 async function readRunsFileMaybe() {
   try {
-    const raw = await readFile9(runsFilePath(), "utf8");
+    const raw = await readFile10(runsFilePath(), "utf8");
     const parsed = JSON.parse(raw);
     if (!READABLE_VERSIONS.has(parsed.version)) {
       throw new Error(`runs.json version mismatch: file is v${parsed.version}, this CLI expects v${RUNS_FILE_VERSION} (also reads: ${[...READABLE_VERSIONS].join(", ")}). Back up and remove the file to start fresh.`);
@@ -12161,13 +12736,13 @@ async function updateRun(id, patch) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/runs/services/build-source-fingerprint.js
-import { readFile as readFile10, stat } from "node:fs/promises";
+import { readFile as readFile11, stat } from "node:fs/promises";
 import { resolve as resolve17 } from "node:path";
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/runs/helpers/sha256-hex.js
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 function sha256Hex(buf) {
-  return createHash7("sha256").update(buf).digest("hex");
+  return createHash8("sha256").update(buf).digest("hex");
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/runs/services/build-source-fingerprint.js
@@ -12204,7 +12779,7 @@ async function buildSourceFingerprint(opts) {
     const abs = resolve17(opts.rawTokensPath);
     rawTokensPath = abs;
     try {
-      const [st, buf] = await Promise.all([stat(abs), readFile10(abs)]);
+      const [st, buf] = await Promise.all([stat(abs), readFile11(abs)]);
       rawTokensMtime = st.mtime.toISOString();
       rawTokensContentHash = sha256Hex(buf);
     } catch {
@@ -12285,6 +12860,23 @@ async function writeScopeDecisionsSnapshot(db, sessionId, decisions) {
   await saveReviewState(paths.statePath, { components: records });
 }
 
+// packages/experience-design-system-backend-pipeline/dist/src/persistence/src/review-session/repositories/load-accepted-names.js
+import { readFile as readFile12 } from "node:fs/promises";
+async function loadAcceptedNames(sessionId) {
+  try {
+    const artifactsRoot = getRefineArtifactsRoot();
+    const paths = await getRefineSessionPaths(sessionId, artifactsRoot);
+    const raw = await readFile12(paths.statePath, "utf8");
+    const snapshot = JSON.parse(raw);
+    const accepted = snapshot.components.filter((c2) => c2.status === "accepted").map((c2) => c2.name);
+    if (accepted.length === 0)
+      return null;
+    return new Set(accepted);
+  } catch {
+    return null;
+  }
+}
+
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/index.js
 import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
 
@@ -12918,7 +13510,7 @@ function errorMessage(error) {
   return error instanceof Error && error.message ? error.message : String(error);
 }
 function defaultSleep(delayMs) {
-  return new Promise((resolve22) => setTimeout(resolve22, delayMs));
+  return new Promise((resolve25) => setTimeout(resolve25, delayMs));
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/apply/src/helpers/sanitize-preview.js
@@ -13159,7 +13751,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((resolve22) => setTimeout(resolve22, baseDelay + jitter));
+        await new Promise((resolve25) => setTimeout(resolve25, baseDelay + jitter));
       }
     }
     throw new Error(`Operation ${operationId} timed out after ${maxAttempts} attempts`);
@@ -13546,7 +14138,7 @@ 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 readFile11, stat as stat3 } from "node:fs/promises";
+import { readFile as readFile13, stat as stat3 } from "node:fs/promises";
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/apply/src/helpers/tokens/collect-json-files.js
 import { readdir, stat as stat2 } from "node:fs/promises";
@@ -13605,7 +14197,7 @@ async function readMergedFromDir(flag, dir) {
   const merged = {};
   for (const file of files.sort()) {
     try {
-      const text = await readFile11(file, "utf8");
+      const text = await readFile13(file, "utf8");
       const parsed = JSON.parse(text);
       if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
         Object.assign(merged, parsed);
@@ -13619,7 +14211,7 @@ async function readMergedFromDir(flag, dir) {
 async function readSingleFile(flag, p) {
   let text;
   try {
-    text = await readFile11(p, "utf8");
+    text = await readFile13(p, "utf8");
   } catch {
     throw new Error(`file not found: ${p} (from ${flag})`);
   }
@@ -13708,29 +14300,522 @@ async function fetchAndPersistExistingContentfulEntities(request) {
   }
 }
 
-// packages/experience-design-system-backend-pipeline/dist/src/steps/apply/src/controller/endpoint/resolve-shared-inputs.js
-init_validate();
-
-// packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/controller/map-tokens/run-map-tokens.js
-init_build_prompt();
-init_create_local_cli_agent_invoker();
-init_describe_agent_failure();
-init_resolve_binary();
-init_resolve_skill_path();
-init_parse_map_token_prop_tool_calls();
-init_cache_keys();
-
-// packages/experience-design-system-backend-pipeline/dist/src/agents/helpers/resolution/binary-exists.js
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-var execFileAsync = promisify(execFile);
+// packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/controller/existing-entities/read-from-session.js
+import { readFile as readFile14 } from "node:fs/promises";
+async function readExistingContentfulEntitiesFromSession(request) {
+  if (!request.path)
+    return void 0;
+  try {
+    const raw = await readFile14(request.path, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed.components) || !Array.isArray(parsed.tokens))
+      return void 0;
+    return parsed;
+  } catch {
+    return void 0;
+  }
+}
 
-// packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/controller/map-tokens/run-map-tokens.js
-var DEFAULT_TIMEOUT_MS2 = 5 * 60 * 1e3;
+// packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/helpers/summarizers/summarize-tokens.js
+function summarizeTokens(tokens) {
+  const kinds = /* @__PURE__ */ new Set();
+  for (const t of tokens)
+    kinds.add(t.type);
+  return { count: tokens.length, kinds: [...kinds].sort() };
+}
 
-// packages/experience-design-system-backend-pipeline/dist/src/orchestrators/run-extract-and-compose-session/run-extract-and-compose-session.js
-import { mkdir as mkdir4 } from "node:fs/promises";
-import { relative as relative2 } from "node:path";
+// packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/helpers/existing-entities/count-character-edits.js
+function countCharacterEdits(a, b) {
+  if (a === b)
+    return 0;
+  if (a.length === 0)
+    return b.length;
+  if (b.length === 0)
+    return a.length;
+  if (a.length > b.length)
+    [a, b] = [b, a];
+  let prev = new Array(a.length + 1);
+  let curr = new Array(a.length + 1);
+  for (let i = 0; i <= a.length; i++)
+    prev[i] = i;
+  for (let j = 1; j <= b.length; j++) {
+    curr[0] = j;
+    for (let i = 1; i <= a.length; i++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[i] = Math.min(curr[i - 1] + 1, prev[i] + 1, prev[i - 1] + cost);
+    }
+    [prev, curr] = [curr, prev];
+  }
+  return prev[a.length];
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/helpers/existing-entities/simplify-name-for-comparison.js
+function simplifyNameForComparison(name) {
+  const stripped = name.toLowerCase().replace(/[^a-z0-9]/g, "");
+  return stripped.endsWith("s") && stripped.length > 1 ? stripped.slice(0, -1) : stripped;
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/helpers/existing-entities/find-nearly-matching-component.js
+var MAX_CHARACTER_EDITS_FOR_LIKELY_MATCH = 2;
+function findNearlyMatchingComponent(components, codebaseName) {
+  const target = simplifyNameForComparison(codebaseName);
+  if (!target)
+    return void 0;
+  let best;
+  for (const c2 of components) {
+    const edits = countCharacterEdits(target, simplifyNameForComparison(c2.name));
+    if (edits > MAX_CHARACTER_EDITS_FOR_LIKELY_MATCH)
+      continue;
+    if (!best || edits < best.edits)
+      best = { component: c2, edits };
+    if (edits === 0)
+      break;
+  }
+  return best?.component;
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/controller/existing-entities/summarize-for-generate.js
+function summarizeForGenerateAgent(entities, codebaseComponentName) {
+  const match2 = findNearlyMatchingComponent(entities.components, codebaseComponentName);
+  const otherComponents = entities.components.filter((c2) => c2.sys.id !== match2?.sys.id).map((c2) => ({ id: c2.sys.id, name: c2.name }));
+  return {
+    likelyMatch: match2 ? {
+      id: match2.sys.id,
+      name: match2.name,
+      designProperties: match2.designProperties.map((p) => ({
+        id: p.id,
+        name: p.name,
+        type: p.type
+      })),
+      contentProperties: match2.contentProperties.map((p) => ({
+        id: p.id,
+        name: p.name,
+        type: p.type
+      })),
+      slots: (match2.slots ?? []).map((s) => ({ id: s.id, name: s.name }))
+    } : void 0,
+    otherComponents,
+    tokens: summarizeTokens(entities.tokens)
+  };
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/controller/existing-entities/summarize-for-map-tokens.js
+function summarizeForMapTokens(request) {
+  return {
+    tokens: request.entities.tokens.map((t) => ({ id: t.sys.id, name: t.name, type: t.type }))
+  };
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/helpers/token-defaults/normalize-token-key.js
+function normalizeTokenKey(key) {
+  return key.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").replace(/[ _]+/g, "-").toLowerCase();
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/helpers/token-defaults/terminal-member.js
+function terminalMember(reference) {
+  if (!/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)+$/.test(reference))
+    return void 0;
+  return reference.slice(reference.lastIndexOf(".") + 1);
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/helpers/token-defaults/resolve-token-defaults.js
+function describeType(tokenKind) {
+  return tokenKind === null ? "the property type" : `a ${tokenKind} token`;
+}
+function resolveTokenDefaults(defaults, leaves) {
+  const leavesByPath = new Map(leaves.map((leaf) => [leaf.path, leaf]));
+  const leavesByNormalizedKey = buildNormalizedIndex(leaves);
+  const outcomesByRawDefault = /* @__PURE__ */ new Map();
+  const diagnostics = [];
+  const outcomesFor = (rawDefault) => {
+    const outcomes = outcomesByRawDefault.get(rawDefault) ?? { resolvedPaths: [], diagnostics: [] };
+    outcomesByRawDefault.set(rawDefault, outcomes);
+    return outcomes;
+  };
+  const recordResolvedPath = (rawDefault, path5) => {
+    outcomesFor(rawDefault).resolvedPaths.push(path5);
+  };
+  const recordDiagnostic = (d) => {
+    outcomesFor(d.rawDefault).diagnostics.push(d);
+    diagnostics.push(d);
+  };
+  for (const input of defaults) {
+    classifyOneDefault(input, leavesByPath, leavesByNormalizedKey, recordResolvedPath, recordDiagnostic, describeType);
+  }
+  const mappings = finalizeMappings(outcomesByRawDefault, recordDiagnostic);
+  return { mappings, diagnostics };
+}
+function buildNormalizedIndex(leaves) {
+  const out = /* @__PURE__ */ new Map();
+  for (const leaf of leaves) {
+    const key = leaf.path.slice(leaf.path.lastIndexOf(".") + 1);
+    const normalizedKey = normalizeTokenKey(key);
+    const matches = out.get(normalizedKey) ?? [];
+    matches.push(leaf);
+    out.set(normalizedKey, matches);
+  }
+  return out;
+}
+function classifyOneDefault(input, leavesByPath, leavesByNormalizedKey, recordResolvedPath, recordDiagnostic, describeType2) {
+  const exact = leavesByPath.get(input.rawDefault);
+  if (exact !== void 0) {
+    if (input.tokenKind === null || exact.type === input.tokenKind) {
+      recordResolvedPath(input.rawDefault, exact.path);
+    } else {
+      recordDiagnostic({
+        rawDefault: input.rawDefault,
+        tokenKind: input.tokenKind,
+        reason: "type_mismatch",
+        candidatePaths: [exact.path],
+        message: `Token default '${input.rawDefault}' is a ${exact.type} token, not ${describeType2(input.tokenKind)}.`
+      });
+    }
+    return;
+  }
+  const member = terminalMember(input.rawDefault);
+  const candidates = member === void 0 ? [] : leavesByNormalizedKey.get(normalizeTokenKey(member)) ?? [];
+  const compatible = input.tokenKind === null ? candidates : candidates.filter((c2) => c2.type === input.tokenKind);
+  if (compatible.length === 1) {
+    recordResolvedPath(input.rawDefault, compatible[0].path);
+    return;
+  }
+  if (compatible.length > 1) {
+    recordDiagnostic({
+      rawDefault: input.rawDefault,
+      tokenKind: input.tokenKind,
+      reason: "ambiguous",
+      candidatePaths: compatible.map((c2) => c2.path).sort(),
+      message: `Token default '${input.rawDefault}' matches multiple compatible DTCG leaves: ${compatible.map((c2) => c2.path).sort().join(", ")}.`
+    });
+    return;
+  }
+  if (candidates.length > 0 && input.tokenKind !== null) {
+    recordDiagnostic({
+      rawDefault: input.rawDefault,
+      tokenKind: input.tokenKind,
+      reason: "type_mismatch",
+      candidatePaths: candidates.map((c2) => c2.path).sort(),
+      message: `Token default '${input.rawDefault}' has matching DTCG leaf names, but none is ${describeType2(input.tokenKind)}.`
+    });
+    return;
+  }
+  recordDiagnostic({
+    rawDefault: input.rawDefault,
+    tokenKind: input.tokenKind,
+    reason: "no_match",
+    candidatePaths: [],
+    message: `Token default '${input.rawDefault}' does not match a DTCG token leaf.`
+  });
+}
+function finalizeMappings(outcomesByRawDefault, recordDiagnostic) {
+  const mappings = {};
+  for (const [rawDefault, outcomes] of outcomesByRawDefault) {
+    if (outcomes.diagnostics.length > 0)
+      continue;
+    const uniquePaths = [...new Set(outcomes.resolvedPaths)];
+    if (uniquePaths.length === 1) {
+      mappings[rawDefault] = uniquePaths[0];
+      continue;
+    }
+    recordDiagnostic({
+      rawDefault,
+      tokenKind: null,
+      reason: "ambiguous",
+      candidatePaths: uniquePaths.sort(),
+      message: `Token default '${rawDefault}' resolves to different compatible DTCG leaves across properties: ${uniquePaths.sort().join(", ")}.`
+    });
+  }
+  return mappings;
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/helpers/components/normalize-component-for-cache.js
+function normalizeComponentForCache(component) {
+  const slots = component.slots.map((slot, index, allSlots) => ({
+    ...slot,
+    name: slot.name.trim() || (allSlots.length === 1 ? "children" : `slot_${index}`)
+  }));
+  return { ...component, slots };
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/helpers/components/lookup-component-cache.js
+function lookupComponentCache(db, component, promptHash) {
+  const normalized = normalizeComponentForCache(component);
+  const inputHash = hashComponentShape(normalized);
+  const cached = lookupCache(db, inputHash, "component", component.component_id, promptHash);
+  if (cached)
+    return cached;
+  const legacyInputHash = hashComponentShape(component);
+  return legacyInputHash === inputHash ? null : lookupCache(db, legacyInputHash, "component", component.component_id, promptHash);
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/helpers/components/resolve-component-cache.js
+function resolveComponentCache(db, component, promptHash, allowedComponentNames2) {
+  const cached = lookupComponentCache(db, component, promptHash);
+  if (cached && findUnknownSlotAllowedComponents(db, cached.sourceSessionId, allowedComponentNames2, component.component_id).length === 0) {
+    return { entry: cached, humanEdited: cached.humanEdited };
+  }
+  const pinned = lookupCacheByEntity(db, "component", component.component_id);
+  if (pinned?.humanEdited && findUnknownSlotAllowedComponents(db, pinned.sourceSessionId, allowedComponentNames2, component.component_id).length === 0) {
+    return { entry: pinned, humanEdited: true };
+  }
+  return null;
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/apply/src/controller/endpoint/resolve-shared-inputs.js
+init_validate();
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/helpers/map-tokens/filter-allowed-paths.js
+function filterAllowedPaths(args) {
+  const { component, prop, tokenAllowed, tokenTypeByPath, propTokenKind, warnings } = args;
+  const kept = [];
+  for (const path5 of tokenAllowed) {
+    const tokenType = tokenTypeByPath.get(path5);
+    if (tokenType === void 0) {
+      warnings.push(`map_token_prop '${component}.${prop}': dropped unknown token path '${path5}'`);
+    } else if (propTokenKind !== null && tokenType !== propTokenKind) {
+      warnings.push(`map_token_prop '${component}.${prop}': dropped '${path5}' \u2014 it is a ${tokenType} token, but the property's $token.kind is ${propTokenKind}`);
+    } else {
+      kept.push(path5);
+    }
+  }
+  return kept;
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/helpers/map-tokens/is-prop-reviewed.js
+function isPropReviewed(db, sessionId, componentId, propName) {
+  const row = db.prepare(`SELECT COUNT(*) AS count FROM raw_prop_token_paths
+        WHERE session_id = ? AND component_id = ? AND prop_name = ?
+          AND source = 'review'`).get(sessionId, componentId, propName);
+  return row.count > 0;
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/helpers/map-tokens/load-token-type-by-path.js
+function loadTokenTypeByPath(db, sessionId) {
+  const rows = db.prepare("SELECT path, type FROM raw_tokens WHERE session_id = ?").all(sessionId);
+  return new Map(rows.map((r) => [r.path, r.type]));
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/controller/map-tokens/apply-map-token-prop-calls.js
+function applyMapTokenPropCalls(db, sessionId, calls, incomingWarnings) {
+  const warnings = [...incomingWarnings];
+  let applied = 0;
+  const tokenTypeByPath = loadTokenTypeByPath(db, sessionId);
+  const findComponent = db.prepare("SELECT component_id FROM raw_components WHERE session_id = ? AND name = ?");
+  const findProp = db.prepare("SELECT cdf_type, cdf_category, cdf_token_kind FROM raw_props WHERE session_id = ? AND component_id = ? AND name = ?");
+  for (const call of calls) {
+    const component = findComponent.get(sessionId, call.component);
+    if (!component) {
+      warnings.push(`map_token_prop: unknown component '${call.component}' \u2014 skipped`);
+      continue;
+    }
+    const prop = findProp.get(sessionId, component.component_id, call.prop);
+    if (!prop) {
+      warnings.push(`map_token_prop '${call.component}.${call.prop}': unknown prop \u2014 skipped`);
+      continue;
+    }
+    if (prop.cdf_type !== "token" || prop.cdf_category !== "design") {
+      warnings.push(`map_token_prop '${call.component}.${call.prop}': target is not a design-category token prop \u2014 skipped`);
+      continue;
+    }
+    if (isPropReviewed(db, sessionId, component.component_id, call.prop)) {
+      warnings.push(`map_token_prop '${call.component}.${call.prop}': a reviewer already set this restriction \u2014 skipped`);
+      continue;
+    }
+    const filteredAllowed = filterAllowedPaths({
+      component: call.component,
+      prop: call.prop,
+      tokenAllowed: call.token_allowed,
+      tokenTypeByPath,
+      propTokenKind: prop.cdf_token_kind,
+      warnings
+    });
+    if (filteredAllowed.length === 0) {
+      warnings.push(`map_token_prop '${call.component}.${call.prop}': no valid token_allowed remain \u2014 skipped`);
+      continue;
+    }
+    replaceRawPropTokenPaths(db, sessionId, component.component_id, call.prop, filteredAllowed, "agent");
+    applied++;
+  }
+  return { applied, warnings };
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/controller/map-tokens/run-map-tokens.js
+init_build_prompt();
+init_create_local_cli_agent_invoker();
+init_describe_agent_failure();
+init_resolve_binary();
+init_resolve_skill_path();
+init_parse_map_token_prop_tool_calls();
+import { resolve as resolve18 } from "node:path";
+init_cache_keys();
+
+// packages/experience-design-system-backend-pipeline/dist/src/agents/helpers/resolution/binary-exists.js
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+async function binaryExists(name) {
+  try {
+    await execFileAsync(process.platform === "win32" ? "where" : "which", [name]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/helpers/map-tokens/count-mappable-props.js
+function countMappableProps(cdfEntries) {
+  return cdfEntries.reduce((count, { entry }) => {
+    const props = entry.$properties ?? {};
+    return count + Object.values(props).filter((prop) => prop.$type === "token" && prop.$category === "design").length;
+  }, 0);
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/helpers/map-tokens/load-raw-defaults.js
+function loadRawDefaults(db, sessionId) {
+  return db.prepare(`SELECT rp.default_value AS default_reference, rp.cdf_token_kind
+       FROM raw_props rp
+       JOIN raw_components rc ON rc.session_id = rp.session_id AND rc.component_id = rp.component_id
+       WHERE rp.session_id = ? AND rc.status = 'generated'
+         AND rp.cdf_type = 'token' AND rp.cdf_category = 'design'
+         AND rp.default_value IS NOT NULL`).all(sessionId);
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/helpers/map-tokens/load-token-leaves.js
+function loadTokenLeaves(db, sessionId) {
+  return db.prepare("SELECT path, type FROM raw_tokens WHERE session_id = ? ORDER BY path").all(sessionId);
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/controller/map-tokens/run-map-tokens.js
+var DEFAULT_TIMEOUT_MS2 = 5 * 60 * 1e3;
+var MapTokensRunFailure = class _MapTokensRunFailure extends Error {
+  reason;
+  constructor(reason) {
+    super(_MapTokensRunFailure.format(reason));
+    this.reason = reason;
+  }
+  static format(r) {
+    switch (r.type) {
+      case "no-session":
+        return "no completed generate components session found. Run generate components first, or pass sessionId.";
+      case "no-components":
+        return `no generated components in session '${r.sessionId}'. Run generate components first.`;
+      case "binary-not-found":
+        return `agent '${r.agent}' not found in $PATH (looked for binary: ${r.binary}). Install it, choose another agent, or run the mapping manually via: ${r.skillPath}`;
+      case "agent-failed":
+        return `map tokens agent failed \u2014 ${r.error}`;
+    }
+  }
+};
+async function runMapTokens(request) {
+  const timeoutMs = request.agentTimeoutMs ?? DEFAULT_TIMEOUT_MS2;
+  const db = openPipelineDb();
+  try {
+    const sessionId = request.sessionId ?? findLatestSessionForCommand(db, "generate components");
+    if (!sessionId) {
+      throw new MapTokensRunFailure({ type: "no-session" });
+    }
+    const tokenLeaves = loadTokenLeaves(db, sessionId);
+    const knownTokenPaths = new Set(tokenLeaves.map((t) => t.path));
+    if (request.tokenMapInline) {
+      const validMappings = {};
+      for (const [rawName, path5] of Object.entries(request.tokenMapInline)) {
+        if (knownTokenPaths.has(path5))
+          validMappings[rawName] = path5;
+      }
+      replaceRawTokenNamePaths(db, sessionId, validMappings, "manual");
+    }
+    const rawDefaults = loadRawDefaults(db, sessionId);
+    const defaultResolution = resolveTokenDefaults(rawDefaults.map((row) => ({ rawDefault: row.default_reference, tokenKind: row.cdf_token_kind })), tokenLeaves);
+    const manualMappings = new Map(getRawTokenNamePathRows(db, sessionId).filter((row) => row.source === "manual").map((row) => [row.rawName, row.path]));
+    const automaticMappings = {};
+    for (const [rawName, path5] of Object.entries(defaultResolution.mappings)) {
+      if (manualMappings.get(rawName) === void 0)
+        automaticMappings[rawName] = path5;
+    }
+    replaceRawTokenNamePaths(db, sessionId, automaticMappings, "automatic");
+    const cdfEntries = loadCDFComponents(db, sessionId);
+    if (cdfEntries.length === 0) {
+      throw new MapTokensRunFailure({ type: "no-components", sessionId });
+    }
+    const mappablePropCount = countMappableProps(cdfEntries);
+    const { groups, tokens } = getDtcgTokensForSession(db, sessionId);
+    const tokenCount = tokens.length;
+    if (mappablePropCount === 0 || tokenCount === 0) {
+      return { type: "nothing-to-map", sessionId, mappablePropCount, tokenCount };
+    }
+    const generatedCdf = Object.fromEntries(cdfEntries.map((c2) => [c2.key, c2.entry]));
+    const tokenTree = rebuildDTCGTree(groups, tokens);
+    const componentSourceRefs = await loadComponentSourceRefs(db, sessionId);
+    const buildMapPrompt = () => buildPrompt({
+      skill: "map-tokens",
+      mode: "autonomous",
+      generatedCdf,
+      tokenTree,
+      componentSourceRefs,
+      outDir: process.cwd(),
+      existingTokensInline: request.existingEntitiesInline,
+      ...request.skillContentOverride !== void 0 ? { skillContentOverride: request.skillContentOverride } : {},
+      ...request.skillContentOverride === void 0 && request.skillPathOverride ? { skillPathOverride: resolve18(request.skillPathOverride) } : {}
+    });
+    if (request.printPrompt) {
+      const prompt2 = await buildMapPrompt();
+      return { type: "printed-prompt", sessionId, prompt: prompt2 };
+    }
+    if (request.skipAgent) {
+      const stepId2 = createStep(db, sessionId, "map tokens", {
+        agent: request.agent,
+        model: request.model ?? "",
+        skipAgent: "true"
+      });
+      updateStep(db, stepId2, "complete", { applied: "0", skipAgent: "true" });
+      return { type: "skipped", sessionId, stepId: stepId2 };
+    }
+    const agent = request.agent;
+    const noCache = request.cache === false || process.env["EDS_NO_CACHE"] === "1";
+    const promptHash = await hashPromptForSkill("map-tokens", agent, request.model, void 0, request.existingEntitiesInline ? [hashContent(request.existingEntitiesInline)] : [], request.skillContentOverride);
+    const inputHash = computeMapTokensInputHash(db, sessionId, componentSourceRefs);
+    if (!noCache) {
+      const cached = lookupCache(db, inputHash, "token_mapping", "__map_tokens__", promptHash);
+      if (cached) {
+        const applied2 = copyMapTokensFromCache(db, cached.sourceSessionId, sessionId);
+        const stepId2 = createStep(db, sessionId, "map tokens", { agent, model: request.model ?? "" });
+        updateStep(db, stepId2, "complete", { cached: "true", applied: String(applied2) });
+        return { type: "cached", sessionId, applied: applied2, stepId: stepId2 };
+      }
+    }
+    const binary = resolveBinary(agent);
+    if (!await binaryExists(binary)) {
+      throw new MapTokensRunFailure({
+        type: "binary-not-found",
+        agent,
+        binary,
+        skillPath: resolveSkillPath("map-tokens")
+      });
+    }
+    const stepId = createStep(db, sessionId, "map tokens", { agent, model: request.model ?? "" });
+    const prompt = await buildMapPrompt();
+    const invoker = createLocalCliAgentInvoker();
+    const result = await invoker.invoke({ agent, model: request.model, prompt, timeoutMs });
+    if (result.timedOut || result.exitCode !== 0) {
+      const error = result.timedOut ? `timed out after ${timeoutMs / 6e4} minutes` : describeAgentFailure(result);
+      updateStep(db, stepId, "failed", {}, error);
+      throw new MapTokensRunFailure({ type: "agent-failed", sessionId, stepId, error });
+    }
+    const { calls, warnings: parseWarnings } = parseMapTokenPropToolCalls(result.stdout);
+    const { applied, warnings } = applyMapTokenPropCalls(db, sessionId, calls, parseWarnings);
+    if (!noCache) {
+      storeCache(db, inputHash, "token_mapping", "__map_tokens__", sessionId, false, promptHash);
+    }
+    updateStep(db, stepId, "complete", { applied: String(applied), warnings: String(warnings.length) });
+    return { type: "applied", sessionId, applied, warnings, stepId };
+  } finally {
+    db.close();
+  }
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/orchestrators/run-extract-and-compose-session/run-extract-and-compose-session.js
+import { mkdir as mkdir4 } from "node:fs/promises";
+import { relative as relative2 } from "node:path";
 
 // packages/experience-design-system-extraction/dist/src/extract/framework-adapters/astro/helpers/collect-astro-props-bindings.js
 import { Node as Node10, Project as Project7 } from "ts-morph";
@@ -14389,7 +15474,7 @@ function hasNoAuthoringSurface(component) {
 }
 
 // packages/experience-design-system-extraction/dist/src/extract/services/quality/helpers/inspection/inspect-component-source.js
-import { readFile as readFile12 } from "node:fs/promises";
+import { readFile as readFile15 } from "node:fs/promises";
 
 // packages/experience-design-system-extraction/dist/src/extract/helpers/evidence/parse-source-imports.js
 function parseImportedNames(importClause) {
@@ -14484,7 +15569,7 @@ var ZERO_SURFACE_RENDERED_UI_REASON = "zero-surface:rendered-ui";
 async function inspectComponentSource(component) {
   let sourceText = "";
   try {
-    sourceText = await readFile12(component.source, "utf8");
+    sourceText = await readFile15(component.source, "utf8");
   } catch {
     return {
       wrapperConfidence: 0,
@@ -14779,7 +15864,7 @@ async function retryDatabaseWrite(operation, attempts = 8) {
       const message = error instanceof Error ? error.message : String(error);
       if (!/database is locked|database is busy/i.test(message) || attempt >= attempts)
         throw error;
-      await new Promise((resolve22) => setTimeout(resolve22, Math.min(250 * attempt, 2e3)));
+      await new Promise((resolve25) => setTimeout(resolve25, Math.min(250 * attempt, 2e3)));
     }
   }
 }
@@ -14811,7 +15896,7 @@ function resolveCompositionAgentName(flagValue) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/orchestrators/run-extract-and-compose-session/helpers/read-candidate-files.js
-import { readFile as readFile13 } from "node:fs/promises";
+import { readFile as readFile16 } from "node:fs/promises";
 async function readCandidateFiles(components, extraFiles = []) {
   const paths = new Set(extraFiles);
   for (const c2 of components) {
@@ -14821,7 +15906,7 @@ async function readCandidateFiles(components, extraFiles = []) {
   const out = [];
   await Promise.all([...paths].map(async (p) => {
     try {
-      const content = await readFile13(p, "utf8");
+      const content = await readFile16(p, "utf8");
       out.push({ path: p, content });
     } catch {
     }
@@ -14988,7 +16073,7 @@ init_build_prompt();
 init_create_local_cli_agent_invoker();
 init_invoke_agent_with_output();
 init_parse_token_tool_calls();
-import { readFile as readFile14 } from "node:fs/promises";
+import { readFile as readFile17 } from "node:fs/promises";
 import { basename as basename5, resolve as pathResolve } from "node:path";
 init_cache_keys();
 init_parse_prompt_overrides();
@@ -15021,7 +16106,7 @@ async function runGenerateTokensSession(request) {
     throw new Error(`Prompt override error(s): ${promptErrors.join("; ")}`);
   const tokensOverride = overridesMap.get("tokens");
   const skillContentOverride = tokensOverride ? await resolvePromptOverride(tokensOverride) : void 0;
-  const rawTokensInline = await readFile14(pathResolve(rawTokensPath), "utf8");
+  const rawTokensInline = await readFile17(pathResolve(rawTokensPath), "utf8");
   const tokenInputHash = hashTokenContent(rawTokensInline);
   const db = openPipelineDb();
   try {
@@ -15089,6 +16174,357 @@ ${result.stdout}`);
   }
 }
 
+// packages/experience-design-system-backend-pipeline/dist/src/orchestrators/run-generate-components-session/run-generate-components-session.js
+init_create_local_cli_agent_invoker();
+init_cache_keys();
+
+// packages/experience-design-system-backend-pipeline/dist/src/orchestrators/run-generate-components-session/helpers/build-empty-session-response.js
+function buildEmptySessionResponse(sessionId) {
+  return {
+    sessionId,
+    results: [],
+    allOk: true,
+    renamedSlotsCount: 0,
+    duplicateNames: [],
+    droppedAllowedComponents: [],
+    emptySession: true
+  };
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/orchestrators/run-generate-components-session/helpers/collect-duplicate-names.js
+function collectDuplicateNames(components) {
+  const nameCounts = /* @__PURE__ */ new Map();
+  for (const c2 of components) {
+    const sources = nameCounts.get(c2.name) ?? [];
+    sources.push(c2.source);
+    nameCounts.set(c2.name, sources);
+  }
+  return [...nameCounts.entries()].filter(([, srcs]) => srcs.length > 1).map(([name, sources]) => ({ name, sources }));
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/orchestrators/run-generate-components-session/helpers/filter-dropped-allowed-components.js
+function filterDroppedAllowedComponents(db, sessionId, components, allowedComponentNames2, acceptedNames) {
+  const dropped = filterUnknownSlotAllowedComponents(db, sessionId, allowedComponentNames2);
+  if (dropped.length === 0)
+    return { components, dropped: [] };
+  return { components: loadRawComponents(db, sessionId, acceptedNames), dropped };
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/orchestrators/run-generate-components-session/helpers/read-existing-entities.js
+async function readExistingEntities(request) {
+  if (request.existingContentfulEntities !== void 0)
+    return request.existingContentfulEntities;
+  if (!request.existingEntitiesPath)
+    return void 0;
+  return readExistingContentfulEntitiesFromSession({ path: request.existingEntitiesPath });
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/orchestrators/run-generate-components-session/helpers/resolve-generate-prompt.js
+init_parse_prompt_overrides();
+init_resolve_prompt_override();
+import { resolve as resolve19 } from "node:path";
+async function resolveGeneratePrompt(overrides) {
+  const { overrides: parsed, errors } = parsePromptOverrides(overrides);
+  if (errors.length > 0)
+    throw new Error(errors.join("; "));
+  const entry = parsed.get("generate");
+  if (!entry)
+    return {};
+  const text = await resolvePromptOverride(entry);
+  if (entry.kind === "text")
+    return { text };
+  return { path: resolve19(entry.value), text };
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/orchestrators/run-generate-components-session/helpers/run-one-generate-component.js
+init_build_prompt();
+init_describe_agent_failure();
+init_invoke_agent_with_output();
+init_parse_tool_calls();
+var DEFAULT_TIMEOUT_MS4 = Number(process.env["EDS_AGENT_TIMEOUT_MS"] ?? 5 * 60 * 1e3);
+var RETRY_BACKOFF_MS = Number(process.env["EDS_RETRY_BACKOFF_MS"] ?? 5e3);
+async function runOneGenerateComponent(options, component, index, total) {
+  const { db, sessionId, invoker, agent, model, tokensInline, tokenMapInline, verbose, noCache, skillPathOverride, skillContentOverride, promptHash, existingContentfulEntities, existingTokensInline, precomputedCachedNames, allowedComponentNames: allowedComponentNames2, onProgress } = options;
+  const { renames } = renameEmptySlots(db, sessionId, component.component_id, component.name, component.slots.length);
+  let effectiveSlots = component.slots;
+  if (renames.length > 0) {
+    const renameMap = new Map(renames.map((r) => [r.oldName, r.newName]));
+    effectiveSlots = component.slots.map((s) => renameMap.has(s.name) ? { ...s, name: renameMap.get(s.name) } : s);
+    for (const rename3 of renames) {
+      onProgress?.({
+        kind: "component:slot-renamed",
+        componentName: component.name,
+        oldName: rename3.oldName,
+        newName: rename3.newName
+      });
+    }
+  }
+  effectiveSlots = effectiveSlots.map((slot) => slot.allowedComponents ? { ...slot, allowedComponents: slot.allowedComponents.filter((name) => allowedComponentNames2.has(name)) } : slot);
+  const cacheComponent = normalizeComponentForCache(component);
+  if (!noCache && precomputedCachedNames.has(component.name)) {
+    onProgress?.({ kind: "component:cached", index, total, name: component.name, pinned: false });
+    return cachedResult(component.name);
+  }
+  if (!noCache) {
+    const resolution = resolveComponentCache(db, component, promptHash, allowedComponentNames2);
+    if (resolution && !resolution.humanEdited) {
+      copyComponentFromCache(db, resolution.entry.sourceSessionId, sessionId, component.component_id, true, {
+        allowedComponentNames: allowedComponentNames2
+      });
+      storeCache(db, hashComponentShape(cacheComponent), "component", component.component_id, resolution.entry.sourceSessionId, resolution.entry.humanEdited, promptHash);
+      onProgress?.({ kind: "component:cached", index, total, name: component.name, pinned: false });
+      return cachedResult(component.name);
+    }
+    if (resolution?.humanEdited) {
+      copyComponentFromCache(db, resolution.entry.sourceSessionId, sessionId, component.component_id, true, {
+        allowedComponentNames: allowedComponentNames2
+      });
+      onProgress?.({ kind: "component:cached", index, total, name: component.name, pinned: true });
+      return cachedResult(component.name, [`${component.name}: source changed but human edits preserved`]);
+    }
+  }
+  const rawComponentsInline = JSON.stringify([
+    {
+      name: component.name,
+      source: component.source,
+      framework: component.framework,
+      props: component.props,
+      slots: effectiveSlots
+    }
+  ], null, 2);
+  const sourceRef = await loadComponentSourceRef(component.name, component.sourcePath ?? component.source, component.props.map((p) => p.name), component.props.map((p) => p.type));
+  const existingComponentsInline = existingContentfulEntities ? JSON.stringify(summarizeForGenerateAgent(existingContentfulEntities, component.name)) : void 0;
+  const prompt = await buildPrompt({
+    skill: "components",
+    mode: "autonomous",
+    rawComponentsInline,
+    tokensInline,
+    tokenMapInline,
+    outDir: process.cwd(),
+    componentName: component.name,
+    componentSourceRefs: [sourceRef],
+    skillPathOverride,
+    skillContentOverride,
+    existingComponentsInline,
+    existingTokensInline,
+    componentAllowlistInline: JSON.stringify([...allowedComponentNames2].sort())
+  });
+  const maxAttempts = 2;
+  let lastError = "";
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    if (attempt > 1)
+      await new Promise((res) => setTimeout(res, RETRY_BACKOFF_MS));
+    onProgress?.({ kind: "component:started", index, total, name: component.name, attempt, maxAttempts });
+    const { result } = await invokeAgentWithOutput(invoker, { agent, model, prompt, timeoutMs: DEFAULT_TIMEOUT_MS4 }, verbose);
+    if (result.timedOut) {
+      const error = `timed out after ${DEFAULT_TIMEOUT_MS4 / 6e4} minutes`;
+      onProgress?.({ kind: "component:failed", index, total, name: component.name, error });
+      return failed(component.name, error, renames.length);
+    }
+    if (result.exitCode !== 0) {
+      lastError = describeAgentFailure(result);
+      continue;
+    }
+    const { calls, warnings } = parseToolCalls(result.stdout);
+    if (calls.length === 0) {
+      lastError = describeAgentFailure(result);
+      continue;
+    }
+    const applied = applyToolCalls(db, sessionId, component.component_id, component.name, calls, warnings, {
+      allowedComponentNames: allowedComponentNames2
+    });
+    if (!noCache) {
+      storeCache(db, hashComponentShape(cacheComponent), "component", component.component_id, sessionId, false, promptHash);
+    }
+    onProgress?.({
+      kind: "component:completed",
+      index,
+      total,
+      name: component.name,
+      classified: applied.classified,
+      excluded: applied.excluded,
+      slots: applied.slots,
+      warnings: applied.warnings
+    });
+    return {
+      componentName: component.name,
+      classified: applied.classified,
+      excluded: applied.excluded,
+      slots: applied.slots,
+      warnings: applied.warnings,
+      failed: false,
+      cached: false,
+      renamedSlotsCount: renames.length
+    };
+  }
+  onProgress?.({ kind: "component:failed", index, total, name: component.name, error: lastError });
+  return failed(component.name, lastError, renames.length);
+}
+function cachedResult(componentName, warnings = []) {
+  return {
+    componentName,
+    classified: 0,
+    excluded: 0,
+    slots: 0,
+    warnings,
+    failed: false,
+    cached: true,
+    renamedSlotsCount: 0
+  };
+}
+function failed(componentName, error, renamedSlotsCount) {
+  return {
+    componentName,
+    classified: 0,
+    excluded: 0,
+    slots: 0,
+    warnings: [],
+    failed: true,
+    error,
+    cached: false,
+    renamedSlotsCount
+  };
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/orchestrators/run-generate-components-session/helpers/run-with-pool.js
+async function runWithPool(items, concurrency, worker) {
+  const results = new Array(items.length);
+  let next = 0;
+  async function run() {
+    while (next < items.length) {
+      const i = next++;
+      results[i] = await worker(items[i], i);
+    }
+  }
+  await Promise.all(Array.from({ length: concurrency }, run));
+  return results;
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/orchestrators/run-generate-components-session/check-generate-components-cache.js
+init_cache_keys();
+async function checkGenerateComponentsCache(request) {
+  if (request.noCache) {
+    return { sessionId: request.sessionId, cachedComponentNames: [], fullyCached: false, cacheDisabled: true };
+  }
+  const existingEntities = await readExistingEntities(request);
+  const existingTokensInline = existingEntities ? JSON.stringify(summarizeForMapTokens({ entities: existingEntities })) : void 0;
+  const prompt = await resolveGeneratePrompt(request.promptOverrides);
+  const agent = request.agent;
+  const promptHash = await hashPromptForSkill("components", agent, request.agentModel, prompt.path, existingTokensInline ? [hashContent(existingTokensInline)] : [], prompt.text);
+  const db = openPipelineDb();
+  try {
+    const acceptedNames = await loadAcceptedNames(request.sessionId);
+    const components = loadRawComponents(db, request.sessionId, acceptedNames ?? void 0);
+    if (components.length === 0) {
+      return { sessionId: request.sessionId, cachedComponentNames: [], fullyCached: false, cacheDisabled: false };
+    }
+    const allowedComponentNames2 = /* @__PURE__ */ new Set([
+      ...components.map((component) => component.name),
+      ...(existingEntities?.components ?? []).map((component) => component.name)
+    ]);
+    const cachedComponents = components.flatMap((component) => {
+      const resolution = resolveComponentCache(db, component, promptHash, allowedComponentNames2);
+      return resolution ? [{ component, resolution }] : [];
+    });
+    if (request.restoreCache)
+      restoreCached(db, request.sessionId, cachedComponents, promptHash, allowedComponentNames2);
+    return {
+      sessionId: request.sessionId,
+      cachedComponentNames: cachedComponents.map(({ component }) => component.name),
+      fullyCached: cachedComponents.length === components.length,
+      cacheDisabled: false
+    };
+  } finally {
+    db.close();
+  }
+}
+function restoreCached(db, sessionId, cachedComponents, promptHash, allowedComponentNames2) {
+  const restorations = [];
+  const rekeyed = [];
+  const componentStatus = db.prepare("SELECT status FROM raw_components WHERE session_id = ? AND component_id = ?");
+  for (const { component, resolution } of cachedComponents) {
+    const current = componentStatus.get(sessionId, component.component_id);
+    if (current?.status === "generated")
+      continue;
+    renameEmptySlots(db, sessionId, component.component_id, component.name, component.slots.length);
+    restorations.push({
+      sourceSessionId: resolution.entry.sourceSessionId,
+      targetSessionId: sessionId,
+      componentId: component.component_id
+    });
+    rekeyed.push({ component, cached: resolution.entry });
+  }
+  copyComponentsFromCache(db, restorations, { allowedComponentNames: allowedComponentNames2 });
+  storeCaches(db, rekeyed.map(({ component, cached }) => ({
+    inputHash: hashComponentShape(normalizeComponentForCache(component)),
+    entityType: "component",
+    entityId: component.component_id,
+    sourceSessionId: cached.sourceSessionId,
+    humanEdited: cached.humanEdited,
+    promptHash
+  })));
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/orchestrators/run-generate-components-session/run-generate-components-session.js
+var DEFAULT_COMPONENT_CONCURRENCY = Number(process.env["EDS_GENERATE_CONCURRENCY"] ?? 10);
+async function runGenerateComponentsSession(request) {
+  const prompt = await resolveGeneratePrompt(request.promptOverrides);
+  const existingEntities = await readExistingEntities(request);
+  const existingTokensInline = existingEntities ? JSON.stringify(summarizeForMapTokens({ entities: existingEntities })) : void 0;
+  const existingTokensHash = existingTokensInline ? [hashContent(existingTokensInline)] : [];
+  const agent = request.agent;
+  const promptHash = await hashPromptForSkill("components", agent, request.agentModel, prompt.path, existingTokensHash, prompt.text);
+  const db = openPipelineDb();
+  try {
+    const acceptedNames = await loadAcceptedNames(request.sessionId);
+    const acceptedSet = acceptedNames ? new Set(acceptedNames) : void 0;
+    let components = loadRawComponents(db, request.sessionId, acceptedSet ?? void 0);
+    if (components.length === 0)
+      return buildEmptySessionResponse(request.sessionId);
+    const allowedComponentNames2 = /* @__PURE__ */ new Set([
+      ...components.map((c2) => c2.name),
+      ...(existingEntities?.components ?? []).map((c2) => c2.name)
+    ]);
+    const { components: filtered, dropped } = filterDroppedAllowedComponents(db, request.sessionId, components, allowedComponentNames2, acceptedSet);
+    components = filtered;
+    const duplicateNames = collectDuplicateNames(components);
+    const invoker = createLocalCliAgentInvoker({});
+    const concurrency = Math.max(1, Math.min(DEFAULT_COMPONENT_CONCURRENCY, components.length));
+    const results = await runWithPool(components, concurrency, (component, index) => runOneGenerateComponent({
+      db,
+      sessionId: request.sessionId,
+      invoker,
+      agent,
+      model: request.agentModel,
+      tokensInline: request.tokensInline,
+      tokenMapInline: request.tokenMapInline,
+      verbose: request.verbose ?? false,
+      noCache: request.noCache,
+      skillPathOverride: prompt.path,
+      skillContentOverride: prompt.text,
+      promptHash,
+      existingContentfulEntities: existingEntities,
+      existingTokensInline,
+      precomputedCachedNames: request.precomputedCachedNames ?? /* @__PURE__ */ new Set(),
+      allowedComponentNames: allowedComponentNames2,
+      onProgress: request.onProgress
+    }, component, index, components.length));
+    const allOk = results.every((r) => !r.failed);
+    const renamedSlotsCount = results.reduce((sum, r) => sum + r.renamedSlotsCount, 0);
+    return {
+      sessionId: request.sessionId,
+      results,
+      allOk,
+      renamedSlotsCount,
+      duplicateNames,
+      droppedAllowedComponents: dropped,
+      emptySession: false
+    };
+  } finally {
+    db.close();
+  }
+}
+
 // packages/experience-design-system-cli/src/tui/import/steps/03-path-validation/helpers/scan-files.ts
 function scanFiles(directory) {
   return toScanResult(collectFiles(directory));
@@ -15738,7 +17174,7 @@ function ExtractionScreen({
 
 // packages/experience-design-system-types/dist/src/config/index.js
 import { randomBytes as randomBytes3 } from "node:crypto";
-import { mkdir as mkdir6, readFile as readFile15, rename as rename2, writeFile as writeFile6 } from "node:fs/promises";
+import { mkdir as mkdir6, readFile as readFile18, rename as rename2, writeFile as writeFile6 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
 import { dirname as dirname13, join as join17 } from "node:path";
 function configRoot2() {
@@ -15748,7 +17184,7 @@ var configFilePath2 = () => join17(configRoot2(), "config.json");
 var debugSessionsDir2 = () => join17(configRoot2(), "debug", "sessions");
 async function readSettings2() {
   try {
-    return JSON.parse(await readFile15(configFilePath2(), "utf8"));
+    return JSON.parse(await readFile18(configFilePath2(), "utf8"));
   } catch {
     return {};
   }
@@ -15770,11 +17206,11 @@ import { useEffect as useEffect5, useRef as useRef2, useState as useState8 } fro
 
 // packages/experience-design-system-cli/src/tui/import/steps/06-extraction/run.ts
 import { mkdir as mkdir7 } from "node:fs/promises";
-import { join as join19, resolve as resolve20 } from "node:path";
+import { join as join19, resolve as resolve22 } from "node:path";
 
 // packages/experience-design-system-cli/src/tui/import/steps/06-extraction/find-skill-path.ts
 import { existsSync as existsSync8 } from "node:fs";
-import { dirname as dirname14, join as join18, resolve as resolve18 } from "node:path";
+import { dirname as dirname14, join as join18, resolve as resolve20 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function findSkillPath(fileName) {
   const thisDir = dirname14(fileURLToPath4(import.meta.url));
@@ -15782,7 +17218,7 @@ function findSkillPath(fileName) {
   for (; ; ) {
     const candidate = join18(dir, "skills", fileName);
     if (existsSync8(candidate)) return candidate;
-    const parent = resolve18(dir, "..");
+    const parent = resolve20(dir, "..");
     if (parent === dir) {
       throw new Error(`skill file not found (looked for skills/${fileName} from ${thisDir})`);
     }
@@ -15791,11 +17227,11 @@ function findSkillPath(fileName) {
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/06-extraction/selection.ts
-import { resolve as resolve19 } from "node:path";
+import { resolve as resolve21 } from "node:path";
 var SELECT_SKILL_PATH = findSkillPath("select-components.md");
-var DEFAULT_TIMEOUT_MS4 = Number(process.env.EDS_AGENT_TIMEOUT_MS ?? 5 * 60 * 1e3);
+var DEFAULT_TIMEOUT_MS5 = 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(resolve19(options.promptPath)) : await hashFile(SELECT_SKILL_PATH);
+  const promptHash = options.promptText ? hashContent(options.promptText) : options.promptPath ? await hashFile(resolve21(options.promptPath)) : await hashFile(SELECT_SKILL_PATH);
   return hashContent(`${promptHash}|${options.agent}|${options.model ?? ""}`);
 }
 async function runSelection(options) {
@@ -15829,7 +17265,7 @@ async function runSelection(options) {
     });
     const { result } = await invokeAgentWithOutput(
       invoker,
-      { agent: options.agent, model: options.model, prompt, timeoutMs: DEFAULT_TIMEOUT_MS4 },
+      { agent: options.agent, model: options.model, prompt, timeoutMs: DEFAULT_TIMEOUT_MS5 },
       false
     );
     if (result.timedOut) throw new Error("selection agent timed out");
@@ -15890,7 +17326,7 @@ var realDeps = {
 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 = join19(resolve20(input.projectPath), ".contentful");
+  const outDir = join19(resolve22(input.projectPath), ".contentful");
   let progress = initialProgress({
     hasCredentials: input.credentials !== null,
     hasRawTokens: input.rawTokensPath !== "",
@@ -16016,7 +17452,7 @@ async function resolveSelectionPrompt(overrides) {
   if (select?.kind === "text") return { promptText: select.value };
   if (select?.kind === "path") {
     await resolvePromptOverride(select);
-    return { promptPath: resolve20(select.value) };
+    return { promptPath: resolve22(select.value) };
   }
   return {};
 }
@@ -16920,7 +18356,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 });
       }
     }
@@ -16967,8 +18403,7 @@ function buildVisibleRows(props) {
         sharedSuffix,
         cycleChild: child.isCycleMember || void 0,
         itemIdx: childRec?.idx ?? -1,
-        rootName: key,
-        parentName: child.parent
+        rootName: key
       });
     });
   }
@@ -17051,19 +18486,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) => {
@@ -17097,8 +18526,7 @@ function buildVisibleRows(props) {
         sharedSuffix,
         cycleChild: child.isCycleChild || void 0,
         itemIdx: childRec?.idx ?? -1,
-        rootName: root,
-        parentName: child.parent
+        rootName: root
       });
     });
   }
@@ -17251,7 +18679,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);
@@ -17281,7 +18709,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: [
               " ",
@@ -17940,7 +19368,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" };
@@ -18199,42 +19626,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);
@@ -18406,14 +19812,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++) {
@@ -18513,7 +19911,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);
@@ -18566,11 +19964,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;
@@ -18578,9 +19971,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;
@@ -18851,58 +20241,19 @@ function ScopeGateView({ components, onConfirm, onQuit }) {
 import { useEffect as useEffect8, useMemo as useMemo3, useRef as useRef5, useState as useState13 } from "react";
 
 // packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/cache-check.ts
-import { execFile as execFile2 } from "node:child_process";
-
-// packages/experience-design-system-cli/src/legacy/legacy-cli-path.ts
-import { existsSync as existsSync9 } from "node:fs";
-import { join as join20 } from "node:path";
-var PACKAGE_NAME2 = "@contentful/experience-design-system-cli";
-function findLegacyCliPath() {
-  const root = findPackageRoot(import.meta.url, PACKAGE_NAME2);
-  const candidates = [
-    join20(root, "legacy", "bin", "cli.js"),
-    join20(root, "..", "experience-design-system-cli-legacy", "bin", "cli.js")
-  ];
-  const found = candidates.find((candidate) => existsSync9(candidate));
-  if (!found) {
-    throw new Error(`Legacy CLI not found. Looked in:
-${candidates.join("\n")}`);
-  }
-  return found;
-}
-
-// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/cache-check.ts
-function buildCacheCheckArgs(input) {
-  const args = ["__generate", "components", "--agent", input.agent, "--session", input.sessionId];
-  if (input.tokensPath) args.push("--tokens", input.tokensPath);
-  if (input.agentModel) args.push("--model", input.agentModel);
-  if (input.noCache) args.push("--no-cache");
-  for (const prompt of input.promptOverrides) args.push("--prompt", prompt);
-  if (input.existingEntitiesPath) args.push("--existing-entities-path", input.existingEntitiesPath);
-  args.push("--cache-status", "--restore-cache");
-  return args;
-}
-function parseCacheComponents(stdout) {
-  const line = /^cache-components=(.+)$/m.exec(stdout)?.[1];
-  if (!line) return [];
-  try {
-    const names = JSON.parse(line);
-    return Array.isArray(names) ? names.filter((name) => typeof name === "string") : [];
-  } catch {
-    return [];
-  }
-}
-var runLegacyCli = (args) => new Promise((resolve22) => {
-  execFile2("node", [findLegacyCliPath(), ...args], (error, stdout, stderr) => {
-    resolve22({ exitCode: error?.code ? Number(error.code) : 0, stdout, stderr });
-  });
-});
-async function checkGenerationCache(input, run = runLegacyCli) {
+async function checkGenerationCache(input) {
   if (input.noCache) return [];
   try {
-    const result = await run(buildCacheCheckArgs(input));
-    if (result.exitCode !== 0) return [];
-    return parseCacheComponents(result.stdout);
+    const result = await checkGenerateComponentsCache({
+      sessionId: input.sessionId,
+      agent: input.agent,
+      ...input.agentModel ? { agentModel: input.agentModel } : {},
+      promptOverrides: input.promptOverrides,
+      existingEntitiesPath: input.existingEntitiesPath,
+      noCache: input.noCache,
+      restoreCache: true
+    });
+    return result.cachedComponentNames;
   } catch {
     return [];
   }
@@ -18951,33 +20302,6 @@ function useScopeGateFlow(input, deps = realDeps2) {
 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;
 }
@@ -19033,17 +20357,215 @@ function GenerationScreen({
   );
 }
 
-// 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-generation/dist/src/agent-names.js
-var AGENT_BINARIES2 = {
-  claude: "claude",
-  codex: "codex",
-  opencode: "opencode",
-  cursor: "cursor-agent",
-  copilot: "copilot"
-};
+// 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/run.ts
+import { resolve as resolve23 } from "node:path";
+
+// 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/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,
+  saveDecisions,
+  runGenerate: runGenerateComponentsSession,
+  runMapTokens,
+  prepareMapTokens
+};
+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 = { components: null, mapTokens: "idle", mapTokensEligible: null };
+  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));
+  }
+  let generated;
+  try {
+    generated = await deps.runGenerate({
+      sessionId: input.sessionId,
+      agent: input.agent,
+      ...input.agentModel ? { agentModel: input.agentModel } : {},
+      promptOverrides: appendGeneratePromptOverride(input),
+      noCache: input.noCache,
+      existingEntitiesPath: input.existingEntitiesPath,
+      precomputedCachedNames: new Set(handedOverNames),
+      onProgress: (event) => update({ components: applyProgressEvent2(event, progress.components, accepted.length) })
+    });
+  } catch (error) {
+    return fail2("generate components", errorMessage3(error));
+  }
+  if (generated.emptySession) return fail2("generate components", "no raw components in session");
+  if (!generated.allOk) {
+    const firstFailure = generated.results.find((r) => r.failed);
+    return fail2("generate components", firstFailure?.error ?? "unknown error");
+  }
+  let plan;
+  try {
+    plan = await deps.prepareMapTokens(input, input.sessionId);
+  } catch (error) {
+    return fail2("map tokens", errorMessage3(error));
+  }
+  update({ mapTokensEligible: plan.eligible });
+  if (plan.eligible) {
+    update({ mapTokens: "running" });
+    try {
+      const mapTokensOptions = await buildMapTokensOptions(input);
+      await deps.runMapTokens({
+        sessionId: input.sessionId,
+        agent: input.agent,
+        ...input.agentModel ? { model: input.agentModel } : {},
+        cache: !input.noCache,
+        ...mapTokensOptions
+      });
+    } catch (error) {
+      const message = error instanceof MapTokensRunFailure ? error.message : error instanceof Error ? error.message : String(error);
+      return fail2("map tokens", message);
+    }
+  }
+  update({ mapTokens: "complete" });
+  const generatedCount = generated.results.filter((r) => !r.failed).length;
+  return {
+    ok: true,
+    generation: {
+      route: "review",
+      sessionId: input.sessionId,
+      acceptedCount: accepted.length,
+      generatedCount,
+      mapTokensEligible: plan.eligible
+    }
+  };
+}
+async function buildMapTokensOptions(input) {
+  const { overrides: parsed, errors } = parsePromptOverrides(input.promptOverrides);
+  if (errors.length > 0) throw new Error(errors.join("; "));
+  const mapOverride = parsed.get("map-tokens");
+  const prompt = {};
+  if (mapOverride?.kind === "text") prompt.skillContentOverride = mapOverride.value;
+  if (mapOverride?.kind === "path") {
+    await resolvePromptOverride(mapOverride);
+    prompt.skillPathOverride = resolve23(mapOverride.value);
+  }
+  if (input.existingEntitiesPath) {
+    const entities = await readExistingContentfulEntitiesFromSession({ path: input.existingEntitiesPath });
+    if (entities) return { ...prompt, existingEntitiesInline: JSON.stringify(summarizeForMapTokens({ entities })) };
+  }
+  return prompt;
+}
+function appendGeneratePromptOverride(input) {
+  if (!input.generatePromptPath) return input.promptOverrides;
+  const already = input.promptOverrides.some((override) => override.startsWith("generate="));
+  if (already) return input.promptOverrides;
+  return [...input.promptOverrides, `generate=${input.generatePromptPath}`];
+}
+function applyProgressEvent2(event, previous, total) {
+  if (event.kind === "component:started") {
+    return { done: previous?.done ?? 0, total: event.total || total, current: event.name };
+  }
+  if (event.kind === "component:completed" || event.kind === "component:failed" || event.kind === "component:cached") {
+    return { done: (previous?.done ?? 0) + 1, total: event.total || total, current: event.name };
+  }
+  return previous;
+}
+
+// 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/steps/10-flow/flow/build-flow-start.ts
+import { join as join20 } from "node:path";
+function buildFlowStart(input) {
+  const { extraction, handoff, saved, generatePromptPath } = input;
+  const credentials = extraction.credentials ?? {
+    spaceId: saved?.spaceId ?? "",
+    environmentId: saved?.environmentId ?? "",
+    cmaToken: saved?.cmaToken ?? "",
+    host: saved?.host ?? ""
+  };
+  return {
+    handoff,
+    agent: extraction.agent,
+    projectPath: extraction.projectPath,
+    outDir: extraction.projectPath ? join20(extraction.projectPath, ".contentful") : "",
+    rawTokensPath: extraction.rawTokensPath,
+    credentials: {
+      spaceId: credentials.spaceId,
+      environmentId: credentials.environmentId || "master",
+      cmaToken: credentials.cmaToken,
+      host: toConfiguredHost2(credentials.host) ?? DEFAULT_CONFIGURED_HOST
+    },
+    ...generatePromptPath ? { generatePromptPath } : {}
+  };
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/10-flow/flow/screen.tsx
+import { Box as Box41 } from "ink";
 
 // packages/experience-design-system-types/dist/src/cdf/validate.js
 import { Ajv as Ajv2 } from "ajv";
@@ -19328,315 +20850,6 @@ var DTCGTokenSchema2 = z4.strictObject({
 // packages/experience-design-system-types/dist/src/dtcg/validate.js
 var TOKEN_TYPE_SET4 = new Set(DESIGN_TOKEN_TYPES2);
 
-// packages/experience-design-system-generation/dist/src/services/agent/helpers/resolve-agent-binary.js
-function resolveAgentBinary(agent) {
-  const envKey = `EDS_AGENT_BINARY_${agent.toUpperCase()}`;
-  const override = process.env[envKey];
-  if (override && override.trim())
-    return override.trim();
-  return AGENT_BINARIES2[agent];
-}
-
-// packages/experience-design-system-generation/dist/src/services/agent/helpers/check-agent-auth.js
-import { spawn as spawn4 } from "node:child_process";
-
-// packages/experience-design-system-generation/dist/src/services/agent/helpers/check-claude-auth.js
-import { spawn as spawn3 } from "node:child_process";
-function checkClaudeAuth(binary) {
-  return new Promise((resolve22) => {
-    const child = spawn3(binary, ["auth", "status", "--json"], {
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let done = false;
-    const timer = setTimeout(() => {
-      if (!done) {
-        done = true;
-        child.kill("SIGTERM");
-        resolve22("unauthenticated");
-      }
-    }, 5e3);
-    child.stdout?.on("data", (chunk) => {
-      stdout += chunk.toString();
-    });
-    child.on("close", (code) => {
-      if (done)
-        return;
-      done = true;
-      clearTimeout(timer);
-      if (code !== 0) {
-        resolve22("unauthenticated");
-        return;
-      }
-      try {
-        const status = JSON.parse(stdout);
-        resolve22(status.loggedIn ? "ok" : "unauthenticated");
-      } catch {
-        resolve22("unauthenticated");
-      }
-    });
-  });
-}
-
-// 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((resolve22) => {
-    if (binary.startsWith("/")) {
-      import("node:fs/promises").then((fs) => fs.access(binary).then(() => resolve22(true), () => resolve22(false)));
-      return;
-    }
-    const child = spawn4(process.platform === "win32" ? "where" : "which", [binary], { stdio: "ignore" });
-    child.on("close", (code) => resolve22(code === 0));
-  });
-  if (!binaryExists2)
-    return "not-found";
-  if (agent !== "claude")
-    return "ok";
-  return checkClaudeAuth(binary);
-}
-
-// 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 execFile3, spawn as spawn5 } 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((resolve22) => {
-    const child = spawn5("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) => resolve22({ exitCode: 1, stdout, stderr: stderr + error.message }));
-    child.on("close", (code) => resolve22({ exitCode: code ?? 0, stdout, stderr }));
-  });
-}
-function runMapTokens2(command) {
-  return new Promise((resolve22) => {
-    execFile3("node", [findLegacyCliPath(), ...buildMapTokensArgs(command)], (error, stdout, stderr) => {
-      resolve22({ 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/steps/10-flow/flow/build-flow-start.ts
-import { join as join21 } from "node:path";
-function buildFlowStart(input) {
-  const { extraction, handoff, saved, generatePromptPath } = input;
-  const credentials = extraction.credentials ?? {
-    spaceId: saved?.spaceId ?? "",
-    environmentId: saved?.environmentId ?? "",
-    cmaToken: saved?.cmaToken ?? "",
-    host: saved?.host ?? ""
-  };
-  return {
-    handoff,
-    agent: extraction.agent,
-    projectPath: extraction.projectPath,
-    outDir: extraction.projectPath ? join21(extraction.projectPath, ".contentful") : "",
-    rawTokensPath: extraction.rawTokensPath,
-    credentials: {
-      spaceId: credentials.spaceId,
-      environmentId: credentials.environmentId || "master",
-      cmaToken: credentials.cmaToken,
-      host: toConfiguredHost2(credentials.host) ?? DEFAULT_CONFIGURED_HOST
-    },
-    ...generatePromptPath ? { generatePromptPath } : {}
-  };
-}
-
-// packages/experience-design-system-cli/src/tui/import/steps/10-flow/flow/screen.tsx
-import { Box as Box41 } from "ink";
-
 // packages/experience-design-system-cli/src/tui/import/steps/preview-validation-error/logic.ts
 function failedComponentNames(errors) {
   return [...new Set(errors.map((error) => error.componentName))];
@@ -19662,8 +20875,8 @@ function missingNote(missingNames) {
 Note: ${plural2(missingNames.length, "component name")} from the server (${missingNames.join(", ")}) ${verb} not match anything in this session \u2014 they cannot be edited or skipped from here.`;
 }
 function contextText(errors, missingNames) {
-  const failed = failedComponentNames(errors);
-  return `${plural2(failed.length, "component")} failed server validation. Edit their definitions in the review TUI, or skip them and retry preview without them.${missingNote(missingNames)}`;
+  const failed2 = failedComponentNames(errors);
+  return `${plural2(failed2.length, "component")} failed server validation. Edit their definitions in the review TUI, or skip them and retry preview without them.${missingNote(missingNames)}`;
 }
 function skipLabel(matchedNames) {
   if (matchedNames.length === 0) return "No matching components to skip";
@@ -21394,8 +22607,8 @@ function FieldEditor({
     return /* @__PURE__ */ jsxs22(Box21, { flexDirection: "column", width, borderStyle: "single", borderColor: PALETTE3.warning, children: [
       /* @__PURE__ */ jsx27(Text23, { bold: true, color: PALETTE3.warning, children: "FIELD EDITOR \u2014 no fields" }),
       /* @__PURE__ */ jsx27(Text23, { color: PALETTE3.warning, children: "\u26A0 No properties classified for this component. The LLM didn't find anything to classify." }),
-      /* @__PURE__ */ jsx27(Text23, { color: PALETTE3.muted, children: "There is nothing to edit here." }),
-      /* @__PURE__ */ jsx27(Text23, { color: PALETTE3.muted, children: active ? "[Esc] go back to the list" : "In the list: [r] reject this component \xB7 [a] accept it" })
+      /* @__PURE__ */ jsx27(Text23, { color: PALETTE3.muted, children: "You can add fields manually below or reject this component." }),
+      /* @__PURE__ */ jsx27(Text23, { color: PALETTE3.muted, children: "Enter to save \xB7 Esc to discard" })
     ] });
   }
   const hasEmptyProperties = props.length === 0 && slots.length === 0;
@@ -21610,7 +22823,7 @@ function FieldEditor({
       children: [
         hasEmptyProperties && /* @__PURE__ */ jsx27(Text23, { color: PALETTE3.warning, children: "\u26A0 No properties classified for this component. The LLM didn't find anything to classify. Reject this component or add fields manually." }),
         header,
-        /* @__PURE__ */ jsx27(Box21, { flexDirection: "column", width: innerWidth, flexShrink: 0, children: focusLevel === "field" && !inComponentDesc && !inSlots && currentProp ? /* @__PURE__ */ jsx27(
+        /* @__PURE__ */ jsx27(Box21, { flexDirection: "column", width: innerWidth, flexShrink: 0, children: focusLevel === "field" && !inComponentDesc && currentProp ? /* @__PURE__ */ jsx27(
           PropRow,
           {
             prop: currentProp,
@@ -22519,7 +23732,6 @@ function finalizeReviewSession(extractSessionId, components) {
         db.exec("ROLLBACK");
         throw error;
       }
-      removeSlotAllowedComponents(db, extractSessionId, [], toReject);
     } finally {
       db.close();
     }
@@ -22597,10 +23809,10 @@ var TimeoutError = class extends Error {
     this.name = "TimeoutError";
   }
 };
-var DEFAULT_TIMEOUT_MS5 = 15e3;
+var DEFAULT_TIMEOUT_MS6 = 15e3;
 async function runLivePreview(opts) {
   const { sessionId, tokensPath, spaceId, environmentId, cmaToken, host, generation } = opts;
-  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS5;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS6;
   if (!spaceId || !environmentId || !cmaToken) {
     return { generation, response: null };
   }
@@ -24251,50 +25463,33 @@ function GenerateReviewStepView({
     const cycle = cycleRows[cyclesCursor];
     return cycle ? enumerateCycleBreaks(cycle, components) : [];
   }, [cycleRows, cyclesCursor, components]);
-  const saveSlotChange = (parentKey, nextEntry, historyLabel) => {
+  const handleBreakEdge = (edge) => {
+    const target = components.find((component) => component.key === edge.fromComponent);
+    const slot = target?.entry.$slots?.[edge.slotName];
+    if (!target || !slot || !Array.isArray(slot.$allowedComponents)) return;
+    const nextEntry = {
+      ...target.entry,
+      $slots: {
+        ...target.entry.$slots,
+        [edge.slotName]: {
+          ...slot,
+          $allowedComponents: slot.$allowedComponents.filter((value) => value !== edge.toComponent)
+        }
+      }
+    };
     const next = components.map(
-      (component) => component.key === parentKey ? { ...component, entry: nextEntry } : component
+      (component) => component.key === target.key ? { ...component, entry: nextEntry } : component
     );
     setComponents(next);
     const db = openPipelineDb();
     try {
-      storeCDFComponents(db, extractSessionId, [{ key: parentKey, entry: nextEntry }]);
+      storeCDFComponents(db, extractSessionId, [{ key: target.key, entry: nextEntry }]);
     } finally {
       db.close();
     }
     recomputeCycles(next);
     livePreviewHook.trigger();
-    pushHistorySnapshot(next, historyLabel);
-  };
-  const handleBreakEdge = (edge) => {
-    const target = components.find((component) => component.key === edge.fromComponent);
-    const slot = target?.entry.$slots?.[edge.slotName];
-    if (!target || !slot || !Array.isArray(slot.$allowedComponents)) return;
-    saveSlotChange(
-      target.key,
-      {
-        ...target.entry,
-        $slots: {
-          ...target.entry.$slots,
-          [edge.slotName]: {
-            ...slot,
-            $allowedComponents: slot.$allowedComponents.filter((value) => value !== edge.toComponent)
-          }
-        }
-      },
-      "break-cycle-edge"
-    );
-  };
-  const handleRemoveSlotChild = (parentKey, childKey) => {
-    const parent = components.find((component) => component.key === parentKey);
-    if (!parent?.entry.$slots) return;
-    const slots = Object.fromEntries(
-      Object.entries(parent.entry.$slots).map(([slotName, slot]) => [
-        slotName,
-        Array.isArray(slot.$allowedComponents) ? { ...slot, $allowedComponents: slot.$allowedComponents.filter((value) => value !== childKey) } : slot
-      ])
-    );
-    saveSlotChange(parentKey, { ...parent.entry, $slots: slots }, "remove-slot-child");
+    pushHistorySnapshot(next, "break-cycle-edge");
   };
   const handleRejectComponent = (key) => {
     const rejectCascade2 = computeRejectCascade(key, componentGraph);
@@ -24624,11 +25819,6 @@ function GenerateReviewStepView({
     if (input === "r") {
       const current = components[selectedIdx];
       if (!current) return;
-      const row = visibleRowsMemo[cursorRowIdx];
-      if (row?.kind === "group-child" && row.parentName) {
-        handleRemoveSlotChild(row.parentName, current.key);
-        return;
-      }
       handleRejectComponent(current.key);
       return;
     }
@@ -25105,10 +26295,10 @@ function DoneStep({
 import { useState as useState24 } from "react";
 import { Box as Box37, Text as Text40 } from "ink";
 import { readdirSync as readdirSync3 } from "node:fs";
-import { dirname as dirname15, basename as basename6, join as join22 } from "node:path";
+import { dirname as dirname15, basename as basename6, join as join21 } from "node:path";
 
 // packages/experience-design-system-cli/src/tui/import/steps/10-flow/support/path-utils.ts
-import { resolve as resolve21 } from "node:path";
+import { resolve as resolve24 } from "node:path";
 import { homedir as homedir4 } from "node:os";
 function expandTilde(input) {
   if (input === "~" || input.startsWith("~/") || input.startsWith("~\\")) {
@@ -25122,7 +26312,7 @@ function normalizePath(input) {
     p = p.slice(1, -1);
   }
   p = expandTilde(p);
-  return resolve21(p);
+  return resolve24(p);
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/10-flow/support/use-blinking-cursor.ts
@@ -25151,13 +26341,13 @@ function autocomplete(partial) {
   }
   const matches = entries.filter((e) => e.startsWith(base));
   if (matches.length === 0) return null;
-  if (matches.length === 1) return join22(dir, matches[0]);
+  if (matches.length === 1) return join21(dir, matches[0]);
   let prefix = matches[0];
   for (const m of matches) {
     while (!m.startsWith(prefix)) prefix = prefix.slice(0, -1);
     if (!prefix) break;
   }
-  return prefix.length > base.length ? join22(dir, prefix) : null;
+  return prefix.length > base.length ? join21(dir, prefix) : null;
 }
 function PathPrompt({
   defaultPath,
@@ -25910,7 +27100,7 @@ import { useEffect as useEffect20, useRef as useRef12, useSyncExternalStore } fr
 import { appendFileSync, writeFileSync } from "node:fs";
 import { mkdir as mkdir8 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join as join24 } from "node:path";
+import { join as join23 } from "node:path";
 
 // packages/experience-design-system-cli/src/tui/import/steps/10-flow/support/wizard-state-transitions.ts
 function shouldBypassPreview(state) {
@@ -26198,19 +27388,19 @@ function resultOf(operation, preview) {
   const items = operation.items ?? [];
   if (items.length > 0) {
     const count = (entityType, action) => items.filter((i) => i.entityType === entityType && i.action === action && i.status === "succeeded").length;
-    const failed = (entityType) => items.filter((i) => i.entityType === entityType && i.status === "failed").length;
+    const failed2 = (entityType) => items.filter((i) => i.entityType === entityType && i.status === "failed").length;
     return {
       componentTypes: {
         created: count("ComponentType", "create"),
         updated: count("ComponentType", "update"),
         removed: count("ComponentType", "delete"),
-        failed: failed("ComponentType")
+        failed: failed2("ComponentType")
       },
       designTokens: {
         created: count("DesignToken", "create"),
         updated: count("DesignToken", "update"),
         removed: count("DesignToken", "delete"),
-        failed: failed("DesignToken")
+        failed: failed2("DesignToken")
       },
       summary: operation.summary,
       failures: items.filter((item) => item.status === "failed").map((item) => ({
@@ -26255,7 +27445,7 @@ function pushFailure(e, deps) {
 
 // packages/experience-design-system-cli/src/tui/import/steps/10-flow/flow/save.ts
 import { writeFile as writeFile7 } from "node:fs/promises";
-import { join as join23 } from "node:path";
+import { join as join22 } from "node:path";
 
 // packages/experience-design-system-cli/src/tui/import/steps/10-flow/support/run-print-files-helpers.ts
 function nextStateAfterPrint(opts) {
@@ -26281,12 +27471,12 @@ var realSaveDeps = () => ({
   writeFile: (path5, contents) => writeFile7(path5, contents),
   appendRun,
   buildSourceFingerprint,
-  sleep: (ms) => new Promise((resolve22) => setTimeout(resolve22, ms)),
+  sleep: (ms) => new Promise((resolve25) => setTimeout(resolve25, ms)),
   warn: (message) => process.stderr.write(message)
 });
 async function runPrintFiles(input, deps, onPatch) {
   onPatch({ step: "printing" });
-  const componentsPath = join23(input.outDir, "components.json");
+  const componentsPath = join22(input.outDir, "components.json");
   try {
     const db = deps.openDb();
     let components = [];
@@ -26367,7 +27557,7 @@ var EMPTY_PUSH_RESULT = {
 };
 
 // packages/experience-design-system-cli/src/tui/import/steps/10-flow/flow/controller.ts
-var WIZARD_LOG = join24(tmpdir(), "experiences-import-wizard.log");
+var WIZARD_LOG = join23(tmpdir(), "experiences-import-wizard.log");
 function appendWizardLog(entry) {
   appendFileSync(WIZARD_LOG, JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), ...entry }) + "\n");
 }
@@ -26657,8 +27847,8 @@ import { Box as Box42, Text as Text44, useInput as useInput9 } from "ink";
 
 // packages/experience-design-system-cli/src/tui/debug-store.ts
 import { mkdir as mkdir9, writeFile as writeFile8 } from "node:fs/promises";
-import { existsSync as existsSync10, readdirSync as readdirSync4 } from "node:fs";
-import { join as join25 } from "node:path";
+import { existsSync as existsSync9, readdirSync as readdirSync4 } from "node:fs";
+import { join as join24 } from "node:path";
 
 // packages/experience-design-system-cli/src/tui/settings/debug-mode/debug-mode-store.ts
 var DEFAULT_DEBUG_MODE_SETTING = {
@@ -26689,7 +27879,7 @@ function slugify(value) {
 function generateSessionId3() {
   const today = datePrefix();
   const root = debugSessionsDir2();
-  const existing = existsSync10(root) ? readdirSync4(root) : [];
+  const existing = existsSync9(root) ? readdirSync4(root) : [];
   const seqPattern = new RegExp(`^${today}-session-(\\d+)$`);
   const maxSeq = existing.reduce((max, entry) => {
     const match2 = seqPattern.exec(entry);
@@ -26699,7 +27889,7 @@ function generateSessionId3() {
 }
 var SESSION_ID = generateSessionId3();
 function sessionDebugDir() {
-  return join25(debugSessionsDir2(), SESSION_ID);
+  return join24(debugSessionsDir2(), SESSION_ID);
 }
 function currentDebugSessionDir() {
   return sessionDebugDir();
@@ -26748,15 +27938,15 @@ async function finishDebugRun({
   const durationMs = Date.now() - run.startedAt;
   const content = renderMarkdown(run, { outputs: redact(outputs), status, exitMethod, durationMs });
   const flowSegments = run.flow.split("/");
-  const dir = join25(sessionDebugDir(), ...flowSegments);
+  const dir = join24(sessionDebugDir(), ...flowSegments);
   await mkdir9(dir, { recursive: true });
   const filename = nextAttemptFilename(dir, run.menuOption);
-  await writeFile8(join25(dir, filename), content, { mode: 384 });
+  await writeFile8(join24(dir, filename), content, { mode: 384 });
 }
 function nextAttemptFilename(dir, menuOption) {
   const today = datePrefix();
   const optionSlug = slugify(menuOption);
-  const existing = existsSync10(dir) ? readdirSync4(dir) : [];
+  const existing = existsSync9(dir) ? readdirSync4(dir) : [];
   const attemptPattern = new RegExp(`^${today}-${optionSlug}-attempt-(\\d+)\\.md$`);
   const maxAttempt = existing.reduce((max, entry) => {
     const match2 = attemptPattern.exec(entry);
@@ -27396,7 +28586,7 @@ function App({ importOptions }) {
     const launch = { projectPath: projectPath2, tokens, filePaths, ...importOptions };
     const state = await inspectTokens({
       rawTokensPath: tokens,
-      outDir: join26(resolveUserPath(projectPath2), ".contentful"),
+      outDir: join25(resolveUserPath(projectPath2), ".contentful"),
       cache: importOptions.cache
     });
     if (state.kind === "cached") {