@contentful/experience-design-system-cli 2.37.1-dev-build-eed963c1.0 → 2.37.1-dev-build-6fb2b08b.0

package/dist/app.js

@@ -8,6 +8,71 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// packages/experience-design-system-cli/src/tui/package-root.ts
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+function findPackageRoot(startUrl, packageName) {
+  let dir = dirname(fileURLToPath(startUrl));
+  let found;
+  while (true) {
+    const manifestPath = join(dir, "package.json");
+    if (existsSync(manifestPath)) {
+      const pkg = JSON.parse(readFileSync(manifestPath, "utf8"));
+      if (pkg.name === packageName) found = dir;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) return found ?? dir;
+    dir = parent;
+  }
+}
+var init_package_root = __esm({
+  "packages/experience-design-system-cli/src/tui/package-root.ts"() {
+    "use strict";
+  }
+});
+
+// packages/experience-design-system-cli/src/tui/upgrade/version.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+import semver from "semver";
+function readPackageVersion() {
+  const root = findPackageRoot(import.meta.url, PACKAGE_NAME);
+  const pkg = JSON.parse(readFileSync2(join2(root, "package.json"), "utf8"));
+  return pkg.version ?? "unknown";
+}
+function parseVersionTag(tag) {
+  const match2 = /^v(\d+\.\d+\.\d+)$/.exec(tag);
+  return match2 ? match2[1] : void 0;
+}
+async function checkForUpgrade() {
+  const current = readPackageVersion();
+  try {
+    const response = await fetch(TAGS_URL);
+    if (!response.ok) return { status: "error" };
+    const tags = await response.json();
+    const versions = tags.map((tag) => tag.name ? parseVersionTag(tag.name) : void 0).filter((v) => v !== void 0);
+    if (versions.length === 0) return { status: "error" };
+    const latest = versions.reduce((best, v) => semver.gt(v, best) ? v : best);
+    if (!semver.valid(current)) return { status: "error" };
+    if (semver.gt(latest, current)) {
+      return { status: "update-available", current, latest };
+    }
+    return { status: "up-to-date", current };
+  } catch {
+    return { status: "error" };
+  }
+}
+var PACKAGE_NAME, TAGS_URL;
+var init_version = __esm({
+  "packages/experience-design-system-cli/src/tui/upgrade/version.ts"() {
+    "use strict";
+    init_package_root();
+    PACKAGE_NAME = "@contentful/experience-design-system-cli";
+    TAGS_URL = "https://api.github.com/repos/contentful/experience-design-system-sdk-public/tags?per_page=10";
+  }
+});
+
 // packages/experience-design-system-backend-pipeline/dist/src/agents/types/agent-name.js
 var AGENT_NAMES;
 var init_agent_name = __esm({
@@ -772,7 +837,7 @@ async function runAgent(options) {
     promptLen: prompt.length,
     promptHead: prompt.slice(0, 500)
   });
-  return new Promise((resolve25) => {
+  return new Promise((resolve27) => {
     const bedrockEnv = bedrock ? BEDROCK_ENV_BY_AGENT[agent] : void 0;
     const child = spawn(binary, args, {
       stdio: ["pipe", "pipe", "pipe"],
@@ -821,7 +886,7 @@ async function runAgent(options) {
         stderrLen: stderr.length,
         stderrTail: stderr.slice(-1e3)
       });
-      resolve25(result);
+      resolve27(result);
     });
   });
 }
@@ -843,7 +908,7 @@ async function checkAgentAuth(agent) {
     return "not-found";
   if (agent !== "claude")
     return "ok";
-  return new Promise((resolve25) => {
+  return new Promise((resolve27) => {
     const child = spawn2(binary, ["auth", "status", "--json"], { stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let done = false;
@@ -852,7 +917,7 @@ async function checkAgentAuth(agent) {
         return;
       done = true;
       child.kill("SIGTERM");
-      resolve25("unauthenticated");
+      resolve27("unauthenticated");
     }, 5e3);
     child.stdout?.on("data", (chunk) => {
       stdout += chunk.toString();
@@ -863,14 +928,14 @@ async function checkAgentAuth(agent) {
       done = true;
       clearTimeout(timer);
       if (code !== 0) {
-        resolve25("unauthenticated");
+        resolve27("unauthenticated");
         return;
       }
       try {
         const status = JSON.parse(stdout);
-        resolve25(status.loggedIn ? "ok" : "unauthenticated");
+        resolve27(status.loggedIn ? "ok" : "unauthenticated");
       } catch {
-        resolve25("unauthenticated");
+        resolve27("unauthenticated");
       }
     });
   });
@@ -880,9 +945,9 @@ async function binaryIsOnPath(binary) {
     const fs = await import("node:fs/promises");
     return fs.access(binary).then(() => true, () => false);
   }
-  return new Promise((resolve25) => {
+  return new Promise((resolve27) => {
     const child = spawn2(process.platform === "win32" ? "where" : "which", [binary], { stdio: "ignore" });
-    child.on("close", (code) => resolve25(code === 0));
+    child.on("close", (code) => resolve27(code === 0));
   });
 }
 var init_check_agent_auth = __esm({
@@ -2016,6 +2081,253 @@ var init_cache_keys = __esm({
   }
 });
 
+// packages/experience-design-system-types/dist/src/config/index.js
+import { randomBytes as randomBytes4 } from "node:crypto";
+import { mkdir as mkdir6, readFile as readFile18, rename as rename2, writeFile as writeFile6 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { dirname as dirname13, join as join17 } from "node:path";
+function configRoot2() {
+  return process.env["EDS_HOME"] || join17(homedir3(), ".contentful", "experience-design-system-cli");
+}
+async function readSettings2() {
+  try {
+    return JSON.parse(await readFile18(configFilePath2(), "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function writeSettings2(settings) {
+  const path5 = configFilePath2();
+  await mkdir6(dirname13(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 = () => join17(configRoot2(), "config.json");
+  }
+});
+
+// packages/experience-design-system-cli/src/tui/settings/debug-mode/debug-mode-store.ts
+async function readDebugModeSetting() {
+  const { debugMode } = await readSettings2();
+  return { ...DEFAULT_DEBUG_MODE_SETTING, ...debugMode };
+}
+async function writeDebugModeSetting(setting) {
+  await updateSettings2({ debugMode: setting });
+}
+var DEFAULT_DEBUG_MODE_SETTING;
+var init_debug_mode_store = __esm({
+  "packages/experience-design-system-cli/src/tui/settings/debug-mode/debug-mode-store.ts"() {
+    "use strict";
+    init_config();
+    DEFAULT_DEBUG_MODE_SETTING = {
+      enabled: true
+    };
+  }
+});
+
+// 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 resolve26 } 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 !== "" ? resolve26(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(resolve26(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(resolve26(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 stepLabel2 = stepMatch ? `${stepMatch[1]} - ${stepMatch[2]}` : run.step;
+  const flowSlug = run.flow.split("/").join("-");
+  return `# Debug Log
+
+- Run ID: ${run.runId}
+- Flow: ${flowSlug}
+- Step: ${stepLabel2}
+- 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();
+    void Promise.all([isDebugModeEnabled(), readBaseDir()]).then(([enabled, base]) => {
+      if (!enabled || !base) return void 0;
+      return mkdir9(join24(startSession(base, { replace: false }), "debug"), { recursive: true });
+    });
+    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-cli/app.tsx
 import { join as join25 } from "node:path";
 import { useEffect as useEffect26, useState as useState33 } from "react";
@@ -2055,60 +2367,8 @@ function brandBar(width, ramp = BRAND_RAMP) {
 }
 var FOCUS_MARKER = "\u276F";
 
-// packages/experience-design-system-cli/src/tui/upgrade/version.ts
-import { readFileSync as readFileSync2 } from "node:fs";
-import { join as join2 } from "node:path";
-import semver from "semver";
-
-// packages/experience-design-system-cli/src/tui/package-root.ts
-import { existsSync, readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-function findPackageRoot(startUrl, packageName) {
-  let dir = dirname(fileURLToPath(startUrl));
-  let found;
-  while (true) {
-    const manifestPath = join(dir, "package.json");
-    if (existsSync(manifestPath)) {
-      const pkg = JSON.parse(readFileSync(manifestPath, "utf8"));
-      if (pkg.name === packageName) found = dir;
-    }
-    const parent = dirname(dir);
-    if (parent === dir) return found ?? dir;
-    dir = parent;
-  }
-}
-
-// packages/experience-design-system-cli/src/tui/upgrade/version.ts
-var PACKAGE_NAME = "@contentful/experience-design-system-cli";
-var TAGS_URL = "https://api.github.com/repos/contentful/experience-design-system-sdk-public/tags?per_page=10";
-function readPackageVersion() {
-  const root = findPackageRoot(import.meta.url, PACKAGE_NAME);
-  const pkg = JSON.parse(readFileSync2(join2(root, "package.json"), "utf8"));
-  return pkg.version ?? "unknown";
-}
-function parseVersionTag(tag) {
-  const match2 = /^v(\d+\.\d+\.\d+)$/.exec(tag);
-  return match2 ? match2[1] : void 0;
-}
-async function checkForUpgrade() {
-  const current = readPackageVersion();
-  try {
-    const response = await fetch(TAGS_URL);
-    if (!response.ok) return { status: "error" };
-    const tags = await response.json();
-    const versions = tags.map((tag) => tag.name ? parseVersionTag(tag.name) : void 0).filter((v) => v !== void 0);
-    if (versions.length === 0) return { status: "error" };
-    const latest = versions.reduce((best, v) => semver.gt(v, best) ? v : best);
-    if (!semver.valid(current)) return { status: "error" };
-    if (semver.gt(latest, current)) {
-      return { status: "update-available", current, latest };
-    }
-    return { status: "up-to-date", current };
-  } catch {
-    return { status: "error" };
-  }
-}
+// packages/experience-design-system-cli/src/tui/home/home.tsx
+init_version();
 
 // packages/experience-design-system-cli/src/tui/use-terminal-width.ts
 import { useEffect, useState } from "react";
@@ -4733,7 +4993,7 @@ async function getCliCacheVersion() {
     return _cliCacheVersionCache;
   }
 }
-function storeExtractCache(db, filePath, fileHash, cliVersion, components) {
+function storeExtractCache(db, filePath, fileHash, cliVersion2, components) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const componentsJson = JSON.stringify(components);
   db.prepare(`INSERT INTO extract_cache (file_path, file_hash, cli_version, created_at, updated_at, components_json)
@@ -4741,12 +5001,12 @@ function storeExtractCache(db, filePath, fileHash, cliVersion, components) {
      ON CONFLICT(file_hash, cli_version) DO UPDATE SET
        file_path = excluded.file_path,
        updated_at = excluded.updated_at,
-       components_json = excluded.components_json`).run(filePath, fileHash, cliVersion, now, now, componentsJson);
+       components_json = excluded.components_json`).run(filePath, fileHash, cliVersion2, now, now, componentsJson);
 }
-function lookupExtractCache(db, fileHash, cliVersion) {
+function lookupExtractCache(db, fileHash, cliVersion2) {
   const row = db.prepare(`SELECT file_path, file_hash, cli_version, created_at, updated_at, components_json
        FROM extract_cache
-       WHERE file_hash = ? AND cli_version = ?`).get(fileHash, cliVersion);
+       WHERE file_hash = ? AND cli_version = ?`).get(fileHash, cliVersion2);
   if (!row)
     return null;
   let components = [];
@@ -4764,31 +5024,31 @@ function lookupExtractCache(db, fileHash, cliVersion) {
     components
   };
 }
-function storeCompositionCache(db, inputHash, cliVersion, agentOutput) {
+function storeCompositionCache(db, inputHash, cliVersion2, agentOutput) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   db.prepare(`INSERT INTO composition_cache (input_hash, cli_version, agent_output, created_at, updated_at)
      VALUES (?, ?, ?, ?, ?)
      ON CONFLICT(input_hash, cli_version) DO UPDATE SET
        agent_output = excluded.agent_output,
-       updated_at = excluded.updated_at`).run(inputHash, cliVersion, agentOutput, now, now);
+       updated_at = excluded.updated_at`).run(inputHash, cliVersion2, agentOutput, now, now);
 }
-function lookupCompositionCache(db, inputHash, cliVersion) {
-  const row = db.prepare(`SELECT agent_output FROM composition_cache WHERE input_hash = ? AND cli_version = ?`).get(inputHash, cliVersion);
+function lookupCompositionCache(db, inputHash, cliVersion2) {
+  const row = db.prepare(`SELECT agent_output FROM composition_cache WHERE input_hash = ? AND cli_version = ?`).get(inputHash, cliVersion2);
   return row ? row.agent_output : null;
 }
-function storeSelectCache(db, componentHash, promptHash, cliVersion, decision, reason) {
+function storeSelectCache(db, componentHash, promptHash, cliVersion2, decision, reason) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   db.prepare(`INSERT INTO select_cache (component_hash, prompt_hash, cli_version, decision, reason, created_at, updated_at)
      VALUES (?, ?, ?, ?, ?, ?, ?)
      ON CONFLICT(component_hash, prompt_hash, cli_version) DO UPDATE SET
        decision = excluded.decision,
        reason = excluded.reason,
-       updated_at = excluded.updated_at`).run(componentHash, promptHash, cliVersion, decision, reason, now, now);
+       updated_at = excluded.updated_at`).run(componentHash, promptHash, cliVersion2, decision, reason, now, now);
 }
-function lookupSelectCache(db, componentHash, promptHash, cliVersion) {
+function lookupSelectCache(db, componentHash, promptHash, cliVersion2) {
   const row = db.prepare(`SELECT component_hash, prompt_hash, cli_version, decision, reason, created_at, updated_at
        FROM select_cache
-       WHERE component_hash = ? AND prompt_hash = ? AND cli_version = ?`).get(componentHash, promptHash, cliVersion);
+       WHERE component_hash = ? AND prompt_hash = ? AND cli_version = ?`).get(componentHash, promptHash, cliVersion2);
   if (!row)
     return null;
   return {
@@ -12307,11 +12567,11 @@ import { access as access2, mkdir, readFile as readFile7, writeFile } from "node
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/review-session/repositories/review-session-paths.js
 import { resolve as resolve15 } from "node:path";
 async function getRefineSessionPaths(sessionId, artifactsRoot) {
-  const sessionDir = resolve15(artifactsRoot, sessionId);
+  const sessionDir2 = resolve15(artifactsRoot, sessionId);
   return {
-    sessionDir,
-    eventsPath: resolve15(sessionDir, "events.jsonl"),
-    statePath: resolve15(sessionDir, "current-review-state.json")
+    sessionDir: sessionDir2,
+    eventsPath: resolve15(sessionDir2, "events.jsonl"),
+    statePath: resolve15(sessionDir2, "current-review-state.json")
   };
 }
 
@@ -12877,9 +13137,63 @@ async function loadAcceptedNames(sessionId) {
   }
 }
 
-// packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/index.js
-import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
-
+// packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/index.js
+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";
+var ADJECTIVES2 = [
+  "bright",
+  "calm",
+  "dark",
+  "fast",
+  "green",
+  "happy",
+  "keen",
+  "light",
+  "long",
+  "loud",
+  "pale",
+  "quick",
+  "sharp",
+  "slow",
+  "soft",
+  "warm",
+  "wild",
+  "wise"
+];
+var NOUNS2 = [
+  "cloud",
+  "creek",
+  "dawn",
+  "dusk",
+  "field",
+  "flame",
+  "frost",
+  "grove",
+  "hill",
+  "lake",
+  "leaf",
+  "moon",
+  "peak",
+  "rain",
+  "river",
+  "rock",
+  "snow",
+  "star",
+  "storm",
+  "tide",
+  "tree",
+  "wave",
+  "wind"
+];
+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");
+  return `${adj}-${noun}-${hex}`;
+}
+
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/repositories/migration.js
 import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
 
@@ -13510,7 +13824,7 @@ function errorMessage(error) {
   return error instanceof Error && error.message ? error.message : String(error);
 }
 function defaultSleep(delayMs) {
-  return new Promise((resolve25) => setTimeout(resolve25, delayMs));
+  return new Promise((resolve27) => setTimeout(resolve27, delayMs));
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/apply/src/helpers/sanitize-preview.js
@@ -13751,7 +14065,7 @@ var ApiClient = class {
         const progress = maxAttempts > 1 ? attempt / (maxAttempts - 1) : 0;
         const baseDelay = intervalMs + (maxIntervalMs - intervalMs) * progress;
         const jitter = Math.random() * baseDelay * 0.15;
-        await new Promise((resolve25) => setTimeout(resolve25, baseDelay + jitter));
+        await new Promise((resolve27) => setTimeout(resolve27, baseDelay + jitter));
       }
     }
     throw new Error(`Operation ${operationId} timed out after ${maxAttempts} attempts`);
@@ -14685,6 +14999,172 @@ function loadTokenLeaves(db, sessionId) {
   return db.prepare("SELECT path, type FROM raw_tokens WHERE session_id = ? ORDER BY path").all(sessionId);
 }
 
+// packages/experience-design-system-backend-pipeline/dist/src/analytics/client/cli-info.js
+var cliVersionString = "0.0.0-unknown";
+function cliVersion() {
+  return cliVersionString;
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/analytics/client/opt-out.js
+var persistedDisabled = false;
+function analyticsEnabled() {
+  return !persistedDisabled && !process.env["DISABLE_ANALYTICS"];
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/analytics/client/segment-client.js
+import { Analytics } from "@segment/analytics-node";
+var DEFAULT_WRITE_KEY = "6DmxiEPN3SV1vbRTTMcNqDzCvkfwT06N";
+var analyticsClient = null;
+function resolveWriteKey() {
+  const key = (process.env["SEGMENT_WRITE_KEY"] ?? "").trim();
+  return key.length > 0 ? key : DEFAULT_WRITE_KEY;
+}
+function getClient() {
+  if (!analyticsEnabled())
+    return null;
+  const writeKey = resolveWriteKey();
+  if (!writeKey)
+    return null;
+  if (!analyticsClient) {
+    analyticsClient = new Analytics({ writeKey });
+    analyticsClient.on("error", () => {
+    });
+  }
+  return analyticsClient;
+}
+async function trackEvent(event, properties, anonymousId, options) {
+  const client2 = getClient();
+  if (!client2)
+    return;
+  try {
+    client2.track({
+      event,
+      properties,
+      anonymousId,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+    if (options?.flush)
+      await flushAnalytics();
+  } catch {
+  }
+}
+async function flushAnalytics() {
+  if (!analyticsClient)
+    return;
+  try {
+    await analyticsClient.closeAndFlush();
+  } catch {
+  } finally {
+    analyticsClient = null;
+  }
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/analytics/constants.js
+var ANALYTICS_SESSION_ENV = "EDS_ANALYTICS_SESSION_ID";
+var IMPORT_PIPELINE_ENV = "EDS_IMPORT_PIPELINE";
+
+// packages/experience-design-system-backend-pipeline/dist/src/analytics/session.js
+function resolveAnalyticsSessionId(explicit) {
+  const inherited = process.env[ANALYTICS_SESSION_ENV]?.trim();
+  if (inherited)
+    return inherited;
+  const passed = explicit?.trim();
+  if (passed)
+    return passed;
+  return generateSessionId2();
+}
+function isPipelineAnalyticsChild() {
+  return Boolean(process.env[ANALYTICS_SESSION_ENV]?.trim());
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/analytics/tracker/pending-command.js
+var state = {
+  pending: null,
+  sessionId: void 0,
+  sessionStartedEmitted: false
+};
+function isPipelineStep() {
+  return process.env[IMPORT_PIPELINE_ENV] === "1";
+}
+function buildBaseProps(command) {
+  return {
+    dsi_session_id: state.sessionId,
+    command,
+    ...isPipelineStep() ? { is_pipeline_step: true } : {}
+  };
+}
+function mergeContext(target, source) {
+  if (source.space_key !== void 0)
+    target.space_key = source.space_key;
+  if (source.environment_key !== void 0)
+    target.environment_key = source.environment_key;
+  if (source.x_contentful_request_id !== void 0) {
+    target.x_contentful_request_id = source.x_contentful_request_id;
+  }
+}
+function setCommandContext(context) {
+  if (!state.pending)
+    return;
+  mergeContext(state.pending.context, context);
+  mergeContext(state.pending.completion, context);
+}
+function enrichCommandResult(fields) {
+  if (!state.pending)
+    return;
+  Object.assign(state.pending.completion, fields);
+  mergeContext(state.pending.context, fields);
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/analytics/os.js
+var OS_NAMES2 = {
+  android: "Android",
+  aix: "Linux",
+  darwin: "macOS",
+  freebsd: "Linux",
+  linux: "Linux",
+  openbsd: "Linux",
+  sunos: "Linux",
+  win32: "Windows"
+};
+function getOsName() {
+  return OS_NAMES2[process.platform] ?? "other";
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/analytics/tracker/emit-events.js
+async function bindAnalyticsSessionId(explicit, context) {
+  const id = resolveAnalyticsSessionId(explicit);
+  await bindAnalyticsSession(id, context);
+  return id;
+}
+async function bindAnalyticsSession(id, context) {
+  state.sessionId = id;
+  if (context)
+    setCommandContext(context);
+  await emitInvokedIfReady();
+}
+async function emitSessionStarted(entryCommand) {
+  if (!state.sessionId || state.sessionStartedEmitted)
+    return;
+  state.sessionStartedEmitted = true;
+  await trackEvent("dsi_cli_session_started", {
+    dsi_session_id: state.sessionId,
+    entry_command: entryCommand,
+    cli_version: cliVersion(),
+    node_version: process.version,
+    os_name: getOsName()
+  }, state.sessionId, { flush: true });
+  await emitInvokedIfReady();
+}
+async function emitInvokedIfReady() {
+  if (!state.pending || state.pending.invoked || !state.sessionId)
+    return;
+  state.pending.invoked = true;
+  await trackEvent("dsi_cli_command_invoked", {
+    ...buildBaseProps(state.pending.command),
+    ...state.pending.context
+  }, state.sessionId, { flush: true });
+}
+
 // packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/controller/map-tokens/run-map-tokens.js
 var DEFAULT_TIMEOUT_MS2 = 5 * 60 * 1e3;
 var MapTokensRunFailure = class _MapTokensRunFailure extends Error {
@@ -14714,6 +15194,7 @@ async function runMapTokens(request) {
     if (!sessionId) {
       throw new MapTokensRunFailure({ type: "no-session" });
     }
+    await bindAnalyticsSessionId(sessionId);
     const tokenLeaves = loadTokenLeaves(db, sessionId);
     const knownTokenPaths = new Set(tokenLeaves.map((t) => t.path));
     if (request.tokenMapInline) {
@@ -15864,7 +16345,7 @@ async function retryDatabaseWrite(operation, attempts = 8) {
       const message = error instanceof Error ? error.message : String(error);
       if (!/database is locked|database is busy/i.test(message) || attempt >= attempts)
         throw error;
-      await new Promise((resolve25) => setTimeout(resolve25, Math.min(250 * attempt, 2e3)));
+      await new Promise((resolve27) => setTimeout(resolve27, Math.min(250 * attempt, 2e3)));
     }
   }
 }
@@ -16027,6 +16508,9 @@ async function runExtractAndComposeSession(request) {
       outDir
     });
     await onSessionCreated?.(sessionId);
+    await bindAnalyticsSessionId(sessionId);
+    if (!isPipelineAnalyticsChild())
+      await emitSessionStarted("analyze_extract");
     const stepId = createStep(db, sessionId, "analyze extract", { project: projectPath });
     if (cacheHits === 0 && !noCache) {
       await persistExtractCache(db, sourceFiles, extraction.components, cacheVersion);
@@ -16054,6 +16538,7 @@ async function runExtractAndComposeSession(request) {
     await persistSlotCycles(db, sessionId, composition.components);
     storeScannedFiles(db, sessionId, sourceFiles.map((f) => relative2(projectPath, f)));
     await retryDatabaseWrite(() => updateStep(db, stepId, "complete", { sessionId }));
+    enrichCommandResult({ extracted_component_count: composition.components.length });
     return {
       sessionId,
       compositionPhase: composition.phase,
@@ -16116,6 +16601,7 @@ async function runGenerateTokensSession(request) {
       outDir
     });
     await onSessionCreated?.(tokenSessionId);
+    await bindAnalyticsSessionId(tokenSessionId);
     const tokenPromptHash = await hashPromptForSkill("tokens", agent, agentModel, skillPath);
     const warnings = [];
     onProgress?.({ kind: "resolving" });
@@ -16492,6 +16978,7 @@ async function runGenerateComponentsSession(request) {
   const existingTokensHash = existingTokensInline ? [hashContent(existingTokensInline)] : [];
   const agent = request.agent;
   const promptHash = await hashPromptForSkill("components", agent, request.agentModel, effectiveSkillPath, existingTokensHash, prompt.text);
+  await bindAnalyticsSessionId(request.sessionId);
   const db = openPipelineDb();
   try {
     const acceptedNames = await loadAcceptedNames(request.sessionId);
@@ -16691,6 +17178,7 @@ function useCredentialsControls(handlers) {
 }
 
 // packages/experience-design-system-cli/src/tui/user-agent.ts
+init_version();
 function cliUserAgent() {
   return buildUserAgent(readPackageVersion());
 }
@@ -17035,11 +17523,34 @@ function RunningStep({
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/05-token-reuse/logic.ts
-import { access as access5, stat as stat4 } from "node:fs/promises";
+import { access as access5, readdir as readdir2, stat as stat4 } from "node:fs/promises";
 import { join as join16 } from "node:path";
-async function inspectTokens({ rawTokensPath, outDir, cache }) {
+async function findLatestTokens(contentfulDir) {
+  const candidates = [join16(contentfulDir, "tokens.json")];
+  try {
+    for (const session of await readdir2(contentfulDir, { withFileTypes: true })) {
+      if (!session.isDirectory()) continue;
+      for (const run of await readdir2(join16(contentfulDir, session.name), { withFileTypes: true }).catch(() => [])) {
+        if (run.isDirectory() && /^dsi-import-\d+$/.test(run.name)) {
+          candidates.push(join16(contentfulDir, session.name, run.name, "tokens.json"));
+        }
+      }
+    }
+  } catch {
+  }
+  const found = [];
+  for (const path5 of candidates) {
+    try {
+      found.push({ path: path5, mtimeMs: (await stat4(path5)).mtimeMs });
+    } catch {
+    }
+  }
+  return found.sort((a, b) => b.mtimeMs - a.mtimeMs)[0]?.path ?? null;
+}
+async function inspectTokens({ rawTokensPath, contentfulDir, cache }) {
   if (!cache) return { kind: "none" };
-  const tokensPath = join16(outDir, "tokens.json");
+  const tokensPath = await findLatestTokens(contentfulDir);
+  if (!tokensPath) return { kind: "none" };
   try {
     await access5(tokensPath);
   } catch {
@@ -17190,34 +17701,8 @@ function ExtractionScreen({
   );
 }
 
-// packages/experience-design-system-types/dist/src/config/index.js
-import { randomBytes as randomBytes3 } from "node:crypto";
-import { mkdir as mkdir6, readFile as readFile18, rename as rename2, writeFile as writeFile6 } from "node:fs/promises";
-import { homedir as homedir3 } from "node:os";
-import { dirname as dirname13, join as join17 } from "node:path";
-function configRoot2() {
-  return process.env["EDS_HOME"] || join17(homedir3(), ".contentful", "experience-design-system-cli");
-}
-var configFilePath2 = () => join17(configRoot2(), "config.json");
-var debugSessionsDir2 = () => join17(configRoot2(), "debug", "sessions");
-async function readSettings2() {
-  try {
-    return JSON.parse(await readFile18(configFilePath2(), "utf8"));
-  } catch {
-    return {};
-  }
-}
-async function writeSettings2(settings) {
-  const path5 = configFilePath2();
-  await mkdir6(dirname13(path5), { recursive: true });
-  const tmp = `${path5}.${process.pid}.${randomBytes3(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 });
-}
+// packages/experience-design-system-cli/app.tsx
+init_config();
 
 // packages/experience-design-system-cli/src/tui/import/steps/06-extraction/use-extraction.ts
 import { useEffect as useEffect5, useRef as useRef2, useState as useState8 } from "react";
@@ -17256,13 +17741,13 @@ async function runSelection(options) {
   const db = openPipelineDb();
   let components;
   const cachedDecisions = /* @__PURE__ */ new Map();
-  const cliVersion = await getCliCacheVersion();
+  const cliVersion2 = await getCliCacheVersion();
   const promptHash = await hashSelectPrompt(options);
   try {
     components = loadRawComponents(db, options.sessionId);
     if (!options.noCache) {
       for (const component of components) {
-        const cached = lookupSelectCache(db, hashComponentShape(component), promptHash, cliVersion);
+        const cached = lookupSelectCache(db, hashComponentShape(component), promptHash, cliVersion2);
         if (cached) cachedDecisions.set(component.name, { decision: cached.decision, reason: cached.reason });
       }
     }
@@ -17317,7 +17802,7 @@ async function runSelection(options) {
           writeDb,
           hashComponentShape(component),
           promptHash,
-          cliVersion,
+          cliVersion2,
           rejected ? "rejected" : "accepted",
           rejected ? reason : null
         );
@@ -17344,7 +17829,7 @@ var realDeps = {
 var fail = (step, message) => ({ ok: false, step, message });
 var errorMessage2 = (error) => error instanceof Error ? error.message : String(error);
 async function runExtraction(input, onProgress, deps = realDeps) {
-  const outDir = join19(resolve22(input.projectPath), ".contentful");
+  const outDir = input.outDir ?? join19(resolve22(input.projectPath), ".contentful");
   let progress = initialProgress({
     hasCredentials: input.credentials !== null,
     hasRawTokens: input.rawTokensPath !== "",
@@ -17477,7 +17962,7 @@ async function resolveSelectionPrompt(overrides) {
 
 // packages/experience-design-system-cli/src/tui/import/steps/06-extraction/use-extraction.ts
 function useExtraction(input) {
-  const [state, setState] = useState8();
+  const [state2, setState] = useState8();
   const current = useRef2();
   useEffect5(() => {
     current.current = input;
@@ -17502,7 +17987,7 @@ function useExtraction(input) {
       if (current.current === input) current.current = void 0;
     };
   }, [input]);
-  return state;
+  return state2;
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/screen.tsx
@@ -18672,8 +19157,7 @@ function GroupedSidebar(props) {
     dimPredicate,
     visibleRows: providedRows,
     graph,
-    filterVisibleKeys,
-    emptyMessage
+    filterVisibleKeys
   } = props;
   const allRows = providedRows ?? buildVisibleRows({
     items,
@@ -18690,10 +19174,6 @@ function GroupedSidebar(props) {
   const end = windowed ? start + (visibleCount ?? allRows.length) : allRows.length;
   const rows = windowed ? allRows.slice(start, end) : allRows;
   return /* @__PURE__ */ jsxs18(WindowedPanel, { width, height: props.height, title, focused, children: [
-    allRows.length === 0 && emptyMessage !== void 0 && /* @__PURE__ */ jsxs18(Text19, { color: PALETTE2.warning, children: [
-      " ",
-      emptyMessage
-    ] }),
     windowed && /* @__PURE__ */ jsx21(WindowIndicator, { direction: "up", count: start }),
     rows.map((row, i) => {
       const absoluteRowIdx = start + i;
@@ -19009,9 +19489,9 @@ function createSidebarViewsHelpSection(includeBreaking) {
     { keys: "L", label: "Flat view" },
     { keys: "i", label: "Focus lineage" }
   ];
-  if (includeBreaking) entries.push({ keys: "w", label: "Show only components with breaking changes" });
+  if (includeBreaking) entries.push({ keys: "w", label: "Only breaking" });
   entries.push(
-    { keys: "o", label: "Show only components in slot cycles" },
+    { keys: "o", label: "Only cycles" },
     { keys: "space", label: "Expand/collapse group" },
     { keys: "E / C", label: "Expand/collapse all" }
   );
@@ -19578,17 +20058,6 @@ function computeFilterKeys(input) {
   if (active.has("deleted")) for (const k of input.data.deleted ?? []) out.add(k);
   return out;
 }
-var FILTER_LABELS = {
-  broken: "components with breaking changes",
-  cycles: "slot cycles",
-  deleted: "removed components"
-};
-function describeEmptyFilter(input) {
-  const names = [...input.filters].map((f) => FILTER_LABELS[f]);
-  if (input.slotDependencies) names.push("slot dependencies");
-  if (names.length === 0) return void 0;
-  return `Nothing to show: no ${names.join(" or ")} in this import.`;
-}
 function intersectFilterKeys(a, b) {
   if (a === void 0) return b;
   if (b === void 0) return a;
@@ -19609,62 +20078,62 @@ function buildFlatDimPredicate(input) {
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/state.ts
-function apply(state, entries) {
-  const next = new Map(state);
+function apply(state2, entries) {
+  const next = new Map(state2);
   for (const [name, decision] of entries) next.set(name, decision);
   return next;
 }
-function reduceDecisions(state, action, components, graph) {
+function reduceDecisions(state2, action, components, graph) {
   switch (action.type) {
     case "accept": {
-      if (state.get(action.name) === "accepted") return state;
+      if (state2.get(action.name) === "accepted") return state2;
       return apply(
-        state,
+        state2,
         acceptCascade(graph, action.name).map((name) => [name, "accepted"])
       );
     }
     case "reject": {
-      if (state.get(action.name) === "rejected") return state;
+      if (state2.get(action.name) === "rejected") return state2;
       const { toReject, toDeselect } = rejectCascade(graph, action.name);
-      return apply(state, [
+      return apply(state2, [
         ...toReject.map((name) => [name, "rejected"]),
         ...toDeselect.map((name) => [name, "undecided"])
       ]);
     }
     case "toggle-all": {
       const nonCycle = components.filter((c2) => !graph.cycleParticipants.has(c2.name)).map((c2) => c2.name);
-      const anyNotAccepted = nonCycle.some((name) => state.get(name) !== "accepted");
+      const anyNotAccepted = nonCycle.some((name) => state2.get(name) !== "accepted");
       if (anyNotAccepted) {
-        return apply(state, [
+        return apply(state2, [
           ...nonCycle.map((name) => [name, "accepted"]),
           ...reachableCycleMembers(graph, nonCycle).map((name) => [name, "accepted"])
         ]);
       }
-      return apply(state, [
+      return apply(state2, [
         ...nonCycle.map((name) => [name, "rejected"]),
-        ...components.filter((c2) => graph.cycleParticipants.has(c2.name) && state.get(c2.name) === "accepted").map((c2) => [c2.name, "undecided"])
+        ...components.filter((c2) => graph.cycleParticipants.has(c2.name) && state2.get(c2.name) === "accepted").map((c2) => [c2.name, "undecided"])
       ]);
     }
     case "accept-unflagged": {
       const seeds = components.filter((c2) => !graph.cycleParticipants.has(c2.name) && !isAiFlagged(c2)).map((c2) => c2.name);
-      return apply(state, [
+      return apply(state2, [
         ...seeds.map((name) => [name, "accepted"]),
         ...reachableCycleMembers(graph, seeds).map((name) => [name, "accepted"])
       ]);
     }
   }
 }
-function rejectNeedsConfirmation(graph, name, state) {
-  if (state.get(name) === "rejected") return false;
+function rejectNeedsConfirmation(graph, name, state2) {
+  if (state2.get(name) === "rejected") return false;
   const { toReject, toDeselect } = rejectCascade(graph, name);
   const ancestors = toReject.filter((n) => n !== name);
   return ancestors.length + toDeselect.length >= 2;
 }
-function partitionDecisions(components, state) {
+function partitionDecisions(components, state2) {
   const accepted = [];
   const rejected = [];
   for (const c2 of components) {
-    if (state.get(c2.name) === "accepted") accepted.push(c2.name);
+    if (state2.get(c2.name) === "accepted") accepted.push(c2.name);
     else rejected.push(c2.name);
   }
   return { accepted, rejected };
@@ -19784,7 +20253,6 @@ function useScopeGate({ components, onConfirm, onQuit }) {
     }),
     [groupedItems, cycleParticipants, expandedGroups, columnOneView, graph, filterVisibleKeys]
   );
-  const emptyMessage = visibleRows.length === 0 && filterVisibleKeys !== void 0 && !jumpFilterTarget ? describeEmptyFilter({ filters: activeFilters, slotDependencies: showDependencies }) : void 0;
   const total = visibleRows.length;
   const safeCursor = Math.min(nav.cursor, Math.max(0, total - 1));
   const currentRow = visibleRows[safeCursor];
@@ -20106,7 +20574,6 @@ function useScopeGate({ components, onConfirm, onQuit }) {
     expandedGroups,
     toggleExpanded,
     visibleRows,
-    emptyMessage,
     safeCursor,
     scrollOffset: nav.scrollOffset,
     selectionStateByKey,
@@ -20160,7 +20627,7 @@ var HELP_SECTIONS = [
     title: "Panels",
     entries: [
       { keys: "c", label: "Cycle list" },
-      { keys: "d", label: "Show slot dependenciess" },
+      { keys: "d", label: "Show slot dependencies in main list" },
       { keys: "x", label: "Review flags" }
     ]
   },
@@ -20229,7 +20696,6 @@ function ScopeGateView({ components, onConfirm, onQuit }) {
           aiFlaggedByKey: gate.aiFlaggedByKey,
           dimPredicate: gate.dimPredicate,
           visibleRows: gate.visibleRows,
-          emptyMessage: gate.emptyMessage,
           viewMode: gate.columnOneView,
           graph: graph.nodes
         }
@@ -20559,7 +21025,7 @@ function applyProgressEvent2(event, previous, total) {
 
 // packages/experience-design-system-cli/src/tui/import/steps/08-generation/use-generation.ts
 function useGeneration(input) {
-  const [state, setState] = useState14();
+  const [state2, setState] = useState14();
   const current = useRef6();
   useEffect9(() => {
     current.current = input;
@@ -20577,7 +21043,7 @@ function useGeneration(input) {
       if (current.current === input) current.current = void 0;
     };
   }, [input]);
-  return state;
+  return state2;
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/10-flow/flow/build-flow-start.ts
@@ -21342,7 +21808,7 @@ function parseToState(json) {
   });
   return { state: { componentDescription, props, slots }, error: null };
 }
-function serializeState(state, originalJson) {
+function serializeState(state2, originalJson) {
   let wrapperKey = null;
   try {
     const orig = JSON.parse(originalJson);
@@ -21356,7 +21822,7 @@ function serializeState(state, originalJson) {
   } catch {
   }
   const $properties = {};
-  for (const p of state.props) {
+  for (const p of state2.props) {
     const def = {
       $type: p.type,
       $category: p.category
@@ -21379,10 +21845,10 @@ function serializeState(state, originalJson) {
     $type: "component",
     $properties
   };
-  if (state.componentDescription) entry.$description = state.componentDescription;
-  if (state.slots.length > 0) {
+  if (state2.componentDescription) entry.$description = state2.componentDescription;
+  if (state2.slots.length > 0) {
     entry.$slots = {};
-    for (const s of state.slots) {
+    for (const s of state2.slots) {
       const slotDef = {};
       if (s.description) slotDef.$description = s.description;
       if (s.required) slotDef.$required = true;
@@ -24472,71 +24938,71 @@ function ReviewReloadDialog({ open }) {
 
 // packages/experience-design-system-cli/src/tui/import/steps/09-review/review-input.ts
 var PANEL_CONTENT_HEIGHT = 12;
-function handleReviewOverlayInput(input, key, state) {
-  if (state.loading) return true;
-  if (state.loadError) {
-    if (input === "q" || key.escape || key.return) state.onQuit();
+function handleReviewOverlayInput(input, key, state2) {
+  if (state2.loading) return true;
+  if (state2.loadError) {
+    if (input === "q" || key.escape || key.return) state2.onQuit();
     return true;
   }
-  if (state.showFinalize) {
+  if (state2.showFinalize) {
     if (key.downArrow) {
-      state.finalizePreview.scrollBy(1);
+      state2.finalizePreview.scrollBy(1);
       return true;
     }
     if (key.upArrow) {
-      state.finalizePreview.scrollBy(-1);
+      state2.finalizePreview.scrollBy(-1);
       return true;
     }
     return true;
   }
-  if (state.dialogOpen || state.showHelp) return true;
-  if (state.showReloadDialog) {
+  if (state2.dialogOpen || state2.showHelp) return true;
+  if (state2.showReloadDialog) {
     if (key.return) {
-      state.reloadFromSave();
-      state.setShowReloadDialog(false);
+      state2.reloadFromSave();
+      state2.setShowReloadDialog(false);
       return true;
     }
     if (key.escape) {
-      state.setShowReloadDialog(false);
+      state2.setShowReloadDialog(false);
       return true;
     }
     return true;
   }
   if (key.ctrl && input === "z") {
-    state.handleUndo();
+    state2.handleUndo();
     return true;
   }
   if (key.ctrl && input === "y") {
-    state.handleRedo();
+    state2.handleRedo();
     return true;
   }
   if (key.ctrl && input === "r") {
-    state.setShowReloadDialog(true);
+    state2.setShowReloadDialog(true);
     return true;
   }
   return false;
 }
-function handleTokenReviewInput(input, key, state) {
-  if (state.panelOpen !== "token-review") return false;
-  const suggestions = state.currentTokenSuggestions();
-  const row = suggestions[state.tokenReviewRow];
-  if (state.tokenReviewEditing) {
+function handleTokenReviewInput(input, key, state2) {
+  if (state2.panelOpen !== "token-review") return false;
+  const suggestions = state2.currentTokenSuggestions();
+  const row = suggestions[state2.tokenReviewRow];
+  if (state2.tokenReviewEditing) {
     if (key.ctrl && input === "s" && row) {
-      state.handleTokenEditSave(row);
+      state2.handleTokenEditSave(row);
       return true;
     }
     if (row && row.paths.length > 0) {
       if (key.upArrow || input === "k") {
-        state.setTokenReviewEditCursor((cursor) => Math.max(0, cursor - 1));
+        state2.setTokenReviewEditCursor((cursor) => Math.max(0, cursor - 1));
         return true;
       }
       if (key.downArrow || input === "j") {
-        state.setTokenReviewEditCursor((cursor) => Math.min(row.paths.length - 1, cursor + 1));
+        state2.setTokenReviewEditCursor((cursor) => Math.min(row.paths.length - 1, cursor + 1));
         return true;
       }
       if (input === " " || key.return) {
-        const path5 = row.paths[state.tokenReviewEditCursor];
-        state.setTokenReviewEditSelection((previous) => {
+        const path5 = row.paths[state2.tokenReviewEditCursor];
+        state2.setTokenReviewEditSelection((previous) => {
           const next = new Set(previous);
           if (next.has(path5) && next.size === 1) return next;
           if (next.has(path5)) next.delete(path5);
@@ -24547,34 +25013,34 @@ function handleTokenReviewInput(input, key, state) {
       }
     }
     if (key.escape) {
-      state.setTokenReviewEditing(false);
+      state2.setTokenReviewEditing(false);
       return true;
     }
     return true;
   }
   if (key.upArrow || input === "k") {
-    state.setTokenReviewRow((rowIndex) => Math.max(0, rowIndex - 1));
+    state2.setTokenReviewRow((rowIndex) => Math.max(0, rowIndex - 1));
     return true;
   }
   if (key.downArrow || input === "j") {
-    state.setTokenReviewRow((rowIndex) => Math.min(Math.max(0, suggestions.length - 1), rowIndex + 1));
+    state2.setTokenReviewRow((rowIndex) => Math.min(Math.max(0, suggestions.length - 1), rowIndex + 1));
     return true;
   }
   if (key.return && row) {
-    state.setTokenReviewEditCursor(0);
-    state.setTokenReviewEditSelection(new Set(row.allowed));
-    state.setTokenReviewEditing(true);
+    state2.setTokenReviewEditCursor(0);
+    state2.setTokenReviewEditSelection(new Set(row.allowed));
+    state2.setTokenReviewEditing(true);
     return true;
   }
   if (key.escape || input === "t") {
-    state.setPanelOpen("none");
+    state2.setPanelOpen("none");
     return true;
   }
   return true;
 }
-function setReviewPanel(state, panel) {
-  state.setPanelOpen(panel);
-  state.setPanelScrollOffset(() => 0);
+function setReviewPanel(state2, panel) {
+  state2.setPanelOpen(panel);
+  state2.setPanelScrollOffset(() => 0);
 }
 function rationalePanelForInput(input, propKey, componentKey) {
   if (input === propKey) return "prop-rationale";
@@ -24582,70 +25048,70 @@ function rationalePanelForInput(input, propKey, componentKey) {
   if (input === "s") return "source";
   return null;
 }
-function handleRationalePanelInput(input, key, state) {
-  if (state.panelOpen === "none" || state.panelOpen === "token-review") return false;
-  const next = computeNextScrollOffset(state.panelScrollOffset, input, key, 9999, PANEL_CONTENT_HEIGHT);
+function handleRationalePanelInput(input, key, state2) {
+  if (state2.panelOpen === "none" || state2.panelOpen === "token-review") return false;
+  const next = computeNextScrollOffset(state2.panelScrollOffset, input, key, 9999, PANEL_CONTENT_HEIGHT);
   if (next !== null) {
-    state.setPanelScrollOffset(() => next);
+    state2.setPanelScrollOffset(() => next);
     return true;
   }
   if (key.escape) {
-    setReviewPanel(state, "none");
+    setReviewPanel(state2, "none");
     return true;
   }
   const togglable = !key.ctrl && !key.tab && !key.meta && !key.return;
   if (!togglable) return true;
-  const panel = rationalePanelForInput(input, state.propKey, state.componentKey);
-  if (panel) setReviewPanel(state, state.panelOpen === panel ? "none" : panel);
+  const panel = rationalePanelForInput(input, state2.propKey, state2.componentKey);
+  if (panel) setReviewPanel(state2, state2.panelOpen === panel ? "none" : panel);
   return true;
 }
-function handleReviewPanelShortcuts(input, key, state) {
-  if (handleTokenReviewInput(input, key, state)) return true;
-  if (handleRationalePanelInput(input, key, state)) return true;
-  const rationaleKeyOk = !state.textEntryActive && !state.showJson && !key.ctrl && !key.tab && !key.meta && !key.return;
+function handleReviewPanelShortcuts(input, key, state2) {
+  if (handleTokenReviewInput(input, key, state2)) return true;
+  if (handleRationalePanelInput(input, key, state2)) return true;
+  const rationaleKeyOk = !state2.textEntryActive && !state2.showJson && !key.ctrl && !key.tab && !key.meta && !key.return;
   if (!rationaleKeyOk) return false;
-  const panel = rationalePanelForInput(input, state.propKey, state.componentKey);
+  const panel = rationalePanelForInput(input, state2.propKey, state2.componentKey);
   if (panel) {
-    setReviewPanel(state, panel);
+    setReviewPanel(state2, panel);
     return true;
   }
-  if (input === "t" && state.currentTokenSuggestions().length > 0) {
-    state.setPanelOpen("token-review");
-    state.setTokenReviewRow(0);
+  if (input === "t" && state2.currentTokenSuggestions().length > 0) {
+    state2.setPanelOpen("token-review");
+    state2.setTokenReviewRow(0);
     return true;
   }
   return false;
 }
-function handleReviewViewToggleInput(input, state) {
+function handleReviewViewToggleInput(input, state2) {
   if (input === "J") {
-    state.setShowJson((previous) => !previous);
-    state.setJsonScrollOffset(0);
-    state.pendingGRef.current = false;
+    state2.setShowJson((previous) => !previous);
+    state2.setJsonScrollOffset(0);
+    state2.pendingGRef.current = false;
     return true;
   }
   return false;
 }
-function handleJsonPanelInput(input, key, state) {
-  if (state.sidebarFocused || !state.showJson) return false;
-  const totalLines = state.jsonValue.split("\n").length;
-  const maxOffset = Math.max(0, totalLines - state.height);
+function handleJsonPanelInput(input, key, state2) {
+  if (state2.sidebarFocused || !state2.showJson) return false;
+  const totalLines = state2.jsonValue.split("\n").length;
+  const maxOffset = Math.max(0, totalLines - state2.height);
   if (input === "g" && !key.ctrl) {
-    if (state.pendingGRef.current) {
-      state.pendingGRef.current = false;
-      state.setJsonScrollOffset(() => 0);
+    if (state2.pendingGRef.current) {
+      state2.pendingGRef.current = false;
+      state2.setJsonScrollOffset(() => 0);
       return true;
     }
-    state.pendingGRef.current = true;
+    state2.pendingGRef.current = true;
     return true;
   }
-  const next = computeNextScrollOffset(state.jsonScrollOffset, input, key, totalLines, state.height);
+  const next = computeNextScrollOffset(state2.jsonScrollOffset, input, key, totalLines, state2.height);
   if (next !== null) {
-    state.pendingGRef.current = false;
+    state2.pendingGRef.current = false;
     const clamped = Math.min(maxOffset, Math.max(0, next));
-    state.setJsonScrollOffset(() => clamped);
+    state2.setJsonScrollOffset(() => clamped);
     return true;
   }
-  state.pendingGRef.current = false;
+  state2.pendingGRef.current = false;
   return true;
 }
 
@@ -24989,12 +25455,12 @@ var HELP_SECTIONS2 = [
     title: "Panels",
     entries: [
       { keys: "c", label: "Cycle list" },
-      { keys: "b", label: "Show breaking changes" },
-      { keys: "w", label: "Filter components with breaking changes" },
-      { keys: "o", label: "Filter components in slot cycles" },
+      { keys: "b", label: "Breaking changes" },
+      { keys: "w", label: "Only breaking" },
+      { keys: "o", label: "Only cycles" },
       { keys: "p", label: "Prop rationale" },
       { keys: "P", label: "Component rationale" },
-      { keys: "s", label: "Source code snippet" },
+      { keys: "s", label: "Source" },
       { keys: "J", label: "Toggle JSON" },
       { keys: "t", label: "Token review" }
     ]
@@ -25713,18 +26179,18 @@ function GenerateReviewStepView({
       }
       return;
     }
-    if (input === "c" && !reviewEditor.textEntryActive && !key.ctrl && !key.meta && cycleRows.length > 0) {
+    if (input === "c" && !key.ctrl && !key.meta && cycleRows.length > 0) {
       cyclePanel.open();
       setCyclePanelScroll(0);
       setCyclesCursor(0);
       return;
     }
-    if (input === "b" && !reviewEditor.textEntryActive && sidebarFocused && breakingChanges.length > 0) {
+    if (input === "b" && sidebarFocused && breakingChanges.length > 0) {
       breakingPanel.open();
       setBreakingCursor(0);
       return;
     }
-    if (!reviewEditor.textEntryActive && (input === "o" || input === "w")) {
+    if (input === "o" || input === "w") {
       const category = input === "o" ? "cycles" : "broken";
       setActiveFilters((prev) => {
         const next = new Set(prev);
@@ -26110,7 +26576,6 @@ function GenerateReviewStepView({
           visibleCount,
           dimPredicate,
           visibleRows: visibleRowsMemo,
-          emptyMessage: visibleRowsMemo.length === 0 && filterVisibleKeys !== void 0 && !jumpFilterTarget ? describeEmptyFilter({ filters: activeFilters }) : void 0,
           viewMode: columnOneView,
           graph: sidebarGraph
         }
@@ -26995,38 +27460,38 @@ function buildRunTeaserLine(runId) {
 
 // packages/experience-design-system-cli/src/tui/import/steps/10-flow/flow/screen.tsx
 import { jsx as jsx52, jsxs as jsxs42 } from "react/jsx-runtime";
-function totalStepsFor(state) {
-  const hasTokenStage = !!state.tokensPath || !!state.rawTokensPath;
-  return 3 + (hasTokenStage ? 1 : 0) + 2 + (state.mapTokensEligible === true ? 1 : 0);
+function totalStepsFor(state2) {
+  const hasTokenStage = !!state2.tokensPath || !!state2.rawTokensPath;
+  return 3 + (hasTokenStage ? 1 : 0) + 2 + (state2.mapTokensEligible === true ? 1 : 0);
 }
 function canEditFromPreview(cdf) {
   if (!cdf) return false;
   return parseCDFComponents(cdf).components.length > 0;
 }
 function FlowScreen({
-  state,
+  state: state2,
   controller,
   livePreview = true,
   generatePromptPath,
   onExit
 }) {
-  const totalSteps = totalStepsFor(state);
+  const totalSteps = totalStepsFor(state2);
   const quit = () => onExit(0);
   const content = (() => {
-    switch (state.step) {
+    switch (state2.step) {
       case "final-review":
         return /* @__PURE__ */ jsx52(
           GenerateReviewStep,
           {
-            extractSessionId: state.extractSessionId,
-            tokenSessionId: state.tokenSessionId,
+            extractSessionId: state2.extractSessionId,
+            tokenSessionId: state2.tokenSessionId,
             livePreview,
-            spaceId: state.spaceId,
-            environmentId: state.environmentId,
-            cmaToken: state.cmaToken,
-            host: state.host,
-            tokensPath: state.tokensPath,
-            initialFinalizeError: state.finalizeErrorBanner,
+            spaceId: state2.spaceId,
+            environmentId: state2.environmentId,
+            cmaToken: state2.cmaToken,
+            host: state2.host,
+            tokensPath: state2.tokensPath,
+            initialFinalizeError: state2.finalizeErrorBanner,
             onFinalize: controller.finalize,
             onQuit: quit
           }
@@ -27042,27 +27507,27 @@ function FlowScreen({
           }
         );
       case "preview-gate":
-        if (!state.serverPreview) return null;
+        if (!state2.serverPreview) return null;
         return /* @__PURE__ */ jsx52(
           WizardPreviewStep,
           {
-            preview: state.serverPreview,
-            spaceId: state.spaceId,
-            environmentId: state.environmentId,
+            preview: state2.serverPreview,
+            spaceId: state2.spaceId,
+            environmentId: state2.environmentId,
             stepNumber: totalSteps,
             totalSteps,
             onConfirm: controller.confirmPreview,
-            ...canEditFromPreview(state.cdf) ? { onEdit: controller.editDefinitions } : {},
+            ...canEditFromPreview(state2.cdf) ? { onEdit: controller.editDefinitions } : {},
             onQuit: quit
           }
         );
       case "pushing":
-        return /* @__PURE__ */ jsx52(PushingStep, { stepNumber: totalSteps, totalSteps, progress: state.pushProgress });
+        return /* @__PURE__ */ jsx52(PushingStep, { stepNumber: totalSteps, totalSteps, progress: state2.pushProgress });
       case "path-prompt":
         return /* @__PURE__ */ jsx52(
           PathPrompt,
           {
-            defaultPath: state.outDir,
+            defaultPath: state2.outDir,
             onSubmit: (submitted) => void controller.submitPath(submitted),
             onCancel: quit
           }
@@ -27078,12 +27543,12 @@ function FlowScreen({
           }
         );
       case "print-gate": {
-        const teaser = buildRunTeaserLine(state.lastRunId);
+        const teaser = buildRunTeaserLine(state2.lastRunId);
         return /* @__PURE__ */ jsx52(
           GateStep,
           {
             message: "Files saved",
-            summary: state.componentsPath ? `components.json \u2192 ${state.componentsPath}` : void 0,
+            summary: state2.componentsPath ? `components.json \u2192 ${state2.componentsPath}` : void 0,
             context: teaser ? `Your files are saved to disk. ${teaser}` : "Your files are saved to disk. Run `experiences import` again when you're ready to push to Contentful.",
             continueLabel: "Exit",
             onContinue: quit,
@@ -27092,17 +27557,17 @@ function FlowScreen({
         );
       }
       case "done": {
-        const totalFailed = state.pushResult.componentTypes.failed + state.pushResult.designTokens.failed;
+        const totalFailed = state2.pushResult.componentTypes.failed + state2.pushResult.designTokens.failed;
         return /* @__PURE__ */ jsx52(
           DoneStep,
           {
-            componentTypes: state.pushResult.componentTypes,
-            designTokens: state.pushResult.designTokens,
-            summary: state.pushResult.summary,
-            failures: state.pushResult.failures,
-            spaceId: state.spaceId,
-            environmentId: state.environmentId,
-            host: state.host,
+            componentTypes: state2.pushResult.componentTypes,
+            designTokens: state2.pushResult.designTokens,
+            summary: state2.pushResult.summary,
+            failures: state2.pushResult.failures,
+            spaceId: state2.spaceId,
+            environmentId: state2.environmentId,
+            host: state2.host,
             onExit: () => onExit(totalFailed > 0 ? 1 : 0)
           }
         );
@@ -27111,8 +27576,8 @@ function FlowScreen({
         return /* @__PURE__ */ jsx52(
           PreviewValidationErrorScreen,
           {
-            errors: state.previewValidationErrors,
-            missingNames: state.previewValidationMissingNames,
+            errors: state2.previewValidationErrors,
+            missingNames: state2.previewValidationMissingNames,
             onEdit: controller.editDefinitions,
             onSkip: () => void controller.skipValidationErrors(),
             onQuit: quit
@@ -27122,10 +27587,10 @@ function FlowScreen({
         return /* @__PURE__ */ jsx52(
           ErrorStep,
           {
-            stepName: state.errorStep,
-            message: state.errorMessage,
+            stepName: state2.errorStep,
+            message: state2.errorMessage,
             onExit: () => onExit(1),
-            onAcknowledgeBreakingChanges: state.errorAllowBreakingChangeAcknowledgment && state.cdf ? controller.acknowledgeBreakingChanges : void 0
+            onAcknowledgeBreakingChanges: state2.errorAllowBreakingChangeAcknowledgment && state2.cdf ? controller.acknowledgeBreakingChanges : void 0
           }
         );
     }
@@ -27143,11 +27608,11 @@ import { useEffect as useEffect20, useRef as useRef12, useSyncExternalStore } fr
 import { appendFileSync, writeFileSync } from "node:fs";
 import { mkdir as mkdir8 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join as join23 } from "node:path";
+import { join as join23, resolve as resolve25 } from "node:path";
 
 // packages/experience-design-system-cli/src/tui/import/steps/10-flow/support/wizard-state-transitions.ts
-function shouldBypassPreview(state) {
-  return state.credentialsSkipped === true;
+function shouldBypassPreview(state2) {
+  return state2.credentialsSkipped === true;
 }
 function buildSkippedPreviewTransition() {
   return { step: "done", serverPreview: null };
@@ -27156,8 +27621,8 @@ function resolveCycleGateAction(opts) {
   if (!opts.hasCycles) return "proceed";
   return "block";
 }
-function shouldRefusePush(state) {
-  return state.credentialsSkipped === true;
+function shouldRefusePush(state2) {
+  return state2.credentialsSkipped === true;
 }
 function buildSkippedPushTransition() {
   return { step: "print-gate" };
@@ -27514,7 +27979,7 @@ var realSaveDeps = () => ({
   writeFile: (path5, contents) => writeFile7(path5, contents),
   appendRun,
   buildSourceFingerprint,
-  sleep: (ms) => new Promise((resolve25) => setTimeout(resolve25, ms)),
+  sleep: (ms) => new Promise((resolve27) => setTimeout(resolve27, ms)),
   warn: (message) => process.stderr.write(message)
 });
 async function runPrintFiles(input, deps, onPatch) {
@@ -27552,17 +28017,17 @@ async function runPrintFiles(input, deps, onPatch) {
   return { ok: true, patch: nextStateAfterPrint({ skipGate: input.skipGate, componentsPath }) };
 }
 async function recordRun(input, deps) {
-  const { state } = input;
+  const { state: state2 } = input;
   try {
     let sourceFingerprint = null;
     try {
-      if (state.extractSessionId) {
+      if (state2.extractSessionId) {
         const db = deps.openDb();
         try {
           sourceFingerprint = await deps.buildSourceFingerprint({
             db,
-            extractSessionId: state.extractSessionId,
-            rawTokensPath: state.rawTokensPath || null
+            extractSessionId: state2.extractSessionId,
+            rawTokensPath: state2.rawTokensPath || null
           });
         } finally {
           db.close();
@@ -27573,16 +28038,16 @@ async function recordRun(input, deps) {
 `);
     }
     const record3 = await deps.appendRun({
-      projectPath: state.projectPath,
+      projectPath: state2.projectPath,
       savePath: input.savePath,
-      componentCount: state.generatedAcceptedCount || state.generatedCount,
-      tokenCount: state.tokenCount,
-      tokensPath: (state.tokenSessionId ? state.tokensPath || null : null) || null,
-      tokenSessionId: state.tokenSessionId,
-      agent: state.agent,
+      componentCount: state2.generatedAcceptedCount || state2.generatedCount,
+      tokenCount: state2.tokenCount,
+      tokensPath: (state2.tokenSessionId ? state2.tokensPath || null : null) || null,
+      tokenSessionId: state2.tokenSessionId,
+      agent: state2.agent,
       pushedTo: null,
-      extractSessionId: state.extractSessionId ?? "",
-      generateSessionId: state.generateSessionId,
+      extractSessionId: state2.extractSessionId ?? "",
+      generateSessionId: state2.generateSessionId,
       sourceFingerprint
     });
     return record3.id;
@@ -27718,7 +28183,7 @@ function namesToSkip(errors) {
   return [...new Set(errors.map((e) => e.componentName))];
 }
 function createFlowController(start, deps) {
-  let state = initialFlowState(start);
+  let state2 = initialFlowState(start);
   const listeners = /* @__PURE__ */ new Set();
   let allowEmptyDeleteAll = false;
   let pendingSave = {};
@@ -27727,27 +28192,27 @@ function createFlowController(start, deps) {
       deps.log({ update: sanitizeForLog(patch) });
     } catch {
     }
-    if (patch.step !== void 0 && patch.step !== state.step) {
+    if (patch.step !== void 0 && patch.step !== state2.step) {
       try {
         deps.beforeStepChange?.();
       } catch {
       }
     }
-    state = { ...state, ...patch };
+    state2 = { ...state2, ...patch };
     for (const listener of listeners) listener();
   };
   const preview = async () => {
-    if (!state.credentialsSkipped) update({ step: "previewing" });
+    if (!state2.credentialsSkipped) update({ step: "previewing" });
     update(
       await runPreview(
         {
-          state,
-          extractSessionId: state.extractSessionId,
-          tokensPath: state.tokensPath,
-          spaceId: state.spaceId,
-          environmentId: state.environmentId,
-          cmaToken: state.cmaToken,
-          host: state.host,
+          state: state2,
+          extractSessionId: state2.extractSessionId,
+          tokensPath: state2.tokensPath,
+          spaceId: state2.spaceId,
+          environmentId: state2.environmentId,
+          cmaToken: state2.cmaToken,
+          host: state2.host,
           deleteAll: allowEmptyDeleteAll
         },
         deps.preview
@@ -27755,18 +28220,18 @@ function createFlowController(start, deps) {
     );
   };
   const push = async (acknowledgeBreakingChanges) => {
-    if (!state.cdf) return;
+    if (!state2.cdf) return;
     update(
       await runPush(
         {
-          state,
-          cdf: state.cdf,
-          spaceId: state.spaceId,
-          environmentId: state.environmentId,
-          cmaToken: state.cmaToken,
-          host: state.host,
+          state: state2,
+          cdf: state2.cdf,
+          spaceId: state2.spaceId,
+          environmentId: state2.environmentId,
+          cmaToken: state2.cmaToken,
+          host: state2.host,
           acknowledgeBreakingChanges,
-          preview: state.serverPreview
+          preview: state2.serverPreview
         },
         deps.push,
         update
@@ -27782,11 +28247,11 @@ function createFlowController(start, deps) {
     const { skipGate, andPush } = pendingSave;
     const written = await runPrintFiles(
       {
-        extractSessionId: state.extractSessionId,
+        extractSessionId: state2.extractSessionId,
         outDir: path5,
         ...skipGate ? { skipGate: true } : {},
-        ...state.tokenSessionId ? { tokenSessionId: state.tokenSessionId } : {},
-        ...state.tokensPath ? { tokensPath: state.tokensPath } : {},
+        ...state2.tokenSessionId ? { tokenSessionId: state2.tokenSessionId } : {},
+        ...state2.tokensPath ? { tokensPath: state2.tokensPath } : {},
         ...allowEmptyDeleteAll ? { allowEmpty: true } : {}
       },
       deps.save,
@@ -27794,21 +28259,21 @@ function createFlowController(start, deps) {
     );
     update(written.patch);
     if (!written.ok) return;
-    const runId = await recordRun({ state, savePath: path5 }, deps.save);
+    const runId = await recordRun({ state: state2, savePath: path5 }, deps.save);
     if (runId) update({ lastRunId: runId });
     if (andPush) await preview();
   };
   const detectAcceptedCycles = () => {
-    if (!state.extractSessionId) return [];
+    if (!state2.extractSessionId) return [];
     try {
-      const accepted = deps.loadAcceptedComponents(state.extractSessionId);
+      const accepted = deps.loadAcceptedComponents(state2.extractSessionId);
       return findSlotCycles3(buildComponentGraph3(accepted));
     } catch {
       return [];
     }
   };
   const begin = () => {
-    if (!state.extractSessionId || !start.handoff.generation) {
+    if (!state2.extractSessionId || !start.handoff.generation) {
       update({
         step: "error",
         errorStep: "start import",
@@ -27825,7 +28290,7 @@ function createFlowController(start, deps) {
   };
   begin();
   return {
-    getState: () => state,
+    getState: () => state2,
     subscribe: (listener) => {
       listeners.add(listener);
       return () => listeners.delete(listener);
@@ -27848,7 +28313,7 @@ function createFlowController(start, deps) {
     },
     async submitPath(submitted) {
       await deps.mkdir(submitted);
-      if (await deps.detectSaveConflict(submitted)) {
+      if (resolve25(submitted) !== resolve25(state2.outDir) && await deps.detectSaveConflict(submitted)) {
         const subdir = deps.buildTimestampedSubdir(submitted);
         await deps.mkdir(subdir);
         await proceedToWrite(subdir);
@@ -27860,9 +28325,9 @@ function createFlowController(start, deps) {
     acknowledgeBreakingChanges: () => void push(true),
     editDefinitions: () => update({ step: "final-review" }),
     async skipValidationErrors() {
-      if (state.extractSessionId) {
-        const names = namesToSkip(state.previewValidationErrors);
-        if (names.length > 0) await deps.rejectComponentsByName(state.extractSessionId, names);
+      if (state2.extractSessionId) {
+        const names = namesToSkip(state2.previewValidationErrors);
+        if (names.length > 0) await deps.rejectComponentsByName(state2.extractSessionId, names);
       }
       await preview();
     }
@@ -27884,184 +28349,32 @@ function useFlow(start, options = {}) {
     });
   }
   const current = controller.current;
-  const state = useSyncExternalStore(
+  const state2 = useSyncExternalStore(
     (listener) => current?.subscribe(listener) ?? (() => void 0),
     () => current?.getState()
   );
   useEffect20(() => {
     if (!start) controller.current = void 0;
   }, [start]);
-  return current && state ? { controller: current, state } : void 0;
+  return current && state2 ? { controller: current, state: state2 } : void 0;
 }
 
 // packages/experience-design-system-cli/src/tui/help/PageContainer.tsx
 import { useEffect as useEffect21, useState as useState27 } from "react";
 import { Box as Box42, Text as Text44, useInput as useInput9 } from "ink";
-
-// packages/experience-design-system-cli/src/tui/debug-store.ts
-import { mkdir as mkdir9, writeFile as writeFile8 } from "node:fs/promises";
-import { existsSync as existsSync9, readdirSync as readdirSync4 } from "node:fs";
-import { join as join24 } from "node:path";
-
-// packages/experience-design-system-cli/src/tui/settings/debug-mode/debug-mode-store.ts
-var DEFAULT_DEBUG_MODE_SETTING = {
-  enabled: true
-};
-async function readDebugModeSetting() {
-  const { debugMode } = await readSettings2();
-  return { ...DEFAULT_DEBUG_MODE_SETTING, ...debugMode };
-}
-async function writeDebugModeSetting(setting) {
-  await updateSettings2({ debugMode: setting });
-}
-
-// packages/experience-design-system-cli/src/tui/debug-store.ts
-var pendingRun;
-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, "");
-}
-function generateSessionId3() {
-  const today = datePrefix();
-  const root = debugSessionsDir2();
-  const existing = existsSync9(root) ? readdirSync4(root) : [];
-  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}`;
-}
-var SESSION_ID = generateSessionId3();
-function sessionDebugDir() {
-  return join24(debugSessionsDir2(), SESSION_ID);
-}
-function currentDebugSessionDir() {
-  return sessionDebugDir();
-}
-void isDebugModeEnabled().then((enabled) => {
-  if (!enabled) return void 0;
-  return mkdir9(sessionDebugDir(), { recursive: true });
-});
-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 flowSegments = run.flow.split("/");
-  const dir = join24(sessionDebugDir(), ...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 stepLabel2 = stepMatch ? `${stepMatch[1]} - ${stepMatch[2]}` : run.step;
-  const flowSlug = run.flow.split("/").join("-");
-  return `# Debug Log
-
-- Run ID: ${run.runId}
-- Flow: ${flowSlug}
-- Step: ${stepLabel2}
-- 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" });
-}
-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_debug_store();
 
 // packages/experience-design-system-cli/src/tui/help/help-info.ts
+init_config();
+init_debug_store();
+init_debug_mode_store();
+init_version();
 async function readHelpInfo() {
   const debugMode = await readDebugModeSetting();
   return {
     storage: [
       { label: "Config folder", value: configRoot2() },
-      { label: "Settings file", value: configFilePath2() },
-      { label: "Debug logs", value: debugSessionsDir2() }
+      { label: "Settings file", value: configFilePath2() }
     ],
     troubleshooting: [
       { label: "CLI version", value: readPackageVersion() },
@@ -28070,7 +28383,7 @@ async function readHelpInfo() {
       { label: "Debug Mode", value: debugMode.enabled ? "on" : "off" },
       {
         label: "This session",
-        value: debugMode.enabled ? currentDebugSessionDir() : "no logs written while Debug Mode is off"
+        value: !debugMode.enabled ? "no logs written while Debug Mode is off" : currentDebugSessionDir() ?? "not started: set the Root Project Directory in Settings, or start an import"
       }
     ]
   };
@@ -28187,6 +28500,7 @@ import { Box as Box44, Text as Text46, useInput as useInput11 } from "ink";
 import TextInput4 from "ink-text-input";
 
 // packages/experience-design-system-cli/src/tui/settings/utils/v1-store.ts
+init_config();
 var readV1Store = readSettings2;
 var writeV1Store = writeSettings2;
 
@@ -28199,7 +28513,8 @@ async function readCredentials() {
     cmaToken: store.cmaToken || "",
     host: store.host || "",
     defaultComponentDir: store.defaultComponentDir || "",
-    defaultTokenFile: store.defaultTokenFile || ""
+    defaultTokenFile: store.defaultTokenFile || "",
+    contentfulBaseDir: store.contentfulBaseDir || ""
   };
 }
 async function writeCredentials(config) {
@@ -28215,6 +28530,7 @@ async function writeCredentials(config) {
 }
 
 // packages/experience-design-system-cli/src/tui/settings/contentful-configuration/ContentfulConfigScreen.tsx
+init_debug_store();
 import { Fragment as Fragment17, jsx as jsx55, jsxs as jsxs45 } from "react/jsx-runtime";
 var FIELD_ORDER = [
   "spaceId",
@@ -28222,7 +28538,8 @@ var FIELD_ORDER = [
   "cmaToken",
   "host",
   "defaultComponentDir",
-  "defaultTokenFile"
+  "defaultTokenFile",
+  "contentfulBaseDir"
 ];
 function debugFields(config) {
   return {
@@ -28231,17 +28548,23 @@ function debugFields(config) {
     cma_token: config?.cmaToken ?? "",
     host: config?.host ?? "",
     default_component_dir: config?.defaultComponentDir ?? "",
-    default_token_file: config?.defaultTokenFile ?? ""
+    default_token_file: config?.defaultTokenFile ?? "",
+    contentful_base_dir: config?.contentfulBaseDir ?? ""
   };
 }
 var FIELD_LABELS = {
   spaceId: "Space ID",
   environmentId: "Environment ID",
   cmaToken: "CMA Token",
-  host: "API Host (optional)",
-  defaultComponentDir: "Default component directory (optional)",
-  defaultTokenFile: "Default token file (optional)"
+  host: "API Host",
+  defaultComponentDir: "Default component directory",
+  defaultTokenFile: "Default token file",
+  contentfulBaseDir: "Root Project Directory"
 };
+var FIELD_HINTS = {
+  contentfulBaseDir: "(where .contentful goes)"
+};
+var LABEL_WIDTH = Math.max(...Object.values(FIELD_LABELS).map((label) => label.length));
 function ConfigurationScreen({ onDone }) {
   const [stage, setStage] = useState29("loading");
   const [config, setConfig] = useState29(null);
@@ -28277,6 +28600,7 @@ function ConfigurationScreen({ onDone }) {
     setNotice(null);
     writeCredentials(config).then(() => {
       setLastSaved(config);
+      if (config.contentfulBaseDir) void startDebugSessionIn(config.contentfulBaseDir, { replace: true });
       setNotice({ kind: "success", text: "Configuration saved" });
       setStage("form");
     }).catch((err) => {
@@ -28342,10 +28666,7 @@ function ConfigurationScreen({ onDone }) {
       const display = field === "cmaToken" ? "\u2022".repeat(value.length) : value;
       return /* @__PURE__ */ jsxs45(Box44, { gap: 1, children: [
         /* @__PURE__ */ jsx55(Text46, { color: isActive ? PALETTE.accent : void 0, children: isActive ? "\u276F" : " " }),
-        /* @__PURE__ */ jsxs45(Text46, { bold: isActive, children: [
-          FIELD_LABELS[field],
-          ":"
-        ] }),
+        /* @__PURE__ */ jsx55(Box44, { width: LABEL_WIDTH, flexShrink: 0, children: /* @__PURE__ */ jsx55(Text46, { bold: isActive, color: isActive ? PALETTE.accent : PALETTE.muted, children: FIELD_LABELS[field] }) }),
         isActive && editing ? /* @__PURE__ */ jsx55(
           TextInput4,
           {
@@ -28354,7 +28675,8 @@ function ConfigurationScreen({ onDone }) {
             onSubmit: () => setEditing(false),
             mask: field === "cmaToken" ? "\u2022" : void 0
           }
-        ) : /* @__PURE__ */ jsx55(Text46, { children: display || /* @__PURE__ */ jsx55(Text46, { color: PALETTE.muted, children: "(empty)" }) })
+        ) : /* @__PURE__ */ jsx55(Text46, { bold: !!display, children: display || (FIELD_HINTS[field] ? "" : /* @__PURE__ */ jsx55(Text46, { color: PALETTE.muted, children: "(empty)" })) }),
+        FIELD_HINTS[field] && /* @__PURE__ */ jsx55(Text46, { color: PALETTE.muted, children: FIELD_HINTS[field] })
       ] }, field);
     }) }),
     notice && /* @__PURE__ */ jsxs45(Fragment17, { children: [
@@ -28406,6 +28728,7 @@ async function writeAnalyticsSetting(setting) {
 }
 
 // packages/experience-design-system-cli/src/tui/settings/opt-in-analytics/screen.tsx
+init_debug_store();
 import { Fragment as Fragment18, jsx as jsx56, jsxs as jsxs46 } from "react/jsx-runtime";
 function OptInAnalyticsScreen({ onDone }) {
   const [loading, setLoading] = useState30(true);
@@ -28466,6 +28789,8 @@ function OptInAnalyticsScreen({ onDone }) {
 // packages/experience-design-system-cli/src/tui/upgrade/PageContainer.tsx
 import { useEffect as useEffect24, useState as useState31 } from "react";
 import { Box as Box46, Text as Text48, useInput as useInput13 } from "ink";
+init_version();
+init_debug_store();
 import { jsx as jsx57, jsxs as jsxs47 } from "react/jsx-runtime";
 var UPGRADE_COMMANDS = ["git pull", "pnpm install", "pnpm build"];
 function UpgradeScreen({ onDone }) {
@@ -28537,6 +28862,8 @@ function renderBody(upgradeCheck) {
 // packages/experience-design-system-cli/src/tui/settings/debug-mode/screen.tsx
 import { useEffect as useEffect25, useState as useState32 } from "react";
 import { Box as Box47, Text as Text49, useInput as useInput14 } from "ink";
+init_debug_mode_store();
+init_debug_store();
 import { jsx as jsx58, jsxs as jsxs48 } from "react/jsx-runtime";
 function DebugModeScreen({ onDone }) {
   const [loading, setLoading] = useState32(true);
@@ -28637,16 +28964,16 @@ function App({ importOptions, inkClear }) {
   const finishCredentials = async (result, projectPath2, tokens, filePaths) => {
     if (!result.skipped) await writeCredentials({ ...result.credentials });
     const launch = { projectPath: projectPath2, tokens, filePaths, ...importOptions };
-    const state = await inspectTokens({
+    const state2 = await inspectTokens({
       rawTokensPath: tokens,
-      outDir: join25(resolveUserPath(projectPath2), ".contentful"),
+      contentfulDir: join25(resolveUserPath(projectPath2), ".contentful"),
       cache: importOptions.cache
     });
-    if (state.kind === "cached") {
+    if (state2.kind === "cached") {
       setPendingLaunch({
         launch,
         credentials: result,
-        cached: { tokensPath: state.tokensPath, sourceChanged: state.sourceChanged }
+        cached: { tokensPath: state2.tokensPath, sourceChanged: state2.sourceChanged }
       });
       return;
     }
@@ -28660,6 +28987,7 @@ function App({ importOptions, inkClear }) {
     const settings = await readSettings2();
     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 ?? ""));
     setExtractionRun({
       ...generatePromptPath ? { generatePromptPath } : {},
       // the later steps get the same agent, so they use what the stage used
@@ -28668,6 +28996,7 @@ function App({ importOptions, inkClear }) {
       tokenStrategy,
       input: {
         projectPath: resolveUserPath(launch.projectPath ?? ""),
+        outDir,
         filePaths: launch.filePaths ?? [],
         rawTokensPath: launch.tokens ?? "",
         tokenStrategy,