@contentful/experience-design-system-cli 2.37.1-dev-build-34dbca05.0 → 2.37.1-dev-build-a2454a09.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((resolve26) => {
     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);
+      resolve26(result);
     });
   });
 }
@@ -843,7 +908,7 @@ async function checkAgentAuth(agent) {
     return "not-found";
   if (agent !== "claude")
     return "ok";
-  return new Promise((resolve25) => {
+  return new Promise((resolve26) => {
     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");
+      resolve26("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");
+        resolve26("unauthenticated");
         return;
       }
       try {
         const status = JSON.parse(stdout);
-        resolve25(status.loggedIn ? "ok" : "unauthenticated");
+        resolve26(status.loggedIn ? "ok" : "unauthenticated");
       } catch {
-        resolve25("unauthenticated");
+        resolve26("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((resolve26) => {
     const child = spawn2(process.platform === "win32" ? "where" : "which", [binary], { stdio: "ignore" });
-    child.on("close", (code) => resolve25(code === 0));
+    child.on("close", (code) => resolve26(code === 0));
   });
 }
 var init_check_agent_auth = __esm({
@@ -2016,6 +2081,233 @@ var init_cache_keys = __esm({
   }
 });
 
+// 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");
+}
+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 });
+}
+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,
+  finishDebugRun: () => finishDebugRun,
+  startDebugRun: () => startDebugRun,
+  startDebugSessionIn: () => startDebugSessionIn
+});
+import { mkdir as mkdir8, writeFile as writeFile7 } from "node:fs/promises";
+import { existsSync as existsSync9, readdirSync as readdirSync3 } from "node:fs";
+import { join as join20, resolve as resolve23 } 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 !== "" ? resolve23(dir) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function nextSessionId(contentfulDir) {
+  const today = datePrefix();
+  const existing = existsSync9(contentfulDir) ? readdirSync3(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 = join20(base, ".contentful");
+  if (replace || !sessionDir) sessionDir = join20(contentfulDir, nextSessionId(contentfulDir));
+  return sessionDir;
+}
+function currentDebugSessionDir() {
+  return sessionDir && join20(sessionDir, "debug");
+}
+async function startDebugSessionIn(base, { replace = false } = {}) {
+  try {
+    if (!await isDebugModeEnabled()) return;
+    await mkdir8(join20(startSession(resolve23(base), { replace }), "debug"), { recursive: true });
+  } catch {
+  }
+}
+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 = join20(root, ...flowSegments);
+  await mkdir8(dir, { recursive: true });
+  const filename = nextAttemptFilename(dir, run.menuOption);
+  await writeFile7(join20(dir, filename), content, { mode: 384 });
+}
+function nextAttemptFilename(dir, menuOption) {
+  const today = datePrefix();
+  const optionSlug = slugify(menuOption);
+  const existing = existsSync9(dir) ? readdirSync3(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 mkdir8(join20(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 useEffect27, useState as useState33 } from "react";
@@ -2039,76 +2331,24 @@ var PALETTE = {
   success: BRAND.green,
   error: BRAND.orange,
   warning: BRAND.yellow,
-  muted: BRAND.slate,
-  border: BRAND.steel
-};
-var BRAND_RAMP = [BRAND.blue, BRAND.orange, BRAND.yellow];
-var BAR_CELL = "\u2501";
-function brandBar(width, ramp = BRAND_RAMP) {
-  if (width <= 0 || ramp.length === 0) return [];
-  const base = Math.floor(width / ramp.length);
-  const remainder = width % ramp.length;
-  return ramp.map((color, i) => ({
-    text: BAR_CELL.repeat(base + (i < remainder ? 1 : 0)),
-    color
-  })).filter((segment) => segment.text.length > 0);
-}
-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" };
-  }
+  muted: BRAND.slate,
+  border: BRAND.steel
+};
+var BRAND_RAMP = [BRAND.blue, BRAND.orange, BRAND.yellow];
+var BAR_CELL = "\u2501";
+function brandBar(width, ramp = BRAND_RAMP) {
+  if (width <= 0 || ramp.length === 0) return [];
+  const base = Math.floor(width / ramp.length);
+  const remainder = width % ramp.length;
+  return ramp.map((color, i) => ({
+    text: BAR_CELL.repeat(base + (i < remainder ? 1 : 0)),
+    color
+  })).filter((segment) => segment.text.length > 0);
 }
+var FOCUS_MARKER = "\u276F";
+
+// 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";
@@ -2699,8 +2939,8 @@ function indexRowsByKey(items, key) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/repositories/sessions/read.js
-function getSessionById(db, sessionId2) {
-  const row = db.prepare("SELECT id FROM sessions WHERE id = ?").get(sessionId2);
+function getSessionById(db, sessionId) {
+  const row = db.prepare("SELECT id FROM sessions WHERE id = ?").get(sessionId);
   return row ?? null;
 }
 function getLatestCompletedSessionForCommand(db, command) {
@@ -2716,8 +2956,8 @@ function getLatestCompletedSessionForCommand(db, command) {
 function createSession(db, id, name, timestamp) {
   db.prepare("INSERT INTO sessions (id, name, created_at, updated_at) VALUES (?, ?, ?, ?)").run(id, name, timestamp, timestamp);
 }
-function updateSessionTimestamp(db, sessionId2, timestamp) {
-  db.prepare("UPDATE sessions SET updated_at = ? WHERE id = ?").run(timestamp, sessionId2);
+function updateSessionTimestamp(db, sessionId, timestamp) {
+  db.prepare("UPDATE sessions SET updated_at = ? WHERE id = ?").run(timestamp, sessionId);
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/repositories/steps/read.js
@@ -2727,13 +2967,13 @@ function getSessionIdForStep(db, stepId) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/repositories/steps/write.js
-function updatePendingStepsToInterrupted(db, sessionId2, command, timestamp) {
+function updatePendingStepsToInterrupted(db, sessionId, command, timestamp) {
   db.prepare(`UPDATE steps SET status = 'interrupted', completed_at = ?, updated_at = ?
-     WHERE session_id = ? AND command = ? AND status = 'pending'`).run(timestamp, timestamp, sessionId2, command);
+     WHERE session_id = ? AND command = ? AND status = 'pending'`).run(timestamp, timestamp, sessionId, command);
 }
-function createPendingStep(db, sessionId2, command, inputs, timestamp) {
+function createPendingStep(db, sessionId, command, inputs, timestamp) {
   const result = db.prepare(`INSERT INTO steps (session_id, command, status, started_at, inputs, outputs, updated_at)
-       VALUES (?, ?, 'pending', ?, ?, '{}', ?)`).run(sessionId2, command, timestamp, JSON.stringify(inputs), timestamp);
+       VALUES (?, ?, 'pending', ?, ?, '{}', ?)`).run(sessionId, command, timestamp, JSON.stringify(inputs), timestamp);
   return Number(result.lastInsertRowid);
 }
 function updateStepStatus(db, stepId, status, outputs, error, timestamp) {
@@ -2995,12 +3235,12 @@ function buildDtcgTokens(tokenRows) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/repositories/tokens/read.js
-function getDtcgTokensForSession(db, sessionId2) {
-  const groupRows = db.prepare("SELECT path, description FROM raw_token_groups WHERE session_id = ? ORDER BY path").all(sessionId2).map((row) => ({
+function getDtcgTokensForSession(db, sessionId) {
+  const groupRows = db.prepare("SELECT path, description FROM raw_token_groups WHERE session_id = ? ORDER BY path").all(sessionId).map((row) => ({
     path: String(row.path),
     description: row.description === null ? null : String(row.description)
   }));
-  const tokenRows = db.prepare("SELECT path, type, value, description FROM raw_tokens WHERE session_id = ? ORDER BY path").all(sessionId2).map((row) => ({
+  const tokenRows = db.prepare("SELECT path, type, value, description FROM raw_tokens WHERE session_id = ? ORDER BY path").all(sessionId).map((row) => ({
     path: String(row.path),
     type: String(row.type),
     value: String(row.value),
@@ -3011,12 +3251,12 @@ function getDtcgTokensForSession(db, sessionId2) {
     tokens: buildDtcgTokens(tokenRows)
   };
 }
-function getRawTokenNamePaths(db, sessionId2) {
-  const rows = db.prepare("SELECT raw_name, path FROM raw_token_name_paths WHERE session_id = ? ORDER BY raw_name").all(sessionId2);
+function getRawTokenNamePaths(db, sessionId) {
+  const rows = db.prepare("SELECT raw_name, path FROM raw_token_name_paths WHERE session_id = ? ORDER BY raw_name").all(sessionId);
   return Object.fromEntries(rows.map((row) => [String(row.raw_name), String(row.path)]));
 }
-function getRawTokenNamePathRows(db, sessionId2) {
-  return db.prepare("SELECT raw_name, path, source FROM raw_token_name_paths WHERE session_id = ? ORDER BY raw_name").all(sessionId2).map((row) => ({
+function getRawTokenNamePathRows(db, sessionId) {
+  return db.prepare("SELECT raw_name, path, source FROM raw_token_name_paths WHERE session_id = ? ORDER BY raw_name").all(sessionId).map((row) => ({
     rawName: String(row.raw_name),
     path: String(row.path),
     source: String(row.source)
@@ -3049,49 +3289,49 @@ function hashTokenContent(rawTokenContent) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/repositories/tokens/write.js
-function deleteRawTokensForSession(db, sessionId2) {
-  db.prepare("DELETE FROM raw_token_groups WHERE session_id = ?").run(sessionId2);
-  db.prepare("DELETE FROM raw_tokens WHERE session_id = ?").run(sessionId2);
+function deleteRawTokensForSession(db, sessionId) {
+  db.prepare("DELETE FROM raw_token_groups WHERE session_id = ?").run(sessionId);
+  db.prepare("DELETE FROM raw_tokens WHERE session_id = ?").run(sessionId);
 }
-function createRawTokenGroups(db, sessionId2, groups) {
+function createRawTokenGroups(db, sessionId, groups) {
   const insertGroup = db.prepare(`INSERT INTO raw_token_groups (session_id, path, description) VALUES (?, ?, ?)`);
   for (const group of groups) {
-    insertGroup.run(sessionId2, group.path, group.$description ?? null);
+    insertGroup.run(sessionId, group.path, group.$description ?? null);
   }
 }
-function createRawTokens(db, sessionId2, tokens) {
+function createRawTokens(db, sessionId, tokens) {
   const insertToken = db.prepare(`INSERT INTO raw_tokens (session_id, path, type, value, description) VALUES (?, ?, ?, ?, ?)`);
   for (const token of tokens) {
-    insertToken.run(sessionId2, token.path, token.$type, JSON.stringify(token.$value), token.$description ?? null);
+    insertToken.run(sessionId, token.path, token.$type, JSON.stringify(token.$value), token.$description ?? null);
   }
 }
-function upsertRawToken(db, sessionId2, call) {
+function upsertRawToken(db, sessionId, call) {
   db.prepare(`INSERT INTO raw_tokens (session_id, path, type, value, description) VALUES (?, ?, ?, ?, ?)
-     ON CONFLICT(session_id, path) DO UPDATE SET type = excluded.type, value = excluded.value, description = excluded.description`).run(sessionId2, call.path, call.type, JSON.stringify(call.value), call.description ?? null);
+     ON CONFLICT(session_id, path) DO UPDATE SET type = excluded.type, value = excluded.value, description = excluded.description`).run(sessionId, call.path, call.type, JSON.stringify(call.value), call.description ?? null);
 }
-function upsertRawTokenGroup(db, sessionId2, call) {
+function upsertRawTokenGroup(db, sessionId, call) {
   db.prepare(`INSERT INTO raw_token_groups (session_id, path, description) VALUES (?, ?, ?)
-     ON CONFLICT(session_id, path) DO UPDATE SET description = excluded.description`).run(sessionId2, call.path, call.description ?? null);
+     ON CONFLICT(session_id, path) DO UPDATE SET description = excluded.description`).run(sessionId, call.path, call.description ?? null);
 }
-function updateRawTokenNamePaths(db, sessionId2, tokenNamePaths, source) {
+function updateRawTokenNamePaths(db, sessionId, tokenNamePaths, source) {
   const entries = Object.entries(tokenNamePaths);
   const deletePaths = db.prepare("DELETE FROM raw_token_name_paths WHERE session_id = ? AND source = ?");
   const insertPath = db.prepare("INSERT OR IGNORE INTO raw_token_name_paths (session_id, raw_name, path, source) VALUES (?, ?, ?, ?)");
   const deleteAutomaticByName = db.prepare("DELETE FROM raw_token_name_paths WHERE session_id = ? AND raw_name = ? AND source = 'automatic'");
-  deletePaths.run(sessionId2, source);
+  deletePaths.run(sessionId, source);
   for (const [rawName, path5] of entries) {
     if (source === "manual")
-      deleteAutomaticByName.run(sessionId2, rawName);
-    insertPath.run(sessionId2, rawName, path5, source);
+      deleteAutomaticByName.run(sessionId, rawName);
+    insertPath.run(sessionId, rawName, path5, source);
   }
 }
-function updateRawPropTokenPaths(db, sessionId2, componentId, propName, paths, source) {
+function updateRawPropTokenPaths(db, sessionId, componentId, propName, paths, source) {
   db.prepare(`DELETE FROM raw_prop_token_paths
-     WHERE session_id = ? AND component_id = ? AND prop_name = ?`).run(sessionId2, componentId, propName);
+     WHERE session_id = ? AND component_id = ? AND prop_name = ?`).run(sessionId, componentId, propName);
   const insertPath = db.prepare(`INSERT INTO raw_prop_token_paths (session_id, component_id, prop_name, source, position, path)
      VALUES (?, ?, ?, ?, ?, ?)`);
   paths.forEach((path5, position) => {
-    insertPath.run(sessionId2, componentId, propName, source, position, path5);
+    insertPath.run(sessionId, componentId, propName, source, position, path5);
   });
 }
 
@@ -3109,18 +3349,18 @@ function withTransaction(db, fn) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/services/tokens/store-dtcg-tokens.js
-function storeDtcgTokens(db, sessionId2, groups, tokens) {
+function storeDtcgTokens(db, sessionId, groups, tokens) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   withTransaction(db, () => {
-    deleteRawTokensForSession(db, sessionId2);
-    createRawTokenGroups(db, sessionId2, groups);
-    createRawTokens(db, sessionId2, tokens);
-    updateSessionTimestamp(db, sessionId2, now);
+    deleteRawTokensForSession(db, sessionId);
+    createRawTokenGroups(db, sessionId, groups);
+    createRawTokens(db, sessionId, tokens);
+    updateSessionTimestamp(db, sessionId, now);
   });
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/services/tokens/apply-tool-calls.js
-function applyTokenToolCalls(db, sessionId2, calls, incomingWarnings) {
+function applyTokenToolCalls(db, sessionId, calls, incomingWarnings) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const warnings = [...incomingWarnings];
   let tokens = 0;
@@ -3128,31 +3368,31 @@ function applyTokenToolCalls(db, sessionId2, calls, incomingWarnings) {
   withTransaction(db, () => {
     for (const call of calls) {
       if (call.tool === "set_token") {
-        upsertRawToken(db, sessionId2, call);
+        upsertRawToken(db, sessionId, call);
         tokens++;
       } else if (call.tool === "set_group") {
-        upsertRawTokenGroup(db, sessionId2, call);
+        upsertRawTokenGroup(db, sessionId, call);
         groups++;
       }
     }
-    updateSessionTimestamp(db, sessionId2, now);
+    updateSessionTimestamp(db, sessionId, now);
   });
   return { tokens, groups, warnings };
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/services/tokens/replace-raw-token-name-paths.js
-function replaceRawTokenNamePaths(db, sessionId2, tokenNamePaths, source = "automatic") {
+function replaceRawTokenNamePaths(db, sessionId, tokenNamePaths, source = "automatic") {
   withTransaction(db, () => {
-    updateRawTokenNamePaths(db, sessionId2, tokenNamePaths, source);
-    updateSessionTimestamp(db, sessionId2, (/* @__PURE__ */ new Date()).toISOString());
+    updateRawTokenNamePaths(db, sessionId, tokenNamePaths, source);
+    updateSessionTimestamp(db, sessionId, (/* @__PURE__ */ new Date()).toISOString());
   });
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/session/services/tokens/replace-raw-prop-token-paths.js
-function replaceRawPropTokenPaths(db, sessionId2, componentId, propName, paths, source) {
+function replaceRawPropTokenPaths(db, sessionId, componentId, propName, paths, source) {
   withTransaction(db, () => {
-    updateRawPropTokenPaths(db, sessionId2, componentId, propName, paths, source);
-    updateSessionTimestamp(db, sessionId2, (/* @__PURE__ */ new Date()).toISOString());
+    updateRawPropTokenPaths(db, sessionId, componentId, propName, paths, source);
+    updateSessionTimestamp(db, sessionId, (/* @__PURE__ */ new Date()).toISOString());
   });
 }
 
@@ -3596,11 +3836,11 @@ function applyDbMigrations(db) {
     `);
   }
 }
-function loadComponentReviewMetadata(db, sessionId2, componentName) {
-  const compRow = db.prepare(`SELECT component_id, source, source_path FROM raw_components WHERE session_id = ? AND name = ?`).get(sessionId2, componentName);
+function loadComponentReviewMetadata(db, sessionId, componentName) {
+  const compRow = db.prepare(`SELECT component_id, source, source_path FROM raw_components WHERE session_id = ? AND name = ?`).get(sessionId, componentName);
   if (!compRow)
     return null;
-  const propRows = db.prepare(`SELECT name, rationale, source_start_line, source_end_line FROM raw_props WHERE session_id = ? AND component_id = ?`).all(sessionId2, compRow.component_id);
+  const propRows = db.prepare(`SELECT name, rationale, source_start_line, source_end_line FROM raw_props WHERE session_id = ? AND component_id = ?`).all(sessionId, compRow.component_id);
   const props = {};
   for (const r of propRows) {
     props[r.name] = {
@@ -3622,15 +3862,15 @@ function loadComponentReviewMetadata(db, sessionId2, componentName) {
     props
   };
 }
-function loadComponentRationale(db, sessionId2, componentName) {
+function loadComponentRationale(db, sessionId, componentName) {
   const compRow = db.prepare(`SELECT component_id, name, description, component_description_rationale, props_rationale, slots_rationale
-       FROM raw_components WHERE session_id = ? AND name = ?`).get(sessionId2, componentName);
+       FROM raw_components WHERE session_id = ? AND name = ?`).get(sessionId, componentName);
   if (!compRow)
     return null;
   const propRows = db.prepare(`SELECT name, cdf_category, category, description, rationale FROM raw_props
-       WHERE session_id = ? AND component_id = ? ORDER BY position`).all(sessionId2, compRow.component_id);
+       WHERE session_id = ? AND component_id = ? ORDER BY position`).all(sessionId, compRow.component_id);
   const slotRows = db.prepare(`SELECT name, description, rationale FROM raw_slots
-       WHERE session_id = ? AND component_id = ? ORDER BY position`).all(sessionId2, compRow.component_id);
+       WHERE session_id = ? AND component_id = ? ORDER BY position`).all(sessionId, compRow.component_id);
   return {
     name: compRow.name,
     description: compRow.description,
@@ -3650,7 +3890,7 @@ function loadComponentRationale(db, sessionId2, componentName) {
     }))
   };
 }
-function applyToolCalls(db, sessionId2, componentId, componentName, calls, incomingWarnings, options = {}) {
+function applyToolCalls(db, sessionId, componentId, componentName, calls, incomingWarnings, options = {}) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const warnings = [...incomingWarnings];
   let classified = 0;
@@ -3678,58 +3918,58 @@ function applyToolCalls(db, sessionId2, componentId, componentName, calls, incom
     for (const call of calls) {
       if (call.tool === "classify_component") {
         if (call.description !== void 0) {
-          db.prepare("UPDATE raw_components SET description = ? WHERE session_id = ? AND component_id = ?").run(call.description, sessionId2, componentId);
+          db.prepare("UPDATE raw_components SET description = ? WHERE session_id = ? AND component_id = ?").run(call.description, sessionId, componentId);
         }
         if (call.rationale) {
           if (call.rationale.description !== void 0) {
-            db.prepare("UPDATE raw_components SET component_description_rationale = ? WHERE session_id = ? AND component_id = ?").run(call.rationale.description, sessionId2, componentId);
+            db.prepare("UPDATE raw_components SET component_description_rationale = ? WHERE session_id = ? AND component_id = ?").run(call.rationale.description, sessionId, componentId);
           }
           if (call.rationale.props !== void 0) {
-            db.prepare("UPDATE raw_components SET props_rationale = ? WHERE session_id = ? AND component_id = ?").run(call.rationale.props, sessionId2, componentId);
+            db.prepare("UPDATE raw_components SET props_rationale = ? WHERE session_id = ? AND component_id = ?").run(call.rationale.props, sessionId, componentId);
           }
           if (call.rationale.slots !== void 0) {
-            db.prepare("UPDATE raw_components SET slots_rationale = ? WHERE session_id = ? AND component_id = ?").run(call.rationale.slots, sessionId2, componentId);
+            db.prepare("UPDATE raw_components SET slots_rationale = ? WHERE session_id = ? AND component_id = ?").run(call.rationale.slots, sessionId, componentId);
           }
         }
       } else if (call.tool === "classify_prop") {
-        const changes = updateProp.run(call.cdf_type, call.cdf_category, call.token_kind ?? null, call.required !== void 0 ? call.required ? 1 : 0 : 0, call.description ?? null, call.reason ?? null, sessionId2, componentId, call.prop);
+        const changes = updateProp.run(call.cdf_type, call.cdf_category, call.token_kind ?? null, call.required !== void 0 ? call.required ? 1 : 0 : 0, call.description ?? null, call.reason ?? null, sessionId, componentId, call.prop);
         if (changes.changes === 0) {
           warnings.push(`${componentName}: classify_prop '${call.prop}' \u2014 prop not found, skipped`);
           continue;
         }
         if (call.cdf_type === "token") {
-          deleteAllowedValues.run(sessionId2, componentId, call.prop);
+          deleteAllowedValues.run(sessionId, componentId, call.prop);
           if (call.values && call.values.length > 0) {
             const count = call.values.length;
             warnings.push(`${componentName}: classify_prop '${call.prop}' \u2014 dropped ${count} value${count === 1 ? "" : "s"} on a token property; its options list is $token.allowed, not $values`);
           }
         } else {
-          deleteTokenPaths.run(sessionId2, componentId, call.prop);
+          deleteTokenPaths.run(sessionId, componentId, call.prop);
           if (call.values && call.values.length > 0) {
-            deleteAllowedValues.run(sessionId2, componentId, call.prop);
-            call.values.forEach((v, i) => insertAllowedValue.run(sessionId2, componentId, call.prop, v, i));
+            deleteAllowedValues.run(sessionId, componentId, call.prop);
+            call.values.forEach((v, i) => insertAllowedValue.run(sessionId, componentId, call.prop, v, i));
           }
         }
         if (call.default !== void 0) {
           const storedDefault = typeof call.default === "boolean" ? String(call.default) : call.default;
-          db.prepare(`UPDATE raw_props SET default_value = ? WHERE session_id = ? AND component_id = ? AND name = ?`).run(storedDefault, sessionId2, componentId, call.prop);
+          db.prepare(`UPDATE raw_props SET default_value = ? WHERE session_id = ? AND component_id = ? AND name = ?`).run(storedDefault, sessionId, componentId, call.prop);
         }
         classified++;
       } else if (call.tool === "exclude_prop") {
-        clearProp.run(call.reason || null, sessionId2, componentId, call.prop);
+        clearProp.run(call.reason || null, sessionId, componentId, call.prop);
         excluded++;
       } else if (call.tool === "classify_slot") {
         const slotRequired = call.required !== void 0 ? call.required ? 1 : 0 : 1;
-        const slotChanges = updateSlot.run(slotRequired, call.description ?? null, sessionId2, componentId, call.slot);
+        const slotChanges = updateSlot.run(slotRequired, call.description ?? null, sessionId, componentId, call.slot);
         if (slotChanges.changes === 0) {
           warnings.push(`${componentName}: classify_slot '${call.slot}' \u2014 slot not found, skipped`);
           continue;
         }
         if (call.rationale !== void 0) {
-          db.prepare("UPDATE raw_slots SET rationale = ? WHERE session_id = ? AND component_id = ? AND name = ?").run(call.rationale, sessionId2, componentId, call.slot);
+          db.prepare("UPDATE raw_slots SET rationale = ? WHERE session_id = ? AND component_id = ? AND name = ?").run(call.rationale, sessionId, componentId, call.slot);
         }
         if (call.allowed_components !== void 0) {
-          deleteAllowedComponents.run(sessionId2, componentId, call.slot);
+          deleteAllowedComponents.run(sessionId, componentId, call.slot);
           const allowedComponents = options.allowedComponentNames ? call.allowed_components.filter((allowedComponent) => options.allowedComponentNames.has(allowedComponent)) : call.allowed_components;
           if (options.allowedComponentNames) {
             const dropped = [
@@ -3739,13 +3979,13 @@ function applyToolCalls(db, sessionId2, componentId, componentName, calls, incom
               warnings.push(`${componentName}: classify_slot '${call.slot}' \u2014 dropped unknown allowed component '${allowedComponent}'`);
             }
           }
-          allowedComponents.forEach((ac, i) => insertAllowedComponent.run(sessionId2, componentId, call.slot, ac, i));
+          allowedComponents.forEach((ac, i) => insertAllowedComponent.run(sessionId, componentId, call.slot, ac, i));
         }
         slots++;
       }
     }
-    db.prepare(`UPDATE raw_components SET status = 'generated', extracted_at = ? WHERE session_id = ? AND component_id = ?`).run(now, sessionId2, componentId);
-    db.prepare("UPDATE sessions SET updated_at = ? WHERE id = ?").run(now, sessionId2);
+    db.prepare(`UPDATE raw_components SET status = 'generated', extracted_at = ? WHERE session_id = ? AND component_id = ?`).run(now, sessionId, componentId);
+    db.prepare("UPDATE sessions SET updated_at = ? WHERE id = ?").run(now, sessionId);
     db.exec("COMMIT");
   } catch (e) {
     db.exec("ROLLBACK");
@@ -3756,13 +3996,13 @@ function applyToolCalls(db, sessionId2, componentId, componentName, calls, incom
 function getOrCreateSession(db, sessionFlag, sessionName, hints) {
   return getOrCreateSessionForCommand(db, sessionFlag, sessionName, hints);
 }
-function createStep(db, sessionId2, command, inputs) {
+function createStep(db, sessionId, command, inputs) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   db.exec("BEGIN");
   try {
-    updatePendingStepsToInterrupted(db, sessionId2, command, now);
-    const stepId = createPendingStep(db, sessionId2, command, inputs, now);
-    updateSessionTimestamp(db, sessionId2, now);
+    updatePendingStepsToInterrupted(db, sessionId, command, now);
+    const stepId = createPendingStep(db, sessionId, command, inputs, now);
+    updateSessionTimestamp(db, sessionId, now);
     db.exec("COMMIT");
     return stepId;
   } catch (e) {
@@ -3785,7 +4025,7 @@ function updateStep(db, stepId, status, outputs, error) {
     throw e;
   }
 }
-function storeRawComponents(db, sessionId2, components, options) {
+function storeRawComponents(db, sessionId, components, options) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const insertComp = db.prepare(`INSERT INTO raw_components (session_id, component_id, name, source, framework, extracted_at, extraction_confidence, review_reasons, needs_review, source_path)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
@@ -3806,34 +4046,34 @@ function storeRawComponents(db, sessionId2, components, options) {
     let statusSnapshot = [];
     if (options?.preserveCDF) {
       cdfSnapshot = db.prepare(`SELECT component_id, name, position, cdf_type, cdf_category, cdf_token_kind
-           FROM raw_props WHERE session_id = ? AND cdf_type IS NOT NULL`).all(sessionId2);
+           FROM raw_props WHERE session_id = ? AND cdf_type IS NOT NULL`).all(sessionId);
       descSnapshot = db.prepare(`SELECT component_id, description
-           FROM raw_components WHERE session_id = ? AND description IS NOT NULL`).all(sessionId2);
+           FROM raw_components WHERE session_id = ? AND description IS NOT NULL`).all(sessionId);
       if (cdfSnapshot.length > 0) {
         avSnapshot = db.prepare(`SELECT component_id, prop_name, position, value
-             FROM raw_prop_allowed_values WHERE session_id = ?`).all(sessionId2);
+             FROM raw_prop_allowed_values WHERE session_id = ?`).all(sessionId);
       }
     }
     if (options?.preserveStatus) {
       statusSnapshot = db.prepare(`SELECT component_id, status, reject_reason
-           FROM raw_components WHERE session_id = ?`).all(sessionId2);
+           FROM raw_components WHERE session_id = ?`).all(sessionId);
     }
-    db.prepare("DELETE FROM raw_components WHERE session_id = ?").run(sessionId2);
+    db.prepare("DELETE FROM raw_components WHERE session_id = ?").run(sessionId);
     for (const comp of components) {
       const componentId = deriveComponentId(comp.name, comp.source);
-      insertComp.run(sessionId2, componentId, comp.name, comp.source, comp.framework, now, comp.extractionConfidence ?? null, JSON.stringify(comp.reviewReasons ?? []), comp.needsReview ? 1 : 0, comp.sourcePath ?? null);
+      insertComp.run(sessionId, componentId, comp.name, comp.source, comp.framework, now, comp.extractionConfidence ?? null, JSON.stringify(comp.reviewReasons ?? []), comp.needsReview ? 1 : 0, comp.sourcePath ?? null);
       for (let i = 0; i < comp.props.length; i++) {
         const prop = comp.props[i];
-        insertProp.run(sessionId2, componentId, prop.name, prop.type, prop.required ? 1 : 0, prop.category ?? null, prop.defaultValue ?? null, prop.description ?? null, prop.tokenReference ?? null, i, prop.sourceStartLine ?? null, prop.sourceEndLine ?? null);
+        insertProp.run(sessionId, componentId, prop.name, prop.type, prop.required ? 1 : 0, prop.category ?? null, prop.defaultValue ?? null, prop.description ?? null, prop.tokenReference ?? null, i, prop.sourceStartLine ?? null, prop.sourceEndLine ?? null);
         if (prop.allowedValues) {
-          prop.allowedValues.forEach((v, j) => insertAllowedValue.run(sessionId2, componentId, prop.name, j, v));
+          prop.allowedValues.forEach((v, j) => insertAllowedValue.run(sessionId, componentId, prop.name, j, v));
         }
       }
       for (let i = 0; i < comp.slots.length; i++) {
         const slot = comp.slots[i];
-        insertSlot.run(sessionId2, componentId, slot.name, slot.isDefault ? 1 : 0, slot.description ?? null, i);
+        insertSlot.run(sessionId, componentId, slot.name, slot.isDefault ? 1 : 0, slot.description ?? null, i);
         if (slot.allowedComponents) {
-          slot.allowedComponents.forEach((ac, j) => insertAllowedComponent.run(sessionId2, componentId, slot.name, j, ac));
+          slot.allowedComponents.forEach((ac, j) => insertAllowedComponent.run(sessionId, componentId, slot.name, j, ac));
         }
       }
     }
@@ -3845,7 +4085,7 @@ function storeRawComponents(db, sessionId2, components, options) {
       const restoredPropKeys = /* @__PURE__ */ new Set();
       const unmatchedSnaps = [];
       for (const snap of cdfSnapshot) {
-        const result = updateCDFByName.run(snap.cdf_type, snap.cdf_category, snap.cdf_token_kind, sessionId2, snap.component_id, snap.name);
+        const result = updateCDFByName.run(snap.cdf_type, snap.cdf_category, snap.cdf_token_kind, sessionId, snap.component_id, snap.name);
         if (Number(result.changes) > 0) {
           restoredPropKeys.add(`${snap.component_id}::${snap.name}`);
         } else {
@@ -3853,9 +4093,9 @@ function storeRawComponents(db, sessionId2, components, options) {
         }
       }
       for (const snap of unmatchedSnaps) {
-        const result = updateCDFByPosition.run(snap.cdf_type, snap.cdf_category, snap.cdf_token_kind, sessionId2, snap.component_id, snap.position);
+        const result = updateCDFByPosition.run(snap.cdf_type, snap.cdf_category, snap.cdf_token_kind, sessionId, snap.component_id, snap.position);
         if (Number(result.changes) > 0) {
-          const matched = db.prepare(`SELECT name FROM raw_props WHERE session_id = ? AND component_id = ? AND position = ?`).get(sessionId2, snap.component_id, snap.position);
+          const matched = db.prepare(`SELECT name FROM raw_props WHERE session_id = ? AND component_id = ? AND position = ?`).get(sessionId, snap.component_id, snap.position);
           if (matched) {
             restoredPropKeys.add(`${snap.component_id}::${matched.name}`);
           }
@@ -3863,7 +4103,7 @@ function storeRawComponents(db, sessionId2, components, options) {
       }
       const updateDesc = db.prepare(`UPDATE raw_components SET description = ? WHERE session_id = ? AND component_id = ?`);
       for (const snap of descSnapshot) {
-        updateDesc.run(snap.description, sessionId2, snap.component_id);
+        updateDesc.run(snap.description, sessionId, snap.component_id);
       }
       const relevantAV = avSnapshot.filter((av) => restoredPropKeys.has(`${av.component_id}::${av.prop_name}`));
       if (relevantAV.length > 0) {
@@ -3874,10 +4114,10 @@ function storeRawComponents(db, sessionId2, components, options) {
         for (const av of relevantAV) {
           const key = `${av.component_id}::${av.prop_name}`;
           if (!deletedKeys.has(key)) {
-            deleteAV.run(sessionId2, av.component_id, av.prop_name);
+            deleteAV.run(sessionId, av.component_id, av.prop_name);
             deletedKeys.add(key);
           }
-          insertAV.run(sessionId2, av.component_id, av.prop_name, av.position, av.value);
+          insertAV.run(sessionId, av.component_id, av.prop_name, av.position, av.value);
         }
       }
     }
@@ -3885,33 +4125,33 @@ function storeRawComponents(db, sessionId2, components, options) {
       const restoreStatus = db.prepare(`UPDATE raw_components SET status = ?, reject_reason = ?
          WHERE session_id = ? AND component_id = ?`);
       for (const snapshot of statusSnapshot) {
-        restoreStatus.run(snapshot.status, snapshot.reject_reason, sessionId2, snapshot.component_id);
+        restoreStatus.run(snapshot.status, snapshot.reject_reason, sessionId, snapshot.component_id);
       }
     }
     if (options?.status) {
-      db.prepare("UPDATE raw_components SET status = ? WHERE session_id = ?").run(options.status, sessionId2);
+      db.prepare("UPDATE raw_components SET status = ? WHERE session_id = ?").run(options.status, sessionId);
     }
-    db.prepare("UPDATE sessions SET updated_at = ? WHERE id = ?").run(now, sessionId2);
+    db.prepare("UPDATE sessions SET updated_at = ? WHERE id = ?").run(now, sessionId);
     db.exec("COMMIT");
   } catch (e) {
     db.exec("ROLLBACK");
     throw e;
   }
 }
-function loadRawComponents(db, sessionId2, allowedNames) {
-  const all = db.prepare("SELECT component_id, name, source, framework, extraction_confidence, review_reasons, needs_review, source_path FROM raw_components WHERE session_id = ? ORDER BY rowid").all(sessionId2);
+function loadRawComponents(db, sessionId, allowedNames) {
+  const all = db.prepare("SELECT component_id, name, source, framework, extraction_confidence, review_reasons, needs_review, source_path FROM raw_components WHERE session_id = ? ORDER BY rowid").all(sessionId);
   const components = allowedNames ? all.filter((c2) => allowedNames.has(c2.name)) : all;
   if (components.length === 0)
     return [];
   const props = db.prepare(`SELECT component_id, name, type, required, category, default_value, description, token_reference, position,
               rationale, source_start_line, source_end_line
-       FROM raw_props WHERE session_id = ? ORDER BY component_id, position`).all(sessionId2);
+       FROM raw_props WHERE session_id = ? ORDER BY component_id, position`).all(sessionId);
   const allowedValues = db.prepare(`SELECT component_id, prop_name, position, value
-       FROM raw_prop_allowed_values WHERE session_id = ? ORDER BY component_id, prop_name, position`).all(sessionId2);
+       FROM raw_prop_allowed_values WHERE session_id = ? ORDER BY component_id, prop_name, position`).all(sessionId);
   const slots = db.prepare(`SELECT component_id, name, is_default, description, position
-       FROM raw_slots WHERE session_id = ? ORDER BY component_id, position`).all(sessionId2);
+       FROM raw_slots WHERE session_id = ? ORDER BY component_id, position`).all(sessionId);
   const allowedComponents = db.prepare(`SELECT component_id, slot_name, position, allowed_component
-       FROM raw_slot_allowed_components WHERE session_id = ? ORDER BY component_id, slot_name, position`).all(sessionId2);
+       FROM raw_slot_allowed_components WHERE session_id = ? ORDER BY component_id, slot_name, position`).all(sessionId);
   const propsByComponent = indexRowsByKey(props, (p) => p.component_id);
   const allowedValuesByProp = indexRowsByKey(allowedValues, (av) => `${av.component_id}::${av.prop_name}`);
   const slotsByComponent = indexRowsByKey(slots, (s) => s.component_id);
@@ -4116,18 +4356,18 @@ async function loadComponentSourceRef(name, sourcePath, propNames = [], propType
     ref.usesNotShown = notShown;
   return ref;
 }
-async function loadComponentSourceRefs(db, sessionId2) {
-  const rows = db.prepare(`SELECT component_id, name, source, source_path FROM raw_components WHERE session_id = ? AND status = 'generated' ORDER BY rowid`).all(sessionId2);
+async function loadComponentSourceRefs(db, sessionId) {
+  const rows = db.prepare(`SELECT component_id, name, source, source_path FROM raw_components WHERE session_id = ? AND status = 'generated' ORDER BY rowid`).all(sessionId);
   const propsFor = db.prepare(`SELECT name, type FROM raw_props WHERE session_id = ? AND component_id = ? ORDER BY position`);
   return Promise.all(rows.map((r) => {
-    const props = propsFor.all(sessionId2, r.component_id);
+    const props = propsFor.all(sessionId, r.component_id);
     return loadComponentSourceRef(r.name, r.source_path ?? r.source, props.map((p) => p.name), props.map((p) => p.type));
   }));
 }
-function renameEmptySlots(db, sessionId2, componentId, componentName, slotCount) {
+function renameEmptySlots(db, sessionId, componentId, componentName, slotCount) {
   const emptySlots = db.prepare(`SELECT name, position FROM raw_slots
        WHERE session_id = ? AND component_id = ? AND trim(name) = ''
-       ORDER BY position`).all(sessionId2, componentId);
+       ORDER BY position`).all(sessionId, componentId);
   if (emptySlots.length === 0)
     return { renames: [], warnings: [] };
   const renames = [];
@@ -4137,7 +4377,7 @@ function renameEmptySlots(db, sessionId2, componentId, componentName, slotCount)
   try {
     for (const slot of emptySlots) {
       const newName = slotCount === 1 ? "children" : `slot_${slot.position}`;
-      rename3.run(newName, sessionId2, componentId, slot.name, slot.position);
+      rename3.run(newName, sessionId, componentId, slot.name, slot.position);
       renames.push({ oldName: slot.name, newName });
       warnings.push(`${componentName}: slot at position ${slot.position} had empty name \u2014 renamed to "${newName}" for classification`);
     }
@@ -4156,7 +4396,7 @@ function parseReviewReasons(raw) {
     return [];
   }
 }
-function storeCDFComponents(db, sessionId2, components) {
+function storeCDFComponents(db, sessionId, components) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const updateComp = db.prepare(`UPDATE raw_components SET status = 'generated', description = ? WHERE session_id = ? AND name = ?`);
   const updateProp = db.prepare(`UPDATE raw_props SET cdf_type = ?, cdf_category = ?, cdf_token_kind = ?, required = ? WHERE session_id = ? AND component_id = ? AND name = ?`);
@@ -4169,8 +4409,8 @@ function storeCDFComponents(db, sessionId2, components) {
   const insertTokenPath = db.prepare(`INSERT INTO raw_prop_token_paths (session_id, component_id, prop_name, source, position, path)
      VALUES (?, ?, ?, ?, ?, ?)`);
   const writeTokenPaths = (componentId, propName, paths) => {
-    deleteTokenPaths.run(sessionId2, componentId, propName);
-    paths.forEach((path5, position) => insertTokenPath.run(sessionId2, componentId, propName, "review", position, path5));
+    deleteTokenPaths.run(sessionId, componentId, propName);
+    paths.forEach((path5, position) => insertTokenPath.run(sessionId, componentId, propName, "review", position, path5));
   };
   const deleteSlots = db.prepare(`DELETE FROM raw_slots WHERE session_id = ? AND component_id = ?`);
   const deleteSlotAllowedComponents = db.prepare(`DELETE FROM raw_slot_allowed_components WHERE session_id = ? AND component_id = ?`);
@@ -4180,42 +4420,42 @@ function storeCDFComponents(db, sessionId2, components) {
   db.exec("BEGIN");
   try {
     for (const { key, entry } of components) {
-      const row = db.prepare("SELECT component_id FROM raw_components WHERE session_id = ? AND name = ?").get(sessionId2, key);
+      const row = db.prepare("SELECT component_id FROM raw_components WHERE session_id = ? AND name = ?").get(sessionId, key);
       if (row) {
         const { component_id: componentId } = row;
-        updateComp.run(entry.$description ?? null, sessionId2, key);
+        updateComp.run(entry.$description ?? null, sessionId, key);
         for (const [propName, prop] of Object.entries(entry.$properties)) {
-          updateProp.run(prop.$type, prop.$category, prop["$token.kind"] ?? null, prop.$required ? 1 : 0, sessionId2, componentId, propName);
+          updateProp.run(prop.$type, prop.$category, prop["$token.kind"] ?? null, prop.$required ? 1 : 0, sessionId, componentId, propName);
           if (prop.$values && prop.$values.length > 0) {
-            deleteAllowedValues.run(sessionId2, componentId, propName);
-            prop.$values.forEach((v, i) => insertAllowedValue.run(sessionId2, componentId, propName, v, i));
+            deleteAllowedValues.run(sessionId, componentId, propName);
+            prop.$values.forEach((v, i) => insertAllowedValue.run(sessionId, componentId, propName, v, i));
           }
           if (prop.$type === "token" && prop.$category === "design") {
             writeTokenPaths(componentId, propName, prop["$token.allowed"] ?? []);
           }
         }
-        const existingDefaults = new Map(readExistingSlotDefaults.all(sessionId2, componentId).map((r) => [r.name, r.is_default]));
-        deleteSlotAllowedComponents.run(sessionId2, componentId);
-        deleteSlots.run(sessionId2, componentId);
+        const existingDefaults = new Map(readExistingSlotDefaults.all(sessionId, componentId).map((r) => [r.name, r.is_default]));
+        deleteSlotAllowedComponents.run(sessionId, componentId);
+        deleteSlots.run(sessionId, componentId);
         let slotPos = 0;
         for (const [slotName, slot] of Object.entries(entry.$slots ?? {})) {
           const isDefault = existingDefaults.get(slotName) ?? 0;
-          insertSlotOnUpdate.run(sessionId2, componentId, slotName, isDefault, slot.$required ? 1 : 0, slot.$description ?? null, slotPos++);
+          insertSlotOnUpdate.run(sessionId, componentId, slotName, isDefault, slot.$required ? 1 : 0, slot.$description ?? null, slotPos++);
           if (slot.$allowedComponents && slot.$allowedComponents.length > 0) {
-            slot.$allowedComponents.forEach((ac, i) => insertAllowedComponent.run(sessionId2, componentId, slotName, ac, i));
+            slot.$allowedComponents.forEach((ac, i) => insertAllowedComponent.run(sessionId, componentId, slotName, ac, i));
           }
         }
       } else {
         const componentId = deriveComponentId(key, "generated");
         db.prepare(`INSERT INTO raw_components (session_id, component_id, name, source, framework, extracted_at, status, description)
-           VALUES (?, ?, ?, '', 'react', ?, 'generated', ?)`).run(sessionId2, componentId, key, now, entry.$description ?? null);
+           VALUES (?, ?, ?, '', 'react', ?, 'generated', ?)`).run(sessionId, componentId, key, now, entry.$description ?? null);
         let position = 0;
         for (const [propName, prop] of Object.entries(entry.$properties)) {
           db.prepare(`INSERT OR REPLACE INTO raw_props
                (session_id, component_id, name, type, required, category, default_value, description, token_reference, position, cdf_type, cdf_category, cdf_token_kind)
-             VALUES (?, ?, ?, '', ?, NULL, NULL, NULL, NULL, ?, ?, ?, ?)`).run(sessionId2, componentId, propName, prop.$required ? 1 : 0, position++, prop.$type, prop.$category, prop["$token.kind"] ?? null);
+             VALUES (?, ?, ?, '', ?, NULL, NULL, NULL, NULL, ?, ?, ?, ?)`).run(sessionId, componentId, propName, prop.$required ? 1 : 0, position++, prop.$type, prop.$category, prop["$token.kind"] ?? null);
           if (prop.$values && prop.$values.length > 0) {
-            prop.$values.forEach((v, i) => insertAllowedValue.run(sessionId2, componentId, propName, v, i));
+            prop.$values.forEach((v, i) => insertAllowedValue.run(sessionId, componentId, propName, v, i));
           }
           if (prop.$type === "token" && prop.$category === "design") {
             writeTokenPaths(componentId, propName, prop["$token.allowed"] ?? []);
@@ -4225,39 +4465,39 @@ function storeCDFComponents(db, sessionId2, components) {
         for (const [slotName, slot] of Object.entries(entry.$slots ?? {})) {
           db.prepare(`INSERT OR REPLACE INTO raw_slots
                (session_id, component_id, name, is_default, required, description, position)
-             VALUES (?, ?, ?, 0, ?, ?, ?)`).run(sessionId2, componentId, slotName, slot.$required ? 1 : 0, slot.$description ?? null, slotPos++);
+             VALUES (?, ?, ?, 0, ?, ?, ?)`).run(sessionId, componentId, slotName, slot.$required ? 1 : 0, slot.$description ?? null, slotPos++);
           if (slot.$allowedComponents && slot.$allowedComponents.length > 0) {
-            slot.$allowedComponents.forEach((ac, i) => insertAllowedComponent.run(sessionId2, componentId, slotName, ac, i));
+            slot.$allowedComponents.forEach((ac, i) => insertAllowedComponent.run(sessionId, componentId, slotName, ac, i));
           }
         }
       }
     }
-    db.prepare("UPDATE sessions SET updated_at = ? WHERE id = ?").run(now, sessionId2);
+    db.prepare("UPDATE sessions SET updated_at = ? WHERE id = ?").run(now, sessionId);
     db.exec("COMMIT");
   } catch (e) {
     db.exec("ROLLBACK");
     throw e;
   }
 }
-function loadCDFComponents(db, sessionId2) {
+function loadCDFComponents(db, sessionId) {
   const components = db.prepare(`SELECT component_id, name, description FROM raw_components
-       WHERE session_id = ? AND status = 'generated' ORDER BY rowid`).all(sessionId2);
+       WHERE session_id = ? AND status = 'generated' ORDER BY rowid`).all(sessionId);
   if (components.length === 0)
     return [];
   const props = db.prepare(`SELECT component_id, name, required, default_value, description,
               cdf_type, cdf_category, cdf_token_kind, position
        FROM raw_props
        WHERE session_id = ? AND cdf_type IS NOT NULL
-       ORDER BY component_id, position`).all(sessionId2);
+       ORDER BY component_id, position`).all(sessionId);
   const allowedValues = db.prepare(`SELECT component_id, prop_name, value, position
-       FROM raw_prop_allowed_values WHERE session_id = ? ORDER BY component_id, prop_name, position`).all(sessionId2);
-  const slots = db.prepare(`SELECT component_id, name, description, required FROM raw_slots WHERE session_id = ? ORDER BY component_id, position`).all(sessionId2);
+       FROM raw_prop_allowed_values WHERE session_id = ? ORDER BY component_id, prop_name, position`).all(sessionId);
+  const slots = db.prepare(`SELECT component_id, name, description, required FROM raw_slots WHERE session_id = ? ORDER BY component_id, position`).all(sessionId);
   const allowedComponents = db.prepare(`SELECT component_id, slot_name, allowed_component
-       FROM raw_slot_allowed_components WHERE session_id = ? ORDER BY component_id, slot_name, position`).all(sessionId2);
+       FROM raw_slot_allowed_components WHERE session_id = ? ORDER BY component_id, slot_name, position`).all(sessionId);
   const tokenPaths = db.prepare(`SELECT component_id, prop_name, position, path
-       FROM raw_prop_token_paths WHERE session_id = ? ORDER BY component_id, prop_name, position`).all(sessionId2);
-  const resolvedDefaultPaths = getRawTokenNamePaths(db, sessionId2);
-  const tokenTypeByPath = new Map(db.prepare("SELECT path, type FROM raw_tokens WHERE session_id = ?").all(sessionId2).map((token) => [token.path, token.type]));
+       FROM raw_prop_token_paths WHERE session_id = ? ORDER BY component_id, prop_name, position`).all(sessionId);
+  const resolvedDefaultPaths = getRawTokenNamePaths(db, sessionId);
+  const tokenTypeByPath = new Map(db.prepare("SELECT path, type FROM raw_tokens WHERE session_id = ?").all(sessionId).map((token) => [token.path, token.type]));
   const propsByComponent = indexRowsByKey(props, (p) => p.component_id);
   const allowedValuesByProp = indexRowsByKey(allowedValues, (av) => `${av.component_id}::${av.prop_name}`);
   const slotsByComponent = indexRowsByKey(slots, (s) => s.component_id);
@@ -4324,16 +4564,16 @@ function loadCDFComponents(db, sessionId2) {
     return { key: name, entry };
   });
 }
-function loadScopeComponents(db, sessionId2) {
+function loadScopeComponents(db, sessionId) {
   const rows = db.prepare(`SELECT name, component_id, status, reject_reason, review_reasons, needs_review FROM raw_components
        WHERE session_id = ? AND status IN ('extracted', 'accepted', 'rejected')
-       ORDER BY name`).all(sessionId2);
+       ORDER BY name`).all(sessionId);
   if (rows.length === 0)
     return [];
   const slotRows = db.prepare(`SELECT component_id, name, position
-       FROM raw_slots WHERE session_id = ? ORDER BY component_id, position`).all(sessionId2);
+       FROM raw_slots WHERE session_id = ? ORDER BY component_id, position`).all(sessionId);
   const allowedRows = db.prepare(`SELECT component_id, slot_name, position, allowed_component
-       FROM raw_slot_allowed_components WHERE session_id = ? ORDER BY component_id, slot_name, position`).all(sessionId2);
+       FROM raw_slot_allowed_components WHERE session_id = ? ORDER BY component_id, slot_name, position`).all(sessionId);
   const slotsByComponent = indexRowsByKey(slotRows, (s) => s.component_id);
   const allowedBySlot = indexRowsByKey(allowedRows, (a) => `${a.component_id}::${a.slot_name}`);
   return rows.map((r) => {
@@ -4352,25 +4592,25 @@ function loadScopeComponents(db, sessionId2) {
     };
   });
 }
-function applyScopeDecisions(db, sessionId2, decisions) {
+function applyScopeDecisions(db, sessionId, decisions) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const acceptedSet = new Set(decisions.accepted);
   const accepted = [...acceptedSet];
   const rejected = [...new Set(decisions.rejected)].filter((n) => !acceptedSet.has(n));
   if (rejected.length > 0) {
     const placeholders = rejected.map(() => "?").join(",");
-    db.prepare(`UPDATE raw_components SET status = 'rejected' WHERE session_id = ? AND name IN (${placeholders})`).run(sessionId2, ...rejected);
+    db.prepare(`UPDATE raw_components SET status = 'rejected' WHERE session_id = ? AND name IN (${placeholders})`).run(sessionId, ...rejected);
   }
   if (accepted.length > 0) {
     const placeholders = accepted.map(() => "?").join(",");
-    db.prepare(`UPDATE raw_components SET status = 'generated' WHERE session_id = ? AND name IN (${placeholders})`).run(sessionId2, ...accepted);
+    db.prepare(`UPDATE raw_components SET status = 'generated' WHERE session_id = ? AND name IN (${placeholders})`).run(sessionId, ...accepted);
   }
-  db.prepare("UPDATE sessions SET updated_at = ? WHERE id = ?").run(now, sessionId2);
+  db.prepare("UPDATE sessions SET updated_at = ? WHERE id = ?").run(now, sessionId);
 }
 function findLatestSessionForCommand(db, command) {
   return getLatestCompletedSessionForCommand(db, command);
 }
-function seedCDFFromPreviewResponse(db, sessionId2, removedItems) {
+function seedCDFFromPreviewResponse(db, sessionId, removedItems) {
   if (removedItems.length === 0)
     return 0;
   let totalSeeded = 0;
@@ -4380,7 +4620,7 @@ function seedCDFFromPreviewResponse(db, sessionId2, removedItems) {
   for (const item of removedItems) {
     if (!item.fullProperties)
       continue;
-    const localComponent = db.prepare(`SELECT component_id FROM raw_components WHERE session_id = ? AND name = ?`).get(sessionId2, item.name);
+    const localComponent = db.prepare(`SELECT component_id FROM raw_components WHERE session_id = ? AND name = ?`).get(sessionId, item.name);
     if (!localComponent)
       continue;
     const contentProps = new Set(item.contentProperties);
@@ -4388,13 +4628,13 @@ function seedCDFFromPreviewResponse(db, sessionId2, removedItems) {
     for (const [propName, propSummary] of Object.entries(item.fullProperties)) {
       const cdfType = mapContentfulTypeToCdfType(propSummary.type);
       const cdfCategory = resolveCdfCategory(propSummary.category, propName, contentProps, designProps);
-      const result = updateStmt.run(cdfType, cdfCategory, sessionId2, localComponent.component_id, propName);
+      const result = updateStmt.run(cdfType, cdfCategory, sessionId, localComponent.component_id, propName);
       totalSeeded += Number(result.changes);
     }
   }
   return totalSeeded;
 }
-function seedDefaultsFromChangedItems(db, sessionId2, changedItems) {
+function seedDefaultsFromChangedItems(db, sessionId, changedItems) {
   if (changedItems.length === 0)
     return 0;
   let totalSeeded = 0;
@@ -4405,7 +4645,7 @@ function seedDefaultsFromChangedItems(db, sessionId2, changedItems) {
   for (const { current } of changedItems) {
     if (!current.fullProperties)
       continue;
-    const localComponent = db.prepare(`SELECT component_id FROM raw_components WHERE session_id = ? AND name = ?`).get(sessionId2, current.name);
+    const localComponent = db.prepare(`SELECT component_id FROM raw_components WHERE session_id = ? AND name = ?`).get(sessionId, current.name);
     if (!localComponent)
       continue;
     const contentProps = new Set(current.contentProperties);
@@ -4413,38 +4653,38 @@ function seedDefaultsFromChangedItems(db, sessionId2, changedItems) {
     for (const [propName, propSummary] of Object.entries(current.fullProperties)) {
       if (propSummary.default !== void 0 && propSummary.default !== null) {
         const defaultStr = typeof propSummary.default === "string" ? propSummary.default : JSON.stringify(propSummary.default);
-        const result2 = updateDefaultStmt.run(defaultStr, sessionId2, localComponent.component_id, propName);
+        const result2 = updateDefaultStmt.run(defaultStr, sessionId, localComponent.component_id, propName);
         totalSeeded += Number(result2.changes);
       }
       const cdfType = mapContentfulTypeToCdfType(propSummary.type);
       const cdfCategory = resolveCdfCategory(propSummary.category, propName, contentProps, designProps);
-      const result = updateCDFStmt.run(cdfType, cdfCategory, sessionId2, localComponent.component_id, propName);
+      const result = updateCDFStmt.run(cdfType, cdfCategory, sessionId, localComponent.component_id, propName);
       totalSeeded += Number(result.changes);
     }
   }
   return totalSeeded;
 }
-function backfillUnclassifiedProps(db, sessionId2) {
+function backfillUnclassifiedProps(db, sessionId) {
   const withCategory = db.prepare(`UPDATE raw_props SET cdf_type = 'string', cdf_category = category
      WHERE session_id = ? AND cdf_type IS NULL AND category IS NOT NULL
        AND component_id IN (
          SELECT component_id FROM raw_components WHERE session_id = ? AND status = 'generated'
-       )`).run(sessionId2, sessionId2);
+       )`).run(sessionId, sessionId);
   const withoutCategory = db.prepare(`UPDATE raw_props SET cdf_type = 'string', cdf_category = 'content'
      WHERE session_id = ? AND cdf_type IS NULL AND category IS NULL
        AND component_id IN (
          SELECT component_id FROM raw_components WHERE session_id = ? AND status = 'generated'
-       )`).run(sessionId2, sessionId2);
+       )`).run(sessionId, sessionId);
   return Number(withCategory.changes) + Number(withoutCategory.changes);
 }
-function computeMapTokensInputHash(db, sessionId2, componentSourceRefs = []) {
+function computeMapTokensInputHash(db, sessionId, componentSourceRefs = []) {
   const props = db.prepare(`SELECT rc.name AS component_name, rp.name AS prop_name, rp.cdf_token_kind, rp.default_value
        FROM raw_props rp
        JOIN raw_components rc ON rc.session_id = rp.session_id AND rc.component_id = rp.component_id
        WHERE rp.session_id = ? AND rp.cdf_type = 'token' AND rp.cdf_category = 'design'
-       ORDER BY rc.name, rp.name`).all(sessionId2);
-  const tokens = db.prepare(`SELECT path, type FROM raw_tokens WHERE session_id = ? ORDER BY path`).all(sessionId2);
-  const defaultMappings = db.prepare("SELECT raw_name, path, source FROM raw_token_name_paths WHERE session_id = ? ORDER BY raw_name").all(sessionId2);
+       ORDER BY rc.name, rp.name`).all(sessionId);
+  const tokens = db.prepare(`SELECT path, type FROM raw_tokens WHERE session_id = ? ORDER BY path`).all(sessionId);
+  const defaultMappings = db.prepare("SELECT raw_name, path, source FROM raw_token_name_paths WHERE session_id = ? ORDER BY raw_name").all(sessionId);
   const payload = {
     props: props.map((p) => ({
       component: p.component_name,
@@ -4525,13 +4765,13 @@ function storeCaches(db, entries) {
     throw e;
   }
 }
-function storeScannedFiles(db, sessionId2, filePaths) {
+function storeScannedFiles(db, sessionId, filePaths) {
   db.exec("BEGIN");
   try {
-    db.prepare("DELETE FROM scanned_files WHERE session_id = ?").run(sessionId2);
+    db.prepare("DELETE FROM scanned_files WHERE session_id = ?").run(sessionId);
     const insert = db.prepare("INSERT INTO scanned_files (session_id, path) VALUES (?, ?)");
     for (const path5 of filePaths) {
-      insert.run(sessionId2, path5);
+      insert.run(sessionId, path5);
     }
     db.exec("COMMIT");
   } catch (e) {
@@ -4539,15 +4779,15 @@ function storeScannedFiles(db, sessionId2, filePaths) {
     throw e;
   }
 }
-function storeSlotCycles(db, sessionId2, cycles) {
+function storeSlotCycles(db, sessionId, cycles) {
   db.exec("BEGIN");
   try {
-    db.prepare("DELETE FROM slot_cycles WHERE session_id = ?").run(sessionId2);
+    db.prepare("DELETE FROM slot_cycles WHERE session_id = ?").run(sessionId);
     const insert = db.prepare(`INSERT INTO slot_cycles (session_id, cycle_index, path_json, edges_json, suggested_break_json)
        VALUES (?, ?, ?, ?, ?)`);
     for (let i = 0; i < cycles.length; i += 1) {
       const cycle = cycles[i];
-      insert.run(sessionId2, i, JSON.stringify(cycle.path), JSON.stringify(cycle.edges), cycle.suggestedBreak ? JSON.stringify(cycle.suggestedBreak) : null);
+      insert.run(sessionId, i, JSON.stringify(cycle.path), JSON.stringify(cycle.edges), cycle.suggestedBreak ? JSON.stringify(cycle.suggestedBreak) : null);
     }
     db.exec("COMMIT");
   } catch (e) {
@@ -4555,20 +4795,20 @@ function storeSlotCycles(db, sessionId2, cycles) {
     throw e;
   }
 }
-function loadSlotCycles(db, sessionId2) {
-  const rows = db.prepare("SELECT cycle_index, path_json, edges_json, suggested_break_json FROM slot_cycles WHERE session_id = ? ORDER BY cycle_index").all(sessionId2);
+function loadSlotCycles(db, sessionId) {
+  const rows = db.prepare("SELECT cycle_index, path_json, edges_json, suggested_break_json FROM slot_cycles WHERE session_id = ? ORDER BY cycle_index").all(sessionId);
   return rows.map((r) => ({
     path: JSON.parse(r.path_json),
     edges: JSON.parse(r.edges_json),
     suggestedBreak: r.suggested_break_json ? JSON.parse(r.suggested_break_json) : null
   }));
 }
-function findUnknownSlotAllowedComponents(db, sessionId2, allowedComponentNames2, componentId) {
+function findUnknownSlotAllowedComponents(db, sessionId, allowedComponentNames2, componentId) {
   const rows = db.prepare(`SELECT a.component_id, c.name AS component_name, a.slot_name, a.allowed_component
        FROM raw_slot_allowed_components a
        JOIN raw_components c ON c.session_id = a.session_id AND c.component_id = a.component_id
        WHERE a.session_id = ? AND (? IS NULL OR a.component_id = ?)
-       ORDER BY a.component_id, a.slot_name, a.position`).all(sessionId2, componentId ?? null, componentId ?? null);
+       ORDER BY a.component_id, a.slot_name, a.position`).all(sessionId, componentId ?? null, componentId ?? null);
   return rows.filter((row) => !allowedComponentNames2.has(row.allowed_component)).map((row) => ({
     componentId: row.component_id,
     componentName: row.component_name,
@@ -4576,8 +4816,8 @@ function findUnknownSlotAllowedComponents(db, sessionId2, allowedComponentNames2
     allowedComponent: row.allowed_component
   }));
 }
-function filterUnknownSlotAllowedComponents(db, sessionId2, allowedComponentNames2) {
-  const unknown5 = findUnknownSlotAllowedComponents(db, sessionId2, allowedComponentNames2);
+function filterUnknownSlotAllowedComponents(db, sessionId, allowedComponentNames2) {
+  const unknown5 = findUnknownSlotAllowedComponents(db, sessionId, allowedComponentNames2);
   if (unknown5.length === 0)
     return unknown5;
   db.exec("BEGIN");
@@ -4585,7 +4825,7 @@ function filterUnknownSlotAllowedComponents(db, sessionId2, allowedComponentName
     const remove = db.prepare(`DELETE FROM raw_slot_allowed_components
        WHERE session_id = ? AND component_id = ? AND slot_name = ? AND allowed_component = ?`);
     for (const row of unknown5) {
-      remove.run(sessionId2, row.componentId, row.slotName, row.allowedComponent);
+      remove.run(sessionId, row.componentId, row.slotName, row.allowedComponent);
     }
     db.exec("COMMIT");
   } catch (e) {
@@ -4733,7 +4973,7 @@ async function getCliCacheVersion() {
     return _cliCacheVersionCache;
   }
 }
-function storeExtractCache(db, filePath, fileHash, cliVersion2, components) {
+function storeExtractCache(db, filePath, fileHash, cliVersion, 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 +4981,12 @@ function storeExtractCache(db, filePath, fileHash, cliVersion2, 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, cliVersion2, now, now, componentsJson);
+       components_json = excluded.components_json`).run(filePath, fileHash, cliVersion, now, now, componentsJson);
 }
-function lookupExtractCache(db, fileHash, cliVersion2) {
+function lookupExtractCache(db, fileHash, cliVersion) {
   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, cliVersion2);
+       WHERE file_hash = ? AND cli_version = ?`).get(fileHash, cliVersion);
   if (!row)
     return null;
   let components = [];
@@ -4764,31 +5004,31 @@ function lookupExtractCache(db, fileHash, cliVersion2) {
     components
   };
 }
-function storeCompositionCache(db, inputHash, cliVersion2, agentOutput) {
+function storeCompositionCache(db, inputHash, cliVersion, 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, cliVersion2, agentOutput, now, now);
+       updated_at = excluded.updated_at`).run(inputHash, cliVersion, agentOutput, now, now);
 }
-function lookupCompositionCache(db, inputHash, cliVersion2) {
-  const row = db.prepare(`SELECT agent_output FROM composition_cache WHERE input_hash = ? AND cli_version = ?`).get(inputHash, cliVersion2);
+function lookupCompositionCache(db, inputHash, cliVersion) {
+  const row = db.prepare(`SELECT agent_output FROM composition_cache WHERE input_hash = ? AND cli_version = ?`).get(inputHash, cliVersion);
   return row ? row.agent_output : null;
 }
-function storeSelectCache(db, componentHash, promptHash, cliVersion2, decision, reason) {
+function storeSelectCache(db, componentHash, promptHash, cliVersion, 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, cliVersion2, decision, reason, now, now);
+       updated_at = excluded.updated_at`).run(componentHash, promptHash, cliVersion, decision, reason, now, now);
 }
-function lookupSelectCache(db, componentHash, promptHash, cliVersion2) {
+function lookupSelectCache(db, componentHash, promptHash, cliVersion) {
   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, cliVersion2);
+       WHERE component_hash = ? AND prompt_hash = ? AND cli_version = ?`).get(componentHash, promptHash, cliVersion);
   if (!row)
     return null;
   return {
@@ -12286,11 +12526,11 @@ async function loadReviewInput(components, options = {}) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/selection/src/controller/review/load-and-validate-for-review.js
-async function loadAndValidateForReview(sessionId2, projectRoot) {
+async function loadAndValidateForReview(sessionId, projectRoot) {
   const db = openPipelineDb();
   let rawComponents;
   try {
-    rawComponents = loadRawComponents(db, sessionId2);
+    rawComponents = loadRawComponents(db, sessionId);
   } finally {
     db.close();
   }
@@ -12306,18 +12546,18 @@ 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(sessionId2, artifactsRoot) {
-  const sessionDir = resolve15(artifactsRoot, sessionId2);
+async function getRefineSessionPaths(sessionId, artifactsRoot) {
+  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")
   };
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/review-session/repositories/ensure-review-session.js
-async function ensureRefineSession(sessionId2, artifactsRoot, initialSnapshot) {
-  const paths = await getRefineSessionPaths(sessionId2, artifactsRoot);
+async function ensureRefineSession(sessionId, artifactsRoot, initialSnapshot) {
+  const paths = await getRefineSessionPaths(sessionId, artifactsRoot);
   await mkdir(paths.sessionDir, { recursive: true });
   try {
     await access2(paths.statePath);
@@ -12346,16 +12586,16 @@ async function saveReviewState(statePath, session) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/selection/src/controller/review/merge-preview-validation-errors-into-review-session.js
-async function mergePreviewValidationErrorsIntoReviewSession(sessionId2, errors, opts = {}) {
+async function mergePreviewValidationErrorsIntoReviewSession(sessionId, errors, opts = {}) {
   const artifactsRoot = opts.artifactsRoot ?? getRefineArtifactsRoot();
-  const paths = await getRefineSessionPaths(sessionId2, artifactsRoot);
+  const paths = await getRefineSessionPaths(sessionId, artifactsRoot);
   let snapshot;
   try {
     await access3(paths.statePath);
     snapshot = JSON.parse(await readFile8(paths.statePath, "utf8"));
   } catch {
-    snapshot = await loadAndValidateForReview(sessionId2, void 0);
-    snapshot = await ensureRefineSession(sessionId2, artifactsRoot, snapshot);
+    snapshot = await loadAndValidateForReview(sessionId, void 0);
+    snapshot = await ensureRefineSession(sessionId, artifactsRoot, snapshot);
   }
   const errorsByName = /* @__PURE__ */ new Map();
   for (const err of errors) {
@@ -12391,18 +12631,18 @@ async function mergePreviewValidationErrorsIntoReviewSession(sessionId2, errors,
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/selection/src/controller/review/reject-components-by-name.js
 import { readFile as readFile9 } from "node:fs/promises";
-async function rejectComponentsByName(sessionId2, names, opts = {}) {
+async function rejectComponentsByName(sessionId, names, opts = {}) {
   if (names.length === 0)
     return;
   const db = openPipelineDb();
   try {
     const placeholders = names.map(() => "?").join(",");
-    db.prepare(`UPDATE raw_components SET status = 'generate-rejected' WHERE session_id = ? AND name IN (${placeholders})`).run(sessionId2, ...names);
+    db.prepare(`UPDATE raw_components SET status = 'generate-rejected' WHERE session_id = ? AND name IN (${placeholders})`).run(sessionId, ...names);
   } finally {
     db.close();
   }
   const artifactsRoot = opts.artifactsRoot ?? getRefineArtifactsRoot();
-  const paths = await getRefineSessionPaths(sessionId2, artifactsRoot);
+  const paths = await getRefineSessionPaths(sessionId, artifactsRoot);
   const nameSet = new Set(names);
   let snapshot;
   try {
@@ -12830,9 +13070,9 @@ function buildTimestampedSubdir(base, now = /* @__PURE__ */ new Date()) {
 
 // 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";
-async function writeScopeDecisionsSnapshot(db, sessionId2, decisions) {
+async function writeScopeDecisionsSnapshot(db, sessionId, decisions) {
   const acceptedSet = new Set(decisions.accepted);
-  const rawComponents = loadRawComponents(db, sessionId2);
+  const rawComponents = loadRawComponents(db, sessionId);
   const records = rawComponents.map((c2) => {
     const status = acceptedSet.has(c2.name) ? "accepted" : "rejected";
     const proposal = {
@@ -12855,17 +13095,17 @@ async function writeScopeDecisionsSnapshot(db, sessionId2, decisions) {
       status
     };
   });
-  const paths = await getRefineSessionPaths(sessionId2, getRefineArtifactsRoot());
+  const paths = await getRefineSessionPaths(sessionId, getRefineArtifactsRoot());
   await mkdir3(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 readFile12 } from "node:fs/promises";
-async function loadAcceptedNames(sessionId2) {
+async function loadAcceptedNames(sessionId) {
   try {
     const artifactsRoot = getRefineArtifactsRoot();
-    const paths = await getRefineSessionPaths(sessionId2, artifactsRoot);
+    const paths = await getRefineSessionPaths(sessionId, artifactsRoot);
     const raw = await readFile12(paths.statePath, "utf8");
     const snapshot = JSON.parse(raw);
     const accepted = snapshot.components.filter((c2) => c2.status === "accepted").map((c2) => c2.name);
@@ -12880,60 +13120,6 @@ async function loadAcceptedNames(sessionId2) {
 // 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";
 
@@ -13564,7 +13750,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((resolve26) => setTimeout(resolve26, delayMs));
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/apply/src/helpers/sanitize-preview.js
@@ -13805,7 +13991,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((resolve26) => setTimeout(resolve26, baseDelay + jitter));
       }
     }
     throw new Error(`Operation ${operationId} timed out after ${maxAttempts} attempts`);
@@ -14636,33 +14822,33 @@ function filterAllowedPaths(args) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/helpers/map-tokens/is-prop-reviewed.js
-function isPropReviewed(db, sessionId2, componentId, propName) {
+function isPropReviewed(db, sessionId, componentId, propName) {
   const row = db.prepare(`SELECT COUNT(*) AS count FROM raw_prop_token_paths
         WHERE session_id = ? AND component_id = ? AND prop_name = ?
-          AND source = 'review'`).get(sessionId2, componentId, propName);
+          AND source = 'review'`).get(sessionId, componentId, propName);
   return row.count > 0;
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/helpers/map-tokens/load-token-type-by-path.js
-function loadTokenTypeByPath(db, sessionId2) {
-  const rows = db.prepare("SELECT path, type FROM raw_tokens WHERE session_id = ?").all(sessionId2);
+function loadTokenTypeByPath(db, sessionId) {
+  const rows = db.prepare("SELECT path, type FROM raw_tokens WHERE session_id = ?").all(sessionId);
   return new Map(rows.map((r) => [r.path, r.type]));
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/controller/map-tokens/apply-map-token-prop-calls.js
-function applyMapTokenPropCalls(db, sessionId2, calls, incomingWarnings) {
+function applyMapTokenPropCalls(db, sessionId, calls, incomingWarnings) {
   const warnings = [...incomingWarnings];
   let applied = 0;
-  const tokenTypeByPath = loadTokenTypeByPath(db, sessionId2);
+  const tokenTypeByPath = loadTokenTypeByPath(db, sessionId);
   const findComponent = db.prepare("SELECT component_id FROM raw_components WHERE session_id = ? AND name = ?");
   const findProp = db.prepare("SELECT cdf_type, cdf_category, cdf_token_kind FROM raw_props WHERE session_id = ? AND component_id = ? AND name = ?");
   for (const call of calls) {
-    const component = findComponent.get(sessionId2, call.component);
+    const component = findComponent.get(sessionId, call.component);
     if (!component) {
       warnings.push(`map_token_prop: unknown component '${call.component}' \u2014 skipped`);
       continue;
     }
-    const prop = findProp.get(sessionId2, component.component_id, call.prop);
+    const prop = findProp.get(sessionId, component.component_id, call.prop);
     if (!prop) {
       warnings.push(`map_token_prop '${call.component}.${call.prop}': unknown prop \u2014 skipped`);
       continue;
@@ -14671,7 +14857,7 @@ function applyMapTokenPropCalls(db, sessionId2, calls, incomingWarnings) {
       warnings.push(`map_token_prop '${call.component}.${call.prop}': target is not a design-category token prop \u2014 skipped`);
       continue;
     }
-    if (isPropReviewed(db, sessionId2, component.component_id, call.prop)) {
+    if (isPropReviewed(db, sessionId, component.component_id, call.prop)) {
       warnings.push(`map_token_prop '${call.component}.${call.prop}': a reviewer already set this restriction \u2014 skipped`);
       continue;
     }
@@ -14687,7 +14873,7 @@ function applyMapTokenPropCalls(db, sessionId2, calls, incomingWarnings) {
       warnings.push(`map_token_prop '${call.component}.${call.prop}': no valid token_allowed remain \u2014 skipped`);
       continue;
     }
-    replaceRawPropTokenPaths(db, sessionId2, component.component_id, call.prop, filteredAllowed, "agent");
+    replaceRawPropTokenPaths(db, sessionId, component.component_id, call.prop, filteredAllowed, "agent");
     applied++;
   }
   return { applied, warnings };
@@ -14725,176 +14911,18 @@ function countMappableProps(cdfEntries) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/helpers/map-tokens/load-raw-defaults.js
-function loadRawDefaults(db, sessionId2) {
+function loadRawDefaults(db, sessionId) {
   return db.prepare(`SELECT rp.default_value AS default_reference, rp.cdf_token_kind
        FROM raw_props rp
        JOIN raw_components rc ON rc.session_id = rp.session_id AND rc.component_id = rp.component_id
        WHERE rp.session_id = ? AND rc.status = 'generated'
          AND rp.cdf_type = 'token' AND rp.cdf_category = 'design'
-         AND rp.default_value IS NOT NULL`).all(sessionId2);
+         AND rp.default_value IS NOT NULL`).all(sessionId);
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/helpers/map-tokens/load-token-leaves.js
-function loadTokenLeaves(db, sessionId2) {
-  return db.prepare("SELECT path, type FROM raw_tokens WHERE session_id = ? ORDER BY path").all(sessionId2);
-}
-
-// packages/experience-design-system-backend-pipeline/dist/src/analytics/client.js
-import { Analytics } from "@segment/analytics-node";
-var DEFAULT_WRITE_KEY = "6DmxiEPN3SV1vbRTTMcNqDzCvkfwT06N";
-var analyticsClient = null;
-var persistedDisabled = false;
-var cliVersionString = "0.0.0-unknown";
-function cliVersion() {
-  return cliVersionString;
-}
-function analyticsEnabled() {
-  return !persistedDisabled && !process.env["DISABLE_ANALYTICS"];
-}
-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/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.js
-var pending = null;
-var sessionId;
-var sessionStartedEmitted = false;
-function isPipelineStep() {
-  return process.env[IMPORT_PIPELINE_ENV] === "1";
-}
-function buildBaseProps(command) {
-  return {
-    dsi_session_id: 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;
-  }
-}
-async function bindAnalyticsSessionId(explicit, context) {
-  const id = resolveAnalyticsSessionId(explicit);
-  await bindAnalyticsSession(id, context);
-  return id;
-}
-function setCommandContext(context) {
-  if (!pending)
-    return;
-  mergeContext(pending.context, context);
-  mergeContext(pending.completion, context);
-}
-function enrichCommandResult(fields) {
-  if (!pending)
-    return;
-  Object.assign(pending.completion, fields);
-  mergeContext(pending.context, fields);
-}
-async function bindAnalyticsSession(id, context) {
-  sessionId = id;
-  if (context)
-    setCommandContext(context);
-  await emitInvokedIfReady();
-}
-async function emitSessionStarted(entryCommand) {
-  if (!sessionId || sessionStartedEmitted)
-    return;
-  sessionStartedEmitted = true;
-  await trackEvent("dsi_cli_session_started", {
-    dsi_session_id: sessionId,
-    entry_command: entryCommand,
-    cli_version: cliVersion(),
-    node_version: process.version,
-    os_name: getOsName()
-  }, sessionId, { flush: true });
-  await emitInvokedIfReady();
-}
-async function emitInvokedIfReady() {
-  if (!pending || pending.invoked || !sessionId)
-    return;
-  pending.invoked = true;
-  await trackEvent("dsi_cli_command_invoked", {
-    ...buildBaseProps(pending.command),
-    ...pending.context
-  }, sessionId, { flush: true });
+function loadTokenLeaves(db, sessionId) {
+  return db.prepare("SELECT path, type FROM raw_tokens WHERE session_id = ? ORDER BY path").all(sessionId);
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/controller/map-tokens/run-map-tokens.js
@@ -14922,53 +14950,42 @@ async function runMapTokens(request) {
   const timeoutMs = request.agentTimeoutMs ?? DEFAULT_TIMEOUT_MS2;
   const db = openPipelineDb();
   try {
-    const sessionId2 = request.sessionId ?? findLatestSessionForCommand(db, "generate components");
-    if (!sessionId2) {
+    const sessionId = request.sessionId ?? findLatestSessionForCommand(db, "generate components");
+    if (!sessionId) {
       throw new MapTokensRunFailure({ type: "no-session" });
     }
-    await bindAnalyticsSessionId(sessionId2);
-    const tokenLeaves = loadTokenLeaves(db, sessionId2);
+    const tokenLeaves = loadTokenLeaves(db, sessionId);
     const knownTokenPaths = new Set(tokenLeaves.map((t) => t.path));
-    const diagnostics = [];
     if (request.tokenMapInline) {
       const validMappings = {};
       for (const [rawName, path5] of Object.entries(request.tokenMapInline)) {
-        if (knownTokenPaths.has(path5)) {
+        if (knownTokenPaths.has(path5))
           validMappings[rawName] = path5;
-        } else {
-          diagnostics.push(`Token map '${rawName}' -> '${path5}': path not found in session tokens \u2014 skipped.`);
-        }
       }
-      replaceRawTokenNamePaths(db, sessionId2, validMappings, "manual");
+      replaceRawTokenNamePaths(db, sessionId, validMappings, "manual");
     }
-    const rawDefaults = loadRawDefaults(db, sessionId2);
+    const rawDefaults = loadRawDefaults(db, sessionId);
     const defaultResolution = resolveTokenDefaults(rawDefaults.map((row) => ({ rawDefault: row.default_reference, tokenKind: row.cdf_token_kind })), tokenLeaves);
-    for (const diagnostic of defaultResolution.diagnostics)
-      diagnostics.push(diagnostic.message);
-    const manualMappings = new Map(getRawTokenNamePathRows(db, sessionId2).filter((row) => row.source === "manual").map((row) => [row.rawName, row.path]));
+    const manualMappings = new Map(getRawTokenNamePathRows(db, sessionId).filter((row) => row.source === "manual").map((row) => [row.rawName, row.path]));
     const automaticMappings = {};
     for (const [rawName, path5] of Object.entries(defaultResolution.mappings)) {
-      const manualPath = manualMappings.get(rawName);
-      if (manualPath === void 0) {
+      if (manualMappings.get(rawName) === void 0)
         automaticMappings[rawName] = path5;
-      } else if (manualPath !== path5) {
-        diagnostics.push(`Token default '${rawName}' automatically resolves to '${path5}', but manual mapping '${manualPath}' is retained.`);
-      }
     }
-    replaceRawTokenNamePaths(db, sessionId2, automaticMappings, "automatic");
-    const cdfEntries = loadCDFComponents(db, sessionId2);
+    replaceRawTokenNamePaths(db, sessionId, automaticMappings, "automatic");
+    const cdfEntries = loadCDFComponents(db, sessionId);
     if (cdfEntries.length === 0) {
-      throw new MapTokensRunFailure({ type: "no-components", sessionId: sessionId2 });
+      throw new MapTokensRunFailure({ type: "no-components", sessionId });
     }
     const mappablePropCount = countMappableProps(cdfEntries);
-    const { groups, tokens } = getDtcgTokensForSession(db, sessionId2);
+    const { groups, tokens } = getDtcgTokensForSession(db, sessionId);
     const tokenCount = tokens.length;
     if (mappablePropCount === 0 || tokenCount === 0) {
-      return { type: "nothing-to-map", sessionId: sessionId2, mappablePropCount, tokenCount, diagnostics };
+      return { type: "nothing-to-map", sessionId, mappablePropCount, tokenCount };
     }
     const generatedCdf = Object.fromEntries(cdfEntries.map((c2) => [c2.key, c2.entry]));
     const tokenTree = rebuildDTCGTree(groups, tokens);
-    const componentSourceRefs = await loadComponentSourceRefs(db, sessionId2);
+    const componentSourceRefs = await loadComponentSourceRefs(db, sessionId);
     const buildMapPrompt = () => buildPrompt({
       skill: "map-tokens",
       mode: "autonomous",
@@ -14982,28 +14999,28 @@ async function runMapTokens(request) {
     });
     if (request.printPrompt) {
       const prompt2 = await buildMapPrompt();
-      return { type: "printed-prompt", sessionId: sessionId2, prompt: prompt2, diagnostics };
+      return { type: "printed-prompt", sessionId, prompt: prompt2 };
     }
     if (request.skipAgent) {
-      const stepId2 = createStep(db, sessionId2, "map tokens", {
+      const stepId2 = createStep(db, sessionId, "map tokens", {
         agent: request.agent,
         model: request.model ?? "",
         skipAgent: "true"
       });
       updateStep(db, stepId2, "complete", { applied: "0", skipAgent: "true" });
-      return { type: "skipped", sessionId: sessionId2, stepId: stepId2, diagnostics };
+      return { type: "skipped", sessionId, stepId: stepId2 };
     }
     const agent = request.agent;
     const noCache = request.cache === false || process.env["EDS_NO_CACHE"] === "1";
     const promptHash = await hashPromptForSkill("map-tokens", agent, request.model, request.skillPathOverride, request.existingEntitiesInline ? [hashContent(request.existingEntitiesInline)] : [], request.skillContentOverride);
-    const inputHash = computeMapTokensInputHash(db, sessionId2, componentSourceRefs);
+    const inputHash = computeMapTokensInputHash(db, sessionId, componentSourceRefs);
     if (!noCache) {
       const cached = lookupCache(db, inputHash, "token_mapping", "__map_tokens__", promptHash);
       if (cached) {
-        const applied2 = copyMapTokensFromCache(db, cached.sourceSessionId, sessionId2);
-        const stepId2 = createStep(db, sessionId2, "map tokens", { agent, model: request.model ?? "" });
+        const applied2 = copyMapTokensFromCache(db, cached.sourceSessionId, sessionId);
+        const stepId2 = createStep(db, sessionId, "map tokens", { agent, model: request.model ?? "" });
         updateStep(db, stepId2, "complete", { cached: "true", applied: String(applied2) });
-        return { type: "cached", sessionId: sessionId2, applied: applied2, stepId: stepId2, diagnostics };
+        return { type: "cached", sessionId, applied: applied2, stepId: stepId2 };
       }
     }
     const binary = resolveBinary(agent);
@@ -15015,22 +15032,22 @@ async function runMapTokens(request) {
         skillPath: resolveSkillPath("map-tokens")
       });
     }
-    const stepId = createStep(db, sessionId2, "map tokens", { agent, model: request.model ?? "" });
+    const stepId = createStep(db, sessionId, "map tokens", { agent, model: request.model ?? "" });
     const prompt = await buildMapPrompt();
     const invoker = createLocalCliAgentInvoker();
     const result = await invoker.invoke({ agent, model: request.model, prompt, timeoutMs });
     if (result.timedOut || result.exitCode !== 0) {
       const error = result.timedOut ? `timed out after ${timeoutMs / 6e4} minutes` : describeAgentFailure(result);
       updateStep(db, stepId, "failed", {}, error);
-      throw new MapTokensRunFailure({ type: "agent-failed", sessionId: sessionId2, stepId, error });
+      throw new MapTokensRunFailure({ type: "agent-failed", sessionId, stepId, error });
     }
     const { calls, warnings: parseWarnings } = parseMapTokenPropToolCalls(result.stdout);
-    const { applied, warnings } = applyMapTokenPropCalls(db, sessionId2, calls, parseWarnings);
+    const { applied, warnings } = applyMapTokenPropCalls(db, sessionId, calls, parseWarnings);
     if (!noCache) {
-      storeCache(db, inputHash, "token_mapping", "__map_tokens__", sessionId2, false, promptHash);
+      storeCache(db, inputHash, "token_mapping", "__map_tokens__", sessionId, false, promptHash);
     }
     updateStep(db, stepId, "complete", { applied: String(applied), warnings: String(warnings.length) });
-    return { type: "applied", sessionId: sessionId2, applied, warnings, stepId, diagnostics };
+    return { type: "applied", sessionId, applied, warnings, stepId };
   } finally {
     db.close();
   }
@@ -16087,20 +16104,20 @@ 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((resolve26) => setTimeout(resolve26, Math.min(250 * attempt, 2e3)));
     }
   }
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/orchestrators/run-extract-and-compose-session/helpers/persist-slot-cycles.js
-async function persistSlotCycles(db, sessionId2, components) {
+async function persistSlotCycles(db, sessionId, components) {
   const graph = components.map((c2) => ({
     name: c2.name,
     slots: c2.slots.map((s) => ({ name: s.name, allowedComponents: s.allowedComponents }))
   }));
   const cycles = findSlotCycles(graph);
   const withBreaks = cycles.map((cycle) => ({ ...cycle, suggestedBreak: suggestCycleBreakEdge(cycle, cycles) }));
-  await retryDatabaseWrite(() => storeSlotCycles(db, sessionId2, withBreaks));
+  await retryDatabaseWrite(() => storeSlotCycles(db, sessionId, withBreaks));
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/orchestrators/run-extract-and-compose-session/helpers/resolve-composition.js
@@ -16244,23 +16261,20 @@ async function runExtractAndComposeSession(request) {
       onDebugEvent
     });
     await mkdir4(outDir, { recursive: true });
-    const { sessionId: sessionId2 } = getOrCreateSession(db, void 0, void 0, {
+    const { sessionId } = getOrCreateSession(db, void 0, void 0, {
       command: "analyze extract",
       inputPath: projectPath,
       outDir
     });
-    await onSessionCreated?.(sessionId2);
-    await bindAnalyticsSessionId(sessionId2);
-    if (!isPipelineAnalyticsChild())
-      await emitSessionStarted("analyze_extract");
-    const stepId = createStep(db, sessionId2, "analyze extract", { project: projectPath });
+    await onSessionCreated?.(sessionId);
+    const stepId = createStep(db, sessionId, "analyze extract", { project: projectPath });
     if (cacheHits === 0 && !noCache) {
       await persistExtractCache(db, sourceFiles, extraction.components, cacheVersion);
     }
     emitPreClassificationExclusions(extraction, onExclusion);
     const classifiedComponents = extraction.components.map(preClassifyComponent);
     const { components: initialValidatedComponents, warnings: filterWarnings } = await evaluateExtractionQuality(classifiedComponents);
-    storeRawComponents(db, sessionId2, initialValidatedComponents);
+    storeRawComponents(db, sessionId, initialValidatedComponents);
     const sources = resolveCompositionSources({ noCache, compositionRefresh });
     const composition = await resolveComposition({
       db,
@@ -16276,13 +16290,12 @@ async function runExtractAndComposeSession(request) {
       onProgress,
       onDebugEvent
     });
-    await retryDatabaseWrite(() => storeRawComponents(db, sessionId2, composition.components, { preserveStatus: true }));
-    await persistSlotCycles(db, sessionId2, composition.components);
-    storeScannedFiles(db, sessionId2, sourceFiles.map((f) => relative2(projectPath, f)));
-    await retryDatabaseWrite(() => updateStep(db, stepId, "complete", { sessionId: sessionId2 }));
-    enrichCommandResult({ extracted_component_count: composition.components.length });
+    await retryDatabaseWrite(() => storeRawComponents(db, sessionId, composition.components, { preserveStatus: true }));
+    await persistSlotCycles(db, sessionId, composition.components);
+    storeScannedFiles(db, sessionId, sourceFiles.map((f) => relative2(projectPath, f)));
+    await retryDatabaseWrite(() => updateStep(db, stepId, "complete", { sessionId }));
     return {
-      sessionId: sessionId2,
+      sessionId,
       compositionPhase: composition.phase,
       components: composition.components,
       warnings: [...extraction.warnings, ...filterWarnings],
@@ -16309,11 +16322,11 @@ 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";
-async function writeTokensFile(db, sessionId2, outDir, onProgress) {
+async function writeTokensFile(db, sessionId, outDir, onProgress) {
   onProgress?.({ kind: "writing-file" });
-  const result = getDtcgTokensForSession(db, sessionId2);
+  const result = getDtcgTokensForSession(db, sessionId);
   if (result.tokens.length === 0) {
-    throw new Error(`generate tokens: no tokens persisted for session ${sessionId2}`);
+    throw new Error(`generate tokens: no tokens persisted for session ${sessionId}`);
   }
   const tree = rebuildDTCGTree(result.groups, result.tokens);
   const tokensPath = join15(outDir, "tokens.json");
@@ -16343,7 +16356,6 @@ async function runGenerateTokensSession(request) {
       outDir
     });
     await onSessionCreated?.(tokenSessionId);
-    await bindAnalyticsSessionId(tokenSessionId);
     const tokenPromptHash = await hashPromptForSkill("tokens", agent, agentModel, skillPath);
     const warnings = [];
     onProgress?.({ kind: "resolving" });
@@ -16407,9 +16419,9 @@ init_create_local_cli_agent_invoker();
 init_cache_keys();
 
 // packages/experience-design-system-backend-pipeline/dist/src/orchestrators/run-generate-components-session/helpers/build-empty-session-response.js
-function buildEmptySessionResponse(sessionId2) {
+function buildEmptySessionResponse(sessionId) {
   return {
-    sessionId: sessionId2,
+    sessionId,
     results: [],
     allOk: true,
     renamedSlotsCount: 0,
@@ -16431,11 +16443,11 @@ function collectDuplicateNames(components) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/orchestrators/run-generate-components-session/helpers/filter-dropped-allowed-components.js
-function filterDroppedAllowedComponents(db, sessionId2, components, allowedComponentNames2, acceptedNames) {
-  const dropped = filterUnknownSlotAllowedComponents(db, sessionId2, allowedComponentNames2);
+function filterDroppedAllowedComponents(db, sessionId, components, allowedComponentNames2, acceptedNames) {
+  const dropped = filterUnknownSlotAllowedComponents(db, sessionId, allowedComponentNames2);
   if (dropped.length === 0)
     return { components, dropped: [] };
-  return { components: loadRawComponents(db, sessionId2, acceptedNames), dropped };
+  return { components: loadRawComponents(db, sessionId, acceptedNames), dropped };
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/orchestrators/run-generate-components-session/helpers/read-existing-entities.js
@@ -16503,8 +16515,8 @@ function buildFailedComponentResult(componentName, error, renamedSlotsCount) {
 var DEFAULT_TIMEOUT_MS4 = Number(process.env["EDS_AGENT_TIMEOUT_MS"] ?? 5 * 60 * 1e3);
 var RETRY_BACKOFF_MS = Number(process.env["EDS_RETRY_BACKOFF_MS"] ?? 5e3);
 async function runOneGenerateComponent(options, component, index, total) {
-  const { db, sessionId: sessionId2, invoker, agent, model, tokensInline, tokenMapInline, verbose, noCache, skillPathOverride, skillContentOverride, promptHash, existingContentfulEntities, existingTokensInline, precomputedCachedNames, allowedComponentNames: allowedComponentNames2, onProgress } = options;
-  const { renames } = renameEmptySlots(db, sessionId2, component.component_id, component.name, component.slots.length);
+  const { db, sessionId, invoker, agent, model, tokensInline, tokenMapInline, verbose, noCache, skillPathOverride, skillContentOverride, promptHash, existingContentfulEntities, existingTokensInline, precomputedCachedNames, allowedComponentNames: allowedComponentNames2, onProgress } = options;
+  const { renames } = renameEmptySlots(db, sessionId, component.component_id, component.name, component.slots.length);
   let effectiveSlots = component.slots;
   if (renames.length > 0) {
     const renameMap = new Map(renames.map((r) => [r.oldName, r.newName]));
@@ -16527,7 +16539,7 @@ async function runOneGenerateComponent(options, component, index, total) {
   if (!noCache) {
     const resolution = resolveComponentCache(db, component, promptHash, allowedComponentNames2);
     if (resolution && !resolution.humanEdited) {
-      copyComponentFromCache(db, resolution.entry.sourceSessionId, sessionId2, component.component_id, true, {
+      copyComponentFromCache(db, resolution.entry.sourceSessionId, sessionId, component.component_id, true, {
         allowedComponentNames: allowedComponentNames2
       });
       storeCache(db, hashComponentShape(cacheComponent), "component", component.component_id, resolution.entry.sourceSessionId, resolution.entry.humanEdited, promptHash);
@@ -16535,7 +16547,7 @@ async function runOneGenerateComponent(options, component, index, total) {
       return buildCachedComponentResult(component.name);
     }
     if (resolution?.humanEdited) {
-      copyComponentFromCache(db, resolution.entry.sourceSessionId, sessionId2, component.component_id, true, {
+      copyComponentFromCache(db, resolution.entry.sourceSessionId, sessionId, component.component_id, true, {
         allowedComponentNames: allowedComponentNames2
       });
       onProgress?.({ kind: "component:cached", index, total, name: component.name, pinned: true });
@@ -16591,11 +16603,11 @@ async function runOneGenerateComponent(options, component, index, total) {
       lastError = describeAgentFailure(result);
       continue;
     }
-    const applied = applyToolCalls(db, sessionId2, component.component_id, component.name, calls, warnings, {
+    const applied = applyToolCalls(db, sessionId, component.component_id, component.name, calls, warnings, {
       allowedComponentNames: allowedComponentNames2
     });
     if (!noCache) {
-      storeCache(db, hashComponentShape(cacheComponent), "component", component.component_id, sessionId2, false, promptHash);
+      storeCache(db, hashComponentShape(cacheComponent), "component", component.component_id, sessionId, false, promptHash);
     }
     onProgress?.({
       kind: "component:completed",
@@ -16640,18 +16652,18 @@ async function runWithPool(items, concurrency, worker) {
 init_cache_keys();
 
 // packages/experience-design-system-backend-pipeline/dist/src/orchestrators/run-generate-components-session/helpers/restore-cached-components.js
-async function restoreCachedComponents(db, sessionId2, cachedComponents, promptHash, allowedComponentNames2) {
+async function restoreCachedComponents(db, sessionId, cachedComponents, promptHash, allowedComponentNames2) {
   const restorations = [];
   const rekeyed = [];
   const componentStatus = db.prepare("SELECT status FROM raw_components WHERE session_id = ? AND component_id = ?");
   for (const { component, resolution } of cachedComponents) {
-    const current = componentStatus.get(sessionId2, component.component_id);
+    const current = componentStatus.get(sessionId, component.component_id);
     if (current?.status === "generated")
       continue;
-    renameEmptySlots(db, sessionId2, component.component_id, component.name, component.slots.length);
+    renameEmptySlots(db, sessionId, component.component_id, component.name, component.slots.length);
     restorations.push({
       sourceSessionId: resolution.entry.sourceSessionId,
-      targetSessionId: sessionId2,
+      targetSessionId: sessionId,
       componentId: component.component_id
     });
     rekeyed.push({ component, cached: resolution.entry });
@@ -16720,7 +16732,6 @@ 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);
@@ -16920,6 +16931,7 @@ function useCredentialsControls(handlers) {
 }
 
 // packages/experience-design-system-cli/src/tui/user-agent.ts
+init_version();
 function cliUserAgent() {
   return buildUserAgent(readPackageVersion());
 }
@@ -17419,34 +17431,8 @@ function ExtractionScreen({
   );
 }
 
-// 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");
-}
-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}.${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 });
-}
+// 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";
@@ -17485,13 +17471,13 @@ async function runSelection(options) {
   const db = openPipelineDb();
   let components;
   const cachedDecisions = /* @__PURE__ */ new Map();
-  const cliVersion2 = await getCliCacheVersion();
+  const cliVersion = 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, cliVersion2);
+        const cached = lookupSelectCache(db, hashComponentShape(component), promptHash, cliVersion);
         if (cached) cachedDecisions.set(component.name, { decision: cached.decision, reason: cached.reason });
       }
     }
@@ -17546,7 +17532,7 @@ async function runSelection(options) {
           writeDb,
           hashComponentShape(component),
           promptHash,
-          cliVersion2,
+          cliVersion,
           rejected ? "rejected" : "accepted",
           rejected ? reason : null
         );
@@ -17627,12 +17613,12 @@ async function runExtraction(input, onProgress, deps = realDeps) {
   }) : null;
   let selection = null;
   let selectionError;
-  const startSelection = (sessionId2) => {
+  const startSelection = (sessionId) => {
     if (selection) return;
     selection = (async () => {
       if (entities) await entities;
       await deps.runSelection({
-        sessionId: sessionId2,
+        sessionId,
         agent: input.agent,
         model: input.agentModel,
         ...selectionPrompt,
@@ -17653,7 +17639,7 @@ async function runExtraction(input, onProgress, deps = realDeps) {
       promptOverrides: input.promptOverrides,
       noCache: input.noCache,
       onProgress: (event) => update(applyProgressEvent(progress, event)),
-      onSessionCreated: (sessionId2) => startSelection(sessionId2)
+      onSessionCreated: (sessionId) => startSelection(sessionId)
     });
   } catch (error) {
     return fail("analyze extract", errorMessage2(error));
@@ -17722,6 +17708,7 @@ function useExtraction(input) {
         reuseTokens: input.tokenStrategy === "reuse"
       })
     });
+    void Promise.resolve().then(() => (init_debug_store(), debug_store_exports)).then((store) => store.startDebugSessionIn(input.projectPath));
     void runExtraction(input, (progress) => {
       if (current.current === input) setState({ status: "running", progress });
     }).then((result) => {
@@ -17994,11 +17981,11 @@ function CyclesPanel({ cycles, cursor }) {
 // packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/panels/reject-prompt.tsx
 import { Box as Box13, Text as Text14 } from "ink";
 import { jsx as jsx16, jsxs as jsxs13 } from "react/jsx-runtime";
-function RejectPrompt({ pending: pending2 }) {
+function RejectPrompt({ pending }) {
   return /* @__PURE__ */ jsxs13(Box13, { flexDirection: "column", borderStyle: "single", borderColor: PALETTE2.warning, paddingX: 1, marginTop: 1, children: [
-    /* @__PURE__ */ jsx16(Text14, { bold: true, color: PALETTE2.warning, children: `Rejecting ${pending2.target} will:` }),
-    pending2.ancestors.length > 0 && /* @__PURE__ */ jsx16(Text14, { children: `- Reject ancestors: ${pending2.ancestors.join(", ")}` }),
-    pending2.descendants.length > 0 && /* @__PURE__ */ jsx16(Text14, { children: `- Deselect descendants: ${pending2.descendants.join(", ")}` }),
+    /* @__PURE__ */ jsx16(Text14, { bold: true, color: PALETTE2.warning, children: `Rejecting ${pending.target} will:` }),
+    pending.ancestors.length > 0 && /* @__PURE__ */ jsx16(Text14, { children: `- Reject ancestors: ${pending.ancestors.join(", ")}` }),
+    pending.descendants.length > 0 && /* @__PURE__ */ jsx16(Text14, { children: `- Deselect descendants: ${pending.descendants.join(", ")}` }),
     /* @__PURE__ */ jsx16(Text14, { children: "[y] confirm \xB7 [n]/[Esc] cancel" })
   ] });
 }
@@ -20507,11 +20494,11 @@ async function checkGenerationCache(input) {
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/load.ts
-function loadScopeGate(sessionId2) {
+function loadScopeGate(sessionId) {
   try {
     const db = openPipelineDb();
     try {
-      const components = loadScopeComponents(db, sessionId2);
+      const components = loadScopeComponents(db, sessionId);
       if (components.length === 0) {
         return { ok: false, message: "No components found for this session. Please run the import again." };
       }
@@ -20530,8 +20517,8 @@ function loadScopeGate(sessionId2) {
 // packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/use-scope-gate-flow.ts
 var realDeps2 = { load: loadScopeGate, checkCache: checkGenerationCache };
 function useScopeGateFlow(input, deps = realDeps2) {
-  const sessionId2 = input?.sessionId;
-  const loaded = useMemo3(() => sessionId2 ? deps.load(sessionId2) : void 0, [sessionId2]);
+  const sessionId = input?.sessionId;
+  const loaded = useMemo3(() => sessionId ? deps.load(sessionId) : void 0, [sessionId]);
   const cacheCheck = useRef5(void 0);
   const [confirmed, setConfirmed] = useState13();
   useEffect8(() => {
@@ -20608,7 +20595,7 @@ function GenerationScreen({
 import { useEffect as useEffect9, useRef as useRef6, useState as useState14 } from "react";
 
 // packages/experience-design-system-cli/src/tui/import/steps/08-generation/run.ts
-import { resolve as resolve23 } from "node:path";
+import { resolve as resolve24 } from "node:path";
 
 // packages/experience-design-system-cli/src/tui/import/steps/08-generation/map-tokens.ts
 async function prepareMapTokens(input, generatedSessionId) {
@@ -20708,7 +20695,7 @@ async function runGeneration(input, onProgress, deps = realDeps3) {
     update({ mapTokens: "running" });
     try {
       const mapTokensOptions = await buildMapTokensOptions(input);
-      const mapResult = await deps.runMapTokens({
+      await deps.runMapTokens({
         sessionId: input.sessionId,
         agent: input.agent,
         ...input.agentModel ? { model: input.agentModel } : {},
@@ -20716,11 +20703,6 @@ async function runGeneration(input, onProgress, deps = realDeps3) {
         skillPathOverride: MAP_TOKENS_SKILL_PATH,
         ...mapTokensOptions
       });
-      if (mapResult.diagnostics.length > 0) {
-        process.stderr.write(`Unresolved token defaults:
-${mapResult.diagnostics.map((d) => `  ${d}`).join("\n")}
-`);
-      }
     } catch (error) {
       const message = error instanceof MapTokensRunFailure ? error.message : error instanceof Error ? error.message : String(error);
       return fail2("map tokens", message);
@@ -20748,7 +20730,7 @@ async function buildMapTokensOptions(input) {
   if (mapOverride?.kind === "text") prompt.skillContentOverride = mapOverride.value;
   if (mapOverride?.kind === "path") {
     await resolvePromptOverride(mapOverride);
-    prompt.skillPathOverride = resolve23(mapOverride.value);
+    prompt.skillPathOverride = resolve24(mapOverride.value);
   }
   if (input.existingEntitiesPath) {
     const entities = await readExistingContentfulEntitiesFromSession({ path: input.existingEntitiesPath });
@@ -20796,7 +20778,7 @@ function useGeneration(input) {
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/10-flow/flow/build-flow-start.ts
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 function buildFlowStart(input) {
   const { extraction, handoff, saved, generatePromptPath } = input;
   const credentials = extraction.credentials ?? {
@@ -20809,7 +20791,7 @@ function buildFlowStart(input) {
     handoff,
     agent: extraction.agent,
     projectPath: extraction.projectPath,
-    outDir: extraction.projectPath ? join20(extraction.projectPath, ".contentful") : "",
+    outDir: extraction.projectPath ? join21(extraction.projectPath, ".contentful") : "",
     rawTokensPath: extraction.rawTokensPath,
     credentials: {
       spaceId: credentials.spaceId,
@@ -24069,17 +24051,17 @@ var TimeoutError = class extends Error {
 };
 var DEFAULT_TIMEOUT_MS6 = 15e3;
 async function runLivePreview(opts) {
-  const { sessionId: sessionId2, tokensPath, spaceId, environmentId, cmaToken, host, generation } = opts;
+  const { sessionId, tokensPath, spaceId, environmentId, cmaToken, host, generation } = opts;
   const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS6;
   if (!spaceId || !environmentId || !cmaToken) {
     return { generation, response: null };
   }
   let components = [];
-  if (sessionId2) {
+  if (sessionId) {
     const db = openPipelineDb();
     try {
-      backfillUnclassifiedProps(db, sessionId2);
-      components = loadCDFComponents(db, sessionId2);
+      backfillUnclassifiedProps(db, sessionId);
+      components = loadCDFComponents(db, sessionId);
     } finally {
       db.close();
     }
@@ -24996,7 +24978,7 @@ function useReviewPreview({
   components,
   loading,
   livePreview,
-  sessionId: sessionId2,
+  sessionId,
   tokensPath,
   spaceId,
   environmentId,
@@ -25023,7 +25005,7 @@ function useReviewPreview({
   );
   const livePreviewHook = useLivePreview({
     enabled: livePreview,
-    sessionId: sessionId2,
+    sessionId,
     tokensPath,
     spaceId,
     environmentId,
@@ -25311,7 +25293,7 @@ function GenerateReviewStepView({
     () => loadReviewSessionState({
       extractSessionId,
       tokenSessionId,
-      loadExtra: (db, sessionId2) => loadSlotCycles(db, sessionId2),
+      loadExtra: (db, sessionId) => loadSlotCycles(db, sessionId),
       sortEntries: (entries, cycles) => {
         const cycleParticipants = /* @__PURE__ */ new Set();
         for (const cycle of cycles ?? []) {
@@ -26552,11 +26534,11 @@ function DoneStep({
 // packages/experience-design-system-cli/src/tui/import/steps/10-flow/screens/PathPrompt.tsx
 import { useState as useState24 } from "react";
 import { Box as Box37, Text as Text40 } from "ink";
-import { readdirSync as readdirSync3 } from "node:fs";
-import { dirname as dirname15, basename as basename6, join as join21 } from "node:path";
+import { readdirSync as readdirSync4 } from "node:fs";
+import { dirname as dirname15, 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 resolve24 } from "node:path";
+import { resolve as resolve25 } from "node:path";
 import { homedir as homedir4 } from "node:os";
 function expandTilde(input) {
   if (input === "~" || input.startsWith("~/") || input.startsWith("~\\")) {
@@ -26570,7 +26552,7 @@ function normalizePath(input) {
     p = p.slice(1, -1);
   }
   p = expandTilde(p);
-  return resolve24(p);
+  return resolve25(p);
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/10-flow/support/use-blinking-cursor.ts
@@ -26593,19 +26575,19 @@ function autocomplete(partial) {
   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 join21(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 ? join21(dir, prefix) : null;
+  return prefix.length > base.length ? join22(dir, prefix) : null;
 }
 function PathPrompt({
   defaultPath,
@@ -27364,9 +27346,9 @@ import { useEffect as useEffect21, useRef as useRef13, useSyncExternalStore } fr
 
 // 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 join23 } from "node:path";
+import { join as join24 } from "node:path";
 
 // packages/experience-design-system-cli/src/tui/import/steps/10-flow/support/wizard-state-transitions.ts
 function shouldBypassPreview(state) {
@@ -27710,8 +27692,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 join22 } 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) {
@@ -27734,15 +27716,15 @@ 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((resolve25) => setTimeout(resolve25, ms)),
+  sleep: (ms) => new Promise((resolve26) => setTimeout(resolve26, ms)),
   warn: (message) => process.stderr.write(message)
 });
 async function runPrintFiles(input, deps, onPatch) {
   onPatch({ step: "printing" });
-  const componentsPath = join22(input.outDir, "components.json");
+  const componentsPath = join23(input.outDir, "components.json");
   try {
     const db = deps.openDb();
     let components = [];
@@ -27823,7 +27805,7 @@ var EMPTY_PUSH_RESULT = {
 };
 
 // packages/experience-design-system-cli/src/tui/import/steps/10-flow/flow/controller.ts
-var WIZARD_LOG = join23(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");
 }
@@ -27837,16 +27819,16 @@ function realFlowDeps() {
     preview: realPreviewDeps(),
     push: realPushDeps(log),
     save: realSaveDeps(),
-    loadAcceptedComponents: (sessionId2) => {
+    loadAcceptedComponents: (sessionId) => {
       const db = openPipelineDb();
       try {
-        return loadCDFComponents(db, sessionId2);
+        return loadCDFComponents(db, sessionId);
       } finally {
         db.close();
       }
     },
     mkdir: async (path5) => {
-      await mkdir8(path5, { recursive: true });
+      await mkdir9(path5, { recursive: true });
     },
     detectSaveConflict,
     buildTimestampedSubdir,
@@ -28110,171 +28092,19 @@ function useFlow(start, deps = realFlowDeps) {
 // packages/experience-design-system-cli/src/tui/help/PageContainer.tsx
 import { useEffect as useEffect22, 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() },
@@ -28283,7 +28113,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 default project directory in Settings, or start an import"
       }
     ]
   };
@@ -28400,6 +28230,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;
 
@@ -28412,7 +28243,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) {
@@ -28428,6 +28260,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",
@@ -28435,7 +28268,8 @@ var FIELD_ORDER = [
   "cmaToken",
   "host",
   "defaultComponentDir",
-  "defaultTokenFile"
+  "defaultTokenFile",
+  "contentfulBaseDir"
 ];
 function debugFields(config) {
   return {
@@ -28444,7 +28278,8 @@ 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 = {
@@ -28453,7 +28288,8 @@ var FIELD_LABELS = {
   cmaToken: "CMA Token",
   host: "API Host (optional)",
   defaultComponentDir: "Default component directory (optional)",
-  defaultTokenFile: "Default token file (optional)"
+  defaultTokenFile: "Default token file (optional)",
+  contentfulBaseDir: "Default project directory, where .contentful goes (optional)"
 };
 function ConfigurationScreen({ onDone }) {
   const [stage, setStage] = useState29("loading");
@@ -28490,6 +28326,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) => {
@@ -28619,6 +28456,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);
@@ -28679,6 +28517,8 @@ function OptInAnalyticsScreen({ onDone }) {
 // packages/experience-design-system-cli/src/tui/upgrade/PageContainer.tsx
 import { useEffect as useEffect25, 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 }) {
@@ -28750,6 +28590,8 @@ function renderBody(upgradeCheck) {
 // packages/experience-design-system-cli/src/tui/settings/debug-mode/screen.tsx
 import { useEffect as useEffect26, 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);
@@ -28865,9 +28707,9 @@ function App({ importOptions, inkClear }) {
     }
     await startExtraction(launch, "generate", result);
   };
-  const chooseTokenStrategy = (pending2, tokenStrategy) => {
+  const chooseTokenStrategy = (pending, tokenStrategy) => {
     setPendingLaunch(void 0);
-    void startExtraction(pending2.launch, tokenStrategy, pending2.credentials);
+    void startExtraction(pending.launch, tokenStrategy, pending.credentials);
   };
   const startExtraction = async (launch, tokenStrategy, credentials) => {
     const settings = await readSettings2();