@contentful/experience-design-system-cli 2.37.1-dev-build-34dbca05.0 → 2.37.1-dev-build-ced30421.0

package/dist/app.js

@@ -2699,8 +2699,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 +2716,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 +2727,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 +2995,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 +3011,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 +3049,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 +3109,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 +3128,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 +3596,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 +3622,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 +3650,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 +3678,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 +3739,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 +3756,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 +3785,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 +3806,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 +3845,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 +3853,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 +3863,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 +3874,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 +3885,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 +4116,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 +4137,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 +4156,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 +4169,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 +4180,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 +4225,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 +4324,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 +4352,47 @@ 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);
+  }
+  removeSlotAllowedComponents(db, sessionId, decisions.excludedSlotEdges ?? [], rejected);
+  db.prepare("UPDATE sessions SET updated_at = ? WHERE id = ?").run(now, sessionId);
+}
+function removeSlotAllowedComponents(db, sessionId, edges, rejectedNames) {
+  if (edges.length === 0 && rejectedNames.length === 0)
+    return;
+  const componentId = db.prepare("SELECT component_id FROM raw_components WHERE session_id = ? AND name = ?");
+  const removeEdge = db.prepare("DELETE FROM raw_slot_allowed_components WHERE session_id = ? AND component_id = ? AND allowed_component = ?");
+  const removeEverywhere = db.prepare("DELETE FROM raw_slot_allowed_components WHERE session_id = ? AND allowed_component = ?");
+  db.exec("BEGIN");
+  try {
+    for (const edge of edges) {
+      const row = componentId.get(sessionId, edge.parent);
+      if (row)
+        removeEdge.run(sessionId, row.component_id, edge.child);
+    }
+    for (const name of rejectedNames)
+      removeEverywhere.run(sessionId, name);
+    db.exec("COMMIT");
+  } catch (e) {
+    db.exec("ROLLBACK");
+    throw e;
   }
-  db.prepare("UPDATE sessions SET updated_at = ? WHERE id = ?").run(now, sessionId2);
 }
 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 +4402,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 +4410,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 +4427,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 +4435,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 +4547,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 +4561,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 +4577,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 +4598,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 +4607,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 +4755,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 +4763,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 +4786,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 +12308,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,8 +12328,8 @@ 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 sessionDir = resolve15(artifactsRoot, sessionId);
   return {
     sessionDir,
     eventsPath: resolve15(sessionDir, "events.jsonl"),
@@ -12316,8 +12338,8 @@ async function getRefineSessionPaths(sessionId2, artifactsRoot) {
 }
 
 // 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 +12368,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 +12413,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 +12852,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 +12877,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 +12902,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";
 
@@ -14636,33 +14604,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 +14639,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 +14655,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 +14693,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 +14732,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 +14781,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 +14814,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();
   }
@@ -16093,14 +15892,14 @@ async function retryDatabaseWrite(operation, attempts = 8) {
 }
 
 // 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 +16043,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 +16072,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 +16104,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 +16138,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 +16201,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 +16225,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 +16297,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 +16321,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 +16329,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 +16385,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 +16434,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 +16514,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);
@@ -17420,7 +17213,7 @@ function ExtractionScreen({
 }
 
 // packages/experience-design-system-types/dist/src/config/index.js
-import { randomBytes as randomBytes4 } from "node:crypto";
+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";
@@ -17439,7 +17232,7 @@ async function readSettings2() {
 async function writeSettings2(settings) {
   const path5 = configFilePath2();
   await mkdir6(dirname13(path5), { recursive: true });
-  const tmp = `${path5}.${process.pid}.${randomBytes4(4).toString("hex")}.tmp`;
+  const tmp = `${path5}.${process.pid}.${randomBytes3(4).toString("hex")}.tmp`;
   await writeFile6(tmp, `${JSON.stringify(settings, null, 2)}
 `, { mode: 384 });
   await rename2(tmp, path5);
@@ -17485,13 +17278,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 +17339,7 @@ async function runSelection(options) {
           writeDb,
           hashComponentShape(component),
           promptHash,
-          cliVersion2,
+          cliVersion,
           rejected ? "rejected" : "accepted",
           rejected ? reason : null
         );
@@ -17627,12 +17420,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 +17446,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));
@@ -17994,11 +17787,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" })
   ] });
 }
@@ -18603,7 +18396,7 @@ function buildVisibleRows(props) {
         if (visited.has(target)) continue;
         visited.add(target);
         const isCycleMember = cycleParticipants.has(target);
-        out.push({ name: target, depth: cur.depth + 1, isCycleMember });
+        out.push({ name: target, depth: cur.depth + 1, isCycleMember, parent: cur.name });
         queue.push({ name: target, depth: cur.depth + 1 });
       }
     }
