@contentful/experience-design-system-cli 2.39.1 → 2.40.1-dev-build-08f065f9.0

package/dist/app.js

@@ -73,6 +73,359 @@ var init_version = __esm({
   }
 });
 
+// packages/experience-design-system-types/dist/src/config/index.js
+import { randomBytes } from "node:crypto";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname as dirname2, join as join3 } from "node:path";
+function configRoot() {
+  return process.env["EDS_HOME"] || join3(homedir(), ".contentful", "experience-design-system-cli");
+}
+async function readSettings() {
+  try {
+    return JSON.parse(await readFile(configFilePath(), "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function writeSettings(settings) {
+  const path5 = configFilePath();
+  await mkdir(dirname2(path5), { recursive: true });
+  const tmp = `${path5}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
+  await writeFile(tmp, `${JSON.stringify(settings, null, 2)}
+`, { mode: 384 });
+  await rename(tmp, path5);
+}
+async function updateSettings(patch) {
+  await writeSettings({ ...await readSettings(), ...patch });
+}
+var configFilePath;
+var init_config = __esm({
+  "packages/experience-design-system-types/dist/src/config/index.js"() {
+    "use strict";
+    configFilePath = () => join3(configRoot(), "config.json");
+  }
+});
+
+// packages/experience-design-system-cli/src/tui/settings/debug-mode/debug-mode-store.ts
+function toRetentionDays(value) {
+  return RETENTION_CHOICES.find((choice) => choice === value) ?? DEFAULT_RETENTION_DAYS;
+}
+async function readDebugModeSetting() {
+  const { debugMode } = await readSettings();
+  const saved = debugMode ?? {};
+  return {
+    enabled: typeof saved.enabled === "boolean" ? saved.enabled : true,
+    retentionDays: toRetentionDays(saved.retentionDays)
+  };
+}
+async function writeDebugModeSetting(change) {
+  await updateSettings({ debugMode: { ...await readDebugModeSetting(), ...change } });
+}
+var RETENTION_CHOICES, DEFAULT_RETENTION_DAYS;
+var init_debug_mode_store = __esm({
+  "packages/experience-design-system-cli/src/tui/settings/debug-mode/debug-mode-store.ts"() {
+    "use strict";
+    init_config();
+    RETENTION_CHOICES = [7, 14, 30];
+    DEFAULT_RETENTION_DAYS = 30;
+  }
+});
+
+// packages/experience-design-system-cli/src/tui/debug-prune.ts
+import { readdir, rm, rmdir, stat } from "node:fs/promises";
+import { dirname as dirname3, join as join4 } from "node:path";
+async function logFilesIn(dir) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const nested = await Promise.all(
+    entries.map(async (entry) => {
+      const path5 = join4(dir, entry.name);
+      if (entry.isDirectory()) return logFilesIn(path5);
+      return entry.isFile() && entry.name.endsWith(".md") ? [path5] : [];
+    })
+  );
+  return nested.flat();
+}
+async function removeEmptyFolders(from, stop) {
+  let dir = from;
+  let removed = 0;
+  for (; ; ) {
+    try {
+      await rmdir(dir);
+    } catch {
+      return removed;
+    }
+    removed += 1;
+    if (dir === stop) return removed;
+    dir = dirname3(dir);
+  }
+}
+async function pruneExpiredLogs(base, retentionDays, now = Date.now()) {
+  const cutoff = now - retentionDays * DAY_MS;
+  const contentfulDir = join4(base, ".contentful");
+  const result = { logs: 0, folders: 0 };
+  try {
+    const sessions = (await readdir(contentfulDir)).filter((name) => SESSION_FOLDER.test(name));
+    for (const session of sessions) {
+      const files = await logFilesIn(join4(contentfulDir, session, "debug")).catch(() => []);
+      for (const file of files) {
+        try {
+          if ((await stat(file)).mtimeMs >= cutoff) continue;
+          await rm(file);
+          result.logs += 1;
+          result.folders += await removeEmptyFolders(dirname3(file), join4(contentfulDir, session));
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return result;
+}
+var DAY_MS, SESSION_FOLDER;
+var init_debug_prune = __esm({
+  "packages/experience-design-system-cli/src/tui/debug-prune.ts"() {
+    "use strict";
+    DAY_MS = 24 * 60 * 60 * 1e3;
+    SESSION_FOLDER = /^\d{2}-\d{2}-\d{4}-session-\d+$/;
+  }
+});
+
+// packages/experience-design-system-cli/src/tui/debug-store.ts
+var debug_store_exports = {};
+__export(debug_store_exports, {
+  currentDebugSessionDir: () => currentDebugSessionDir,
+  currentSessionDir: () => currentSessionDir,
+  finishDebugRun: () => finishDebugRun,
+  startDebugRun: () => startDebugRun,
+  startDebugSessionIn: () => startDebugSessionIn,
+  startImportRun: () => startImportRun
+});
+import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
+import { existsSync as existsSync2, readdirSync } from "node:fs";
+import { join as join5, resolve } from "node:path";
+function generateRunId() {
+  const now = /* @__PURE__ */ new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+}
+function datePrefix(now = /* @__PURE__ */ new Date()) {
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${pad(now.getMonth() + 1)}-${pad(now.getDate())}-${now.getFullYear()}`;
+}
+function slugify(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+async function readBaseDir() {
+  try {
+    const dir = (await readSettings())["contentfulBaseDir"];
+    return typeof dir === "string" && dir !== "" ? resolve(dir) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function nextSessionId(contentfulDir) {
+  const today = datePrefix();
+  const existing = existsSync2(contentfulDir) ? readdirSync(contentfulDir) : [];
+  const seqPattern = new RegExp(`^${today}-session-(\\d+)$`);
+  const maxSeq = existing.reduce((max, entry) => {
+    const match2 = seqPattern.exec(entry);
+    return match2 ? Math.max(max, Number(match2[1])) : max;
+  }, 0);
+  return `${today}-session-${maxSeq + 1}`;
+}
+function startSession(base, { replace }) {
+  const contentfulDir = join5(base, ".contentful");
+  if (replace || !sessionDir) sessionDir = join5(contentfulDir, nextSessionId(contentfulDir));
+  return sessionDir;
+}
+function currentDebugSessionDir() {
+  return sessionDir && join5(sessionDir, "debug");
+}
+function currentSessionDir() {
+  return sessionDir;
+}
+async function startDebugSessionIn(base, { replace = false } = {}) {
+  try {
+    if (!await isDebugModeEnabled()) return;
+    await mkdir2(join5(startSession(resolve(base), { replace }), "debug"), { recursive: true });
+    await writeWaitingLogs();
+  } catch {
+  }
+}
+function nextImportRunDir(session) {
+  const existing = existsSync2(session) ? readdirSync(session) : [];
+  const maxRun = existing.reduce((max, entry) => {
+    const match2 = /^dsi-import-(\d+)$/.exec(entry);
+    return match2 ? Math.max(max, Number(match2[1])) : max;
+  }, 0);
+  return join5(session, `dsi-import-${maxRun + 1}`);
+}
+async function startImportRun(projectPath) {
+  await startDebugSessionIn(projectPath);
+  if (!sessionDir) return join5(resolve(projectPath), ".contentful");
+  const dir = nextImportRunDir(sessionDir);
+  await mkdir2(dir, { recursive: true });
+  return dir;
+}
+async function isDebugModeEnabled() {
+  try {
+    return (await readDebugModeSetting()).enabled;
+  } catch {
+    return true;
+  }
+}
+function redact(value) {
+  const clone = { ...value };
+  if ("cma_token" in clone) {
+    const raw = clone.cma_token;
+    clone.cma_token = typeof raw === "string" && raw.length > 0 ? `[present, ${raw.length} chars]` : "[not set]";
+  }
+  return clone;
+}
+function startDebugRun({
+  flow,
+  step,
+  menuOption,
+  inputs
+}) {
+  const runId = generateRunId();
+  const startedAt = Date.now();
+  const redactedInputs = redact(inputs);
+  isDebugModeEnabled().then((enabled) => {
+    if (!enabled) return;
+    pendingRun = { flow, step, runId, menuOption, inputs: redactedInputs, startedAt };
+  });
+}
+async function finishDebugRun({
+  outputs,
+  status,
+  exitMethod
+}) {
+  const run = pendingRun;
+  if (!run) return;
+  pendingRun = void 0;
+  const durationMs = Date.now() - run.startedAt;
+  const log = {
+    flow: run.flow,
+    menuOption: run.menuOption,
+    content: renderMarkdown(run, { outputs: redact(outputs), status, exitMethod, durationMs })
+  };
+  const root = currentDebugSessionDir();
+  if (!root) {
+    if (waiting.length < WAITING_LIMIT) waiting.push(log);
+    return;
+  }
+  await writeLog(root, log);
+}
+async function writeLog(root, log) {
+  const dir = join5(root, ...log.flow.split("/"));
+  await mkdir2(dir, { recursive: true });
+  const filename = nextAttemptFilename(dir, log.menuOption);
+  await writeFile2(join5(dir, filename), log.content, { mode: 384 });
+}
+async function writeWaitingLogs() {
+  const root = currentDebugSessionDir();
+  if (!root) return;
+  for (const log of waiting.splice(0)) {
+    try {
+      await writeLog(root, log);
+    } catch {
+    }
+  }
+}
+function nextAttemptFilename(dir, menuOption) {
+  const today = datePrefix();
+  const optionSlug = slugify(menuOption);
+  const existing = existsSync2(dir) ? readdirSync(dir) : [];
+  const attemptPattern = new RegExp(`^${today}-${optionSlug}-attempt-(\\d+)\\.md$`);
+  const maxAttempt = existing.reduce((max, entry) => {
+    const match2 = attemptPattern.exec(entry);
+    return match2 ? Math.max(max, Number(match2[1])) : max;
+  }, 0);
+  return `${today}-${optionSlug}-attempt-${maxAttempt + 1}.md`;
+}
+function renderMarkdown(run, finish) {
+  const stepMatch = /^(\d+)-(.+)$/.exec(run.step);
+  const stepLabel = stepMatch ? `${stepMatch[1]} - ${stepMatch[2]}` : run.step;
+  const flowSlug = run.flow.split("/").join("-");
+  return `# Debug Log
+
+- Run ID: ${run.runId}
+- Flow: ${flowSlug}
+- Step: ${stepLabel}
+- Menu option: ${run.menuOption}
+- Date: ${(/* @__PURE__ */ new Date()).toISOString()}
+- CLI version: ${readPackageVersion()}
+- Platform: ${process.platform} / Node ${process.version}
+- Duration on screen: ${finish.durationMs}ms
+- Status: ${finish.status}
+- Exit method: ${finish.exitMethod}
+
+## Inputs
+\`\`\`json
+${JSON.stringify(run.inputs, null, 2)}
+\`\`\`
+
+## Outputs
+\`\`\`json
+${JSON.stringify(finish.outputs, null, 2)}
+\`\`\`
+`;
+}
+function handleCrash() {
+  return finishDebugRun({ outputs: {}, status: "error", exitMethod: "crashed" });
+}
+var pendingRun, sessionDir, WAITING_LIMIT, waiting;
+var init_debug_store = __esm({
+  "packages/experience-design-system-cli/src/tui/debug-store.ts"() {
+    "use strict";
+    init_config();
+    init_version();
+    init_debug_mode_store();
+    init_debug_prune();
+    void Promise.all([isDebugModeEnabled(), readBaseDir()]).then(async ([enabled, base]) => {
+      if (!base) return;
+      const retention = await readDebugModeSetting().catch(() => void 0);
+      const pruned = retention ? await pruneExpiredLogs(base, retention.retentionDays).catch(() => void 0) : void 0;
+      if (!enabled) return;
+      const debugDir = join5(startSession(base, { replace: false }), "debug");
+      await mkdir2(debugDir, { recursive: true });
+      await writeWaitingLogs();
+      if (retention && pruned && pruned.logs + pruned.folders > 0) {
+        await writeFile2(
+          join5(debugDir, `${datePrefix()}-cleanup-${generateRunId()}.md`),
+          `# Debug Log Cleanup
+
+- Date: ${(/* @__PURE__ */ new Date()).toISOString()}
+- Retention: ${retention.retentionDays} days
+- Logs deleted: ${pruned.logs}
+- Empty folders removed: ${pruned.folders}
+`,
+          { mode: 384 }
+        );
+      }
+    });
+    WAITING_LIMIT = 50;
+    waiting = [];
+    process.once("uncaughtException", (err) => {
+      void handleCrash().finally(() => {
+        throw err;
+      });
+    });
+    process.once("unhandledRejection", (reason) => {
+      void handleCrash().finally(() => {
+        throw reason;
+      });
+    });
+    process.once("SIGINT", () => {
+      void handleCrash().finally(() => {
+        process.exit(130);
+      });
+    });
+  }
+});
+
 // packages/experience-design-system-backend-pipeline/dist/src/agents/types/agent-name.js
 var AGENT_NAMES;
 var init_agent_name = __esm({
@@ -477,14 +830,14 @@ var init_parse_prompt_overrides = __esm({
 });
 
 // packages/experience-design-system-backend-pipeline/dist/src/agents/helpers/prompt-overrides/resolve-prompt-override.js
-import { readFile } from "node:fs/promises";
-import { resolve as resolve2 } from "node:path";
+import { readFile as readFile2 } from "node:fs/promises";
+import { resolve as resolve3 } from "node:path";
 async function resolvePromptOverride(override) {
   if (override.kind === "text")
     return override.value;
-  const abs = resolve2(override.value);
+  const abs = resolve3(override.value);
   try {
-    return await readFile(abs, "utf8");
+    return await readFile2(abs, "utf8");
   } catch {
     throw new Error(`--prompt: could not read prompt file: ${abs}`);
   }
@@ -1772,22 +2125,22 @@ var init_skill_files = __esm({
 });
 
 // packages/experience-design-system-backend-pipeline/dist/src/agents/prompts/resolve-skill-path.js
-import { existsSync as existsSync2 } from "node:fs";
-import { dirname as dirname3, join as join4, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync3 } from "node:fs";
+import { dirname as dirname5, join as join7, resolve as resolve4 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function resolveSkillPath(skill) {
   if (!(skill in SKILL_FILES))
     throw new Error(`Invalid skill: ${skill}`);
-  const thisDir = dirname3(fileURLToPath2(import.meta.url));
+  const thisDir = dirname5(fileURLToPath2(import.meta.url));
   let dir = thisDir;
   for (; ; ) {
-    const candidate = join4(dir, "skills");
-    if (existsSync2(candidate)) {
+    const candidate = join7(dir, "skills");
+    if (existsSync3(candidate)) {
       const file = SKILL_FILES[skill];
       const stepDir = file === "select-components.md" ? "selection" : "generation";
-      return join4(candidate, stepDir, file);
+      return join7(candidate, stepDir, file);
     }
-    const parent = resolve3(dir, "..");
+    const parent = resolve4(dir, "..");
     if (parent === dir) {
       throw new Error(`skill file missing from package (could not locate skills/ directory from: ${thisDir})`);
     }
@@ -1802,20 +2155,20 @@ var init_resolve_skill_path = __esm({
 });
 
 // packages/experience-design-system-backend-pipeline/dist/src/agents/prompts/helpers/read-skill-file.js
-import { readFile as readFile2 } from "node:fs/promises";
-import { resolve as resolve4 } from "node:path";
+import { readFile as readFile3 } from "node:fs/promises";
+import { resolve as resolve5 } from "node:path";
 async function readSkillFile(skill, override) {
   if (override) {
-    const skillPath2 = resolve4(override);
+    const skillPath2 = resolve5(override);
     try {
-      return await readFile2(skillPath2, "utf8");
+      return await readFile3(skillPath2, "utf8");
     } catch {
       throw new Error(`custom prompt file not found (skill: ${skill}, path: ${skillPath2})`);
     }
   }
   const skillPath = resolveSkillPath(skill);
   try {
-    return await readFile2(skillPath, "utf8");
+    return await readFile3(skillPath, "utf8");
   } catch {
     throw new Error(`skill file missing from package (expected at: ${skillPath})`);
   }
@@ -2109,359 +2462,29 @@ __export(cache_keys_exports, {
   hashPromptForSkill: () => hashPromptForSkill
 });
 import { createHash as createHash4 } from "node:crypto";
-import { readFile as readFile3 } from "node:fs/promises";
-import { resolve as resolve5 } from "node:path";
+import { readFile as readFile4 } from "node:fs/promises";
+import { resolve as resolve6 } from "node:path";
 function hashContent(content) {
   return createHash4("sha256").update(content).digest("hex");
 }
 async function hashFile(filePath) {
-  const content = await readFile3(filePath, "utf8");
+  const content = await readFile4(filePath, "utf8");
   return hashContent(content);
 }
 async function hashPromptForSkill(skill, agent, model, skillPathOverride, extraInputs = [], skillContentOverride) {
-  const promptHash = skillContentOverride ? hashContent(skillContentOverride) : skillPathOverride ? await hashFile(resolve5(skillPathOverride)) : await hashFile(resolveSkillPath(skill));
+  const promptHash = skillContentOverride ? hashContent(skillContentOverride) : skillPathOverride ? await hashFile(resolve6(skillPathOverride)) : await hashFile(resolveSkillPath(skill));
   const extraSegment = extraInputs.length > 0 ? `|${extraInputs.join("|")}` : "";
   return hashContent(`${promptHash}|${agent}|${model ?? ""}${extraSegment}`);
 }
 var init_cache_keys = __esm({
   "packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/helpers/cache-keys.js"() {
     "use strict";
-    init_agents();
-  }
-});
-
-// packages/experience-design-system-types/dist/src/config/index.js
-import { randomBytes as randomBytes4 } from "node:crypto";
-import { mkdir as mkdir6, readFile as readFile20, rename as rename2, writeFile as writeFile6 } from "node:fs/promises";
-import { homedir as homedir3 } from "node:os";
-import { dirname as dirname14, join as join16 } from "node:path";
-function configRoot2() {
-  return process.env["EDS_HOME"] || join16(homedir3(), ".contentful", "experience-design-system-cli");
-}
-async function readSettings2() {
-  try {
-    return JSON.parse(await readFile20(configFilePath2(), "utf8"));
-  } catch {
-    return {};
-  }
-}
-async function writeSettings2(settings) {
-  const path5 = configFilePath2();
-  await mkdir6(dirname14(path5), { recursive: true });
-  const tmp = `${path5}.${process.pid}.${randomBytes4(4).toString("hex")}.tmp`;
-  await writeFile6(tmp, `${JSON.stringify(settings, null, 2)}
-`, { mode: 384 });
-  await rename2(tmp, path5);
-}
-async function updateSettings2(patch) {
-  await writeSettings2({ ...await readSettings2(), ...patch });
-}
-var configFilePath2;
-var init_config = __esm({
-  "packages/experience-design-system-types/dist/src/config/index.js"() {
-    "use strict";
-    configFilePath2 = () => join16(configRoot2(), "config.json");
-  }
-});
-
-// packages/experience-design-system-cli/src/tui/settings/debug-mode/debug-mode-store.ts
-function toRetentionDays(value) {
-  return RETENTION_CHOICES.find((choice) => choice === value) ?? DEFAULT_RETENTION_DAYS;
-}
-async function readDebugModeSetting() {
-  const { debugMode } = await readSettings2();
-  const saved = debugMode ?? {};
-  return {
-    enabled: typeof saved.enabled === "boolean" ? saved.enabled : true,
-    retentionDays: toRetentionDays(saved.retentionDays)
-  };
-}
-async function writeDebugModeSetting(change) {
-  await updateSettings2({ debugMode: { ...await readDebugModeSetting(), ...change } });
-}
-var RETENTION_CHOICES, DEFAULT_RETENTION_DAYS;
-var init_debug_mode_store = __esm({
-  "packages/experience-design-system-cli/src/tui/settings/debug-mode/debug-mode-store.ts"() {
-    "use strict";
-    init_config();
-    RETENTION_CHOICES = [7, 14, 30];
-    DEFAULT_RETENTION_DAYS = 30;
-  }
-});
-
-// packages/experience-design-system-cli/src/tui/debug-prune.ts
-import { readdir as readdir2, rm, rmdir, stat as stat4 } from "node:fs/promises";
-import { dirname as dirname17, join as join23 } from "node:path";
-async function logFilesIn(dir) {
-  const entries = await readdir2(dir, { withFileTypes: true });
-  const nested = await Promise.all(
-    entries.map(async (entry) => {
-      const path5 = join23(dir, entry.name);
-      if (entry.isDirectory()) return logFilesIn(path5);
-      return entry.isFile() && entry.name.endsWith(".md") ? [path5] : [];
-    })
-  );
-  return nested.flat();
-}
-async function removeEmptyFolders(from, stop) {
-  let dir = from;
-  let removed = 0;
-  for (; ; ) {
-    try {
-      await rmdir(dir);
-    } catch {
-      return removed;
-    }
-    removed += 1;
-    if (dir === stop) return removed;
-    dir = dirname17(dir);
-  }
-}
-async function pruneExpiredLogs(base, retentionDays, now = Date.now()) {
-  const cutoff = now - retentionDays * DAY_MS;
-  const contentfulDir = join23(base, ".contentful");
-  const result = { logs: 0, folders: 0 };
-  try {
-    const sessions = (await readdir2(contentfulDir)).filter((name) => SESSION_FOLDER.test(name));
-    for (const session of sessions) {
-      const files = await logFilesIn(join23(contentfulDir, session, "debug")).catch(() => []);
-      for (const file of files) {
-        try {
-          if ((await stat4(file)).mtimeMs >= cutoff) continue;
-          await rm(file);
-          result.logs += 1;
-          result.folders += await removeEmptyFolders(dirname17(file), join23(contentfulDir, session));
-        } catch {
-        }
-      }
-    }
-  } catch {
-  }
-  return result;
-}
-var DAY_MS, SESSION_FOLDER;
-var init_debug_prune = __esm({
-  "packages/experience-design-system-cli/src/tui/debug-prune.ts"() {
-    "use strict";
-    DAY_MS = 24 * 60 * 60 * 1e3;
-    SESSION_FOLDER = /^\d{2}-\d{2}-\d{4}-session-\d+$/;
-  }
-});
-
-// packages/experience-design-system-cli/src/tui/debug-store.ts
-var debug_store_exports = {};
-__export(debug_store_exports, {
-  currentDebugSessionDir: () => currentDebugSessionDir,
-  currentSessionDir: () => currentSessionDir,
-  finishDebugRun: () => finishDebugRun,
-  startDebugRun: () => startDebugRun,
-  startDebugSessionIn: () => startDebugSessionIn,
-  startImportRun: () => startImportRun
-});
-import { mkdir as mkdir9, writeFile as writeFile8 } from "node:fs/promises";
-import { existsSync as existsSync9, readdirSync as readdirSync4 } from "node:fs";
-import { join as join24, resolve as resolve27 } from "node:path";
-function generateRunId() {
-  const now = /* @__PURE__ */ new Date();
-  const pad = (n) => String(n).padStart(2, "0");
-  return `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
-}
-function datePrefix(now = /* @__PURE__ */ new Date()) {
-  const pad = (n) => String(n).padStart(2, "0");
-  return `${pad(now.getMonth() + 1)}-${pad(now.getDate())}-${now.getFullYear()}`;
-}
-function slugify(value) {
-  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-}
-async function readBaseDir() {
-  try {
-    const dir = (await readSettings2())["contentfulBaseDir"];
-    return typeof dir === "string" && dir !== "" ? resolve27(dir) : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function nextSessionId(contentfulDir) {
-  const today = datePrefix();
-  const existing = existsSync9(contentfulDir) ? readdirSync4(contentfulDir) : [];
-  const seqPattern = new RegExp(`^${today}-session-(\\d+)$`);
-  const maxSeq = existing.reduce((max, entry) => {
-    const match2 = seqPattern.exec(entry);
-    return match2 ? Math.max(max, Number(match2[1])) : max;
-  }, 0);
-  return `${today}-session-${maxSeq + 1}`;
-}
-function startSession(base, { replace }) {
-  const contentfulDir = join24(base, ".contentful");
-  if (replace || !sessionDir) sessionDir = join24(contentfulDir, nextSessionId(contentfulDir));
-  return sessionDir;
-}
-function currentDebugSessionDir() {
-  return sessionDir && join24(sessionDir, "debug");
-}
-function currentSessionDir() {
-  return sessionDir;
-}
-async function startDebugSessionIn(base, { replace = false } = {}) {
-  try {
-    if (!await isDebugModeEnabled()) return;
-    await mkdir9(join24(startSession(resolve27(base), { replace }), "debug"), { recursive: true });
-  } catch {
-  }
-}
-function nextImportRunDir(session) {
-  const existing = existsSync9(session) ? readdirSync4(session) : [];
-  const maxRun = existing.reduce((max, entry) => {
-    const match2 = /^dsi-import-(\d+)$/.exec(entry);
-    return match2 ? Math.max(max, Number(match2[1])) : max;
-  }, 0);
-  return join24(session, `dsi-import-${maxRun + 1}`);
-}
-async function startImportRun(projectPath) {
-  await startDebugSessionIn(projectPath);
-  if (!sessionDir) return join24(resolve27(projectPath), ".contentful");
-  const dir = nextImportRunDir(sessionDir);
-  await mkdir9(dir, { recursive: true });
-  return dir;
-}
-async function isDebugModeEnabled() {
-  try {
-    return (await readDebugModeSetting()).enabled;
-  } catch {
-    return true;
-  }
-}
-function redact(value) {
-  const clone = { ...value };
-  if ("cma_token" in clone) {
-    const raw = clone.cma_token;
-    clone.cma_token = typeof raw === "string" && raw.length > 0 ? `[present, ${raw.length} chars]` : "[not set]";
-  }
-  return clone;
-}
-function startDebugRun({
-  flow,
-  step,
-  menuOption,
-  inputs
-}) {
-  const runId = generateRunId();
-  const startedAt = Date.now();
-  const redactedInputs = redact(inputs);
-  isDebugModeEnabled().then((enabled) => {
-    if (!enabled) return;
-    pendingRun = { flow, step, runId, menuOption, inputs: redactedInputs, startedAt };
-  });
-}
-async function finishDebugRun({
-  outputs,
-  status,
-  exitMethod
-}) {
-  const run = pendingRun;
-  if (!run) return;
-  pendingRun = void 0;
-  const durationMs = Date.now() - run.startedAt;
-  const content = renderMarkdown(run, { outputs: redact(outputs), status, exitMethod, durationMs });
-  const root = currentDebugSessionDir();
-  if (!root) return;
-  const flowSegments = run.flow.split("/");
-  const dir = join24(root, ...flowSegments);
-  await mkdir9(dir, { recursive: true });
-  const filename = nextAttemptFilename(dir, run.menuOption);
-  await writeFile8(join24(dir, filename), content, { mode: 384 });
-}
-function nextAttemptFilename(dir, menuOption) {
-  const today = datePrefix();
-  const optionSlug = slugify(menuOption);
-  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);
-    return match2 ? Math.max(max, Number(match2[1])) : max;
-  }, 0);
-  return `${today}-${optionSlug}-attempt-${maxAttempt + 1}.md`;
-}
-function renderMarkdown(run, finish) {
-  const stepMatch = /^(\d+)-(.+)$/.exec(run.step);
-  const stepLabel = stepMatch ? `${stepMatch[1]} - ${stepMatch[2]}` : run.step;
-  const flowSlug = run.flow.split("/").join("-");
-  return `# Debug Log
-
-- Run ID: ${run.runId}
-- Flow: ${flowSlug}
-- Step: ${stepLabel}
-- Menu option: ${run.menuOption}
-- Date: ${(/* @__PURE__ */ new Date()).toISOString()}
-- CLI version: ${readPackageVersion()}
-- Platform: ${process.platform} / Node ${process.version}
-- Duration on screen: ${finish.durationMs}ms
-- Status: ${finish.status}
-- Exit method: ${finish.exitMethod}
-
-## Inputs
-\`\`\`json
-${JSON.stringify(run.inputs, null, 2)}
-\`\`\`
-
-## Outputs
-\`\`\`json
-${JSON.stringify(finish.outputs, null, 2)}
-\`\`\`
-`;
-}
-function handleCrash() {
-  return finishDebugRun({ outputs: {}, status: "error", exitMethod: "crashed" });
-}
-var pendingRun, sessionDir;
-var init_debug_store = __esm({
-  "packages/experience-design-system-cli/src/tui/debug-store.ts"() {
-    "use strict";
-    init_config();
-    init_version();
-    init_debug_mode_store();
-    init_debug_prune();
-    void Promise.all([isDebugModeEnabled(), readBaseDir()]).then(async ([enabled, base]) => {
-      if (!base) return;
-      const retention = await readDebugModeSetting().catch(() => void 0);
-      const pruned = retention ? await pruneExpiredLogs(base, retention.retentionDays).catch(() => void 0) : void 0;
-      if (!enabled) return;
-      const debugDir = join24(startSession(base, { replace: false }), "debug");
-      await mkdir9(debugDir, { recursive: true });
-      if (retention && pruned && pruned.logs + pruned.folders > 0) {
-        await writeFile8(
-          join24(debugDir, `${datePrefix()}-cleanup-${generateRunId()}.md`),
-          `# Debug Log Cleanup
-
-- Date: ${(/* @__PURE__ */ new Date()).toISOString()}
-- Retention: ${retention.retentionDays} days
-- Logs deleted: ${pruned.logs}
-- Empty folders removed: ${pruned.folders}
-`,
-          { mode: 384 }
-        );
-      }
-    });
-    process.once("uncaughtException", (err) => {
-      void handleCrash().finally(() => {
-        throw err;
-      });
-    });
-    process.once("unhandledRejection", (reason) => {
-      void handleCrash().finally(() => {
-        throw reason;
-      });
-    });
-    process.once("SIGINT", () => {
-      void handleCrash().finally(() => {
-        process.exit(130);
-      });
-    });
+    init_agents();
   }
 });
 
 // packages/experience-design-system-cli/app.tsx
-import { useEffect as useEffect28, useState as useState39 } from "react";
+import { useEffect as useEffect30, useState as useState39 } from "react";
 
 // packages/experience-design-system-cli/src/tui/home/home.tsx
 import { useEffect as useEffect2, useState as useState2 } from "react";
@@ -2669,8 +2692,9 @@ function ImportScreen({ exitCode, onDone }) {
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/00-preflight/screen.tsx
-import { useState as useState4 } from "react";
+import { useEffect as useEffect4, useRef, useState as useState4 } from "react";
 import { Box as Box9, Text as Text9 } from "ink";
+init_debug_store();
 
 // packages/experience-design-system-cli/src/tui/import/steps/00-preflight/controls.ts
 import { useInput as useInput3 } from "ink";
@@ -3087,9 +3111,35 @@ function RunningStep({
 
 // packages/experience-design-system-cli/src/tui/import/steps/00-preflight/screen.tsx
 import { jsx as jsx9, jsxs as jsxs9 } from "react/jsx-runtime";
+var optionAt = (index) => IMPORT_TARGET_OPTIONS[index].target;
 function PreflightScreen({ onChoose, onQuit }) {
   const [focus, setFocus] = useState4(0);
-  usePreflightControls({ focus, onFocus: setFocus, onChoose, onQuit });
+  const viewed = useRef([optionAt(0)]).current;
+  useEffect4(() => {
+    startDebugRun({
+      flow: "import/preflight",
+      step: "00-preflight",
+      menuOption: "Preflight",
+      inputs: { options: IMPORT_TARGET_OPTIONS.map((option) => option.target), initial_focus: optionAt(0) }
+    });
+  }, []);
+  const moveTo = (next) => {
+    setFocus(next);
+    if (viewed[viewed.length - 1] !== optionAt(next)) viewed.push(optionAt(next));
+  };
+  const choose = (target) => {
+    void finishDebugRun({
+      outputs: { chosen: target, viewed, steps_that_will_run: overviewFor(target).map((step) => step.description) },
+      status: "success",
+      exitMethod: "saved"
+    });
+    onChoose(target);
+  };
+  const quit = () => {
+    void finishDebugRun({ outputs: { chosen: null, viewed }, status: "success", exitMethod: "discarded" });
+    onQuit();
+  };
+  usePreflightControls({ focus, onFocus: moveTo, onChoose: choose, onQuit: quit });
   return /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", children: [
     /* @__PURE__ */ jsx9(StepHeader, { step: "setup" }),
     /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", gap: 1, paddingX: 2, paddingBottom: 1, children: [
@@ -3101,18 +3151,19 @@ function PreflightScreen({ onChoose, onQuit }) {
           /* @__PURE__ */ jsx9(Text9, { bold: focused, color: focused ? PALETTE.accent : void 0, children: option.label })
         ] }, option.target);
       }) }),
-      /* @__PURE__ */ jsx9(OverviewBox, { steps: overviewFor(IMPORT_TARGET_OPTIONS[focus].target) }),
+      /* @__PURE__ */ jsx9(OverviewBox, { steps: overviewFor(optionAt(focus)) }),
       /* @__PURE__ */ jsx9(ControlHints, { hints: PREFLIGHT_CONTROLS })
     ] })
   ] });
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/01-welcome/screen.tsx
-import { useState as useState5 } from "react";
+import { useEffect as useEffect5, useRef as useRef3, useState as useState5 } from "react";
 import { Box as Box10, Text as Text10 } from "ink";
+init_debug_store();
 
 // packages/experience-design-system-cli/src/tui/shared/components/ClearableTextInput.tsx
-import { useRef } from "react";
+import { useRef as useRef2 } from "react";
 import { useInput as useInput6 } from "ink";
 import TextInput from "ink-text-input";
 import { jsx as jsx10 } from "react/jsx-runtime";
@@ -3120,7 +3171,7 @@ function isClearKey(input, key) {
   return key.ctrl && input === "d";
 }
 function ClearableTextInput({ onChange, ...props }) {
-  const justCleared = useRef(false);
+  const justCleared = useRef2(false);
   useInput6((input, key) => {
     if (!isClearKey(input, key)) return;
     justCleared.current = true;
@@ -3166,12 +3217,46 @@ function useWelcomeControls(onQuit) {
 
 // packages/experience-design-system-cli/src/tui/import/steps/01-welcome/screen.tsx
 import { jsx as jsx11, jsxs as jsxs10 } from "react/jsx-runtime";
-function WelcomeScreen({ onContinue, onQuit, initialPath = "" }) {
+function WelcomeScreen({ mode, onContinue, onQuit, initialPath = "" }) {
   const [projectPath, setProjectPath] = useState5(initialPath);
-  useWelcomeControls(onQuit);
+  const visit = useRef3({ emptySubmits: 0 }).current;
+  useEffect5(() => {
+    startDebugRun({
+      flow: "import/welcome",
+      step: "01-welcome",
+      menuOption: "Welcome",
+      inputs: { import_mode: mode, initial_path: initialPath }
+    });
+  }, []);
+  const quit = () => {
+    void finishDebugRun({
+      outputs: {
+        project_path: null,
+        typed_something: toProjectPath(projectPath) !== null,
+        empty_submits: visit.emptySubmits
+      },
+      status: "success",
+      exitMethod: "discarded"
+    });
+    onQuit();
+  };
+  useWelcomeControls(quit);
   const submit = (value) => {
     const path5 = toProjectPath(value);
-    if (path5) onContinue(path5);
+    if (!path5) {
+      visit.emptySubmits += 1;
+      return;
+    }
+    void finishDebugRun({
+      outputs: {
+        project_path: path5,
+        changed_from_initial: path5 !== initialPath.trim(),
+        empty_submits: visit.emptySubmits
+      },
+      status: "success",
+      exitMethod: "saved"
+    });
+    onContinue(path5);
   };
   return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", children: [
     /* @__PURE__ */ jsx11(StepHeader, { step: "setup" }),
@@ -3221,17 +3306,17 @@ function useTokenInputControls(onBack) {
 import { statSync } from "node:fs";
 
 // packages/experience-design-system-cli/src/tui/import/resolve-user-path.ts
-import { homedir } from "node:os";
-import { resolve } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { resolve as resolve2 } from "node:path";
 function stripQuotes(value) {
   const quoted = value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'");
   return value.length >= 2 && quoted ? value.slice(1, -1) : value;
 }
 function expandHome(value) {
-  return value === "~" || value.startsWith("~/") || value.startsWith("~\\") ? homedir() + value.slice(1) : value;
+  return value === "~" || value.startsWith("~/") || value.startsWith("~\\") ? homedir2() + value.slice(1) : value;
 }
 function resolveUserPath(raw) {
-  return resolve(expandHome(stripQuotes(raw.trim())));
+  return resolve2(expandHome(stripQuotes(raw.trim())));
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/02-token-input/validate-path.ts
@@ -3304,7 +3389,7 @@ function TokenInputScreen({ onConfirm, onBack, initialPath = "" }) {
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/03-path-validation/screen.tsx
-import { useEffect as useEffect4, useMemo, useState as useState7 } from "react";
+import { useEffect as useEffect6, useMemo, useState as useState7 } from "react";
 import { Box as Box12, Text as Text12 } from "ink";
 
 // packages/experience-design-system-cli/src/tui/import/steps/03-path-validation/controls.ts
@@ -3408,19 +3493,19 @@ 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 { readFile as readFile5 } 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";
-import { dirname as dirname2, join as join3 } from "node:path";
-function configRoot() {
-  return process.env["EDS_HOME"] || join3(homedir2(), ".contentful", "experience-design-system-cli");
+import { homedir as homedir3 } from "node:os";
+import { dirname as dirname4, join as join6 } from "node:path";
+function configRoot2() {
+  return process.env["EDS_HOME"] || join6(homedir3(), ".contentful", "experience-design-system-cli");
 }
-var runsFilePath = () => join3(configRoot(), "state", "runs.json");
+var runsFilePath = () => join6(configRoot2(), "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";
+import { dirname as dirname6, resolve as resolve7 } from "node:path";
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/helpers/source-excerpt.js
 var ELLIPSIS_MARKER = "/* \u2026 */";
@@ -3596,7 +3681,7 @@ function updateStepStatus(db, stepId, status, outputs, error, timestamp) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/helpers/session-id.js
-import { randomBytes } from "node:crypto";
+import { randomBytes as randomBytes2 } from "node:crypto";
 var ADJECTIVES = [
   "aged",
   "amber",
@@ -3802,7 +3887,7 @@ var NOUNS = [
   "wind"
 ];
 function generateSessionId() {
-  const buf = randomBytes(4);
+  const buf = randomBytes2(4);
   const adjIdx = buf[0] % ADJECTIVES.length;
   const nounIdx = buf[1] % NOUNS.length;
   const hex = ((buf[2] << 8 | buf[3]) & 65535).toString(16).padStart(4, "0");
@@ -4191,13 +4276,13 @@ CREATE INDEX IF NOT EXISTS idx_scanned_files_session    ON scanned_files(session
 `;
 function getPipelineDbPath() {
   if (process.env.EDS_PIPELINE_DB_PATH) {
-    return resolve6(process.env.EDS_PIPELINE_DB_PATH);
+    return resolve7(process.env.EDS_PIPELINE_DB_PATH);
   }
-  return resolve6(configRoot(), "pipeline.db");
+  return resolve7(configRoot2(), "pipeline.db");
 }
 function openPipelineDb(dbPath) {
   const path5 = dbPath ?? getPipelineDbPath();
-  mkdirSync(dirname4(path5), { recursive: true });
+  mkdirSync(dirname6(path5), { recursive: true });
   try {
     const db = new DatabaseSync(path5);
     db.exec("PRAGMA busy_timeout = 5000");
@@ -4862,16 +4947,16 @@ function extractRelativeImportPaths(sourceText) {
   return [...specifiers];
 }
 async function resolveRelativeImport(specifier, fromDir) {
-  const basePath = resolve6(fromDir, specifier);
+  const basePath = resolve7(fromDir, specifier);
   const candidates = [
     basePath,
     ...rewrittenSourcePaths(basePath),
     ...SIBLING_FILE_EXTENSIONS.map((ext) => `${basePath}${ext}`),
-    ...SIBLING_FILE_EXTENSIONS.map((ext) => resolve6(basePath, `index${ext}`))
+    ...SIBLING_FILE_EXTENSIONS.map((ext) => resolve7(basePath, `index${ext}`))
   ];
   for (const candidate of candidates) {
     try {
-      await readFile4(candidate, "utf8");
+      await readFile5(candidate, "utf8");
       return candidate;
     } catch {
     }
@@ -4888,9 +4973,9 @@ async function resolveImportSpecifiers(sourceText, fromDir) {
   return resolvedPaths;
 }
 async function loadSiblingFiles(sourceText, sourcePath, propNames, candidateTypeNames = []) {
-  const visited = /* @__PURE__ */ new Set([resolve6(sourcePath)]);
+  const visited = /* @__PURE__ */ new Set([resolve7(sourcePath)]);
   const discovered = [];
-  let frontier = [{ text: sourceText, dir: dirname4(sourcePath) }];
+  let frontier = [{ text: sourceText, dir: dirname6(sourcePath) }];
   for (let hop = 0; hop < MAX_SIBLING_DEPTH && discovered.length < MAX_SIBLING_CANDIDATES_EXPLORED; hop++) {
     const nextFrontier = [];
     for (const node of frontier) {
@@ -4905,12 +4990,12 @@ async function loadSiblingFiles(sourceText, sourcePath, propNames, candidateType
           break;
         let content;
         try {
-          content = await readFile4(resolvedPath, "utf8");
+          content = await readFile5(resolvedPath, "utf8");
         } catch {
           continue;
         }
         discovered.push({ path: resolvedPath, content });
-        nextFrontier.push({ text: content, dir: dirname4(resolvedPath) });
+        nextFrontier.push({ text: content, dir: dirname6(resolvedPath) });
       }
     }
     frontier = nextFrontier;
@@ -4944,7 +5029,7 @@ async function loadComponentSourceRef(name, sourcePath, propNames = [], propType
   let truncatedSiblingCount = 0;
   const usesNotShown = /* @__PURE__ */ new Set();
   try {
-    const rawText = await readFile4(sourcePath, "utf8");
+    const rawText = await readFile5(sourcePath, "utf8");
     let siblingUsesNotShown;
     let declaredTypeNames;
     ({
@@ -5705,8 +5790,8 @@ init_token_types();
 import { Project as Project2, Node as Node2, SyntaxKind as SyntaxKind2 } from "ts-morph";
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/shared/extract-tsx-components.js
-import { existsSync as existsSync3, readFileSync as readFileSync4 } from "node:fs";
-import { dirname as dirname5, join as join5, resolve as resolve7 } from "node:path";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
+import { dirname as dirname7, join as join8, resolve as resolve8 } from "node:path";
 import { Node, Project, SyntaxKind } from "ts-morph";
 import ts from "typescript";
 var packageRootByFilePathCache = /* @__PURE__ */ new Map();
@@ -5894,7 +5979,7 @@ function resolveRepoLocalAliasImportPath(importingFilePath, moduleSpecifier) {
       continue;
     for (const targetPattern of targets) {
       const substitutedTarget = substituteTsConfigPathTarget(targetPattern, match2.wildcard);
-      const resolvedPath = resolve7(tsConfigPaths.baseUrl, substitutedTarget);
+      const resolvedPath = resolve8(tsConfigPaths.baseUrl, substitutedTarget);
       const sourceFilePath = resolveImportSourcePath(resolvedPath);
       if (sourceFilePath)
         return sourceFilePath;
@@ -5906,16 +5991,16 @@ function findNearestTsConfigPath(filePath) {
   if (nearestTsConfigPathCache.has(filePath)) {
     return nearestTsConfigPathCache.get(filePath) ?? void 0;
   }
-  let currentDir = dirname5(filePath);
+  let currentDir = dirname7(filePath);
   while (true) {
     for (const candidateName of ["tsconfig.json", "jsconfig.json"]) {
-      const candidatePath = join5(currentDir, candidateName);
-      if (existsSync3(candidatePath)) {
+      const candidatePath = join8(currentDir, candidateName);
+      if (existsSync4(candidatePath)) {
         nearestTsConfigPathCache.set(filePath, candidatePath);
         return candidatePath;
       }
     }
-    const parentDir = dirname5(currentDir);
+    const parentDir = dirname7(currentDir);
     if (parentDir === currentDir) {
       nearestTsConfigPathCache.set(filePath, null);
       return void 0;
@@ -5932,13 +6017,13 @@ function getTsConfigPaths(tsConfigPath) {
     tsConfigPathsCache.set(tsConfigPath, null);
     return void 0;
   }
-  const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, dirname5(tsConfigPath));
+  const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, dirname7(tsConfigPath));
   const paths = parsedConfig.options.paths;
   if (!paths || Object.keys(paths).length === 0) {
     tsConfigPathsCache.set(tsConfigPath, null);
     return void 0;
   }
-  const baseUrl = parsedConfig.options.baseUrl ?? dirname5(tsConfigPath);
+  const baseUrl = parsedConfig.options.baseUrl ?? dirname7(tsConfigPath);
   const result = { baseUrl, paths };
   tsConfigPathsCache.set(tsConfigPath, result);
   return result;
@@ -5966,12 +6051,12 @@ function resolveImportSourcePath(basePath) {
     `${basePath}.tsx`,
     `${basePath}.js`,
     `${basePath}.jsx`,
-    join5(basePath, "index.ts"),
-    join5(basePath, "index.tsx"),
-    join5(basePath, "index.js"),
-    join5(basePath, "index.jsx")
+    join8(basePath, "index.ts"),
+    join8(basePath, "index.tsx"),
+    join8(basePath, "index.js"),
+    join8(basePath, "index.jsx")
   ];
-  return candidates.find((candidatePath) => existsSync3(candidatePath));
+  return candidates.find((candidatePath) => existsSync4(candidatePath));
 }
 function findProjectSourceFileByImportPath(project, resolvedPath) {
   const candidatePaths = [
@@ -5980,10 +6065,10 @@ function findProjectSourceFileByImportPath(project, resolvedPath) {
     `${resolvedPath}.tsx`,
     `${resolvedPath}.js`,
     `${resolvedPath}.jsx`,
-    join5(resolvedPath, "index.ts"),
-    join5(resolvedPath, "index.tsx"),
-    join5(resolvedPath, "index.js"),
-    join5(resolvedPath, "index.jsx")
+    join8(resolvedPath, "index.ts"),
+    join8(resolvedPath, "index.tsx"),
+    join8(resolvedPath, "index.js"),
+    join8(resolvedPath, "index.jsx")
   ];
   for (const candidatePath of candidatePaths) {
     const sourceFile = project.getSourceFile(candidatePath);
@@ -6004,10 +6089,10 @@ function findWorkspacePackageEntrySourceFile(originSourceFile, moduleSpecifier)
   if (!packageRootDir)
     return void 0;
   const preferredEntryPaths = [
-    join5(packageRootDir, "src/index.ts"),
-    join5(packageRootDir, "src/index.tsx"),
-    join5(packageRootDir, "index.ts"),
-    join5(packageRootDir, "index.tsx")
+    join8(packageRootDir, "src/index.ts"),
+    join8(packageRootDir, "src/index.tsx"),
+    join8(packageRootDir, "index.ts"),
+    join8(packageRootDir, "index.tsx")
   ];
   for (const entryPath of preferredEntryPaths) {
     const entrySourceFile = project.getSourceFile(entryPath);
@@ -6015,7 +6100,7 @@ function findWorkspacePackageEntrySourceFile(originSourceFile, moduleSpecifier)
       return entrySourceFile;
     }
   }
-  return candidateSourceFiles.find((sourceFile) => sourceFile.getDirectoryPath() === join5(packageRootDir, "src"));
+  return candidateSourceFiles.find((sourceFile) => sourceFile.getDirectoryPath() === join8(packageRootDir, "src"));
 }
 function getWorkspacePackageManifestForSourceFile(sourceFile) {
   const packageRootDir = findNearestPackageRootDir(sourceFile.getFilePath());
@@ -6024,7 +6109,7 @@ function getWorkspacePackageManifestForSourceFile(sourceFile) {
   if (workspacePackageManifestCache.has(packageRootDir)) {
     return workspacePackageManifestCache.get(packageRootDir) ?? void 0;
   }
-  const packageJsonPath = join5(packageRootDir, "package.json");
+  const packageJsonPath = join8(packageRootDir, "package.json");
   try {
     const packageJson = JSON.parse(readFileSync4(packageJsonPath, "utf8"));
     const manifest = typeof packageJson.name === "string" ? { name: packageJson.name, rootDir: packageRootDir } : null;
@@ -6039,13 +6124,13 @@ function findNearestPackageRootDir(filePath) {
   if (packageRootByFilePathCache.has(filePath)) {
     return packageRootByFilePathCache.get(filePath) ?? void 0;
   }
-  let currentDir = dirname5(filePath);
+  let currentDir = dirname7(filePath);
   while (true) {
-    if (existsSync3(join5(currentDir, "package.json"))) {
+    if (existsSync4(join8(currentDir, "package.json"))) {
       packageRootByFilePathCache.set(filePath, currentDir);
       return currentDir;
     }
-    const parentDir = dirname5(currentDir);
+    const parentDir = dirname7(currentDir);
     if (parentDir === currentDir) {
       packageRootByFilePathCache.set(filePath, null);
       return void 0;
@@ -6055,7 +6140,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 readFile5 } from "node:fs/promises";
+import { readFile as readFile6 } from "node:fs/promises";
 async function runFileExtractionWorkers(filePaths, concurrency, extractFile, formatError, onProgress, onResult) {
   const warnings = [];
   const items = [];
@@ -6067,7 +6152,7 @@ async function runFileExtractionWorkers(filePaths, concurrency, extractFile, for
       if (!filePath)
         break;
       try {
-        const source = await readFile5(filePath, "utf-8");
+        const source = await readFile6(filePath, "utf-8");
         const outcome = await extractFile(filePath, source);
         warnings.push(...outcome.warnings ?? []);
         if (outcome.item)
@@ -9042,35 +9127,35 @@ 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 readFile6 } from "node:fs/promises";
-import { existsSync as existsSync5, readFileSync as readFileSync5, readdirSync, statSync as statSync3 } from "node:fs";
+import { basename, dirname as dirname9, resolve as resolve10, join as join10 } from "node:path";
+import { readFile as readFile7 } from "node:fs/promises";
+import { existsSync as existsSync6, readFileSync as readFileSync5, readdirSync as readdirSync2, statSync as statSync3 } from "node:fs";
 import { parse as parseSFC } from "@vue/compiler-sfc";
 import { Project as Project3, Node as Node6 } from "ts-morph";
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/shared/resolve-local-module.js
-import { existsSync as existsSync4, statSync as statSync2 } from "node:fs";
-import { dirname as dirname6, join as join6, resolve as resolve8 } from "node:path";
+import { existsSync as existsSync5, statSync as statSync2 } from "node:fs";
+import { dirname as dirname8, join as join9, resolve as resolve9 } from "node:path";
 function resolveLocalModule(importingFilePath, specifier, options = {}) {
-  const basePath = resolve8(dirname6(importingFilePath), specifier);
+  const basePath = resolve9(dirname8(importingFilePath), specifier);
   const candidates = [
     basePath,
     `${basePath}.js`,
     `${basePath}.ts`,
     `${basePath}.mjs`,
     `${basePath}.cjs`,
-    join6(basePath, "index.js"),
-    join6(basePath, "index.ts"),
-    join6(basePath, "index.mjs"),
-    join6(basePath, "index.cjs")
+    join9(basePath, "index.js"),
+    join9(basePath, "index.ts"),
+    join9(basePath, "index.mjs"),
+    join9(basePath, "index.cjs")
   ];
   for (const candidate of candidates) {
-    if (existsSync4(candidate) && statSync2(candidate).isFile())
+    if (existsSync5(candidate) && statSync2(candidate).isFile())
       return candidate;
   }
   if (options.allowJavaScriptExtensionFallback && basePath.endsWith(".js")) {
     const tsPath = `${basePath.slice(0, -".js".length)}.ts`;
-    if (existsSync4(tsPath) && statSync2(tsPath).isFile())
+    if (existsSync5(tsPath) && statSync2(tsPath).isFile())
       return tsPath;
   }
   return null;
@@ -9141,7 +9226,7 @@ function getVueComponentName(filePath) {
   if (fileName !== "index") {
     return fileName;
   }
-  const parentDirName = basename(dirname7(filePath));
+  const parentDirName = basename(dirname9(filePath));
   return parentDirName || fileName;
 }
 async function extractOptionsComponent(filePath, scriptContent, fileWarnings, name, templateAst, sfcSource) {
@@ -9285,7 +9370,7 @@ async function extractNamedObjectExportProps(importedRef, visitedImports) {
   if (visitedImports.has(visitKey))
     return [];
   visitedImports.add(visitKey);
-  const source = await readFile6(importedRef.filePath, "utf-8");
+  const source = await readFile7(importedRef.filePath, "utf-8");
   const project = new Project3({
     compilerOptions: {
       strict: false,
@@ -9313,18 +9398,18 @@ function findWorkspaceRoot(startDir) {
     return workspaceRootCache.get(startDir);
   let dir = startDir;
   while (true) {
-    const pkgJsonPath = join7(dir, "package.json");
-    if (existsSync5(pkgJsonPath)) {
+    const pkgJsonPath = join10(dir, "package.json");
+    if (existsSync6(pkgJsonPath)) {
       try {
         const pkg = JSON.parse(readFileSync5(pkgJsonPath, "utf8"));
-        if (pkg.workspaces || existsSync5(join7(dir, "pnpm-workspace.yaml"))) {
+        if (pkg.workspaces || existsSync6(join10(dir, "pnpm-workspace.yaml"))) {
           workspaceRootCache.set(startDir, dir);
           return dir;
         }
       } catch {
       }
     }
-    const parent = dirname7(dir);
+    const parent = dirname9(dir);
     if (parent === dir) {
       workspaceRootCache.set(startDir, null);
       return null;
@@ -9338,8 +9423,8 @@ function getWorkspacePackageDirs(workspaceRoot) {
     return workspacePackageDirsCache.get(workspaceRoot);
   }
   const packageMap = /* @__PURE__ */ new Map();
-  const packagesDir = join7(workspaceRoot, "packages");
-  if (!existsSync5(packagesDir)) {
+  const packagesDir = join10(workspaceRoot, "packages");
+  if (!existsSync6(packagesDir)) {
     workspacePackageDirsCache.set(workspaceRoot, packageMap);
     return packageMap;
   }
@@ -9348,12 +9433,12 @@ function getWorkspacePackageDirs(workspaceRoot) {
       return;
     let entries;
     try {
-      entries = readdirSync(dir);
+      entries = readdirSync2(dir);
     } catch {
       return;
     }
-    const pkgJsonPath = join7(dir, "package.json");
-    if (existsSync5(pkgJsonPath)) {
+    const pkgJsonPath = join10(dir, "package.json");
+    if (existsSync6(pkgJsonPath)) {
       try {
         const pkg = JSON.parse(readFileSync5(pkgJsonPath, "utf8"));
         if (typeof pkg.name === "string") {
@@ -9365,7 +9450,7 @@ function getWorkspacePackageDirs(workspaceRoot) {
     for (const entry of entries) {
       if (entry === "node_modules" || entry === ".git" || entry.startsWith("."))
         continue;
-      const entryPath = join7(dir, entry);
+      const entryPath = join10(dir, entry);
       try {
         const stat5 = statSync3(entryPath);
         if (stat5.isDirectory()) {
@@ -9380,7 +9465,7 @@ function getWorkspacePackageDirs(workspaceRoot) {
   return packageMap;
 }
 function resolveWorkspaceVueImport(specifier, importingFilePath) {
-  const workspaceRoot = findWorkspaceRoot(dirname7(importingFilePath));
+  const workspaceRoot = findWorkspaceRoot(dirname9(importingFilePath));
   if (!workspaceRoot)
     return null;
   const packageDirs = getWorkspacePackageDirs(workspaceRoot);
@@ -9405,28 +9490,28 @@ function resolveWorkspaceVueImport(specifier, importingFilePath) {
   const packageDir = packageDirs.get(packageName);
   if (!packageDir)
     return null;
-  const pkgJsonPath = join7(packageDir, "package.json");
+  const pkgJsonPath = join10(packageDir, "package.json");
   try {
     const pkg = JSON.parse(readFileSync5(pkgJsonPath, "utf8"));
     if (pkg.exports && subpath !== ".") {
       const exportValue = pkg.exports[subpath];
       if (typeof exportValue === "string" && exportValue.endsWith(".vue")) {
-        const resolved = resolve9(packageDir, exportValue);
-        if (existsSync5(resolved))
+        const resolved = resolve10(packageDir, exportValue);
+        if (existsSync6(resolved))
           return resolved;
       }
     }
     if (subpath !== ".") {
-      const subDir = resolve9(packageDir, subpath.replace(/^\.\//, ""));
-      for (const base of [join7(packageDir, "src", subpath.replace(/^\.\//, "")), subDir]) {
-        const subPkgPath = join7(base, "package.json");
-        if (existsSync5(subPkgPath)) {
+      const subDir = resolve10(packageDir, subpath.replace(/^\.\//, ""));
+      for (const base of [join10(packageDir, "src", subpath.replace(/^\.\//, "")), subDir]) {
+        const subPkgPath = join10(base, "package.json");
+        if (existsSync6(subPkgPath)) {
           try {
             const subPkg = JSON.parse(readFileSync5(subPkgPath, "utf8"));
             const main = subPkg.main || subPkg.module;
             if (typeof main === "string" && main.endsWith(".vue")) {
-              const resolved = resolve9(base, main);
-              if (existsSync5(resolved))
+              const resolved = resolve10(base, main);
+              if (existsSync6(resolved))
                 return resolved;
             }
           } catch {
@@ -9437,8 +9522,8 @@ function resolveWorkspaceVueImport(specifier, importingFilePath) {
     if (subpath === ".") {
       const main = pkg.main || pkg.module;
       if (typeof main === "string" && main.endsWith(".vue")) {
-        const resolved = resolve9(packageDir, main);
-        if (existsSync5(resolved))
+        const resolved = resolve10(packageDir, main);
+        if (existsSync6(resolved))
           return resolved;
       }
     }
@@ -9447,7 +9532,7 @@ function resolveWorkspaceVueImport(specifier, importingFilePath) {
   return null;
 }
 async function extractOptionsProps(filePath, scriptContent, visited = /* @__PURE__ */ new Set()) {
-  const resolvedFilePath = resolve9(filePath);
+  const resolvedFilePath = resolve10(filePath);
   if (visited.has(resolvedFilePath)) {
     return [];
   }
@@ -9472,7 +9557,7 @@ async function extractOptionsProps(filePath, scriptContent, visited = /* @__PURE
     if (specifier.startsWith(".")) {
       if (!specifier.endsWith(".vue"))
         continue;
-      localImports.set(defaultImport.getText(), resolve9(dirname7(resolvedFilePath), specifier));
+      localImports.set(defaultImport.getText(), resolve10(dirname9(resolvedFilePath), specifier));
     } else {
       const resolvedVuePath = resolveWorkspaceVueImport(specifier, resolvedFilePath);
       if (resolvedVuePath) {
@@ -9516,7 +9601,7 @@ async function extractOptionsProps(filePath, scriptContent, visited = /* @__PURE
   return [];
 }
 async function extractInheritedVueProps(filePath, visited) {
-  const source = await readFile6(filePath, "utf-8");
+  const source = await readFile7(filePath, "utf-8");
   const { descriptor } = parseSFC(source);
   if (!descriptor.script) {
     return [];
@@ -9849,7 +9934,7 @@ async function extractAstroComponents(filePaths, onProgress) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/web-components/extract-web-components.js
-import { basename as basename3, dirname as dirname8, join as join8, resolve as resolve10 } from "node:path";
+import { basename as basename3, dirname as dirname10, join as join11, resolve as resolve11 } from "node:path";
 import { Project as Project5, Node as Node8, SyntaxKind as SyntaxKind6 } from "ts-morph";
 function normalizeComponentName(input) {
   return input.replace(/[^a-zA-Z0-9]/g, "").toLowerCase();
@@ -10494,7 +10579,7 @@ function getElementTagNameFromFastDefinition(classDecl, project) {
 }
 function resolveImportSourcePath2(fromFilePath, specifier) {
   if (specifier.startsWith(".")) {
-    const resolvedPath = resolve10(dirname8(fromFilePath), specifier);
+    const resolvedPath = resolve11(dirname10(fromFilePath), specifier);
     if (resolvedPath.endsWith(".js")) {
       return `${resolvedPath.slice(0, -3)}.ts`;
     }
@@ -10504,14 +10589,14 @@ function resolveImportSourcePath2(fromFilePath, specifier) {
   if (!specifier.startsWith(spectrumPrefix)) {
     return null;
   }
-  const packagesMarker = `${join8("2nd-gen", "packages")}${fromFilePath.includes("\\") ? "\\" : "/"}`;
+  const packagesMarker = `${join11("2nd-gen", "packages")}${fromFilePath.includes("\\") ? "\\" : "/"}`;
   const markerIndex = fromFilePath.lastIndexOf(packagesMarker);
   if (markerIndex === -1) {
     return null;
   }
   const packagesRoot = fromFilePath.slice(0, markerIndex + packagesMarker.length - 1);
   const componentPath = specifier.slice(spectrumPrefix.length);
-  return join8(packagesRoot, "core", "components", componentPath, "index.ts");
+  return join11(packagesRoot, "core", "components", componentPath, "index.ts");
 }
 function getImportedBaseClass(classDecl, project, visitedFiles) {
   const extendsClause = classDecl.getHeritageClauses().find((clause) => clause.getToken() === SyntaxKind6.ExtendsKeyword);
@@ -10664,8 +10749,8 @@ async function extractWebComponentDefinitions(filePaths) {
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/svelte/extract-svelte-components.js
 import os3 from "node:os";
-import { basename as basename4, dirname as dirname9, resolve as resolve11, join as join9 } from "node:path";
-import { existsSync as existsSync6, readFileSync as readFileSync6 } from "node:fs";
+import { basename as basename4, dirname as dirname11, resolve as resolve12, join as join12 } from "node:path";
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "node:fs";
 import { createRequire } from "node:module";
 import { parse as parseSvelte } from "svelte/compiler";
 import { Project as Project6, Node as Node9, ScriptTarget, ModuleKind, ts as ts2 } from "ts-morph";
@@ -10898,10 +10983,10 @@ async function maybeRunResolveUnreachableRetry(components, warnings, retryContex
 function findNearestTsconfig(startDir) {
   let dir = startDir;
   for (let i = 0; i < 16; i++) {
-    const candidate = join9(dir, "tsconfig.json");
-    if (existsSync6(candidate))
+    const candidate = join12(dir, "tsconfig.json");
+    if (existsSync7(candidate))
       return candidate;
-    const parent = dirname9(dir);
+    const parent = dirname11(dir);
     if (!parent || parent === dir)
       return null;
     dir = parent;
@@ -11031,32 +11116,32 @@ function locateDtsForSpecifier(req, specifier, parentFile) {
   } catch {
     resolvedJs = null;
   }
-  const seedDir = resolvedJs ? dirname9(resolvedJs) : dirname9(parentFile);
+  const seedDir = resolvedJs ? dirname11(resolvedJs) : dirname11(parentFile);
   const pkgRoot = findPackageRootForSpecifier(seedDir, specifier);
   if (pkgRoot) {
-    const pkgJsonPath = join9(pkgRoot, "package.json");
-    if (existsSync6(pkgJsonPath)) {
+    const pkgJsonPath = join12(pkgRoot, "package.json");
+    if (existsSync7(pkgJsonPath)) {
       try {
         const pkgRaw = readFileSync6(pkgJsonPath, "utf-8");
         const pkg = JSON.parse(pkgRaw);
         const typesField = pkg.types ?? pkg.typings;
         if (typeof typesField === "string") {
-          const candidate = resolve11(pkgRoot, typesField);
-          if (existsSync6(candidate))
+          const candidate = resolve12(pkgRoot, typesField);
+          if (existsSync7(candidate))
             return candidate;
         }
         const exportsTypes = extractTypesFromExports(pkg.exports);
         if (exportsTypes) {
-          const candidate = resolve11(pkgRoot, exportsTypes);
-          if (existsSync6(candidate))
+          const candidate = resolve12(pkgRoot, exportsTypes);
+          if (existsSync7(candidate))
             return candidate;
         }
       } catch {
       }
     }
     for (const entry of ["index.d.ts", "index.d.mts"]) {
-      const candidate = join9(pkgRoot, entry);
-      if (existsSync6(candidate))
+      const candidate = join12(pkgRoot, entry);
+      if (existsSync7(candidate))
         return candidate;
     }
   }
@@ -11064,7 +11149,7 @@ function locateDtsForSpecifier(req, specifier, parentFile) {
     const noExt = resolvedJs.replace(/\.(m?js|cjs)$/, "");
     for (const ext of [".d.ts", ".d.mts"]) {
       const candidate = `${noExt}${ext}`;
-      if (existsSync6(candidate))
+      if (existsSync7(candidate))
         return candidate;
     }
   }
@@ -11073,9 +11158,9 @@ function locateDtsForSpecifier(req, specifier, parentFile) {
 function findPackageRootForSpecifier(seedDir, specifier) {
   let dir = seedDir;
   for (let i = 0; i < 32; i++) {
-    if (existsSync6(join9(dir, "package.json"))) {
+    if (existsSync7(join12(dir, "package.json"))) {
       try {
-        const pkgRaw = readFileSync6(join9(dir, "package.json"), "utf-8");
+        const pkgRaw = readFileSync6(join12(dir, "package.json"), "utf-8");
         const pkg = JSON.parse(pkgRaw);
         if (pkg.name === specifier)
           return dir;
@@ -11084,7 +11169,7 @@ function findPackageRootForSpecifier(seedDir, specifier) {
       } catch {
       }
     }
-    const parent = dirname9(dir);
+    const parent = dirname11(dir);
     if (!parent || parent === dir)
       return null;
     dir = parent;
@@ -11216,11 +11301,11 @@ async function extractFromSvelteFile(filePath, source) {
 var ANATOMY_FOLDERS = /* @__PURE__ */ new Set(["anatomy", "parts"]);
 function getSvelteComponentName(filePath) {
   const file = basename4(filePath, ".svelte");
-  const parentDir = basename4(dirname9(filePath));
+  const parentDir = basename4(dirname11(filePath));
   if (file === "index")
     return toPascalCase(parentDir);
   if (ANATOMY_FOLDERS.has(parentDir)) {
-    const grandparent = basename4(dirname9(dirname9(filePath)));
+    const grandparent = basename4(dirname11(dirname11(filePath)));
     if (grandparent && grandparent !== "." && grandparent !== "/") {
       return `${toPascalCase(grandparent)}${toPascalCase(file)}`;
     }
@@ -12035,7 +12120,7 @@ function mergeSlots2(fromSnippetProps, fromTemplate) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/extract-angular-components.js
-import { readFile as readFile8 } from "node:fs/promises";
+import { readFile as readFile9 } from "node:fs/promises";
 import { ModuleKind as ModuleKind2, Project as Project7, ScriptTarget as ScriptTarget2 } from "ts-morph";
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/find-component-decorator.js
@@ -12349,7 +12434,7 @@ function extractProps2(cls, meta) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/read-component-metadata.js
-import { dirname as dirname10, resolve as resolve12 } from "node:path";
+import { dirname as dirname12, resolve as resolve13 } from "node:path";
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/resolution/normalize-component-name.js
 var SUFFIXES = ["Component", "Directive"];
@@ -12404,7 +12489,7 @@ function readComponentMetadata(cls, sourceFilePath) {
   const inlineTemplate = readDecoratorString(obj, "template");
   const templateUrlRel = readDecoratorString(obj, "templateUrl");
   const inputsArray = readDecoratorStringArray(obj, "inputs");
-  const templatePath = templateUrlRel ? resolve12(dirname10(sourceFilePath), templateUrlRel) : null;
+  const templatePath = templateUrlRel ? resolve13(dirname12(sourceFilePath), templateUrlRel) : null;
   const decorator = cls.getDecorator("Component");
   const decoratorLine = decorator?.getStartLineNumber() ?? cls.getStartLineNumber();
   return {
@@ -12441,14 +12526,14 @@ function countLines(text, offset) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/template/resolve-template-source.js
-import { readFile as readFile7 } from "node:fs/promises";
+import { readFile as readFile8 } from "node:fs/promises";
 async function resolveTemplateSource(meta) {
   if (meta.inlineTemplate !== null)
     return meta.inlineTemplate;
   if (meta.templatePath === null)
     return null;
   try {
-    return await readFile7(meta.templatePath, "utf8");
+    return await readFile8(meta.templatePath, "utf8");
   } catch {
     return null;
   }
@@ -12638,7 +12723,7 @@ async function extractAngularComponents(filePaths, onProgress, _opts) {
   });
   for (const filePath of filePaths) {
     try {
-      const source = await readFile8(filePath, "utf8");
+      const source = await readFile9(filePath, "utf8");
       const sourceFile = project.createSourceFile(filePath, source, { overwrite: true });
       for (const cls of sourceFile.getClasses()) {
         if (!hasComponentDecorator(cls))
@@ -13226,17 +13311,17 @@ function applyCompositionEdges(components, edges) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/composition/src/helpers/prompt/prompt-loader.js
-import { existsSync as existsSync7, readFileSync as readFileSync7 } from "node:fs";
-import { dirname as dirname11, join as join10, resolve as resolve13 } from "node:path";
+import { existsSync as existsSync8, readFileSync as readFileSync7 } from "node:fs";
+import { dirname as dirname13, join as join13, resolve as resolve14 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function resolvePromptPath(fileName) {
-  const thisDir = dirname11(fileURLToPath3(import.meta.url));
+  const thisDir = dirname13(fileURLToPath3(import.meta.url));
   let dir = thisDir;
   for (; ; ) {
-    const candidate = join10(dir, "prompts");
-    if (existsSync7(candidate))
-      return join10(candidate, fileName);
-    const parent = resolve13(dir, "..");
+    const candidate = join13(dir, "prompts");
+    if (existsSync8(candidate))
+      return join13(candidate, fileName);
+    const parent = resolve14(dir, "..");
     if (parent === dir) {
       throw new Error(`prompt file missing from package installation (could not locate prompts/ directory from: ${thisDir})`);
     }
@@ -13401,7 +13486,7 @@ ${fileDigest}`);
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/composition/src/helpers/edges/manifest-doc-evidence.js
-import { dirname as dirname12 } from "node:path";
+import { dirname as dirname14 } from "node:path";
 function kebabToPascal3(name) {
   return name.split("-").filter(Boolean).map((seg) => seg.charAt(0).toUpperCase() + seg.slice(1)).join("");
 }
@@ -13465,8 +13550,8 @@ function collectAgentsDocEdges(files, components, componentNames) {
   for (const file of files) {
     if (!file.path.endsWith("AGENTS.md"))
       continue;
-    const docDir = dirname12(file.path);
-    const parent = components.find((c2) => c2.sourcePath && dirname12(c2.sourcePath) === docDir)?.name;
+    const docDir = dirname14(file.path);
+    const parent = components.find((c2) => c2.sourcePath && dirname14(c2.sourcePath) === docDir)?.name;
     if (!parent || !componentNames.has(parent))
       continue;
     for (const line of file.content.split("\n")) {
@@ -13791,7 +13876,7 @@ function validateExtractedComponents(components) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/review-session/helpers/load-review-input.js
-import { resolve as resolve15 } from "node:path";
+import { resolve as resolve16 } from "node:path";
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/review-session/helpers/create-component-id.js
 import { createHash as createHash7 } from "node:crypto";
@@ -13802,7 +13887,7 @@ function createComponentId(name, resolvedSourcePath) {
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/review-session/helpers/resolve-component-source-path.js
 import { access } from "node:fs/promises";
-import { isAbsolute, relative, resolve as resolve14 } from "node:path";
+import { isAbsolute, relative, resolve as resolve15 } from "node:path";
 async function resolveComponentSourcePath(source, reviewRoot) {
   if (isAbsolute(source)) {
     try {
@@ -13812,7 +13897,7 @@ async function resolveComponentSourcePath(source, reviewRoot) {
       throw new Error(`Unable to access component source at ${source}`);
     }
   }
-  const candidate = resolve14(reviewRoot, source);
+  const candidate = resolve15(reviewRoot, source);
   const relativeToRoot = relative(reviewRoot, candidate);
   if (relativeToRoot.startsWith("..") || relativeToRoot === ".." || isAbsolute(relativeToRoot)) {
     throw new Error(`Resolved component source is outside the review root: ${source}. Pass --project-root <path> to set the correct base.`);
@@ -13827,7 +13912,7 @@ async function resolveComponentSourcePath(source, reviewRoot) {
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/review-session/helpers/load-review-input.js
 async function loadReviewInput(components, options = {}) {
-  const reviewRoot = resolve15(options.reviewRoot ?? process.cwd());
+  const reviewRoot = resolve16(options.reviewRoot ?? process.cwd());
   const records = await Promise.all(components.map(async (component) => {
     let resolvedSourcePath;
     try {
@@ -13862,50 +13947,50 @@ 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 readFile10 } from "node:fs/promises";
+import { access as access3, readFile as readFile11 } 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 readFile9, writeFile } from "node:fs/promises";
+import { access as access2, mkdir as mkdir3, readFile as readFile10, writeFile as writeFile3 } from "node:fs/promises";
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/review-session/repositories/review-session-paths.js
-import { resolve as resolve16 } from "node:path";
+import { resolve as resolve17 } from "node:path";
 async function getRefineSessionPaths(sessionId, artifactsRoot) {
-  const sessionDir2 = resolve16(artifactsRoot, sessionId);
+  const sessionDir2 = resolve17(artifactsRoot, sessionId);
   return {
     sessionDir: sessionDir2,
-    eventsPath: resolve16(sessionDir2, "events.jsonl"),
-    statePath: resolve16(sessionDir2, "current-review-state.json")
+    eventsPath: resolve17(sessionDir2, "events.jsonl"),
+    statePath: resolve17(sessionDir2, "current-review-state.json")
   };
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/review-session/repositories/ensure-review-session.js
 async function ensureRefineSession(sessionId, artifactsRoot, initialSnapshot) {
   const paths = await getRefineSessionPaths(sessionId, artifactsRoot);
-  await mkdir(paths.sessionDir, { recursive: true });
+  await mkdir3(paths.sessionDir, { recursive: true });
   try {
     await access2(paths.statePath);
-    const savedState = await readFile9(paths.statePath, "utf8");
+    const savedState = await readFile10(paths.statePath, "utf8");
     return JSON.parse(savedState);
   } catch {
-    await writeFile(paths.statePath, JSON.stringify(initialSnapshot, null, 2), "utf8");
-    await writeFile(paths.eventsPath, "", "utf8");
+    await writeFile3(paths.statePath, JSON.stringify(initialSnapshot, null, 2), "utf8");
+    await writeFile3(paths.eventsPath, "", "utf8");
     return initialSnapshot;
   }
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/review-session/repositories/review-artifacts-root.js
-import { resolve as resolve17 } from "node:path";
+import { resolve as resolve18 } from "node:path";
 function getRefineArtifactsRoot() {
   if (process.env["EDS_REVIEW_ARTIFACTS_DIR"]) {
-    return resolve17(process.env["EDS_REVIEW_ARTIFACTS_DIR"]);
+    return resolve18(process.env["EDS_REVIEW_ARTIFACTS_DIR"]);
   }
-  return resolve17(configRoot(), "reviews");
+  return resolve18(configRoot2(), "reviews");
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/review-session/repositories/save-review-state.js
-import { writeFile as writeFile2 } from "node:fs/promises";
+import { writeFile as writeFile4 } from "node:fs/promises";
 async function saveReviewState(statePath, session) {
-  await writeFile2(statePath, JSON.stringify(session, null, 2), "utf8");
+  await writeFile4(statePath, JSON.stringify(session, null, 2), "utf8");
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/selection/src/controller/review/merge-preview-validation-errors-into-review-session.js
@@ -13915,7 +14000,7 @@ async function mergePreviewValidationErrorsIntoReviewSession(sessionId, errors,
   let snapshot;
   try {
     await access3(paths.statePath);
-    snapshot = JSON.parse(await readFile10(paths.statePath, "utf8"));
+    snapshot = JSON.parse(await readFile11(paths.statePath, "utf8"));
   } catch {
     snapshot = await loadAndValidateForReview(sessionId, void 0);
     snapshot = await ensureRefineSession(sessionId, artifactsRoot, snapshot);
@@ -13953,7 +14038,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 readFile11 } from "node:fs/promises";
+import { readFile as readFile12 } from "node:fs/promises";
 async function rejectComponentsByName(sessionId, names, opts = {}) {
   if (names.length === 0)
     return;
@@ -13969,7 +14054,7 @@ async function rejectComponentsByName(sessionId, names, opts = {}) {
   const nameSet = new Set(names);
   let snapshot;
   try {
-    snapshot = JSON.parse(await readFile11(paths.statePath, "utf8"));
+    snapshot = JSON.parse(await readFile12(paths.statePath, "utf8"));
   } catch {
     return;
   }
@@ -14124,10 +14209,10 @@ function isSourceFile(name) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/helpers/collect-files/read-dir-safely.js
-import { readdirSync as readdirSync2 } from "node:fs";
+import { readdirSync as readdirSync3 } from "node:fs";
 function readDirSafely(dir) {
   try {
-    return readdirSync2(dir, { withFileTypes: true });
+    return readdirSync3(dir, { withFileTypes: true });
   } catch {
     return "unreadable";
   }
@@ -14195,7 +14280,7 @@ function collectFiles(root, options = {}) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/runs/helpers/generate-ulid.js
-import { randomBytes as randomBytes2 } from "node:crypto";
+import { randomBytes as randomBytes3 } from "node:crypto";
 var CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
 function encodeBase32(bytes, length) {
   let out = "";
@@ -14221,12 +14306,12 @@ function generateUlid(now = Date.now()) {
     n = Math.floor(n / 256);
   }
   const ts3 = encodeBase32(tsBytes, 10);
-  const rand = encodeBase32(randomBytes2(10), 16);
+  const rand = encodeBase32(randomBytes3(10), 16);
   return (ts3 + rand).toUpperCase();
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/runs/repositories/read-runs-file.js
-import { readFile as readFile12 } from "node:fs/promises";
+import { readFile as readFile13 } from "node:fs/promises";
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/runs/helpers/migrate-record.js
 function migrateRecord(rec) {
@@ -14245,7 +14330,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 readFile12(runsFilePath(), "utf8");
+    const raw = await readFile13(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.`);
@@ -14261,14 +14346,14 @@ async function readRunsFileMaybe() {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/runs/repositories/write-runs-file.js
-import { mkdir as mkdir2, rename, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname13 } from "node:path";
+import { mkdir as mkdir4, rename as rename2, writeFile as writeFile5 } from "node:fs/promises";
+import { dirname as dirname15 } from "node:path";
 async function writeRunsFileAtomic(file) {
-  await mkdir2(dirname13(runsFilePath()), { recursive: true });
+  await mkdir4(dirname15(runsFilePath()), { recursive: true });
   const body = JSON.stringify(file, null, 2) + "\n";
   const tmp = `${runsFilePath()}.${process.pid}.${Date.now()}.tmp`;
-  await writeFile3(tmp, body, { mode: 384 });
-  await rename(tmp, runsFilePath());
+  await writeFile5(tmp, body, { mode: 384 });
+  await rename2(tmp, runsFilePath());
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/runs/services/append-run.js
@@ -14304,8 +14389,8 @@ async function updateRun(id, patch) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/runs/services/build-source-fingerprint.js
-import { readFile as readFile13, stat } from "node:fs/promises";
-import { resolve as resolve18 } from "node:path";
+import { readFile as readFile14, stat as stat2 } from "node:fs/promises";
+import { resolve as resolve19 } from "node:path";
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/runs/helpers/sha256-hex.js
 import { createHash as createHash8 } from "node:crypto";
@@ -14327,12 +14412,12 @@ async function buildSourceFingerprint(opts) {
     const name = rowField(row, "name");
     if (!sourcePath)
       continue;
-    const abs = resolve18(sourcePath);
+    const abs = resolve19(sourcePath);
     if (seen.has(abs))
       continue;
     seen.add(abs);
     try {
-      const st = await stat(abs);
+      const st = await stat2(abs);
       const entry = { mtime: st.mtime.toISOString() };
       if (name)
         entry.componentName = name;
@@ -14344,10 +14429,10 @@ async function buildSourceFingerprint(opts) {
   let rawTokensMtime = null;
   let rawTokensContentHash = null;
   if (opts.rawTokensPath) {
-    const abs = resolve18(opts.rawTokensPath);
+    const abs = resolve19(opts.rawTokensPath);
     rawTokensPath = abs;
     try {
-      const [st, buf] = await Promise.all([stat(abs), readFile13(abs)]);
+      const [st, buf] = await Promise.all([stat2(abs), readFile14(abs)]);
       rawTokensMtime = st.mtime.toISOString();
       rawTokensContentHash = sha256Hex(buf);
     } catch {
@@ -14358,7 +14443,7 @@ async function buildSourceFingerprint(opts) {
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/runs/repositories/list-conflicting-files.js
 import { access as access4 } from "node:fs/promises";
-import { join as join11 } from "node:path";
+import { join as join14 } from "node:path";
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/runs/repositories/save-files.js
 var SAVE_FILES = ["components.json", "tokens.json"];
@@ -14368,7 +14453,7 @@ async function listConflictingFiles(path5) {
   const conflicts = [];
   for (const name of SAVE_FILES) {
     try {
-      await access4(join11(path5, name));
+      await access4(join14(path5, name));
       conflicts.push(name);
     } catch {
     }
@@ -14382,7 +14467,7 @@ async function detectSaveConflict(path5) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/runs/helpers/build-timestamped-subdir.js
-import { join as join12 } from "node:path";
+import { join as join15 } from "node:path";
 function pad2(n) {
   return n < 10 ? `0${n}` : String(n);
 }
@@ -14393,11 +14478,11 @@ function buildTimestampedSubdir(base, now = /* @__PURE__ */ new Date()) {
   const hh = pad2(now.getHours());
   const mm = pad2(now.getMinutes());
   const ss = pad2(now.getSeconds());
-  return join12(base, `dsi-${y}${m}${d}-${hh}${mm}${ss}`);
+  return join15(base, `dsi-${y}${m}${d}-${hh}${mm}${ss}`);
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/review-session/services/write-scope-decisions-snapshot.js
-import { mkdir as mkdir3 } from "node:fs/promises";
+import { mkdir as mkdir5 } from "node:fs/promises";
 async function writeScopeDecisionsSnapshot(db, sessionId, decisions) {
   const acceptedSet = new Set(decisions.accepted);
   const rawComponents = loadRawComponents(db, sessionId);
@@ -14424,17 +14509,17 @@ async function writeScopeDecisionsSnapshot(db, sessionId, decisions) {
     };
   });
   const paths = await getRefineSessionPaths(sessionId, getRefineArtifactsRoot());
-  await mkdir3(paths.sessionDir, { recursive: true });
+  await mkdir5(paths.sessionDir, { recursive: true });
   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 readFile14 } from "node:fs/promises";
+import { readFile as readFile15 } from "node:fs/promises";
 async function loadAcceptedNames(sessionId) {
   try {
     const artifactsRoot = getRefineArtifactsRoot();
     const paths = await getRefineSessionPaths(sessionId, artifactsRoot);
-    const raw = await readFile14(paths.statePath, "utf8");
+    const raw = await readFile15(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)
@@ -14449,7 +14534,7 @@ async function loadAcceptedNames(sessionId) {
 import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/helpers/generate-session-id.js
-import { randomBytes as randomBytes3 } from "node:crypto";
+import { randomBytes as randomBytes4 } from "node:crypto";
 var ADJECTIVES2 = [
   "bright",
   "calm",
@@ -14498,7 +14583,7 @@ var NOUNS2 = [
 function generateSessionId2() {
   const adj = ADJECTIVES2[Math.floor(Math.random() * ADJECTIVES2.length)];
   const noun = NOUNS2[Math.floor(Math.random() * NOUNS2.length)];
-  const hex = randomBytes3(2).toString("hex");
+  const hex = randomBytes4(2).toString("hex");
   return `${adj}-${noun}-${hex}`;
 }
 
@@ -15760,11 +15845,11 @@ 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 readFile15, stat as stat3 } from "node:fs/promises";
+import { readFile as readFile16, stat as stat4 } 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";
-import { join as join13 } from "node:path";
+import { readdir as readdir2, stat as stat3 } from "node:fs/promises";
+import { join as join16 } from "node:path";
 var IGNORE_TOKEN_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", "build", ".next", ".nuxt", ".git"]);
 async function collectJsonFiles(dir) {
   const results = [];
@@ -15774,17 +15859,17 @@ async function collectJsonFiles(dir) {
 async function walk(current, results) {
   let entries;
   try {
-    entries = await readdir(current);
+    entries = await readdir2(current);
   } catch {
     return;
   }
   await Promise.all(entries.map(async (entry) => {
     if (IGNORE_TOKEN_DIRS.has(entry))
       return;
-    const full = join13(current, entry);
+    const full = join16(current, entry);
     let s;
     try {
-      s = await stat2(full);
+      s = await stat3(full);
     } catch {
       return;
     }
@@ -15800,7 +15885,7 @@ async function walk(current, results) {
 async function readTokensFromPath(flag, p) {
   let s;
   try {
-    s = await stat3(p);
+    s = await stat4(p);
   } catch {
     throw new Error(`file not found: ${p} (from ${flag})`);
   }
@@ -15819,7 +15904,7 @@ async function readMergedFromDir(flag, dir) {
   const merged = {};
   for (const file of files.sort()) {
     try {
-      const text = await readFile15(file, "utf8");
+      const text = await readFile16(file, "utf8");
       const parsed = JSON.parse(text);
       if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
         Object.assign(merged, parsed);
@@ -15833,7 +15918,7 @@ async function readMergedFromDir(flag, dir) {
 async function readSingleFile(flag, p) {
   let text;
   try {
-    text = await readFile15(p, "utf8");
+    text = await readFile16(p, "utf8");
   } catch {
     throw new Error(`file not found: ${p} (from ${flag})`);
   }
@@ -15878,8 +15963,8 @@ function buildContentfulManagementClient(request) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/controller/existing-entities/fetch-and-persist.js
-import { writeFile as writeFile4 } from "node:fs/promises";
-import { join as join14 } from "node:path";
+import { writeFile as writeFile6 } from "node:fs/promises";
+import { join as join17 } from "node:path";
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/helpers/existing-entities/fetch-from-contentful.js
 import { fetchAll } from "contentful-management";
@@ -15911,8 +15996,8 @@ async function fetchAndPersistExistingContentfulEntities(request) {
       spaceId: request.spaceId,
       environmentId: request.environmentId
     });
-    const path5 = join14(request.outDir, ".existing-entities.json");
-    await writeFile4(path5, JSON.stringify(entities, null, 2), "utf8");
+    const path5 = join17(request.outDir, ".existing-entities.json");
+    await writeFile6(path5, JSON.stringify(entities, null, 2), "utf8");
     return { ok: true, path: path5, durationMs: Date.now() - t0, entities };
   } catch (error) {
     return {
@@ -15924,12 +16009,12 @@ async function fetchAndPersistExistingContentfulEntities(request) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/controller/existing-entities/read-from-session.js
-import { readFile as readFile16 } from "node:fs/promises";
+import { readFile as readFile17 } from "node:fs/promises";
 async function readExistingContentfulEntitiesFromSession(request) {
   if (!request.path)
     return void 0;
   try {
-    const raw = await readFile16(request.path, "utf8");
+    const raw = await readFile17(request.path, "utf8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed.components) || !Array.isArray(parsed.tokens))
       return void 0;
@@ -16269,7 +16354,7 @@ init_describe_agent_failure();
 init_resolve_binary();
 init_resolve_skill_path();
 init_parse_map_token_prop_tool_calls();
-import { resolve as resolve19 } from "node:path";
+import { resolve as resolve20 } from "node:path";
 init_cache_keys();
 
 // packages/experience-design-system-backend-pipeline/dist/src/agents/helpers/resolution/binary-exists.js
@@ -16578,7 +16663,7 @@ async function runMapTokens(request) {
       outDir: process.cwd(),
       existingTokensInline: request.existingEntitiesInline,
       ...request.skillContentOverride !== void 0 ? { skillContentOverride: request.skillContentOverride } : {},
-      ...request.skillContentOverride === void 0 && request.skillPathOverride ? { skillPathOverride: resolve19(request.skillPathOverride) } : {}
+      ...request.skillContentOverride === void 0 && request.skillPathOverride ? { skillPathOverride: resolve20(request.skillPathOverride) } : {}
     });
     if (request.printPrompt) {
       const prompt2 = await buildMapPrompt();
@@ -16637,7 +16722,7 @@ async function runMapTokens(request) {
 }
 
 // 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 { mkdir as mkdir6 } from "node:fs/promises";
 import { relative as relative2 } from "node:path";
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/helpers/quality/non-authorable-filter.js
@@ -16694,7 +16779,7 @@ function hasNoAuthoringSurface(component) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/helpers/evidence/source-inspection.js
-import { readFile as readFile17 } from "node:fs/promises";
+import { readFile as readFile18 } from "node:fs/promises";
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/constants/review-reasons.js
 var HIGH_CONFIDENCE_DATA_FETCH_WRAPPER_REASON = "data-fetch-wrapper";
@@ -16796,7 +16881,7 @@ function dedupeReasons(reasons) {
 async function inspectComponentSource(component) {
   let sourceText = "";
   try {
-    sourceText = await readFile17(component.source, "utf8");
+    sourceText = await readFile18(component.source, "utf8");
   } catch {
     return {
       wrapperConfidence: 0,
@@ -17235,7 +17320,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 readFile18 } from "node:fs/promises";
+import { readFile as readFile19 } from "node:fs/promises";
 async function readCandidateFiles(components, extraFiles = []) {
   const paths = new Set(extraFiles);
   for (const c2 of components) {
@@ -17245,7 +17330,7 @@ async function readCandidateFiles(components, extraFiles = []) {
   const out = [];
   await Promise.all([...paths].map(async (p) => {
     try {
-      const content = await readFile18(p, "utf8");
+      const content = await readFile19(p, "utf8");
       out.push({ path: p, content });
     } catch {
     }
@@ -17359,7 +17444,7 @@ async function runExtractAndComposeSession(request) {
       onProgress,
       onDebugEvent
     });
-    await mkdir4(outDir, { recursive: true });
+    await mkdir6(outDir, { recursive: true });
     const { sessionId } = getOrCreateSession(db, void 0, void 0, {
       command: "analyze extract",
       inputPath: projectPath,
@@ -17416,15 +17501,15 @@ init_build_prompt();
 init_create_local_cli_agent_invoker();
 init_invoke_agent_with_output();
 init_parse_token_tool_calls();
-import { readFile as readFile19 } from "node:fs/promises";
+import { readFile as readFile20 } from "node:fs/promises";
 import { basename as basename5, resolve as pathResolve } from "node:path";
 init_cache_keys();
 init_parse_prompt_overrides();
 init_resolve_prompt_override();
 
 // packages/experience-design-system-backend-pipeline/dist/src/orchestrators/run-generate-tokens-session/helpers/write-tokens-file.js
-import { mkdir as mkdir5, writeFile as writeFile5 } from "node:fs/promises";
-import { join as join15 } from "node:path";
+import { mkdir as mkdir7, writeFile as writeFile7 } from "node:fs/promises";
+import { join as join18 } from "node:path";
 async function writeTokensFile(db, sessionId, outDir, onProgress) {
   onProgress?.({ kind: "writing-file" });
   const result = getDtcgTokensForSession(db, sessionId);
@@ -17432,9 +17517,9 @@ async function writeTokensFile(db, sessionId, outDir, onProgress) {
     throw new Error(`generate tokens: no tokens persisted for session ${sessionId}`);
   }
   const tree = rebuildDTCGTree(result.groups, result.tokens);
-  const tokensPath = join15(outDir, "tokens.json");
-  await mkdir5(outDir, { recursive: true });
-  await writeFile5(tokensPath, `${JSON.stringify(tree, null, 2)}
+  const tokensPath = join18(outDir, "tokens.json");
+  await mkdir7(outDir, { recursive: true });
+  await writeFile7(tokensPath, `${JSON.stringify(tree, null, 2)}
 `);
   return { tokensPath, tokenCount: result.tokens.length };
 }
@@ -17449,7 +17534,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 readFile19(pathResolve(rawTokensPath), "utf8");
+  const rawTokensInline = await readFile20(pathResolve(rawTokensPath), "utf8");
   const tokenInputHash = hashTokenContent(rawTokensInline);
   const db = openPipelineDb();
   try {
@@ -17566,7 +17651,7 @@ async function readExistingEntities(request) {
 // 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 resolve20 } from "node:path";
+import { resolve as resolve21 } from "node:path";
 async function resolveGeneratePrompt(overrides) {
   const { overrides: parsed, errors } = parsePromptOverrides(overrides);
   if (errors.length > 0)
@@ -17577,7 +17662,7 @@ async function resolveGeneratePrompt(overrides) {
   const text = await resolvePromptOverride(entry);
   if (entry.kind === "text")
     return { text };
-  return { path: resolve20(entry.value), text };
+  return { path: resolve21(entry.value), text };
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/orchestrators/run-generate-components-session/helpers/run-one-generate-component.js
@@ -17961,7 +18046,7 @@ function PathValidationScreen({
 }) {
   const resolvedPath = useMemo(() => resolveUserPath(projectPath), [projectPath]);
   const [scan, setScan] = useState7();
-  useEffect4(() => {
+  useEffect6(() => {
     setScan(scanFiles(resolvedPath));
   }, [resolvedPath]);
   const phase = phaseOf(scan);
@@ -17988,7 +18073,7 @@ function PathValidationScreen({
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/04-credentials/screen.tsx
-import { useRef as useRef2, useState as useState9 } from "react";
+import { useRef as useRef4, useState as useState9 } from "react";
 import { Box as Box14, Text as Text14, useInput as useInput11 } from "ink";
 
 // packages/experience-design-system-cli/src/tui/shared/components/FieldForm.tsx
@@ -18240,7 +18325,7 @@ function CredentialsScreen({
   validate: validate3 = validateCredentials,
   tokensOnly = false
 }) {
-  const initialValues = useRef2(
+  const initialValues = useRef4(
     normalize({
       spaceId: initial.spaceId ?? "",
       environmentId: initial.environmentId || "master",
@@ -18621,23 +18706,23 @@ function TokenReviewScreen({ tokensPath, onContinue, onQuit }) {
 init_config();
 
 // packages/experience-design-system-cli/src/tui/import/steps/06-extraction/use-extraction.ts
-import { useEffect as useEffect5, useRef as useRef3, useState as useState11 } from "react";
+import { useEffect as useEffect7, useRef as useRef5, useState as useState11 } from "react";
 
 // packages/experience-design-system-cli/src/tui/import/steps/06-extraction/run.ts
-import { mkdir as mkdir7 } from "node:fs/promises";
-import { join as join18, resolve as resolve23 } from "node:path";
+import { mkdir as mkdir8 } from "node:fs/promises";
+import { join as join20, resolve as resolve24 } 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 dirname15, join as join17, resolve as resolve21 } from "node:path";
+import { existsSync as existsSync9 } from "node:fs";
+import { dirname as dirname16, join as join19, resolve as resolve22 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function findSkillPath(fileName) {
-  const thisDir = dirname15(fileURLToPath4(import.meta.url));
+  const thisDir = dirname16(fileURLToPath4(import.meta.url));
   let dir = thisDir;
   for (; ; ) {
-    const candidate = join17(dir, "skills", fileName);
-    if (existsSync8(candidate)) return candidate;
-    const parent = resolve21(dir, "..");
+    const candidate = join19(dir, "skills", fileName);
+    if (existsSync9(candidate)) return candidate;
+    const parent = resolve22(dir, "..");
     if (parent === dir) {
       throw new Error(`skill file not found (looked for skills/${fileName} from ${thisDir})`);
     }
@@ -18646,11 +18731,11 @@ function findSkillPath(fileName) {
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/06-extraction/selection.ts
-import { resolve as resolve22 } from "node:path";
+import { resolve as resolve23 } from "node:path";
 var SELECT_SKILL_PATH = findSkillPath("select-components.md");
 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(resolve22(options.promptPath)) : await hashFile(SELECT_SKILL_PATH);
+  const promptHash = options.promptText ? hashContent(options.promptText) : options.promptPath ? await hashFile(resolve23(options.promptPath)) : await hashFile(SELECT_SKILL_PATH);
   return hashContent(`${promptHash}|${options.agent}|${options.model ?? ""}`);
 }
 async function runSelection(options) {
@@ -18745,7 +18830,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 = input.outDir ?? join18(resolve23(input.projectPath), ".contentful");
+  const outDir = input.outDir ?? join20(resolve24(input.projectPath), ".contentful");
   let progress = initialProgress({
     hasCredentials: input.credentials !== null,
     hasRawTokens: input.rawTokensPath !== ""
@@ -18849,7 +18934,7 @@ async function runExtraction(input, onProgress, deps = realDeps) {
 }
 async function fetchEntities(credentials, outDir) {
   try {
-    await mkdir7(outDir, { recursive: true });
+    await mkdir8(outDir, { recursive: true });
     const result = await fetchAndPersistExistingContentfulEntities({
       spaceId: credentials.spaceId,
       environmentId: credentials.environmentId,
@@ -18869,7 +18954,7 @@ async function resolveSelectionPrompt(overrides) {
   if (select?.kind === "text") return { promptText: select.value };
   if (select?.kind === "path") {
     await resolvePromptOverride(select);
-    return { promptPath: resolve23(select.value) };
+    return { promptPath: resolve24(select.value) };
   }
   return {};
 }
@@ -18877,8 +18962,8 @@ async function resolveSelectionPrompt(overrides) {
 // packages/experience-design-system-cli/src/tui/import/steps/06-extraction/use-extraction.ts
 function useExtraction(input) {
   const [state2, setState] = useState11();
-  const current = useRef3();
-  useEffect5(() => {
+  const current = useRef5();
+  useEffect7(() => {
     current.current = input;
     if (!input) {
       setState(void 0);
@@ -18904,7 +18989,7 @@ function useExtraction(input) {
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/06-extraction/use-tokens-only.ts
-import { useEffect as useEffect6, useRef as useRef4, useState as useState12 } from "react";
+import { useEffect as useEffect8, useRef as useRef6, useState as useState12 } from "react";
 
 // packages/experience-design-system-cli/src/tui/import/steps/06-extraction/run-tokens-only.ts
 var TOKENS_SKILL_PATH2 = findSkillPath("generate-tokens.md");
@@ -18938,8 +19023,8 @@ async function runTokensOnly(input, deps = realDeps2) {
 // packages/experience-design-system-cli/src/tui/import/steps/06-extraction/use-tokens-only.ts
 function useTokensOnly(input) {
   const [state2, setState] = useState12();
-  const current = useRef4();
-  useEffect6(() => {
+  const current = useRef6();
+  useEffect8(() => {
     current.current = input;
     if (!input) {
       setState(void 0);
@@ -19198,6 +19283,7 @@ function GotoBanner({
       borderStyle: "single",
       borderColor: PALETTE.accent,
       paddingX: 1,
+      paddingBottom: 1,
       marginTop: width === void 0 ? 1 : 0,
       width,
       flexShrink: 0,
@@ -19209,7 +19295,7 @@ function GotoBanner({
           return renderRow(row, i, i === highlightIndex);
         }),
         moreBelow > 0 && /* @__PURE__ */ jsx24(Text21, { color: PALETTE.muted, children: `  \u25BC ${moreBelow} more` }),
-        footerHint !== void 0 && /* @__PURE__ */ jsx24(Text21, { color: PALETTE.muted, children: footerHint })
+        footerHint !== void 0 && /* @__PURE__ */ jsx24(Box21, { marginTop: 1, children: /* @__PURE__ */ jsx24(Text21, { color: PALETTE.muted, children: footerHint }) })
       ]
     }
   );
@@ -19707,11 +19793,11 @@ function buildVisibleRows(props) {
     if (!expanded) continue;
     const subtree = computeCycleMemberSubtree(key);
     const isLastAtDepthSubtree = (idx) => {
-      const own = subtree[idx].depth;
+      const own2 = subtree[idx].depth;
       for (let j = idx + 1; j < subtree.length; j++) {
         const d = subtree[j].depth;
-        if (d < own) return true;
-        if (d === own) return false;
+        if (d < own2) return true;
+        if (d === own2) return false;
       }
       return true;
     };
@@ -19831,11 +19917,11 @@ function buildVisibleRows(props) {
       injectedChildren.push({ name: c2.name, depth: c2.depth, isCycleChild: false });
     }
     const isLastAtDepth = (idx) => {
-      const own = injectedChildren[idx].depth;
+      const own2 = injectedChildren[idx].depth;
       for (let j = idx + 1; j < injectedChildren.length; j++) {
         const d = injectedChildren[j].depth;
-        if (d < own) return true;
-        if (d === own) return false;
+        if (d < own2) return true;
+        if (d === own2) return false;
       }
       return true;
     };
@@ -20068,7 +20154,7 @@ import React11 from "react";
 import { Box as Box23, Text as Text24 } from "ink";
 
 // packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/sidebar/hooks/useImmediateInput.ts
-import { useLayoutEffect, useRef as useRef5 } from "react";
+import { useLayoutEffect, useRef as useRef7 } from "react";
 import { useStdin } from "ink";
 function parseInput(data) {
   const isShiftTab = data === "\x1B[Z";
@@ -20131,7 +20217,7 @@ function registerInputHandler(stdin, setRawMode, handler) {
 }
 function useImmediateInput(handler, enabled = true) {
   const { stdin, setRawMode } = useStdin();
-  const handlerRef = useRef5(handler);
+  const handlerRef = useRef7(handler);
   handlerRef.current = handler;
   useLayoutEffect(() => {
     if (!enabled) return;
@@ -20142,7 +20228,7 @@ function useImmediateInput(handler, enabled = true) {
 
 // packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/sidebar/hooks/use-terminal-size.ts
 import { useStdout as useStdout2 } from "ink";
-import { useEffect as useEffect7, useState as useState13 } from "react";
+import { useEffect as useEffect9, useState as useState13 } from "react";
 function readTerminalSize(stdout) {
   return {
     columns: stdout?.columns ?? 80,
@@ -20152,7 +20238,7 @@ function readTerminalSize(stdout) {
 function useTerminalSize() {
   const { stdout } = useStdout2();
   const [size, setSize] = useState13(() => readTerminalSize(stdout));
-  useEffect7(() => {
+  useEffect9(() => {
     const updateSize = () => setSize(readTerminalSize(stdout));
     stdout?.on("resize", updateSize);
     updateSize();
@@ -20335,7 +20421,7 @@ function createSidebarViewsHelpSection(includeBreaking) {
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/use-scope-gate.ts
-import { useEffect as useEffect8, useMemo as useMemo3, useRef as useRef6, useState as useState16 } from "react";
+import { useEffect as useEffect10, useMemo as useMemo3, useRef as useRef8, useState as useState16 } from "react";
 
 // packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/columns.ts
 var TWO_COLUMN_MIN_WIDTH = 100;
@@ -21071,8 +21157,8 @@ function useScopeGate({ components, tokenCount, tokensWidth, onConfirm, onQuit }
     for (const p of cycleParticipants) seed.add(p);
     return seed;
   });
-  const seededGroupsRef = useRef6(closures.size > 0 || cycleParticipants.size > 0);
-  useEffect8(() => {
+  const seededGroupsRef = useRef8(closures.size > 0 || cycleParticipants.size > 0);
+  useEffect10(() => {
     if (seededGroupsRef.current) return;
     if (closures.size === 0 && cycleParticipants.size === 0) return;
     seededGroupsRef.current = true;
@@ -21163,7 +21249,7 @@ function useScopeGate({ components, tokenCount, tokensWidth, onConfirm, onQuit }
     entryCount: 0
   });
   const panelLayout = useMemo3(() => computePanelLayout(visibleCount), [visibleCount]);
-  useEffect8(() => {
+  useEffect10(() => {
     setNav((prev) => {
       const maxIdx = Math.max(0, visibleRows.length - 1);
       const nextCursor = Math.min(prev.cursor, maxIdx);
@@ -21638,7 +21724,7 @@ function ScopeGateView({ components, tokensPath, onConfirm, onQuit }) {
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/use-scope-gate-flow.ts
-import { useEffect as useEffect9, useMemo as useMemo5, useRef as useRef7, useState as useState17 } from "react";
+import { useEffect as useEffect11, useMemo as useMemo5, useRef as useRef9, useState as useState17 } from "react";
 
 // packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/cache-check.ts
 async function checkGenerationCache(input) {
@@ -21685,9 +21771,9 @@ var realDeps3 = { load: loadScopeGate, checkCache: checkGenerationCache };
 function useScopeGateFlow(input, deps = realDeps3) {
   const sessionId = input?.sessionId;
   const loaded = useMemo5(() => sessionId ? deps.load(sessionId) : void 0, [sessionId]);
-  const cacheCheck = useRef7(void 0);
+  const cacheCheck = useRef9(void 0);
   const [confirmed, setConfirmed] = useState17();
-  useEffect9(() => {
+  useEffect11(() => {
     if (!input || !loaded?.ok || cacheCheck.current) return;
     cacheCheck.current = deps.checkCache(input.cache);
   }, [input, loaded]);
@@ -21714,7 +21800,7 @@ var capitalize = (name) => name.charAt(0).toUpperCase() + name.slice(1);
 function describeGeneration(input) {
   const agent = capitalize(input.agent);
   return `${formatAcceptanceSummary({ accepted: input.acceptedCount, autoRejected: 0 })}
-${agent} is reading each selected component and writing a Contentful component definition for it${input.hasTokens ? " Using your design tokens for prop resolution." : ""}`;
+${agent} is reading each selected component and writing a Contentful component definition for it.${input.hasTokens ? "\nUsing your design tokens for prop resolution." : ""}`;
 }
 function progressRows2(progress, agent) {
   const name = capitalize(agent);
@@ -21754,10 +21840,10 @@ function GenerationScreen({
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/08-generation/use-generation.ts
-import { useEffect as useEffect10, useRef as useRef8, useState as useState18 } from "react";
+import { useEffect as useEffect12, useRef as useRef10, useState as useState18 } from "react";
 
 // packages/experience-design-system-cli/src/tui/import/steps/08-generation/run.ts
-import { resolve as resolve24 } from "node:path";
+import { resolve as resolve25 } from "node:path";
 
 // packages/experience-design-system-cli/src/tui/import/steps/08-generation/map-tokens.ts
 async function prepareMapTokens(input, generatedSessionId) {
@@ -21892,7 +21978,7 @@ async function buildMapTokensOptions(input) {
   if (mapOverride?.kind === "text") prompt.skillContentOverride = mapOverride.value;
   if (mapOverride?.kind === "path") {
     await resolvePromptOverride(mapOverride);
-    prompt.skillPathOverride = resolve24(mapOverride.value);
+    prompt.skillPathOverride = resolve25(mapOverride.value);
   }
   if (input.existingEntitiesPath) {
     const entities = await readExistingContentfulEntitiesFromSession({ path: input.existingEntitiesPath });
@@ -21919,8 +22005,8 @@ function applyProgressEvent2(event, previous, total) {
 // packages/experience-design-system-cli/src/tui/import/steps/08-generation/use-generation.ts
 function useGeneration(input) {
   const [state2, setState] = useState18();
-  const current = useRef8();
-  useEffect10(() => {
+  const current = useRef10();
+  useEffect12(() => {
     current.current = input;
     if (!input) {
       setState(void 0);
@@ -21940,7 +22026,7 @@ function useGeneration(input) {
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/10-flow/flow/build-flow-start.ts
-import { join as join19 } from "node:path";
+import { join as join21 } from "node:path";
 function buildFlowStart(input) {
   const { extraction, handoff, saved, generatePromptPath, tokensOnly } = input;
   const credentials = extraction.credentials ?? {
@@ -21953,7 +22039,7 @@ function buildFlowStart(input) {
     handoff,
     agent: extraction.agent,
     projectPath: extraction.projectPath,
-    outDir: extraction.projectPath ? join19(extraction.projectPath, ".contentful") : "",
+    outDir: extraction.projectPath ? join21(extraction.projectPath, ".contentful") : "",
     rawTokensPath: extraction.rawTokensPath,
     credentials: {
       spaceId: credentials.spaceId,
@@ -22252,6 +22338,94 @@ 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-types/dist/src/property-contract/json-value.js
+var nodeTypes = globalThis.process?.getBuiltinModule?.("node:util")?.types;
+
+// packages/experience-design-system-types/dist/src/property-contract/date-time-value.js
+import * as z5 from "zod/mini";
+var dateTimeValueSchema = z5.iso.datetime({ offset: true });
+
+// packages/experience-design-system-types/dist/src/property-contract/target-definition.js
+var TARGET_PROPERTY_TYPES = [
+  "String",
+  "Number",
+  "Boolean",
+  "Array",
+  "Record",
+  "Integer",
+  "DateTime",
+  "RichText",
+  "JSON",
+  "ResourceLink",
+  "Literal",
+  "DiscriminatedUnion"
+];
+var SAME_SPACE_RESOURCE_SOURCE = "crn:contentful:::content:spaces/$self/environments/$self";
+var targetDefinitionJsonSchema = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $ref: "#/definitions/target",
+  definitions: {
+    target: {
+      type: "object",
+      required: ["type"],
+      properties: {
+        type: { enum: [...TARGET_PROPERTY_TYPES] },
+        id: { type: "string" },
+        name: { type: "string" },
+        description: { type: "string" },
+        required: { type: "boolean" },
+        values: { type: "array", minItems: 1 },
+        defaultValue: {},
+        items: { $ref: "#/definitions/target" },
+        fields: { type: "object", minProperties: 1, additionalProperties: { $ref: "#/definitions/target" } },
+        allowedResources: {
+          type: "array",
+          minItems: 1,
+          items: {
+            type: "object",
+            required: ["type", "source"],
+            properties: {
+              type: { enum: ["Contentful:Entry", "Contentful:Asset"] },
+              source: { const: SAME_SPACE_RESOURCE_SOURCE },
+              allowedTypes: { type: "array", items: { type: "string" } }
+            },
+            allOf: [
+              {
+                if: { properties: { type: { const: "Contentful:Entry" } } },
+                then: { required: ["allowedTypes"] },
+                else: { not: { required: ["allowedTypes"] } }
+              }
+            ],
+            additionalProperties: false
+          }
+        },
+        value: {},
+        valueType: { $ref: "#/definitions/target" },
+        discriminator: { type: "string", minLength: 1 },
+        members: {
+          type: "array",
+          minItems: 2,
+          uniqueItems: true,
+          items: {
+            allOf: [
+              { $ref: "#/definitions/target" },
+              { type: "object", properties: { type: { const: "Record" } }, required: ["type", "fields"] }
+            ]
+          }
+        }
+      },
+      allOf: [
+        {
+          if: { properties: { type: { const: "DiscriminatedUnion" } } },
+          then: { required: ["discriminator", "members"] },
+          else: { not: { anyOf: [{ required: ["discriminator"] }, { required: ["members"] }] } }
+        }
+      ],
+      additionalProperties: false
+    }
+  }
+};
+
 // 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))];
@@ -22313,7 +22487,7 @@ function PreviewValidationErrorScreen({
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/09-review/generate-review-step.tsx
-import { useCallback as useCallback5, useEffect as useEffect17, useMemo as useMemo6, useRef as useRef13, useState as useState26 } from "react";
+import { useCallback as useCallback5, useEffect as useEffect19, useMemo as useMemo6, useRef as useRef15, useState as useState26 } from "react";
 import figures8 from "figures";
 
 // packages/experience-design-system-cli/src/tui/import/steps/09-review/review-json-panel.ts
@@ -22372,14 +22546,14 @@ function computeRenderStatuses(closure, directIssues) {
   for (const node of closure.nodes) {
     nodesByName.set(node.name, { name: node.name, path: node.path });
   }
-  const own = /* @__PURE__ */ new Map();
+  const own2 = /* @__PURE__ */ new Map();
   for (const node of closure.nodes) {
     const s = directIssues.get(node.name);
-    if (s && s !== "ok") own.set(node.name, s);
+    if (s && s !== "ok") own2.set(node.name, s);
   }
   const inheritedSources = /* @__PURE__ */ new Map();
   for (const node of closure.nodes) {
-    const ownStatus = own.get(node.name);
+    const ownStatus = own2.get(node.name);
     if (!ownStatus) continue;
     for (let i = 0; i < node.path.length - 1; i++) {
       const ancestor = node.path[i];
@@ -22387,7 +22561,7 @@ function computeRenderStatuses(closure, directIssues) {
       inheritedSources.get(ancestor).set(node.name, ownStatus);
     }
   }
-  for (const [name, status] of own.entries()) {
+  for (const [name, status] of own2.entries()) {
     out.set(name, {
       status,
       isOwn: true,
@@ -22574,7 +22748,7 @@ function enumerateCycleBreaks(cycle, components) {
 import { Box as Box32, Text as Text34 } from "ink";
 
 // packages/experience-design-system-cli/src/tui/import/steps/09-review/components/FieldEditor.tsx
-import React13, { useEffect as useEffect11, useLayoutEffect as useLayoutEffect2, useState as useState19 } from "react";
+import React13, { useEffect as useEffect13, useLayoutEffect as useLayoutEffect2, useState as useState19 } from "react";
 import figures6 from "figures";
 import { Box as Box26, measureElement, Text as Text27 } from "ink";
 
@@ -23372,6 +23546,7 @@ function FieldEditor({
   const [rationaleOpen, setRationaleOpen] = useState19(false);
   const [rationaleScrollOffset, setRationaleScrollOffset] = useState19(0);
   const [showHelp, setShowHelp] = useState19(false);
+  const [pendingDelete, setPendingDelete] = useState19(null);
   const props = editorState.props;
   const slots = editorState.slots;
   const contentPropIndexes = React13.useMemo(
@@ -23463,6 +23638,46 @@ function FieldEditor({
     setEditorState(next);
     onChange(serializeState(next, value));
   };
+  const deleteRow = (row) => {
+    if (row.kind === "prop") {
+      const nextProps = removeAt(editorState.props, row.idx);
+      commit({ ...editorState, props: nextProps });
+      setPropIdx(Math.max(0, Math.min(row.idx, nextProps.length - 1)));
+      const rowsAfter2 = selectableRows.filter((r) => !(r.kind === "prop" && r.idx === row.idx));
+      const neighbour2 = rowsAfter2[Math.max(0, selectableRows.findIndex((r) => r.kind === row.kind && r.idx === row.idx) - 1)];
+      if (!neighbour2) {
+        setInSlots(false);
+        setInComponentDesc(true);
+        setFocusLevel("componentDescription");
+      } else if (neighbour2.kind === "prop") {
+        setInSlots(false);
+        setPropIdx(neighbour2.idx > row.idx ? neighbour2.idx - 1 : neighbour2.idx);
+        setFocusLevel("prop");
+      } else {
+        setInSlots(true);
+        setSlotIdx(neighbour2.idx);
+        setFocusLevel("slot");
+      }
+      return;
+    }
+    const nextSlots = removeAt(editorState.slots, row.idx);
+    commit({ ...editorState, slots: nextSlots });
+    const rowsAfter = selectableRows.filter((r) => !(r.kind === "slot" && r.idx === row.idx));
+    const neighbour = rowsAfter[Math.max(0, selectableRows.findIndex((r) => r.kind === row.kind && r.idx === row.idx) - 1)];
+    if (!neighbour) {
+      setInSlots(false);
+      setInComponentDesc(true);
+      setFocusLevel("componentDescription");
+    } else if (neighbour.kind === "slot") {
+      setInSlots(true);
+      setSlotIdx(neighbour.idx > row.idx ? neighbour.idx - 1 : neighbour.idx);
+      setFocusLevel("slot");
+    } else {
+      setInSlots(false);
+      setPropIdx(neighbour.idx);
+      setFocusLevel("prop");
+    }
+  };
   const canonicalize = React13.useCallback((json) => {
     try {
       return JSON.stringify(JSON.parse(json));
@@ -23499,6 +23714,11 @@ function FieldEditor({
       onSave();
       return;
     }
+    if (pendingDelete) {
+      if (input === "y") deleteRow(pendingDelete);
+      setPendingDelete(null);
+      return;
+    }
     const inDescriptionTextEntryForHelp = focusLevel === "field" && editingField && activeField === "description";
     const inStringDefaultTextEntryForHelp = focusLevel === "field" && editingField && activeField === "default" && currentProp != null && (currentProp.type === "string" || currentProp.type === "token");
     const inValueListTextEntry = editingValue != null;
@@ -23698,6 +23918,11 @@ function FieldEditor({
         }
         return;
       }
+      if (input === "d" && !key.ctrl && !key.meta) {
+        if (focusLevel === "prop" && currentProp) setPendingDelete({ kind: "prop", idx: propIdx });
+        if (focusLevel === "slot" && currentSlot) setPendingDelete({ kind: "slot", idx: slotIdx });
+        return;
+      }
       if (focusLevel === "slot" && key.return && currentSlot) {
         setFocusLevel("field");
         setActiveField(SLOT_FIELDS[0] ?? null);
@@ -24004,6 +24229,10 @@ function FieldEditor({
   }
   const hasEmptyProperties = props.length === 0 && slots.length === 0;
   const modeLabel = (() => {
+    if (pendingDelete) {
+      const name = pendingDelete.kind === "prop" ? props[pendingDelete.idx]?.name : slots[pendingDelete.idx]?.name;
+      return `Delete ${pendingDelete.kind} "${name}"? [y] delete \xB7 any other key cancels`;
+    }
     if (editingValue) {
       return editingValue.mode === "add" ? "Enter to add \xB7 [Esc] to cancel" : "Enter to save edit \xB7 [Esc] to cancel";
     }
@@ -24025,7 +24254,7 @@ function FieldEditor({
     if (rationaleOpen) {
       return "[\u2191\u2193] scroll  [i/Esc] close rationale panel";
     }
-    return `[\u2191\u2193] navigate rows  [Enter] edit fields  [s] source  [${propRationaleKey}] prop rationale  [${componentRationaleKey}] component rationale  [h] help  [Esc] exit panel`;
+    return `[\u2191\u2193] navigate  [Enter] edit fields  [d] delete property  [h] help  [s] source  [Esc] exit panel`;
   })();
   const rows = [];
   rows.push({ kind: "component-description" });
@@ -24077,7 +24306,7 @@ function FieldEditor({
     }
     return Math.max(start + 1, end2);
   };
-  useEffect11(() => {
+  useEffect13(() => {
     if (focusLevel === "field" || selectedRowIdx < 0) return;
     setListScrollStart((previous) => {
       if (initialFocusTarget && !initialFocusScrollApplied.current) {
@@ -24291,6 +24520,7 @@ function FieldEditor({
           /* @__PURE__ */ jsx32(Text27, { bold: true, children: "Row navigation" }),
           /* @__PURE__ */ jsx32(Text27, { children: "  \u2191/\u2193               move between rows" }),
           /* @__PURE__ */ jsx32(Text27, { children: "  Enter            edit fields on the current row" }),
+          /* @__PURE__ */ jsx32(Text27, { children: "  d                delete the current prop or slot (asks to confirm)" }),
           /* @__PURE__ */ jsx32(Text27, { children: "  Esc              exit the panel" }),
           /* @__PURE__ */ jsx32(Text27, { children: " " }),
           /* @__PURE__ */ jsx32(Text27, { bold: true, children: "Field editing" }),
@@ -24314,7 +24544,7 @@ function FieldEditor({
           /* @__PURE__ */ jsx32(Text27, { color: PALETTE.muted, children: "press ? or Esc to close" })
         ] }),
         validationError && /* @__PURE__ */ jsx32(Text27, { color: PALETTE.error, children: "\u2717 " + validationError }),
-        /* @__PURE__ */ jsx32(Box26, { paddingTop: 1, children: /* @__PURE__ */ jsx32(Text27, { color: PALETTE.muted, children: modeLabel }) })
+        /* @__PURE__ */ jsx32(Box26, { paddingTop: 1, children: /* @__PURE__ */ jsx32(Text27, { color: pendingDelete ? PALETTE.text : PALETTE.muted, children: modeLabel }) })
       ]
     }
   );
@@ -24653,8 +24883,8 @@ function TokenReviewPanel({
         borderStyle: "single",
         borderColor: active ? PALETTE.text : void 0,
         children: [
-          /* @__PURE__ */ jsx39(Text32, { bold: true, color: active ? void 0 : PALETTE.muted, wrap: "truncate", children: `TOKEN REVIEW \u2014 ${componentName} \xB7 ${current.propName} (edit allowed)` }),
-          /* @__PURE__ */ jsx39(Text32, { color: PALETTE.muted, wrap: "truncate", children: `select which tokens are allowed (${rangeLabel})` }),
+          /* @__PURE__ */ jsx39(Text32, { bold: true, color: active ? void 0 : PALETTE.muted, wrap: "truncate", children: `Review mapped tokens \u2014 ${componentName} \xB7 ${current.propName}${current.kinds.length > 0 ? ` (${current.kinds.join(", ")})` : ""}` }),
+          /* @__PURE__ */ jsx39(Text32, { color: PALETTE.muted, wrap: "truncate", children: `Tick the tokens this property may use (${rangeLabel}).` }),
           /* @__PURE__ */ jsx39(Text32, { children: " " }),
           current.paths.length === 0 && /* @__PURE__ */ jsx39(Text32, { color: PALETTE.muted, children: "(no compatible tokens found for this token kind)" }),
           visiblePaths.map((path5, i) => {
@@ -24687,18 +24917,33 @@ function TokenReviewPanel({
       borderStyle: "single",
       borderColor: active ? PALETTE.text : void 0,
       children: [
-        /* @__PURE__ */ jsx39(Text32, { bold: true, color: active ? void 0 : PALETTE.muted, children: `TOKEN REVIEW \u2014 ${componentName}` }),
+        /* @__PURE__ */ jsx39(Text32, { bold: true, color: active ? void 0 : PALETTE.muted, children: `Review mapped tokens \u2014 ${componentName}` }),
+        /* @__PURE__ */ jsx39(Text32, { color: PALETTE.muted, wrap: "truncate", children: `${componentName} has ${suggestions.length} design ${suggestions.length === 1 ? "prop" : "props"} of type token. Select which tokens are allowed for each property.` }),
+        /* @__PURE__ */ jsx39(Text32, { color: PALETTE.muted, wrap: "truncate", children: "Suggested tokens come from the agent. Allowed tokens are what editors can pick in Contentful." }),
+        /* @__PURE__ */ jsx39(Text32, { children: " " }),
         suggestions.length === 0 && /* @__PURE__ */ jsx39(Text32, { color: PALETTE.muted, children: "(no token suggestions for this component)" }),
         suggestions.map((s, i) => {
           const focused = i === selectedRow;
           return /* @__PURE__ */ jsxs30(Box31, { flexDirection: "column", children: [
-            /* @__PURE__ */ jsx39(Box31, { children: /* @__PURE__ */ jsx39(Text32, { color: focused ? PALETTE.accent : active ? void 0 : PALETTE.muted, bold: focused, children: `${focused ? figures7.pointer : " "} ${s.propName}` }) }),
-            /* @__PURE__ */ jsx39(Text32, { color: PALETTE.muted, children: `  suggested: ${s.suggested.join(", ")}` }),
-            /* @__PURE__ */ jsx39(Text32, { color: PALETTE.muted, children: `  allowed: ${s.allowed.join(", ")}` })
+            /* @__PURE__ */ jsx39(Box31, { children: /* @__PURE__ */ jsx39(Text32, { color: focused ? PALETTE.accent : active ? void 0 : PALETTE.muted, bold: focused, children: `${focused ? figures7.pointer : " "} ${s.propName}${s.kinds.length > 0 ? ` (${s.kinds.join(", ")})` : ""}` }) }),
+            /* @__PURE__ */ jsx39(
+              Text32,
+              {
+                color: PALETTE.muted,
+                children: `  suggested: ${s.suggested.length > 0 ? s.suggested.join(", ") : "none"}`
+              }
+            ),
+            /* @__PURE__ */ jsx39(
+              Text32,
+              {
+                color: PALETTE.muted,
+                children: `  allowed: ${s.allowed.length > 0 ? s.allowed.join(", ") : "none (any token)"}`
+              }
+            ),
+            /* @__PURE__ */ jsx39(Text32, { children: " " })
           ] }, s.propName);
         }),
-        /* @__PURE__ */ jsx39(Text32, { children: " " }),
-        /* @__PURE__ */ jsx39(Text32, { children: "[\u2191/\u2193] move  [Enter] edit allowed  [Esc] close" })
+        /* @__PURE__ */ jsx39(Text32, { color: PALETTE.muted, children: "[\u2191/\u2193] move  [Enter] edit allowed tokens  [Esc] close" })
       ]
     }
   );
@@ -24946,15 +25191,9 @@ function ReviewFinalizeError({
 function ReviewPanelFooter({
   reviewEditor,
   sidebarFocused,
-  sidebarFooter,
-  livePreview,
-  livePreviewSpinner
+  sidebarFooter
 }) {
-  return /* @__PURE__ */ jsxs32(Fragment10, { children: [
-    reviewEditor.panelOpen === "token-review" ? "  [\u2191/\u2193] move  [Enter] edit allowed  [Esc] close" : sidebarFocused ? sidebarFooter : reviewEditor.showJson ? "  [\u2191\u2193] scroll  [Ctrl+u/d] half-page  [gg/G] top/bottom  [Tab] focus list" : "  [Tab] focus list  (edit fields)" + (reviewEditor.currentTokenSuggestions().length > 0 ? "  [t] token review" : ""),
-    livePreview.status === "running" && /* @__PURE__ */ jsx42(Text34, { children: `  ${livePreviewSpinner} live preview` }),
-    livePreview.disabled && /* @__PURE__ */ jsx42(Text34, { children: "  \xB7 live preview disabled" })
-  ] });
+  return /* @__PURE__ */ jsx42(Fragment10, { children: reviewEditor.panelOpen === "token-review" ? "" : sidebarFocused ? sidebarFooter : reviewEditor.showJson ? "  [\u2191\u2193] scroll  [Ctrl+u/d] half-page  [gg/G] top/bottom  [Tab] focus list" : "  [Tab] focus list  [Enter] edit fields" + (reviewEditor.currentTokenSuggestions().length > 0 ? "  [t] review mapped tokens" : "") });
 }
 function ReviewComponentTitle({
   selectedKey,
@@ -24988,9 +25227,7 @@ function ReviewComponentPanel({
   sidebarFocused,
   fieldEditor,
   saveError,
-  sidebarFooter,
-  livePreview,
-  livePreviewSpinner
+  sidebarFooter
 }) {
   const propCount = Object.keys(selectedEntry.$properties).length;
   const slotCount = selectedEntry.$slots ? Object.keys(selectedEntry.$slots).length : 0;
@@ -25027,9 +25264,7 @@ function ReviewComponentPanel({
       {
         reviewEditor,
         sidebarFocused,
-        sidebarFooter,
-        livePreview,
-        livePreviewSpinner
+        sidebarFooter
       }
     ) }) })
   ] }) });
@@ -25143,7 +25378,7 @@ function finalizeReviewSession(extractSessionId, components) {
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/09-review/use-review-session.ts
-import { useCallback as useCallback2, useEffect as useEffect13, useRef as useRef10, useState as useState21 } from "react";
+import { useCallback as useCallback2, useEffect as useEffect15, useRef as useRef12, useState as useState21 } from "react";
 
 // packages/experience-design-system-cli/src/tui/import/steps/09-review/history.ts
 var DEFAULT_MAX_DEPTH = 50;
@@ -25199,7 +25434,7 @@ function createHistoryStack(seed, maxDepth = DEFAULT_MAX_DEPTH) {
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/09-review/use-finalize-preview.ts
-import { useEffect as useEffect12, useRef as useRef9, useState as useState20 } from "react";
+import { useEffect as useEffect14, useRef as useRef11, useState as useState20 } from "react";
 
 // packages/experience-design-system-cli/src/tui/import/steps/09-review/run-live-preview.ts
 var TimeoutError = class extends Error {
@@ -25357,9 +25592,9 @@ function useFinalizePreview(opts) {
   const [status, setStatus] = useState20("idle");
   const [removed, setRemoved] = useState20([]);
   const [scrollOffset, setScrollOffset] = useState20(0);
-  const generationRef = useRef9(0);
+  const generationRef = useRef11(0);
   const acceptedKey = [...acceptedKeys].sort().join("\0");
-  useEffect12(() => {
+  useEffect14(() => {
     if (!open) {
       setStatus("idle");
       setRemoved([]);
@@ -25422,7 +25657,7 @@ function useReviewSession({
     }));
     return { result, catalog };
   }, [loadSession, tokensPath]);
-  useEffect13(() => {
+  useEffect15(() => {
     let disposed = false;
     void (async () => {
       try {
@@ -25475,7 +25710,7 @@ function useReviewSession({
 function useReviewMetadata({ components, selectedIdx, extractSessionId }) {
   const [reviewMetadata, setReviewMetadata] = useState21(null);
   const [componentRationale, setComponentRationale] = useState21(null);
-  useEffect13(() => {
+  useEffect15(() => {
     const current = components[selectedIdx];
     if (!current) {
       setReviewMetadata(null);
@@ -25505,9 +25740,9 @@ function useReviewMetadata({ components, selectedIdx, extractSessionId }) {
   return { reviewMetadata, componentRationale };
 }
 function useReviewHistory({ loading, components, createSnapshot, applySnapshot }) {
-  const historyRef = useRef10(null);
-  const historySeededRef = useRef10(false);
-  useEffect13(() => {
+  const historyRef = useRef12(null);
+  const historySeededRef = useRef12(false);
+  useEffect15(() => {
     if (loading || historySeededRef.current) return;
     historySeededRef.current = true;
     historyRef.current = createHistoryStack(createSnapshot(components));
@@ -25558,7 +25793,7 @@ function useReviewFinalize({
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/09-review/use-review-editor.ts
-import { useEffect as useEffect14, useRef as useRef11, useState as useState22 } from "react";
+import { useEffect as useEffect16, useRef as useRef13, useState as useState22 } from "react";
 
 // packages/experience-design-system-cli/src/tui/import/steps/09-review/token-suggestions.ts
 function collectTokenSuggestions(entry, availableTokens = []) {
@@ -25573,7 +25808,7 @@ function collectTokenSuggestions(entry, availableTokens = []) {
     const compatiblePaths = new Set(compatible);
     const allowed = availableTokens.length > 0 ? persistedAllowed.filter((path5) => compatiblePaths.has(path5)) : persistedAllowed;
     const paths = availableTokens.length > 0 ? compatible : allowed;
-    return { propName, paths, suggested: [...allowed], allowed };
+    return { propName, kinds, paths, suggested: [...allowed], allowed };
   });
 }
 
@@ -25609,9 +25844,9 @@ function useReviewEditor({
   const [tokenReviewEditing, setTokenReviewEditing] = useState22(false);
   const [tokenReviewEditCursor, setTokenReviewEditCursor] = useState22(0);
   const [tokenReviewEditSelection, setTokenReviewEditSelection] = useState22(/* @__PURE__ */ new Set());
-  const tokenReviewSuggestedRef = useRef11(/* @__PURE__ */ new Map());
-  const pendingGRef = useRef11(false);
-  useEffect14(() => {
+  const tokenReviewSuggestedRef = useRef13(/* @__PURE__ */ new Map());
+  const pendingGRef = useRef13(false);
+  useEffect16(() => {
     setTokenReviewRow(0);
     setTokenReviewEditing(false);
     setTokenReviewEditCursor(0);
@@ -26023,7 +26258,7 @@ function handleJsonPanelInput(input, key, state2) {
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/09-review/use-review-preview.ts
-import { useCallback as useCallback4, useEffect as useEffect16, useState as useState25 } from "react";
+import { useCallback as useCallback4, useEffect as useEffect18, useState as useState25 } from "react";
 
 // packages/experience-design-system-cli/src/tui/import/steps/09-review/preview-annotations.ts
 function applyPreviewAnnotations(preview, localNames) {
@@ -26058,25 +26293,25 @@ function applyPreviewAnnotations(preview, localNames) {
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/09-review/use-live-preview.ts
-import { useCallback as useCallback3, useEffect as useEffect15, useRef as useRef12, useState as useState24 } from "react";
+import { useCallback as useCallback3, useEffect as useEffect17, useRef as useRef14, useState as useState24 } from "react";
 var DEFAULT_DEBOUNCE_MS = 500;
 function useLivePreview(opts) {
   const debounceMs = opts.debounceMs ?? DEFAULT_DEBOUNCE_MS;
   const [status, setStatus] = useState24("idle");
   const [disabled, setDisabled] = useState24(false);
-  const timerRef = useRef12(null);
-  const generationRef = useRef12(0);
-  const latestRef = useRef12(0);
-  const inflightRef = useRef12(0);
-  const optsRef = useRef12(opts);
-  useEffect15(() => {
+  const timerRef = useRef14(null);
+  const generationRef = useRef14(0);
+  const latestRef = useRef14(0);
+  const inflightRef = useRef14(0);
+  const optsRef = useRef14(opts);
+  useEffect17(() => {
     optsRef.current = opts;
   });
-  const disabledRef = useRef12(disabled);
-  useEffect15(() => {
+  const disabledRef = useRef14(disabled);
+  useEffect17(() => {
     disabledRef.current = disabled;
   }, [disabled]);
-  useEffect15(() => {
+  useEffect17(() => {
     return () => {
       if (timerRef.current) {
         clearTimeout(timerRef.current);
@@ -26190,13 +26425,13 @@ function useReviewPreview({
     deleteAllComponents
   });
   const [spinnerTick, setSpinnerTick] = useState25(0);
-  useEffect16(() => {
+  useEffect18(() => {
     if (livePreviewHook.status !== "running") return;
     const id = setInterval(() => setSpinnerTick((tick) => tick + 1), 80);
     return () => clearInterval(id);
   }, [livePreviewHook.status]);
   const livePreviewSpinner = SPINNER_FRAMES[spinnerTick % SPINNER_FRAMES.length];
-  useEffect16(() => {
+  useEffect18(() => {
     if (loading) return;
     if (!livePreview) return;
     if (components.length === 0) return;
@@ -26369,7 +26604,7 @@ var HELP_SECTIONS2 = [
       { keys: "P", label: "Component rationale" },
       { keys: "s", label: "Source code snippet" },
       { keys: "J", label: "Toggle JSON" },
-      { keys: "t", label: "Token review" }
+      { keys: "t", label: "Review mapped tokens" }
     ]
   },
   {
@@ -26509,7 +26744,7 @@ function GenerateReviewStepView({
     setFinalizeError
   } = reviewSurface;
   const [removedBannerCollapsed, setRemovedBannerCollapsed] = useState26(false);
-  const removedBannerDefaultedRef = useRef13(false);
+  const removedBannerDefaultedRef = useRef15(false);
   const [cyclePanelScroll, setCyclePanelScroll] = useState26(0);
   const [cyclesCursor, setCyclesCursor] = useState26(0);
   const cyclePanel = useOverlayPanel({
@@ -26529,7 +26764,7 @@ function GenerateReviewStepView({
   const [breakCursor, setBreakCursor] = useState26(0);
   const [breakConfirm, setBreakConfirm] = useState26(false);
   const [expandedGroups, setExpandedGroups] = useState26(/* @__PURE__ */ new Set());
-  const seededGroupsRef = useRef13(false);
+  const seededGroupsRef = useRef15(false);
   const {
     searchOpen,
     setSearchOpen,
@@ -26553,7 +26788,7 @@ function GenerateReviewStepView({
   const [pendingEditorFocus, setPendingEditorFocus] = useState26(null);
   const [autoRejected, setAutoRejected] = useState26([]);
   const [undoSnapshot, setUndoSnapshot] = useState26(null);
-  const autoRejectFiredRef = useRef13(false);
+  const autoRejectFiredRef = useRef15(false);
   const [showReloadDialog, setShowReloadDialog] = useState26(false);
   const acceptedCountForPreview = components.filter((c2) => c2.status === "accepted").length;
   const { previewAnnotations, removedComponents, livePreviewHook, livePreviewSpinner } = useReviewPreview({
@@ -26616,7 +26851,7 @@ function GenerateReviewStepView({
     [components]
   );
   const closures = useMemo6(() => computeAllClosures(componentGraph), [componentGraph]);
-  useEffect17(() => {
+  useEffect19(() => {
     if (seededGroupsRef.current) return;
     if (closures.size === 0 && slotCycles.length === 0) return;
     seededGroupsRef.current = true;
@@ -26643,7 +26878,7 @@ function GenerateReviewStepView({
       suggestedBreak: cycle.edges.length > 0 ? suggestCycleBreakEdge2(cycle, cycleView.pushBlocking) : null
     }));
   }, [slotCycles, cycleView]);
-  useEffect17(() => {
+  useEffect19(() => {
     const decision = computeAutoRejectDecision({
       loading,
       autoRejectFired: autoRejectFiredRef.current,
@@ -26686,8 +26921,8 @@ function GenerateReviewStepView({
     }),
     applySnapshot: applyHistorySnapshot
   });
-  const autoRejectPushedRef = useRef13(false);
-  useEffect17(() => {
+  const autoRejectPushedRef = useRef15(false);
+  useEffect19(() => {
     if (loading) return;
     if (!historySeededRef.current) return;
     if (!autoRejectFiredRef.current) return;
@@ -26771,7 +27006,7 @@ function GenerateReviewStepView({
   const panelHeight = leftPanelHeight + 2;
   const panelContentHeight = Math.max(1, panelHeight - 3);
   const cycleViewportHeight = Math.max(1, panelHeight - 4);
-  useEffect17(() => {
+  useEffect19(() => {
     if (selectableRowPositions.length === 0) return;
     const cursorInRange = selectableRowPositions.includes(cursorRowIdx);
     const maxScroll = Math.max(0, visibleRowsMemo.length - visibleCount);
@@ -27517,9 +27752,7 @@ function GenerateReviewStepView({
               initialFocusTarget: pendingEditorFocus && pendingEditorFocus.componentName === selected.key ? pendingEditorFocus.target : { kind: "description" }
             }
           ),
-          saveError: reviewEditor.saveError,
-          livePreview: livePreviewHook,
-          livePreviewSpinner
+          saveError: reviewEditor.saveError
         }
       ) : /* @__PURE__ */ jsx48(ReviewNoSelection, {})
     ] }),
@@ -27551,7 +27784,7 @@ function GenerateReviewStepView({
         hidden: dialogOpen
       }
     ),
-    !dialogOpen && sidebarFocused && /* @__PURE__ */ jsx48(CompactControlBar, { hasGroupRoots, searchActive: searchOpen || searchQuery.length > 0 })
+    !dialogOpen && sidebarFocused && reviewEditor.panelOpen !== "token-review" && /* @__PURE__ */ jsx48(CompactControlBar, { hasGroupRoots, searchActive: searchOpen || searchQuery.length > 0 })
   ] });
 }
 
@@ -27696,11 +27929,11 @@ function DoneStep({
 // packages/experience-design-system-cli/src/tui/import/steps/10-flow/screens/PathPrompt.tsx
 import { useState as useState28 } from "react";
 import { Box as Box42, Text as Text44 } from "ink";
-import { readdirSync as readdirSync3 } from "node:fs";
-import { dirname as dirname16, basename as basename6, join as join20 } from "node:path";
+import { readdirSync as readdirSync4 } from "node:fs";
+import { dirname as dirname17, basename as basename6, join as join22 } from "node:path";
 
 // packages/experience-design-system-cli/src/tui/import/steps/10-flow/support/path-utils.ts
-import { resolve as resolve25 } from "node:path";
+import { resolve as resolve26 } from "node:path";
 import { homedir as homedir4 } from "node:os";
 function expandTilde(input) {
   if (input === "~" || input.startsWith("~/") || input.startsWith("~\\")) {
@@ -27714,14 +27947,14 @@ function normalizePath(input) {
     p = p.slice(1, -1);
   }
   p = expandTilde(p);
-  return resolve25(p);
+  return resolve26(p);
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/10-flow/support/use-blinking-cursor.ts
-import { useEffect as useEffect18, useState as useState27 } from "react";
+import { useEffect as useEffect20, useState as useState27 } from "react";
 function useBlinkingCursor() {
   const [visible, setVisible] = useState27(true);
-  useEffect18(() => {
+  useEffect20(() => {
     const interval = setInterval(() => setVisible((current) => !current), 500);
     return () => clearInterval(interval);
   }, []);
@@ -27733,23 +27966,23 @@ import { jsx as jsx52, jsxs as jsxs42 } from "react/jsx-runtime";
 function autocomplete(partial) {
   if (!partial) return null;
   const normalized = normalizePath(partial);
-  const dir = dirname16(normalized);
+  const dir = dirname17(normalized);
   const base = basename6(normalized);
   let entries;
   try {
-    entries = readdirSync3(dir);
+    entries = readdirSync4(dir);
   } catch {
     return null;
   }
   const matches = entries.filter((e) => e.startsWith(base));
   if (matches.length === 0) return null;
-  if (matches.length === 1) return join20(dir, matches[0]);
+  if (matches.length === 1) return join22(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 ? join20(dir, prefix) : null;
+  return prefix.length > base.length ? join22(dir, prefix) : null;
 }
 function PathPrompt({
   defaultPath,
@@ -27837,12 +28070,12 @@ function countedThings({ components, tokens }, counts = {}) {
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/10-flow/support/use-timed-spinner.tsx
-import { useEffect as useEffect19, useState as useState29 } from "react";
+import { useEffect as useEffect21, useState as useState29 } from "react";
 import { Spinner as Spinner2 } from "@inkjs/ui";
 import { jsx as jsx53 } from "react/jsx-runtime";
 function useTimedSpinner() {
   const [elapsedSeconds, setElapsedSeconds] = useState29(0);
-  useEffect19(() => {
+  useEffect21(() => {
     const timer = setInterval(() => setElapsedSeconds((current) => current + 1), 1e3);
     return () => {
       clearInterval(timer);
@@ -27900,7 +28133,7 @@ function PushingStep({ progress, produced, counts }) {
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/10-flow/screens/WizardPreviewStep.tsx
-import { useEffect as useEffect20, useState as useState30, useMemo as useMemo7 } from "react";
+import { useEffect as useEffect22, useState as useState30, useMemo as useMemo7 } from "react";
 import { Box as Box44, Text as Text46 } from "ink";
 
 // packages/experience-design-system-cli/src/tui/import/steps/10-flow/support/preview-diff.ts
@@ -28041,12 +28274,20 @@ function diffProperty(name, old, newDef) {
   diffs.push({ key: `${name}-new`, color: PALETTE.success, text: `+ ${name}: ${formatPropDef(newDef)}` });
   return diffs;
 }
+function formatDefault(value) {
+  const sys = value?.sys;
+  if (sys?.linkType === "Contentful:DesignToken" && typeof sys.urn === "string") {
+    const name = sys.urn.split("/designTokens/")[1];
+    if (name) return name;
+  }
+  return JSON.stringify(value);
+}
 function formatOldProp(prop) {
   const parts = [];
   if (prop.type) parts.push(prop.type);
   if (prop.category) parts.push(prop.category);
   parts.push(prop.required ? "required" : "optional");
-  if (prop.default !== void 0) parts.push(`default=${JSON.stringify(prop.default)}`);
+  if (prop.default !== void 0) parts.push(`default=${formatDefault(prop.default)}`);
   return parts.join(", ");
 }
 function formatPropDef(def) {
@@ -28055,7 +28296,7 @@ function formatPropDef(def) {
   if (def["$category"]) parts.push(def["$category"]);
   if (def["$required"] === true) parts.push("required");
   else parts.push("optional");
-  if (def["$default"] !== void 0) parts.push(`default=${JSON.stringify(def["$default"])}`);
+  if (def["$default"] !== void 0) parts.push(`default=${formatDefault(def["$default"])}`);
   return parts.join(", ");
 }
 
@@ -28287,7 +28528,7 @@ function WizardPreviewStep({
   const activeLines = diffExpanded ? diffLines : summaryLines;
   const maxScroll = Math.max(0, activeLines.length - viewportHeight);
   const boundedScrollOffset = Math.min(scrollOffset, maxScroll);
-  useEffect20(() => {
+  useEffect22(() => {
     setScrollOffset((previous) => Math.min(previous, maxScroll));
   }, [maxScroll]);
   useImmediateInput((input, key) => {
@@ -28505,13 +28746,13 @@ function FlowScreen({
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/10-flow/flow/use-flow.ts
-import { useEffect as useEffect21, useRef as useRef14, useSyncExternalStore } from "react";
+import { useEffect as useEffect23, useRef as useRef16, useSyncExternalStore } from "react";
 
 // packages/experience-design-system-cli/src/tui/import/steps/10-flow/flow/controller.ts
 import { appendFileSync, writeFileSync } from "node:fs";
-import { mkdir as mkdir8 } from "node:fs/promises";
+import { mkdir as mkdir9 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join as join22, resolve as resolve26 } from "node:path";
+import { join as join24, resolve as resolve27 } from "node:path";
 
 // packages/experience-design-system-cli/src/tui/import/steps/10-flow/support/wizard-state-transitions.ts
 function shouldBypassPreview(state2) {
@@ -28858,8 +29099,8 @@ 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 join21 } from "node:path";
+import { writeFile as writeFile8 } from "node:fs/promises";
+import { join as join23 } from "node:path";
 
 // packages/experience-design-system-cli/src/tui/import/steps/10-flow/support/run-print-files-helpers.ts
 function nextStateAfterPrint(opts) {
@@ -28882,7 +29123,7 @@ function buildSavedCDF(components, tokens, opts = {}) {
 var realSaveDeps = () => ({
   openDb: openPipelineDb,
   readTokens: (path5) => readTokensFromPath2({ flag: "tokens", path: path5 }),
-  writeFile: (path5, contents) => writeFile7(path5, contents),
+  writeFile: (path5, contents) => writeFile8(path5, contents),
   appendRun,
   buildSourceFingerprint,
   sleep: (ms) => new Promise((resolve29) => setTimeout(resolve29, ms)),
@@ -28890,7 +29131,7 @@ var realSaveDeps = () => ({
 });
 async function runPrintFiles(input, deps, onPatch) {
   onPatch({ step: "printing" });
-  const componentsPath = join21(input.outDir, "components.json");
+  const componentsPath = join23(input.outDir, "components.json");
   try {
     const db = deps.openDb();
     let components = [];
@@ -28971,7 +29212,7 @@ var EMPTY_PUSH_RESULT = {
 };
 
 // packages/experience-design-system-cli/src/tui/import/steps/10-flow/flow/controller.ts
-var WIZARD_LOG = join22(tmpdir(), "experiences-import-wizard.log");
+var WIZARD_LOG = join24(tmpdir(), "experiences-import-wizard.log");
 function appendWizardLog(entry) {
   appendFileSync(WIZARD_LOG, JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), ...entry }) + "\n");
 }
@@ -28994,7 +29235,7 @@ function realFlowDeps() {
       }
     },
     mkdir: async (path5) => {
-      await mkdir8(path5, { recursive: true });
+      await mkdir9(path5, { recursive: true });
     },
     detectSaveConflict,
     buildTimestampedSubdir,
@@ -29224,7 +29465,7 @@ function createFlowController(start, deps) {
     },
     async submitPath(submitted) {
       await deps.mkdir(submitted);
-      if (resolve26(submitted) !== resolve26(state2.outDir) && await deps.detectSaveConflict(submitted)) {
+      if (resolve27(submitted) !== resolve27(state2.outDir) && await deps.detectSaveConflict(submitted)) {
         const subdir = deps.buildTimestampedSubdir(submitted);
         await deps.mkdir(subdir);
         await proceedToWrite(subdir);
@@ -29247,7 +29488,7 @@ function createFlowController(start, deps) {
 
 // packages/experience-design-system-cli/src/tui/import/steps/10-flow/flow/use-flow.ts
 function useFlow(start, options = {}) {
-  const controller = useRef14();
+  const controller = useRef16();
   if (start && !controller.current) {
     try {
       startWizardLog();
@@ -29264,14 +29505,14 @@ function useFlow(start, options = {}) {
     (listener) => current?.subscribe(listener) ?? (() => void 0),
     () => current?.getState()
   );
-  useEffect21(() => {
+  useEffect23(() => {
     if (!start) controller.current = void 0;
   }, [start]);
   return current && state2 ? { controller: current, state: state2 } : void 0;
 }
 
 // packages/experience-design-system-cli/src/tui/help/PageContainer.tsx
-import { useEffect as useEffect22, useState as useState31 } from "react";
+import { useEffect as useEffect24, useState as useState31 } from "react";
 import { Box as Box46, Text as Text47, useInput as useInput13 } from "ink";
 init_debug_store();
 
@@ -29304,7 +29545,7 @@ function describeFileLocations({
 
 // packages/experience-design-system-cli/src/tui/help/help-info.ts
 async function readHelpInfo() {
-  const [debugMode, settings] = await Promise.all([readDebugModeSetting(), readSettings2()]);
+  const [debugMode, settings] = await Promise.all([readDebugModeSetting(), readSettings()]);
   const base = settings["contentfulBaseDir"];
   const locations = describeFileLocations({
     contentfulBaseDir: typeof base === "string" ? base : "",
@@ -29313,9 +29554,9 @@ async function readHelpInfo() {
   });
   return {
     storage: [
-      { label: "Config folder", value: configRoot2() },
-      { label: "Settings file", value: configFilePath2() },
-      { label: "Agent settings", value: `${configFilePath2()} (keys: agent, agentModel, agents)` },
+      { label: "Config folder", value: configRoot() },
+      { label: "Settings file", value: configFilePath() },
+      { label: "Agent settings", value: `${configFilePath()} (keys: agent, agentModel, agents)` },
       { label: "Debug logs", value: locations.debugLogs },
       { label: "Import files", value: locations.importFiles }
     ],
@@ -29345,7 +29586,7 @@ function Section({ title, rows }) {
 }
 function HelpScreen({ onDone }) {
   const [info, setInfo] = useState31();
-  useEffect22(() => {
+  useEffect24(() => {
     startDebugRun({ flow: "help", step: "01-help", menuOption: "Help", inputs: {} });
     void readHelpInfo().then(setInfo);
   }, []);
@@ -29442,7 +29683,7 @@ import { useState as useState36 } from "react";
 import { Box as Box51, Text as Text53, useInput as useInput17 } from "ink";
 
 // packages/experience-design-system-cli/src/tui/settings/configuration/agents/AgentsScreen.tsx
-import { useEffect as useEffect24, useRef as useRef15, useState as useState34 } from "react";
+import { useEffect as useEffect26, useRef as useRef17, useState as useState34 } from "react";
 import { Box as Box49, Text as Text51, useInput as useInput15 } from "ink";
 init_debug_store();
 
@@ -29475,7 +29716,7 @@ function scrubError(error, secrets) {
   return message;
 }
 function describeSettingsFile() {
-  const path5 = configFilePath2();
+  const path5 = configFilePath();
   return { path: path5, eds_home_set: Boolean(process.env["EDS_HOME"]), exists: existsSync10(path5) };
 }
 
@@ -29715,8 +29956,8 @@ async function describeAgents(config) {
 
 // packages/experience-design-system-cli/src/tui/settings/shared/v1-store.ts
 init_config();
-var readV1Store = readSettings2;
-var writeV1Store = writeSettings2;
+var readV1Store = readSettings;
+var writeV1Store = writeSettings;
 
 // packages/experience-design-system-cli/src/tui/settings/configuration/agents/agent-store.ts
 var AGENT_LABELS = {
@@ -29771,7 +30012,7 @@ async function writeAgentConfig(config) {
 }
 
 // packages/experience-design-system-cli/src/tui/settings/configuration/agents/AgentDetail.tsx
-import { useEffect as useEffect23, useState as useState33 } from "react";
+import { useEffect as useEffect25, useState as useState33 } from "react";
 import { Box as Box48, Text as Text50 } from "ink";
 
 // packages/experience-design-system-cli/src/tui/settings/configuration/agents/AgentStatusBadge.tsx
@@ -29834,7 +30075,7 @@ function AgentDetail({
   const [testing, setTesting] = useState33(false);
   const [notice, setNotice] = useState33(null);
   const [checks, setChecks] = useState33(void 0);
-  useEffect23(() => {
+  useEffect25(() => {
     let active = true;
     setChecks(void 0);
     const timer = setTimeout(() => {
@@ -29919,7 +30160,7 @@ function AgentsScreen({ onDone }) {
   const [saving, setSaving] = useState34(false);
   const [loadError, setLoadError] = useState34(null);
   const [checks, setChecks] = useState34({});
-  const visit = useRef15({
+  const visit = useRef17({
     trail: createTrail(),
     before: void 0,
     environment: void 0,
@@ -29932,7 +30173,7 @@ function AgentsScreen({ onDone }) {
       );
     }
   };
-  useEffect24(() => {
+  useEffect26(() => {
     readAgentConfig().then((loaded) => {
       setConfig(loaded);
       inspectAll(loaded);
@@ -30109,7 +30350,7 @@ function AgentsScreen({ onDone }) {
 }
 
 // packages/experience-design-system-cli/src/tui/settings/configuration/project/ProjectScreen.tsx
-import { useEffect as useEffect25, useRef as useRef16, useState as useState35 } from "react";
+import { useEffect as useEffect27, useRef as useRef18, useState as useState35 } from "react";
 import { Box as Box50, Text as Text52, useInput as useInput16 } from "ink";
 init_debug_store();
 
@@ -30167,14 +30408,14 @@ function ProjectScreen({ onDone }) {
   const [saving, setSaving] = useState35(false);
   const [notice, setNotice] = useState35(null);
   const [loadError, setLoadError] = useState35(null);
-  const visit = useRef16({
+  const visit = useRef18({
     trail: createTrail(),
     before: void 0,
     persisted: void 0,
     error: ""
   }).current;
   const scrub = (err) => scrubError(err, [config?.cmaToken ?? ""]);
-  useEffect25(() => {
+  useEffect27(() => {
     readCredentials().then((cfg) => {
       setConfig(cfg);
       visit.before = snapshotOf(cfg);
@@ -30326,7 +30567,7 @@ function ConfigurationScreen({ onDone }) {
 }
 
 // packages/experience-design-system-cli/src/tui/settings/opt-in-analytics/screen.tsx
-import { useEffect as useEffect26, useState as useState37 } from "react";
+import { useEffect as useEffect28, useState as useState37 } from "react";
 import { Box as Box52, Text as Text54, useInput as useInput18 } from "ink";
 
 // packages/experience-design-system-cli/src/tui/settings/opt-in-analytics/analytics-store.ts
@@ -30350,7 +30591,7 @@ import { Fragment as Fragment20, jsx as jsx64, jsxs as jsxs52 } from "react/jsx-
 function OptInAnalyticsScreen({ onDone }) {
   const [loading, setLoading] = useState37(true);
   const [enabled, setEnabled] = useState37(true);
-  useEffect26(() => {
+  useEffect28(() => {
     readAnalyticsSetting().then((setting) => {
       setEnabled(setting.enabled);
       setLoading(false);
@@ -30404,7 +30645,7 @@ function OptInAnalyticsScreen({ onDone }) {
 }
 
 // packages/experience-design-system-cli/src/tui/settings/debug-mode/screen.tsx
-import { useEffect as useEffect27, useRef as useRef17, useState as useState38 } from "react";
+import { useEffect as useEffect29, useRef as useRef19, useState as useState38 } from "react";
 import { Box as Box53, Text as Text55, useInput as useInput19 } from "ink";
 init_debug_mode_store();
 init_debug_store();
@@ -30421,8 +30662,8 @@ function DebugModeScreen({ onDone }) {
     RETENTION_CHOICES[RETENTION_CHOICES.length - 1]
   );
   const [notice, setNotice] = useState38(null);
-  const visit = useRef17({ trail: createTrail(), before: void 0, error: "" }).current;
-  useEffect27(() => {
+  const visit = useRef19({ trail: createTrail(), before: void 0, error: "" }).current;
+  useEffect29(() => {
     readDebugModeSetting().then((loaded) => {
       setSetting(loaded);
       setPending(loaded.retentionDays);
@@ -30577,7 +30818,7 @@ function App({ importOptions, inkClear }) {
   const [flowStart, setFlowStart] = useState39();
   const flow = useFlow(flowStart, { beforeStepChange: inkClear });
   const [importDefaults, setImportDefaults] = useState39();
-  useEffect28(() => {
+  useEffect30(() => {
     if (screen !== "import") {
       setImportDefaults(void 0);
       return;
@@ -30603,7 +30844,7 @@ function App({ importOptions, inkClear }) {
     else await startExtraction(launch, result);
   };
   const prepareRun = async (launch, credentials) => {
-    const settings = await readSettings2();
+    const settings = await readSettings();
     const { agent, agentModel } = resolveAgentChoice(launch.agent, settings);
     const generatePromptPath = typeof settings.generatePromptPath === "string" ? settings.generatePromptPath : void 0;
     const outDir = await (await Promise.resolve().then(() => (init_debug_store(), debug_store_exports))).startImportRun(resolveUserPath(launch.projectPath ?? ""));
@@ -30650,7 +30891,7 @@ function App({ importOptions, inkClear }) {
       }
     });
   };
-  useEffect28(() => {
+  useEffect30(() => {
     if (!tokensOnlyRun || tokensOnly?.status !== "done" || !tokensOnly.result.ok) return;
     const { credentialsSkipped, input, tokens } = tokensOnlyRun;
     const { tokensPath, tokenSessionId, tokenCount } = tokensOnly.result;
@@ -30672,12 +30913,12 @@ function App({ importOptions, inkClear }) {
       }
     });
   }, [tokensOnly, tokensOnlyRun]);
-  useEffect28(() => {
+  useEffect30(() => {
     if (!extractionRun || extraction?.status !== "done" || !extraction.result.ok) return;
     setExtractionRun(void 0);
     setScopeRun({ ...extractionRun, extraction: extraction.result.extraction });
   }, [extraction, extractionRun]);
-  useEffect28(() => {
+  useEffect30(() => {
     if (!scopeRun || scopeFlow?.status !== "confirmed" || generationInput) return;
     const { extraction: produced, input, generatePromptPath } = scopeRun;
     setGenerationInput({
@@ -30695,7 +30936,7 @@ function App({ importOptions, inkClear }) {
       ...generatePromptPath ? { generatePromptPath } : {}
     });
   }, [scopeFlow, scopeRun, generationInput]);
-  useEffect28(() => {
+  useEffect30(() => {
     if (!scopeRun || generation?.status !== "done" || !generation.result.ok) return;
     const { credentialsSkipped, extraction: produced, input, generatePromptPath } = scopeRun;
     inkClear();
@@ -30778,6 +31019,7 @@ function App({ importOptions, inkClear }) {
               return /* @__PURE__ */ jsx66(
                 WelcomeScreen,
                 {
+                  mode: target,
                   onContinue: (projectPath) => answer({ projectPath }),
                   onQuit: () => goBackFrom("project"),
                   initialPath: importDefaults.componentDir