@@ -18650,7 +18443,8 @@ function buildVisibleRows(props) {
         sharedSuffix,
         cycleChild: child.isCycleMember || void 0,
         itemIdx: childRec?.idx ?? -1,
-        rootName: key
+        rootName: key,
+        parentName: child.parent
       });
     });
   }
@@ -18733,13 +18527,19 @@ function buildVisibleRows(props) {
         injectedChildren.push({
           name: target,
           depth: parentDepth + 1,
-          isCycleChild: true
+          isCycleChild: true,
+          parent: parentName
         });
       }
     };
     emitCycleChildrenOf(root, 0);
     for (const c2 of closureChildren) {
-      injectedChildren.push({ name: c2.name, depth: c2.depth, isCycleChild: false });
+      injectedChildren.push({
+        name: c2.name,
+        depth: c2.depth,
+        isCycleChild: false,
+        parent: c2.path[c2.path.length - 2] ?? root
+      });
       emitCycleChildrenOf(c2.name, c2.depth);
     }
     const isLastAtDepth = (idx) => {
@@ -18773,7 +18573,8 @@ function buildVisibleRows(props) {
         sharedSuffix,
         cycleChild: child.isCycleChild || void 0,
         itemIdx: childRec?.idx ?? -1,
-        rootName: root
+        rootName: root,
+        parentName: child.parent
       });
     });
   }
@@ -18926,7 +18727,7 @@ function GroupedSidebar(props) {
       const rs = itemName ? renderStatusByKey?.get(itemName) : void 0;
       const badge = itemName ? previewBadge(previewAnnotationByKey?.get(itemName)) : null;
       const showInheritance = rs !== void 0 && row.kind !== "cycle" && row.kind !== "empty" && row.kind !== "group-root";
-      const supportsSelectionGlyph = selectionStateByKey !== void 0 && itemName !== void 0 && (row.kind === "standalone" || row.kind === "group-root" || row.kind === "group-child" || row.kind === "flat" || row.kind === "cycle");
+      const supportsSelectionGlyph = selectionStateByKey !== void 0 && itemName !== void 0 && (row.kind === "standalone" || row.kind === "group-root" || row.kind === "group-child" || row.kind === "flat" || row.kind === "empty" || row.kind === "cycle");
       const selState = supportsSelectionGlyph ? selectionStateByKey.get(itemName) ?? "undecided" : void 0;
       const isCycleRow = row.kind === "cycle";
       const selStyle = selectionGlyphStyleFor(selState, isCycleRow);
@@ -18956,7 +18757,7 @@ function GroupedSidebar(props) {
             color: isSelected ? PALETTE2.info : labelStyle.dim ? PALETTE2.muted : labelStyle.color,
             bold: isSelected || labelStyle.bold,
             inverse: false,
-            underline: isSelected && !focused,
+            underline: isSelected && focused,
             wrap: wrapLabels ? "wrap" : "truncate",
             children: [
               " ",
@@ -19615,6 +19416,7 @@ function resolveKey(mode, key, ctx) {
 function resolveMain(key, ctx) {
   const { input } = key;
   const inMain = ctx.focusedColumn === "main";
+  if (key.ctrl && input === "z") return { type: "undo" };
   if (input === "q" || key.escape) {
     if (key.escape && ctx.jumpFilterActive) return { type: "clear-jump-filter" };
     if (key.escape && ctx.searchActive) return { type: "clear-search" };
@@ -19873,21 +19675,42 @@ function rejectNeedsConfirmation(graph, name, state) {
   const ancestors = toReject.filter((n) => n !== name);
   return ancestors.length + toDeselect.length >= 2;
 }
-function partitionDecisions(components, state) {
+function removeSlotChild(components, edge) {
+  return components.map(
+    (component) => component.name === edge.parent ? {
+      ...component,
+      slots: component.slots?.map((slot) => ({
+        ...slot,
+        allowedComponents: slot.allowedComponents.filter((name) => name !== edge.child)
+      }))
+    } : component
+  );
+}
+function withoutSlotChildren(components, removedEdges) {
+  return removedEdges.reduce(removeSlotChild, components);
+}
+function partitionDecisions(components, state, removedEdges) {
   const accepted = [];
   const rejected = [];
   for (const c2 of components) {
     if (state.get(c2.name) === "accepted") accepted.push(c2.name);
     else rejected.push(c2.name);
   }
-  return { accepted, rejected };
+  const rejectedNames = new Set(rejected);
+  const excludedSlotEdges = removedEdges.filter((e) => !rejectedNames.has(e.parent) && !rejectedNames.has(e.child));
+  return { accepted, rejected, excludedSlotEdges };
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/use-scope-gate.ts
-function useScopeGate({ components, onConfirm, onQuit }) {
+function useScopeGate({ components: loadedComponents, onConfirm, onQuit }) {
   const { columns: totalWidth, rows: terminalRows } = useTerminalSize();
   const columnPlan = useMemo2(() => computeColumnWidths(totalWidth), [totalWidth]);
   const [decisions, setDecisions] = useState12(/* @__PURE__ */ new Map());
+  const [removedEdges, setRemovedEdges] = useState12([]);
+  const components = useMemo2(
+    () => withoutSlotChildren(loadedComponents, removedEdges),
+    [loadedComponents, removedEdges]
+  );
   const [nav, setNav] = useState12({ cursor: 0, scrollOffset: 0 });
   const [focusedColumn, setFocusedColumn] = useState12("main");
   const [addedComponentsCursor, setAddedComponentsCursor] = useState12(0);
@@ -20059,6 +19882,14 @@ function useScopeGate({ components, onConfirm, onQuit }) {
         return void 0;
     }
   };
+  const focusedNestedEdge = () => {
+    const row = visibleRows[safeCursor];
+    if (row?.kind !== "group-child" || !row.parentName || row.itemIdx < 0) return void 0;
+    const child = groupedItems[row.itemIdx]?.key;
+    return child ? { parent: row.parentName, child } : void 0;
+  };
+  const removeFromParentSlot = (edge) => setRemovedEdges((edges) => [...edges, edge]);
+  const undoSlotRemoval = () => setRemovedEdges((edges) => edges.slice(0, -1));
   const jumpCursorTo = (name) => {
     let idx = -1;
     for (let i = 0; i < visibleRows.length; i++) {
@@ -20158,7 +19989,7 @@ function useScopeGate({ components, onConfirm, onQuit }) {
         onQuit();
         return;
       case "confirm":
-        onConfirm(partitionDecisions(components, decisions));
+        onConfirm(partitionDecisions(components, decisions, removedEdges));
         return;
       case "close-help":
         setShowHelp(false);
@@ -20211,6 +20042,11 @@ function useScopeGate({ components, onConfirm, onQuit }) {
         return;
       }
       case "reject": {
+        const edge = focusedColumn === "main" ? focusedNestedEdge() : void 0;
+        if (edge) {
+          removeFromParentSlot(edge);
+          return;
+        }
         const key = focusedColumn === "added-components" ? addedComponents[safeAddedComponentsCursor]?.name : focusedRowKey();
         if (key) requestReject(key);
         return;
@@ -20218,6 +20054,9 @@ function useScopeGate({ components, onConfirm, onQuit }) {
       case "toggle-all":
         decide({ type: "toggle-all" });
         return;
+      case "undo":
+        undoSlotRemoval();
+        return;
       case "accept-unflagged":
         decide({ type: "accept-unflagged" });
         return;
@@ -20507,11 +20346,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 +20369,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(() => {
@@ -20708,7 +20547,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 +20555,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);
@@ -22865,8 +22699,8 @@ function FieldEditor({
     return /* @__PURE__ */ jsxs22(Box21, { flexDirection: "column", width, borderStyle: "single", borderColor: PALETTE3.warning, children: [
       /* @__PURE__ */ jsx27(Text23, { bold: true, color: PALETTE3.warning, children: "FIELD EDITOR \u2014 no fields" }),
       /* @__PURE__ */ jsx27(Text23, { color: PALETTE3.warning, children: "\u26A0 No properties classified for this component. The LLM didn't find anything to classify." }),
-      /* @__PURE__ */ jsx27(Text23, { color: PALETTE3.muted, children: "You can add fields manually below or reject this component." }),
-      /* @__PURE__ */ jsx27(Text23, { color: PALETTE3.muted, children: "Enter to save \xB7 Esc to discard" })
+      /* @__PURE__ */ jsx27(Text23, { color: PALETTE3.muted, children: "There is nothing to edit here." }),
+      /* @__PURE__ */ jsx27(Text23, { color: PALETTE3.muted, children: active ? "[Esc] go back to the list" : "In the list: [r] reject this component \xB7 [a] accept it" })
     ] });
   }
   const hasEmptyProperties = props.length === 0 && slots.length === 0;
@@ -23081,7 +22915,7 @@ function FieldEditor({
       children: [
         hasEmptyProperties && /* @__PURE__ */ jsx27(Text23, { color: PALETTE3.warning, children: "\u26A0 No properties classified for this component. The LLM didn't find anything to classify. Reject this component or add fields manually." }),
         header,
-        /* @__PURE__ */ jsx27(Box21, { flexDirection: "column", width: innerWidth, flexShrink: 0, children: focusLevel === "field" && !inComponentDesc && currentProp ? /* @__PURE__ */ jsx27(
+        /* @__PURE__ */ jsx27(Box21, { flexDirection: "column", width: innerWidth, flexShrink: 0, children: focusLevel === "field" && !inComponentDesc && !inSlots && currentProp ? /* @__PURE__ */ jsx27(
           PropRow,
           {
             prop: currentProp,
@@ -23990,6 +23824,7 @@ function finalizeReviewSession(extractSessionId, components) {
         db.exec("ROLLBACK");
         throw error;
       }
+      removeSlotAllowedComponents(db, extractSessionId, [], toReject);
     } finally {
       db.close();
     }
@@ -24069,17 +23904,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 +24831,7 @@ function useReviewPreview({
   components,
   loading,
   livePreview,
-  sessionId: sessionId2,
+  sessionId,
   tokensPath,
   spaceId,
   environmentId,
@@ -25023,7 +24858,7 @@ function useReviewPreview({
   );
   const livePreviewHook = useLivePreview({
     enabled: livePreview,
-    sessionId: sessionId2,
+    sessionId,
     tokensPath,
     spaceId,
     environmentId,
@@ -25311,7 +25146,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 ?? []) {
@@ -25721,33 +25556,50 @@ function GenerateReviewStepView({
     const cycle = cycleRows[cyclesCursor];
     return cycle ? enumerateCycleBreaks(cycle, components) : [];
   }, [cycleRows, cyclesCursor, components]);
-  const handleBreakEdge = (edge) => {
-    const target = components.find((component) => component.key === edge.fromComponent);
-    const slot = target?.entry.$slots?.[edge.slotName];
-    if (!target || !slot || !Array.isArray(slot.$allowedComponents)) return;
-    const nextEntry = {
-      ...target.entry,
-      $slots: {
-        ...target.entry.$slots,
-        [edge.slotName]: {
-          ...slot,
-          $allowedComponents: slot.$allowedComponents.filter((value) => value !== edge.toComponent)
-        }
-      }
-    };
+  const saveSlotChange = (parentKey, nextEntry, historyLabel) => {
     const next = components.map(
-      (component) => component.key === target.key ? { ...component, entry: nextEntry } : component
+      (component) => component.key === parentKey ? { ...component, entry: nextEntry } : component
     );
     setComponents(next);
     const db = openPipelineDb();
     try {
-      storeCDFComponents(db, extractSessionId, [{ key: target.key, entry: nextEntry }]);
+      storeCDFComponents(db, extractSessionId, [{ key: parentKey, entry: nextEntry }]);
     } finally {
       db.close();
     }
     recomputeCycles(next);
     livePreviewHook.trigger();
-    pushHistorySnapshot(next, "break-cycle-edge");
+    pushHistorySnapshot(next, historyLabel);
+  };
+  const handleBreakEdge = (edge) => {
+    const target = components.find((component) => component.key === edge.fromComponent);
+    const slot = target?.entry.$slots?.[edge.slotName];
+    if (!target || !slot || !Array.isArray(slot.$allowedComponents)) return;
+    saveSlotChange(
+      target.key,
+      {
+        ...target.entry,
+        $slots: {
+          ...target.entry.$slots,
+          [edge.slotName]: {
+            ...slot,
+            $allowedComponents: slot.$allowedComponents.filter((value) => value !== edge.toComponent)
+          }
+        }
+      },
+      "break-cycle-edge"
+    );
+  };
+  const handleRemoveSlotChild = (parentKey, childKey) => {
+    const parent = components.find((component) => component.key === parentKey);
+    if (!parent?.entry.$slots) return;
+    const slots = Object.fromEntries(
+      Object.entries(parent.entry.$slots).map(([slotName, slot]) => [
+        slotName,
+        Array.isArray(slot.$allowedComponents) ? { ...slot, $allowedComponents: slot.$allowedComponents.filter((value) => value !== childKey) } : slot
+      ])
+    );
+    saveSlotChange(parentKey, { ...parent.entry, $slots: slots }, "remove-slot-child");
   };
   const handleRejectComponent = (key) => {
     const rejectCascade2 = computeRejectCascade(key, componentGraph);
@@ -26077,6 +25929,11 @@ function GenerateReviewStepView({
     if (input === "r") {
       const current = components[selectedIdx];
       if (!current) return;
+      const row = visibleRowsMemo[cursorRowIdx];
+      if (row?.kind === "group-child" && row.parentName) {
+        handleRemoveSlotChild(row.parentName, current.key);
+        return;
+      }
       handleRejectComponent(current.key);
       return;
     }
@@ -27837,10 +27694,10 @@ 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();
       }
@@ -28865,9 +28722,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();