@contentful/experience-design-system-cli 2.37.1-dev-build-c1d02862.0 → 2.37.1-dev-build-40c29bf0.0

package/dist/app.js

@@ -760,8 +760,8 @@ async function runAgent(options) {
   const { agent, prompt, timeoutMs, model, onOutput, promptViaStdin, onDebugEvent } = options;
   const bedrock = options.bedrock ?? process.env.EDS_BEDROCK === "1";
   const binary = resolveBinary(agent);
-  const useStdin = !!promptViaStdin;
-  const args = buildArgs(agent, prompt, model, useStdin, bedrock);
+  const useStdin2 = !!promptViaStdin;
+  const args = buildArgs(agent, prompt, model, useStdin2, bedrock);
   const startedAt = Date.now();
   onDebugEvent?.("run.start", {
     agent,
@@ -778,7 +778,7 @@ async function runAgent(options) {
       stdio: ["pipe", "pipe", "pipe"],
       ...bedrockEnv ? { env: { ...process.env, ...bedrockEnv } } : {}
     });
-    if (useStdin && child.stdin) {
+    if (useStdin2 && child.stdin) {
       child.stdin.on("error", () => {
       });
       child.stdin.write(prompt, () => {
@@ -2001,7 +2001,7 @@ var init_cache_keys = __esm({
 
 // packages/experience-design-system-cli/app.tsx
 import { join as join13 } from "node:path";
-import { useEffect as useEffect11, useState as useState15 } from "react";
+import { useEffect as useEffect14, useState as useState20 } from "react";
 
 // packages/experience-design-system-cli/src/tui/home/home.tsx
 import { useEffect as useEffect2, useState as useState2 } from "react";
@@ -2071,8 +2071,8 @@ function readPackageVersion() {
   return pkg.version ?? "unknown";
 }
 function parseVersionTag(tag) {
-  const match = /^v(\d+\.\d+\.\d+)$/.exec(tag);
-  return match ? match[1] : void 0;
+  const match2 = /^v(\d+\.\d+\.\d+)$/.exec(tag);
+  return match2 ? match2[1] : void 0;
 }
 async function checkForUpgrade() {
   const current = readPackageVersion();
@@ -3093,6 +3093,34 @@ function parseReviewReasons(raw) {
     return [];
   }
 }
+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(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(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(sessionId);
+  const slotsByComponent = indexRowsByKey(slotRows, (s) => s.component_id);
+  const allowedBySlot = indexRowsByKey(allowedRows, (a) => `${a.component_id}::${a.slot_name}`);
+  return rows.map((r) => {
+    const reviewReasons = parseReviewReasons(r.review_reasons);
+    const nonAuthorableReason = reviewReasons.find((reason) => reason.startsWith("non-authorable:"));
+    return {
+      name: r.name,
+      componentId: r.component_id,
+      aiDecision: r.status === "accepted" ? "accepted" : r.status === "rejected" ? "rejected" : null,
+      aiReason: r.reject_reason ?? nonAuthorableReason?.slice("non-authorable:".length) ?? null,
+      needsReview: Boolean(r.needs_review),
+      slots: (slotsByComponent.get(r.component_id) ?? []).map((s) => ({
+        name: s.name,
+        allowedComponents: (allowedBySlot.get(`${r.component_id}::${s.name}`) ?? []).map((a) => a.allowed_component)
+      }))
+    };
+  });
+}
 var _cliCacheVersionCache = null;
 async function getCliCacheVersion() {
   if (_cliCacheVersionCache)
@@ -3720,9 +3748,9 @@ var defaultPathSerializer = ({ path: path5, url: _url }) => {
   let url = _url;
   const matches = _url.match(PATH_PARAM_RE);
   if (matches) {
-    for (const match of matches) {
+    for (const match2 of matches) {
       let explode = false;
-      let name = match.substring(1, match.length - 1);
+      let name = match2.substring(1, match2.length - 1);
       let style = "simple";
       if (name.endsWith("*")) {
         explode = true;
@@ -3740,11 +3768,11 @@ var defaultPathSerializer = ({ path: path5, url: _url }) => {
         continue;
       }
       if (Array.isArray(value)) {
-        url = url.replace(match, serializeArrayParam({ explode, name, style, value }));
+        url = url.replace(match2, serializeArrayParam({ explode, name, style, value }));
         continue;
       }
       if (typeof value === "object") {
-        url = url.replace(match, serializeObjectParam({
+        url = url.replace(match2, serializeObjectParam({
           explode,
           name,
           style,
@@ -3754,19 +3782,19 @@ var defaultPathSerializer = ({ path: path5, url: _url }) => {
         continue;
       }
       if (style === "matrix") {
-        url = url.replace(match, `;${serializePrimitiveParam({
+        url = url.replace(match2, `;${serializePrimitiveParam({
           name,
           value
         })}`);
         continue;
       }
       const replaceValue = encodeURIComponent(style === "label" ? `.${value}` : value);
-      url = url.replace(match, replaceValue);
+      url = url.replace(match2, replaceValue);
     }
   }
   return url;
 };
-var createQuerySerializer = ({ allowReserved, array: array3, object: object2 } = {}) => {
+var createQuerySerializer = ({ allowReserved, array: array4, object: object2 } = {}) => {
   const querySerializer = (queryParams) => {
     const search = [];
     if (queryParams && typeof queryParams === "object") {
@@ -3782,7 +3810,7 @@ var createQuerySerializer = ({ allowReserved, array: array3, object: object2 } =
             name,
             style: "form",
             value,
-            ...array3
+            ...array4
           });
           if (serializedArray)
             search.push(serializedArray);
@@ -5354,12 +5382,12 @@ function findSession(stdout) {
   return null;
 }
 function parseExtractedCount(stderr) {
-  const match = EXTRACTED.exec(stderr);
-  return match ? Number(match[1]) : 0;
+  const match2 = EXTRACTED.exec(stderr);
+  return match2 ? Number(match2[1]) : 0;
 }
 function parsePrintTokensCount(stdout) {
-  const match = PRINT_TOKENS_COUNT.exec(stdout);
-  return match ? Number(match[1]) : 0;
+  const match2 = PRINT_TOKENS_COUNT.exec(stdout);
+  return match2 ? Number(match2[1]) : 0;
 }
 function initialProgress(input) {
   return {
@@ -6140,8 +6168,8 @@ async function runAgent2(options) {
   const { agent, prompt, timeoutMs, model, onOutput, promptViaStdin, onDebugEvent } = options;
   const bedrock = options.bedrock ?? process.env.EDS_BEDROCK === "1";
   const binary = resolveAgentBinary(agent);
-  const useStdin = !!promptViaStdin;
-  const args = buildAgentArgs(agent, prompt, model, useStdin, bedrock);
+  const useStdin2 = !!promptViaStdin;
+  const args = buildAgentArgs(agent, prompt, model, useStdin2, bedrock);
   const startedAt = Date.now();
   onDebugEvent?.("run.start", {
     agent,
@@ -6158,7 +6186,7 @@ async function runAgent2(options) {
       stdio: ["pipe", "pipe", "pipe"],
       ...bedrockEnv ? { env: { ...process.env, ...bedrockEnv } } : {}
     });
-    if (useStdin && child.stdin) {
+    if (useStdin2 && child.stdin) {
       child.stdin.on("error", () => {
       });
       child.stdin.write(prompt, () => {
@@ -6692,194 +6720,2989 @@ function useExtraction(input) {
   return state;
 }
 
-// packages/experience-design-system-cli/src/tui/import/spawn-v1-import.ts
-import { spawn as spawn7 } from "node:child_process";
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/screen.tsx
+import { Box as Box20, Text as Text22 } from "ink";
 
-// packages/experience-design-system-cli/src/commands/import-options.ts
-function importOptionArgs(options) {
-  return [
-    ...options.agent ? ["--agent", options.agent] : [],
-    ...options.prompt.flatMap((value) => ["--prompt", value]),
-    ...options.cache ? [] : ["--no-cache"]
-  ];
-}
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/panels/added-column.tsx
+import React6 from "react";
+import { Box as Box11, Text as Text12 } from "ink";
+import figures from "figures";
 
-// packages/experience-design-system-types/dist/src/handoff/index.js
-import * as z5 from "zod/mini";
-var HANDOFF_ENV = "EDS_IMPORT_HANDOFF";
-var NonEmpty = z5.string().check(z5.minLength(1));
-var TokensSchema = z5.object({
-  /**
-   * What to do about an existing `tokens.json`.
-   * reuse: keep it. regenerate: build it again with the cache off. generate: nothing was asked, build it as usual.
-   */
-  strategy: z5.enum(["reuse", "regenerate", "generate"])
-});
-var ExtractionSchema = z5.object({
-  sessionId: NonEmpty,
-  outDir: NonEmpty,
-  tokensPath: z5.string(),
-  tokenSessionId: z5.nullable(z5.string()),
-  tokenCount: z5.number(),
-  existingEntitiesPath: z5.nullable(z5.string()),
-  /** Never 'running': the wizard starts its background cache check only once this has settled. */
-  existingEntitiesStatus: z5.enum(["idle", "complete", "failed"]),
-  /** The only phases the scope gate can start from. */
-  compositionPhase: z5.enum(["done", "cache-hit"])
-});
-var ImportHandoffSchema = z5.object({
-  /** The user skipped the credentials screen, so nothing is fetched from or pushed to Contentful. */
-  credentialsSkipped: z5.boolean(),
-  tokens: TokensSchema,
-  /** Present once the CLI has run the extraction stage; the wizard then starts at the scope gate. */
-  extraction: z5.optional(ExtractionSchema)
-});
-function serializeHandoff(handoff) {
-  return JSON.stringify(handoff);
-}
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/sidebar/theme.ts
+var PALETTE2 = {
+  info: PALETTE.accent,
+  success: PALETTE.success,
+  error: PALETTE.error,
+  warning: PALETTE.warning,
+  muted: PALETTE.muted,
+  border: PALETTE.border
+};
 
-// packages/experience-design-system-cli/src/tui/import/spawn-v1-import.ts
-function buildArgs2(options) {
-  const args = ["import"];
-  if (options.projectPath) {
-    args.push("--project", options.projectPath);
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/columns.ts
+var TWO_COLUMN_MIN_WIDTH = 100;
+var SCOPE_GATE_MAIN_COLUMN_WIDTH = 54;
+var ACCEPTED_COMPONENTS_COLUMN_WIDTH = 36;
+var PANEL_BORDER_ROWS = 2;
+var PANEL_INDICATOR_ROWS = 2;
+var PANEL_HEADER_ROWS = 2;
+function computePanelLayout(mainVisibleCount) {
+  const safeMainVisibleCount = Math.max(1, mainVisibleCount);
+  const height = safeMainVisibleCount + PANEL_BORDER_ROWS + PANEL_INDICATOR_ROWS + PANEL_HEADER_ROWS;
+  const sideVisibleCount = Math.max(1, height - PANEL_BORDER_ROWS - PANEL_INDICATOR_ROWS - PANEL_HEADER_ROWS);
+  return { height, mainVisibleCount: safeMainVisibleCount, sideVisibleCount };
+}
+function computeColumnWidths(totalWidth) {
+  if (totalWidth < TWO_COLUMN_MIN_WIDTH) {
+    return { layout: "single", main: SCOPE_GATE_MAIN_COLUMN_WIDTH, added: 0 };
+  }
+  const main = SCOPE_GATE_MAIN_COLUMN_WIDTH;
+  const added = ACCEPTED_COMPONENTS_COLUMN_WIDTH;
+  return { layout: "two-column", main, added };
+}
+function sortTieredEntries(cycleTier, restTier) {
+  cycleTier.sort((a, b) => a.name.localeCompare(b.name));
+  restTier.sort((a, b) => a.name.localeCompare(b.name));
+  return [...cycleTier, ...restTier];
+}
+function buildAddedComponentsList(components, stateByKey, cycleParticipants = /* @__PURE__ */ new Set()) {
+  const cycleTier = [];
+  const restTier = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const c2 of components) {
+    if (stateByKey.get(c2.name) !== "accepted") continue;
+    if (seen.has(c2.name)) continue;
+    seen.add(c2.name);
+    if (cycleParticipants.has(c2.name)) cycleTier.push({ name: c2.name, isCycle: true });
+    else restTier.push({ name: c2.name, isCycle: false });
+  }
+  return sortTieredEntries(cycleTier, restTier);
+}
+function computeCounters(components, closures, stateByKey) {
+  let accepted = 0;
+  let rejected = 0;
+  let undecided = 0;
+  for (const c2 of components) {
+    const s = stateByKey.get(c2.name) ?? "undecided";
+    if (s === "accepted") accepted++;
+    else if (s === "rejected") rejected++;
+    else undecided++;
+  }
+  let groups = 0;
+  for (const [root, closure] of closures.entries()) {
+    if (closure.nodes.length <= 1) continue;
+    if (stateByKey.get(root) === "accepted") groups++;
+  }
+  return { accepted, rejected, undecided, groups, total: components.length };
+}
+function sideColumnLabelStyle(input) {
+  const { isCycle, isSelected, focused } = input;
+  const isCursor = isSelected && focused;
+  if (isCursor) {
+    return {
+      nameColor: PALETTE2.info,
+      nameBold: true,
+      nameInverse: false,
+      nameUnderline: false,
+      suffixColor: PALETTE2.info,
+      suffixDim: false,
+      suffixInverse: false,
+      suffixUnderline: false
+    };
   }
-  if (options.tokens) {
-    args.push("--tokens", options.tokens);
+  const underline = isSelected && !focused;
+  if (isCycle) {
+    return {
+      nameColor: PALETTE2.warning,
+      nameBold: false,
+      nameInverse: false,
+      nameUnderline: underline,
+      suffixColor: PALETTE2.warning,
+      suffixDim: false,
+      suffixInverse: false,
+      suffixUnderline: underline
+    };
   }
-  args.push(...importOptionArgs({ agent: options.agent, prompt: options.prompt ?? [], cache: options.cache ?? true }));
-  return args;
+  return {
+    nameColor: PALETTE2.success,
+    nameBold: false,
+    nameInverse: false,
+    nameUnderline: underline,
+    suffixColor: PALETTE2.info,
+    suffixDim: true,
+    suffixInverse: false,
+    suffixUnderline: underline
+  };
 }
-function buildEnv(options, base = process.env) {
-  return { ...base, ...options.handoff ? { [HANDOFF_ENV]: serializeHandoff(options.handoff) } : {} };
+function computeColumnWindow(total, cursor, visibleCount) {
+  if (total <= visibleCount) return { start: 0, end: total, above: 0, below: 0 };
+  let start = Math.max(0, cursor - Math.floor(visibleCount / 2));
+  start = Math.min(start, total - visibleCount);
+  const end = start + visibleCount;
+  return { start, end, above: start, below: total - end };
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/sidebar/components/windowed-panel.tsx
+import { Box as Box10, Text as Text11 } from "ink";
+import { jsx as jsx13, jsxs as jsxs10 } from "react/jsx-runtime";
+var MIN_TERMINAL_PANEL_HEIGHT = 5;
+function terminalPanelHeight(rows, reservedRows = 4) {
+  return Math.max(MIN_TERMINAL_PANEL_HEIGHT, rows - reservedRows);
+}
+function FixedPanel({
+  width,
+  height,
+  minHeight,
+  focused = false,
+  borderStyle,
+  borderColor,
+  paddingLeft,
+  clipOverflow = true,
+  children
+}) {
+  return /* @__PURE__ */ jsx13(
+    Box10,
+    {
+      flexDirection: "column",
+      width,
+      ...height === void 0 ? {} : { height },
+      ...minHeight === void 0 ? {} : { minHeight },
+      ...height === void 0 || !clipOverflow ? {} : { overflowY: "hidden" },
+      flexShrink: 0,
+      borderStyle,
+      borderColor: focused ? borderColor ?? "white" : borderColor,
+      paddingLeft,
+      children
+    }
+  );
 }
-async function spawnV1Import(options = {}) {
-  const cliPath = findLegacyCliPath();
-  const args = buildArgs2(options);
-  return new Promise((resolvePromise) => {
-    const child = spawn7("node", [cliPath, ...args], {
-      stdio: "inherit",
-      env: buildEnv(options)
-    });
-    child.on("close", (code) => {
-      resolvePromise({ exitCode: code ?? 1, result: void 0, stdout: "", stderr: "" });
-    });
-    child.on("error", (err) => {
-      resolvePromise({ exitCode: 1, result: void 0, stdout: "", stderr: err.message });
-    });
-  });
+function WindowedPanel({ width, height, title, focused, children }) {
+  return /* @__PURE__ */ jsxs10(
+    FixedPanel,
+    {
+      width,
+      borderStyle: "single",
+      borderColor: focused ? "white" : void 0,
+      ...height === void 0 ? {} : { height },
+      focused,
+      children: [
+        title && /* @__PURE__ */ jsx13(WindowedPanelHeader, { title, width, focused }),
+        children
+      ]
+    }
+  );
+}
+function WindowedPanelHeader({
+  title,
+  width,
+  focused
+}) {
+  return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx13(Text11, { bold: true, color: PALETTE2.info, inverse: focused, children: title }),
+    /* @__PURE__ */ jsx13(Text11, { dimColor: true, children: "\u2500".repeat(Math.max(0, width - 2)) })
+  ] });
+}
+function formatWindowIndicator(direction, count) {
+  if (count <= 0) return " ";
+  return `${direction === "up" ? "\u2191" : "\u2193"} ${count} more`;
+}
+function WindowIndicator({ direction, count }) {
+  return /* @__PURE__ */ jsx13(Text11, { color: PALETTE2.muted, children: formatWindowIndicator(direction, count) });
 }
 
-// packages/experience-design-system-cli/src/tui/import/terminal-input.ts
-function getTerminalHandle() {
-  return process.stdin._handle;
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/panels/added-column.tsx
+import { jsx as jsx14, jsxs as jsxs11 } from "react/jsx-runtime";
+function AddedColumn(props) {
+  const { title, width, height, entries, cursor, focused, aiFlaggedByKey, visibleCount } = props;
+  const reserveAiBadge = entries.some((e) => aiFlaggedByKey?.get(e.name) === true);
+  const firstNonCycleIdx = entries.findIndex((e) => !e.isCycle);
+  const window = computeColumnWindow(entries.length, cursor, Math.max(1, visibleCount));
+  return /* @__PURE__ */ jsxs11(WindowedPanel, { width, height, title, focused, children: [
+    /* @__PURE__ */ jsx14(WindowIndicator, { direction: "up", count: window.above }),
+    entries.length === 0 ? /* @__PURE__ */ jsx14(Text12, { color: PALETTE2.muted, children: "(none)" }) : entries.slice(window.start, window.end).map((entry, vi) => {
+      const i = window.start + vi;
+      const isSelected = i === cursor;
+      const isCursor = focused && isSelected;
+      const aiFlagged = aiFlaggedByKey?.get(entry.name) === true;
+      const showSeparator = firstNonCycleIdx > 0 && i === firstNonCycleIdx;
+      const style = sideColumnLabelStyle({ isCycle: entry.isCycle, isSelected, focused });
+      return /* @__PURE__ */ jsxs11(React6.Fragment, { children: [
+        showSeparator && /* @__PURE__ */ jsx14(Text12, { dimColor: true, children: "\u2500".repeat(Math.max(0, width - 2)) }),
+        /* @__PURE__ */ jsxs11(Box11, { children: [
+          isCursor ? /* @__PURE__ */ jsx14(Text12, { color: PALETTE2.info, bold: true, children: figures.pointer }) : /* @__PURE__ */ jsx14(Text12, { children: " " }),
+          reserveAiBadge && (aiFlagged ? /* @__PURE__ */ jsx14(Text12, { color: PALETTE2.warning, bold: true, children: " [\xD7]" }) : /* @__PURE__ */ jsx14(Text12, { children: "    " })),
+          entry.isCycle && /* @__PURE__ */ jsx14(Text12, { color: isCursor ? PALETTE2.info : PALETTE2.warning, bold: true, underline: style.nameUnderline, children: " \u26A0" }),
+          /* @__PURE__ */ jsx14(
+            Text12,
+            {
+              color: style.nameColor,
+              bold: style.nameBold,
+              inverse: style.nameInverse,
+              underline: style.nameUnderline,
+              wrap: "wrap",
+              children: " " + entry.name
+            }
+          )
+        ] })
+      ] }, entry.name);
+    }),
+    /* @__PURE__ */ jsx14(WindowIndicator, { direction: "down", count: window.below })
+  ] });
 }
-async function stopReadingTerminal() {
-  await new Promise((resolve10) => setImmediate(resolve10));
-  const handle = getTerminalHandle();
-  if (!handle?.readStop) return;
-  handle.reading = false;
-  handle.readStop();
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/panels/cycles-panel.tsx
+import { Box as Box12, Text as Text13 } from "ink";
+import figures2 from "figures";
+import { jsx as jsx15, jsxs as jsxs12 } from "react/jsx-runtime";
+function cycleLabel(cycle, index) {
+  const parts = [];
+  for (let i = 0; i < cycle.edges.length; i++) {
+    parts.push(cycle.path[i]);
+    parts.push(`[${cycle.edges[i].slotName}]`);
+  }
+  parts.push(cycle.path[cycle.path.length - 1]);
+  return `Cycle ${index + 1}: ${parts.join(" \u2192 ")}`;
 }
-function startReadingTerminal() {
-  const handle = getTerminalHandle();
-  if (!handle?.readStart) return;
-  handle.reading = true;
-  handle.readStart();
+function CyclesPanel({ cycles, cursor }) {
+  return /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", borderStyle: "single", borderColor: PALETTE2.warning, paddingX: 1, marginTop: 1, children: [
+    /* @__PURE__ */ jsx15(Text13, { bold: true, color: PALETTE2.warning, children: `Cycles detected (${cycles.length}):` }),
+    /* @__PURE__ */ jsx15(Text13, { children: " " }),
+    cycles.map((cycle, i) => {
+      const isCursor = i === cursor;
+      return /* @__PURE__ */ jsxs12(Text13, { children: [
+        isCursor ? /* @__PURE__ */ jsx15(Text13, { color: PALETTE2.info, bold: true, children: figures2.pointer }) : /* @__PURE__ */ jsx15(Text13, { children: " " }),
+        /* @__PURE__ */ jsx15(Text13, { color: PALETTE2.warning, inverse: isCursor, children: " " + cycleLabel(cycle, i) })
+      ] }, i);
+    }),
+    /* @__PURE__ */ jsx15(Text13, { children: "[\u2191/\u2193] move \xB7 [Enter] jump \xB7 [c/Esc] close" })
+  ] });
 }
 
-// packages/experience-design-system-cli/src/tui/help/PageContainer.tsx
-import { useEffect as useEffect6, useState as useState9 } from "react";
-import { Box as Box10, Text as Text11, useInput as useInput9 } from "ink";
+// 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 }) {
+  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 ${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" })
+  ] });
+}
 
-// packages/experience-design-system-cli/src/tui/debug-store.ts
-import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
-import { existsSync as existsSync5, readdirSync as readdirSync2 } from "node:fs";
-import { join as join12 } from "node:path";
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/sidebar/components/CompactControlBar.tsx
+import { Box as Box14 } from "ink";
 
-// packages/experience-design-system-cli/src/tui/settings/debug-mode/debug-mode-store.ts
-var DEFAULT_DEBUG_MODE_SETTING = {
-  enabled: true
-};
-async function readDebugModeSetting() {
-  const { debugMode } = await readSettings2();
-  return { ...DEFAULT_DEBUG_MODE_SETTING, ...debugMode };
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/sidebar/components/LegendEntry.tsx
+import { Text as Text15 } from "ink";
+import { jsx as jsx17, jsxs as jsxs14 } from "react/jsx-runtime";
+function legendEntry(keyBracket, label, active = false) {
+  return /* @__PURE__ */ jsxs14(Text15, { children: [
+    /* @__PURE__ */ jsx17(Text15, { color: active ? PALETTE2.warning : PALETTE2.info, inverse: active, children: keyBracket }),
+    /* @__PURE__ */ jsx17(Text15, { color: active ? PALETTE2.warning : void 0, inverse: active, children: " " + label })
+  ] }, keyBracket + label);
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/sidebar/components/CompactControlBar.tsx
+import { jsxs as jsxs15 } from "react/jsx-runtime";
+function CompactControlBar({ hasGroupRoots, searchActive }) {
+  return /* @__PURE__ */ jsxs15(Box14, { borderStyle: "single", borderColor: PALETTE2.border, paddingX: 1, flexWrap: "wrap", columnGap: 2, children: [
+    legendEntry("[\u2191/\u2193]", "move"),
+    legendEntry("[a/r]", "accept/reject"),
+    legendEntry("[f]", "continue/finalize"),
+    hasGroupRoots && legendEntry("[space/E/C]", "expand/collapse"),
+    legendEntry("[/]", "search", searchActive),
+    legendEntry("[h]", "help"),
+    legendEntry("[q]", "quit")
+  ] });
 }
-async function writeDebugModeSetting(setting) {
-  await updateSettings2({ debugMode: setting });
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/sidebar/components/CounterStrip.tsx
+import { Box as Box15, Text as Text16 } from "ink";
+import { jsx as jsx18, jsxs as jsxs16 } from "react/jsx-runtime";
+function CounterStrip(props) {
+  const { counters, totalWidth } = props;
+  const condensed = totalWidth < 60;
+  const labelGrp = condensed ? "Cmp" : "Components with Slots";
+  const labelRej = condensed ? "Rej" : "Rejected";
+  const labelUnd = condensed ? "Und" : "Undecided";
+  const sep = condensed ? " | " : "    ";
+  return /* @__PURE__ */ jsx18(Box15, { children: /* @__PURE__ */ jsxs16(Text16, { children: [
+    /* @__PURE__ */ jsxs16(Text16, { color: PALETTE2.muted, children: [
+      labelGrp,
+      " "
+    ] }),
+    /* @__PURE__ */ jsx18(Text16, { bold: true, children: counters.groups }),
+    /* @__PURE__ */ jsx18(Text16, { color: PALETTE2.muted, children: sep }),
+    /* @__PURE__ */ jsxs16(Text16, { color: PALETTE2.muted, children: [
+      labelRej,
+      " "
+    ] }),
+    /* @__PURE__ */ jsx18(Text16, { bold: true, children: counters.rejected }),
+    /* @__PURE__ */ jsx18(Text16, { color: PALETTE2.muted, children: sep }),
+    /* @__PURE__ */ jsxs16(Text16, { color: PALETTE2.muted, children: [
+      labelUnd,
+      " "
+    ] }),
+    /* @__PURE__ */ jsx18(Text16, { bold: true, children: counters.undecided }),
+    /* @__PURE__ */ jsx18(Text16, { color: PALETTE2.muted, children: sep })
+  ] }) });
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/sidebar/components/GotoBanner.tsx
+import figures3 from "figures";
+import { Box as Box16, Text as Text17 } from "ink";
+import { jsx as jsx19, jsxs as jsxs17 } from "react/jsx-runtime";
+var DEFAULT_MAX_ROWS = 15;
+function windowStart(rowCount, highlightIndex, maxRows) {
+  if (rowCount <= maxRows) return 0;
+  const maxStart = rowCount - maxRows;
+  let start = highlightIndex - Math.floor(maxRows / 2);
+  if (start < 0) start = 0;
+  if (start > maxStart) start = maxStart;
+  return start;
+}
+function defaultRenderRow(row, index, isCursor) {
+  return /* @__PURE__ */ jsxs17(Text17, { children: [
+    isCursor ? /* @__PURE__ */ jsx19(Text17, { color: PALETTE2.info, bold: true, children: figures3.pointer }) : /* @__PURE__ */ jsx19(Text17, { children: " " }),
+    /* @__PURE__ */ jsx19(Text17, { inverse: isCursor, children: " " + row.label })
+  ] }, index);
+}
+function GotoBanner({
+  title,
+  rows,
+  cursor,
+  cursorRowIndex,
+  maxRows = DEFAULT_MAX_ROWS,
+  width,
+  footerHint,
+  renderRow = defaultRenderRow
+}) {
+  const highlightIndex = cursorRowIndex ?? cursor;
+  const start = windowStart(rows.length, highlightIndex, maxRows);
+  const end = Math.min(rows.length, start + maxRows);
+  const visible = rows.slice(start, end);
+  const moreAbove = start;
+  const moreBelow = rows.length - end;
+  return /* @__PURE__ */ jsxs17(
+    Box16,
+    {
+      flexDirection: "column",
+      borderStyle: "single",
+      borderColor: PALETTE2.info,
+      paddingX: 1,
+      marginTop: width === void 0 ? 1 : 0,
+      width,
+      flexShrink: 0,
+      children: [
+        /* @__PURE__ */ jsx19(Text17, { bold: true, children: title }),
+        moreAbove > 0 && /* @__PURE__ */ jsx19(Text17, { color: PALETTE2.muted, children: `  \u25B2 ${moreAbove} more` }),
+        visible.map((row, vi) => {
+          const i = start + vi;
+          return renderRow(row, i, i === highlightIndex);
+        }),
+        moreBelow > 0 && /* @__PURE__ */ jsx19(Text17, { color: PALETTE2.muted, children: `  \u25BC ${moreBelow} more` }),
+        footerHint !== void 0 && /* @__PURE__ */ jsx19(Text17, { color: PALETTE2.muted, children: footerHint })
+      ]
+    }
+  );
 }
 
-// packages/experience-design-system-cli/src/tui/debug-store.ts
-var pendingRun;
-function generateRunId() {
-  const now = /* @__PURE__ */ new Date();
-  const pad = (n) => String(n).padStart(2, "0");
-  return `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/sidebar/components/GroupedSidebar.tsx
+import figures4 from "figures";
+import { Box as Box17, Text as Text19 } from "ink";
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/graph/cycle-detection.ts
+function buildGraph(components) {
+  const nodes = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const c2 of components) {
+    if (seen.has(c2.name)) continue;
+    seen.add(c2.name);
+    nodes.push(c2.name);
+  }
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const node of nodes) adjacency.set(node, []);
+  for (const comp of components) {
+    const outgoing = adjacency.get(comp.name);
+    if (!outgoing) continue;
+    for (const slot of comp.slots) {
+      const allowed = slot.allowedComponents ?? [];
+      for (const target of allowed) {
+        if (!seen.has(target)) continue;
+        outgoing.push({ target, slotName: slot.name });
+      }
+    }
+  }
+  return { nodes, adjacency };
+}
+function stronglyConnectedComponents2(nodes, adjacency) {
+  const index = /* @__PURE__ */ new Map();
+  const lowlink = /* @__PURE__ */ new Map();
+  const onStack = /* @__PURE__ */ new Set();
+  const stack = [];
+  const sccs = [];
+  let counter = 0;
+  const nodeSet = new Set(nodes);
+  function strongconnect(v) {
+    index.set(v, counter);
+    lowlink.set(v, counter);
+    counter += 1;
+    stack.push(v);
+    onStack.add(v);
+    const neighbours = adjacency.get(v) ?? [];
+    for (const { target } of neighbours) {
+      if (!nodeSet.has(target)) continue;
+      if (!index.has(target)) {
+        strongconnect(target);
+        lowlink.set(v, Math.min(lowlink.get(v), lowlink.get(target)));
+      } else if (onStack.has(target)) {
+        lowlink.set(v, Math.min(lowlink.get(v), index.get(target)));
+      }
+    }
+    if (lowlink.get(v) === index.get(v)) {
+      const scc = [];
+      let w;
+      do {
+        w = stack.pop();
+        onStack.delete(w);
+        scc.push(w);
+      } while (w !== v);
+      sccs.push(scc);
+    }
+  }
+  for (const node of nodes) {
+    if (!index.has(node)) strongconnect(node);
+  }
+  return sccs;
+}
+function makeCycle(path5, edges) {
+  return { path: [...path5, path5[0]], edges: [...edges] };
+}
+function findSlotCycles3(components) {
+  if (components.length === 0) return [];
+  const { nodes, adjacency } = buildGraph(components);
+  if (nodes.length === 0) return [];
+  const cycles = [];
+  for (const node of nodes) {
+    const outgoing = adjacency.get(node) ?? [];
+    for (const edge of outgoing) {
+      if (edge.target === node) {
+        cycles.push({
+          path: [node, node],
+          edges: [{ fromComponent: node, slotName: edge.slotName, toComponent: node }]
+        });
+      }
+    }
+  }
+  const nodeOrder = [...nodes].sort();
+  let remaining = [...nodeOrder];
+  while (remaining.length > 0) {
+    let unblock2 = function(u) {
+      blocked.delete(u);
+      const dependents = blockedMap.get(u);
+      if (!dependents) return;
+      for (const w of dependents) {
+        if (blocked.has(w)) unblock2(w);
+      }
+      dependents.clear();
+    }, circuit2 = function(v, root) {
+      let foundCycle = false;
+      pathStack.push(v);
+      blocked.add(v);
+      const outgoing = adjacency.get(v) ?? [];
+      for (const { target: w, slotName } of outgoing) {
+        if (!sccSet.has(w)) continue;
+        edgeStack.push({ fromComponent: v, slotName, toComponent: w });
+        if (w === root) {
+          cycles.push(makeCycle(pathStack, edgeStack));
+          foundCycle = true;
+        } else if (!blocked.has(w)) {
+          if (circuit2(w, root)) foundCycle = true;
+        }
+        edgeStack.pop();
+      }
+      if (foundCycle) {
+        unblock2(v);
+      } else {
+        for (const { target: w } of outgoing) {
+          if (!sccSet.has(w)) continue;
+          let deps = blockedMap.get(w);
+          if (!deps) {
+            deps = /* @__PURE__ */ new Set();
+            blockedMap.set(w, deps);
+          }
+          deps.add(v);
+        }
+      }
+      pathStack.pop();
+      return foundCycle;
+    };
+    var unblock = unblock2, circuit = circuit2;
+    const subgraphNodes = remaining;
+    const sccs = stronglyConnectedComponents2(subgraphNodes, adjacency).filter((scc) => {
+      if (scc.length > 1) return true;
+      return false;
+    });
+    if (sccs.length === 0) break;
+    let startNode = null;
+    let startScc = null;
+    for (const scc of sccs) {
+      const min = [...scc].sort()[0];
+      if (startNode === null || min < startNode) {
+        startNode = min;
+        startScc = scc;
+      }
+    }
+    if (startNode === null || startScc === null) break;
+    const sccSet = new Set(startScc);
+    const blocked = /* @__PURE__ */ new Set();
+    const blockedMap = /* @__PURE__ */ new Map();
+    const pathStack = [];
+    const edgeStack = [];
+    circuit2(startNode, startNode);
+    remaining = remaining.filter((n) => n !== startNode);
+  }
+  return cycles;
 }
-function datePrefix(now = /* @__PURE__ */ new Date()) {
-  const pad = (n) => String(n).padStart(2, "0");
-  return `${pad(now.getMonth() + 1)}-${pad(now.getDate())}-${now.getFullYear()}`;
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/graph/composite-closure.ts
+function edgesFrom(component, known) {
+  if (!component) return [];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const slot of component.slots) {
+    for (const target of slot.allowedComponents ?? []) {
+      if (!known.has(target)) continue;
+      if (seen.has(target)) continue;
+      seen.add(target);
+      out.push(target);
+    }
+  }
+  return out.sort();
+}
+function collectDependents(components) {
+  const known = new Set(components.map((c2) => c2.name));
+  const dependents = /* @__PURE__ */ new Set();
+  for (const c2 of components) {
+    for (const slot of c2.slots) {
+      for (const target of slot.allowedComponents ?? []) {
+        if (known.has(target) && target !== c2.name) dependents.add(target);
+      }
+    }
+  }
+  return dependents;
 }
-function slugify(value) {
-  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+function findRoots(components, selected) {
+  const scope = selected ? components.filter((c2) => selected.has(c2.name)) : components;
+  const dependents = collectDependents(scope);
+  return scope.map((c2) => c2.name).filter((name) => !dependents.has(name)).sort();
 }
-function generateSessionId3() {
-  const today = datePrefix();
-  const root = debugSessionsDir2();
-  const existing = existsSync5(root) ? readdirSync2(root) : [];
-  const seqPattern = new RegExp(`^${today}-session-(\\d+)$`);
-  const maxSeq = existing.reduce((max, entry) => {
-    const match = seqPattern.exec(entry);
-    return match ? Math.max(max, Number(match[1])) : max;
-  }, 0);
-  return `${today}-session-${maxSeq + 1}`;
+function findCycleInClosure(root, reachable, components) {
+  const scopedComponents = components.filter((c2) => reachable.has(c2.name)).map((c2) => ({ name: c2.name, slots: c2.slots }));
+  const cycles = findSlotCycles3(scopedComponents);
+  if (cycles.length === 0) return null;
+  const involvesRoot = cycles.find((cycle) => cycle.path.includes(root));
+  const picked = involvesRoot ?? cycles[0];
+  return picked.path;
 }
-var SESSION_ID = generateSessionId3();
-function sessionDebugDir() {
-  return join12(debugSessionsDir2(), SESSION_ID);
+function walkReachable2(root, byName, known) {
+  const reachable = /* @__PURE__ */ new Set();
+  const stack = [root];
+  while (stack.length > 0) {
+    const cur = stack.pop();
+    if (reachable.has(cur)) continue;
+    reachable.add(cur);
+    for (const next of edgesFrom(byName.get(cur), known)) {
+      if (!reachable.has(next)) stack.push(next);
+    }
+  }
+  return reachable;
 }
-function currentDebugSessionDir() {
-  return sessionDebugDir();
+function computeClosure(root, components) {
+  const known = new Set(components.map((c2) => c2.name));
+  const byName = new Map(components.map((c2) => [c2.name, c2]));
+  if (!known.has(root)) {
+    return {
+      root,
+      nodes: [{ name: root, depth: 0, path: [root], parents: [] }],
+      containsCycle: false
+    };
+  }
+  const reachable = walkReachable2(root, byName, known);
+  const cyclePath = findCycleInClosure(root, reachable, components);
+  if (cyclePath) {
+    const nodes2 = [...reachable].sort().map((name) => ({
+      name,
+      depth: name === root ? 0 : 1,
+      path: [root],
+      parents: []
+    }));
+    return { root, nodes: nodes2, containsCycle: true, cyclePath };
+  }
+  const depth = /* @__PURE__ */ new Map();
+  const parentPath = /* @__PURE__ */ new Map();
+  const parents = /* @__PURE__ */ new Map();
+  depth.set(root, 0);
+  parentPath.set(root, [root]);
+  parents.set(root, /* @__PURE__ */ new Set());
+  const queue = [root];
+  while (queue.length > 0) {
+    const cur = queue.shift();
+    const curDepth = depth.get(cur);
+    const curPath = parentPath.get(cur);
+    for (const next of edgesFrom(byName.get(cur), known)) {
+      if (!parents.has(next)) parents.set(next, /* @__PURE__ */ new Set());
+      parents.get(next).add(cur);
+      const nextDepth = curDepth + 1;
+      const existingDepth = depth.get(next);
+      const nextPath = [...curPath, next];
+      if (existingDepth === void 0 || nextDepth < existingDepth) {
+        depth.set(next, nextDepth);
+        parentPath.set(next, nextPath);
+        queue.push(next);
+      } else if (nextDepth === existingDepth) {
+        const existingPath = parentPath.get(next);
+        if (nextPath.join("\0") < existingPath.join("\0")) {
+          parentPath.set(next, nextPath);
+        }
+      }
+    }
+  }
+  const nodes = [];
+  for (const [name, d] of depth.entries()) {
+    nodes.push({
+      name,
+      depth: d,
+      path: parentPath.get(name),
+      parents: [...parents.get(name) ?? /* @__PURE__ */ new Set()].sort()
+    });
+  }
+  nodes.sort((a, b) => a.depth - b.depth || a.name.localeCompare(b.name));
+  return { root, nodes, containsCycle: false };
 }
-void isDebugModeEnabled().then((enabled) => {
-  if (!enabled) return void 0;
-  return mkdir3(sessionDebugDir(), { recursive: true });
-});
-async function isDebugModeEnabled() {
-  try {
-    return (await readDebugModeSetting()).enabled;
-  } catch {
-    return true;
+function computeAllClosures(components, selected) {
+  const roots = findRoots(components, selected);
+  const scope = selected ? components.filter((c2) => selected.has(c2.name)) : components;
+  const out = /* @__PURE__ */ new Map();
+  for (const root of roots) out.set(root, computeClosure(root, scope));
+  return out;
+}
+function findSharedDeps(closures) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const [root, closure] of closures.entries()) {
+    for (const node of closure.nodes) {
+      if (node.name === root) continue;
+      if (!counts.has(node.name)) counts.set(node.name, []);
+      counts.get(node.name).push(root);
+    }
   }
+  const out = /* @__PURE__ */ new Map();
+  for (const [name, roots] of counts.entries()) {
+    if (roots.length >= 2) out.set(name, [...roots].sort());
+  }
+  return out;
 }
-function redact(value) {
-  const clone = { ...value };
-  if ("cma_token" in clone) {
-    const raw = clone.cma_token;
-    clone.cma_token = typeof raw === "string" && raw.length > 0 ? `[present, ${raw.length} chars]` : "[not set]";
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/sidebar/components/badge.tsx
+import { Text as Text18 } from "ink";
+import { jsx as jsx20 } from "react/jsx-runtime";
+function previewBadge(annotation) {
+  switch (annotation) {
+    case "new":
+      return { char: "+", color: PALETTE2.success };
+    case "changed":
+      return { char: "~", color: PALETTE2.warning };
+    case "removed":
+      return { char: "-", color: PALETTE2.error, dim: true };
+    case "breaking":
+      return { char: "!", color: PALETTE2.error, bold: true };
+    default:
+      return null;
   }
-  return clone;
 }
-function startDebugRun({
-  flow,
-  step,
-  menuOption,
-  inputs
+function PreviewBadge({
+  badge,
+  highlighted = false
 }) {
-  const runId = generateRunId();
-  const startedAt = Date.now();
-  const redactedInputs = redact(inputs);
-  isDebugModeEnabled().then((enabled) => {
-    if (!enabled) return;
-    pendingRun = { flow, step, runId, menuOption, inputs: redactedInputs, startedAt };
-  });
+  return badge ? /* @__PURE__ */ jsx20(Text18, { color: !highlighted && badge.dim ? PALETTE2.muted : badge.color, bold: badge.bold, children: badge.char }) : /* @__PURE__ */ jsx20(Text18, { children: " " });
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/sidebar/components/GroupedSidebar.tsx
+import { jsx as jsx21, jsxs as jsxs18 } from "react/jsx-runtime";
+var GLYPH_EXPAND_COLLAPSED = "\u25B8";
+var GLYPH_EXPAND_EXPANDED = "\u25BE";
+var GLYPH_TREE_MID = "\u251C\u2500";
+var GLYPH_TREE_LAST = "\u2514\u2500";
+var GLYPH_WARN = "\u26A0";
+var GLYPH_ERROR = "\u2717";
+function isEmpty(entry) {
+  return Object.keys(entry.$properties ?? {}).length === 0 && Object.keys(entry.$slots ?? {}).length === 0;
+}
+function allowedComponentNames(entry) {
+  const names = [];
+  for (const slot of Object.values(entry.$slots ?? {})) {
+    if (!Array.isArray(slot?.$allowedComponents)) continue;
+    names.push(...slot.$allowedComponents.filter((value) => typeof value === "string"));
+  }
+  return names;
+}
+function aggregateGlyphFor(closure, statusByName) {
+  let worst = "ok";
+  for (const node of closure.nodes) {
+    const s = statusByName.get(node.name);
+    if (!s) continue;
+    if (s === "error") {
+      worst = "error";
+      break;
+    }
+    if (s === "warning") worst = "warning";
+  }
+  if (worst === "error") return GLYPH_ERROR;
+  if (worst === "warning") return GLYPH_WARN;
+  return null;
 }
-async function finishDebugRun({
-  outputs,
-  status,
-  exitMethod
-}) {
-  const run2 = pendingRun;
+function buildVisibleRows(props) {
+  const { items, cycleParticipants, alwaysExpanded, showFlatTier, viewMode, graph, filterVisibleKeys } = props;
+  if (viewMode === "flat") {
+    const rows2 = [];
+    if (items.length === 0) return rows2;
+    const itemByKey2 = new Map(items.map((it, idx) => [it.key, { it, idx }]));
+    const cycleKeys2 = [];
+    const otherKeys2 = [];
+    for (const it of items) {
+      if (cycleParticipants.has(it.key)) cycleKeys2.push(it.key);
+      else otherKeys2.push(it.key);
+    }
+    cycleKeys2.sort();
+    otherKeys2.sort();
+    const otherKeySet2 = new Set(otherKeys2);
+    const flatGraph = graph.filter((n) => otherKeySet2.has(n.name));
+    const closures2 = computeAllClosures(flatGraph);
+    const depCountByKey = /* @__PURE__ */ new Map();
+    for (const [name, closure] of closures2) {
+      if (closure.nodes.length > 1) depCountByKey.set(name, closure.nodes.length - 1);
+    }
+    for (const key of cycleKeys2) {
+      const rec = itemByKey2.get(key);
+      if (!rec) continue;
+      rows2.push({
+        kind: "cycle",
+        key: `cycle:${key}`,
+        label: `${GLYPH_WARN} ${key} (cycle)`,
+        indent: 0,
+        itemIdx: rec.idx
+      });
+    }
+    for (const key of otherKeys2) {
+      const rec = itemByKey2.get(key);
+      if (!rec) continue;
+      const dep = depCountByKey.get(key);
+      const suffix = dep !== void 0 ? ` (${dep} dep${dep === 1 ? "" : "s"})` : "";
+      rows2.push({
+        kind: "flat",
+        key: `flat:${key}`,
+        label: `${key}${suffix}`,
+        indent: 0,
+        itemIdx: rec.idx
+      });
+    }
+    return rows2;
+  }
+  const rows = [];
+  if (items.length === 0) return rows;
+  const itemByKey = new Map(items.map((it, idx) => [it.key, { it, idx }]));
+  const statusByName = new Map(items.map((it) => [it.key, it.status]));
+  const cycleKeys = [];
+  const emptyKeys = [];
+  const otherKeys = [];
+  for (const it of items) {
+    if (cycleParticipants.has(it.key)) cycleKeys.push(it.key);
+    else if (isEmpty(it.entry)) emptyKeys.push(it.key);
+    else otherKeys.push(it.key);
+  }
+  cycleKeys.sort();
+  emptyKeys.sort();
+  const seenCycleTierChildOccurrence = /* @__PURE__ */ new Set();
+  const computeCycleMemberSubtree = (root) => {
+    const out = [];
+    const visited = /* @__PURE__ */ new Set([root]);
+    const queue = [{ name: root, depth: 0 }];
+    while (queue.length > 0) {
+      const cur = queue.shift();
+      const parentItem = itemByKey.get(cur.name)?.it;
+      if (!parentItem) continue;
+      const slotTargets2 = [];
+      const seenTarget = /* @__PURE__ */ new Set();
+      for (const target of allowedComponentNames(parentItem.entry)) {
+        if (!itemByKey.has(target)) continue;
+        if (seenTarget.has(target)) continue;
+        seenTarget.add(target);
+        slotTargets2.push(target);
+      }
+      slotTargets2.sort();
+      for (const target of slotTargets2) {
+        if (visited.has(target)) continue;
+        visited.add(target);
+        const isCycleMember = cycleParticipants.has(target);
+        out.push({ name: target, depth: cur.depth + 1, isCycleMember });
+        queue.push({ name: target, depth: cur.depth + 1 });
+      }
+    }
+    return out;
+  };
+  for (const key of cycleKeys) {
+    const rec = itemByKey.get(key);
+    if (!rec) continue;
+    const expanded = alwaysExpanded ? true : props.expandedGroups.has(key);
+    const glyphExpand = expanded ? GLYPH_EXPAND_EXPANDED : GLYPH_EXPAND_COLLAPSED;
+    rows.push({
+      kind: "cycle",
+      key: `cycle:${key}`,
+      label: `${glyphExpand} ${GLYPH_WARN} ${key} (cycle)`,
+      indent: 0,
+      itemIdx: rec.idx,
+      rootName: key
+    });
+    if (!expanded) continue;
+    const subtree = computeCycleMemberSubtree(key);
+    const isLastAtDepthSubtree = (idx) => {
+      const own = subtree[idx].depth;
+      for (let j = idx + 1; j < subtree.length; j++) {
+        const d = subtree[j].depth;
+        if (d < own) return true;
+        if (d === own) return false;
+      }
+      return true;
+    };
+    subtree.forEach((child, i) => {
+      const isLast = isLastAtDepthSubtree(i);
+      const glyph = isLast ? GLYPH_TREE_LAST : GLYPH_TREE_MID;
+      let sharedSuffix = false;
+      if (seenCycleTierChildOccurrence.has(child.name)) sharedSuffix = true;
+      else seenCycleTierChildOccurrence.add(child.name);
+      const childRec = itemByKey.get(child.name);
+      const indent = "  ".repeat(Math.max(0, child.depth - 1));
+      const labelName = child.isCycleMember ? `${GLYPH_WARN} ${child.name} (cycle)` : child.name;
+      rows.push({
+        kind: "group-child",
+        key: `cycle-child:${key}:${child.name}`,
+        label: `${indent}${glyph} ${labelName}${sharedSuffix ? " (shared)" : ""}`,
+        indent: child.depth,
+        sharedSuffix,
+        cycleChild: child.isCycleMember || void 0,
+        itemIdx: childRec?.idx ?? -1,
+        rootName: key
+      });
+    });
+  }
+  for (const key of emptyKeys) {
+    const rec = itemByKey.get(key);
+    if (!rec) continue;
+    rows.push({
+      kind: "empty",
+      key: `empty:${key}`,
+      label: `${key} (empty)`,
+      indent: 0,
+      itemIdx: rec.idx
+    });
+  }
+  const otherKeySet = new Set(otherKeys);
+  const subgraph = graph.filter((n) => otherKeySet.has(n.name));
+  const closures = computeAllClosures(subgraph);
+  const sharedDeps = findSharedDeps(closures);
+  const hasCycleDepDirect = (name) => {
+    const it = itemByKey.get(name)?.it;
+    if (!it) return false;
+    for (const target of allowedComponentNames(it.entry)) {
+      if (cycleParticipants.has(target)) return true;
+    }
+    return false;
+  };
+  const rootNames = [...closures.keys()].sort();
+  const standaloneRoots = [];
+  const groupRoots = [];
+  for (const root of rootNames) {
+    const c2 = closures.get(root);
+    const promotesForCycle = hasCycleDepDirect(root);
+    if (c2.nodes.length <= 1 && !promotesForCycle) standaloneRoots.push(root);
+    else groupRoots.push(root);
+  }
+  const seenSharedOccurrence = /* @__PURE__ */ new Set();
+  const seenCycleChildOccurrence = /* @__PURE__ */ new Set();
+  for (const root of groupRoots) {
+    const closure = closures.get(root);
+    let injectedCycleCount = 0;
+    const seenInject = /* @__PURE__ */ new Set();
+    const countInjections = (parentName) => {
+      const parentItem = itemByKey.get(parentName)?.it;
+      if (!parentItem) return;
+      for (const target of allowedComponentNames(parentItem.entry)) {
+        if (!cycleParticipants.has(target)) continue;
+        const key = `${parentName}\u2192${target}`;
+        if (seenInject.has(key)) continue;
+        seenInject.add(key);
+        injectedCycleCount += 1;
+      }
+    };
+    countInjections(root);
+    for (const n of closure.nodes) if (n.name !== root) countInjections(n.name);
+    const depCount = closure.nodes.length - 1 + injectedCycleCount;
+    const expanded = alwaysExpanded ? true : props.expandedGroups.has(root);
+    const glyphExpand = expanded ? GLYPH_EXPAND_EXPANDED : GLYPH_EXPAND_COLLAPSED;
+    const aggregate = expanded ? null : aggregateGlyphFor(closure, statusByName);
+    const rec = itemByKey.get(root);
+    rows.push({
+      kind: "group-root",
+      key: `root:${root}`,
+      label: `${glyphExpand} ${root} (${depCount} dep${depCount === 1 ? "" : "s"})${aggregate ? " " + aggregate : ""}`,
+      indent: 0,
+      aggregateGlyph: aggregate,
+      itemIdx: rec.idx,
+      rootName: root
+    });
+    if (!expanded) continue;
+    const closureChildren = closure.nodes.filter((n) => n.name !== root).slice().sort((a, b) => a.depth - b.depth || a.name.localeCompare(b.name));
+    const injectedChildren = [];
+    const emitCycleChildrenOf = (parentName, parentDepth) => {
+      const parentItem = itemByKey.get(parentName)?.it;
+      if (!parentItem) return;
+      const seen = /* @__PURE__ */ new Set();
+      for (const target of allowedComponentNames(parentItem.entry)) {
+        if (!cycleParticipants.has(target)) continue;
+        if (seen.has(target)) continue;
+        seen.add(target);
+        injectedChildren.push({
+          name: target,
+          depth: parentDepth + 1,
+          isCycleChild: true
+        });
+      }
+    };
+    emitCycleChildrenOf(root, 0);
+    for (const c2 of closureChildren) {
+      injectedChildren.push({ name: c2.name, depth: c2.depth, isCycleChild: false });
+      emitCycleChildrenOf(c2.name, c2.depth);
+    }
+    const isLastAtDepth = (idx) => {
+      const own = injectedChildren[idx].depth;
+      for (let j = idx + 1; j < injectedChildren.length; j++) {
+        const d = injectedChildren[j].depth;
+        if (d < own) return true;
+        if (d === own) return false;
+      }
+      return true;
+    };
+    injectedChildren.forEach((child, i) => {
+      const isLast = isLastAtDepth(i);
+      const glyph = isLast ? GLYPH_TREE_LAST : GLYPH_TREE_MID;
+      let sharedSuffix = false;
+      if (child.isCycleChild) {
+        if (seenCycleChildOccurrence.has(child.name)) sharedSuffix = true;
+        else seenCycleChildOccurrence.add(child.name);
+      } else if (sharedDeps.has(child.name)) {
+        if (seenSharedOccurrence.has(child.name)) sharedSuffix = true;
+        else seenSharedOccurrence.add(child.name);
+      }
+      const childRec = itemByKey.get(child.name);
+      const indent = "  ".repeat(Math.max(0, child.depth - 1));
+      const labelName = child.isCycleChild ? `${GLYPH_WARN} ${child.name} (cycle)` : child.name;
+      rows.push({
+        kind: "group-child",
+        key: `child:${root}:${child.name}`,
+        label: `${indent}${glyph} ${labelName}${sharedSuffix ? " (shared)" : ""}`,
+        indent: child.depth,
+        sharedSuffix,
+        cycleChild: child.isCycleChild || void 0,
+        itemIdx: childRec?.idx ?? -1,
+        rootName: root
+      });
+    });
+  }
+  for (const name of standaloneRoots) {
+    const rec = itemByKey.get(name);
+    if (!rec) continue;
+    rows.push({
+      kind: "standalone",
+      key: `stand:${name}`,
+      label: name,
+      indent: 0,
+      itemIdx: rec.idx
+    });
+  }
+  const nodeByName = new Map(subgraph.map((n) => [n.name, n]));
+  const sharedLeafNames = [...sharedDeps.keys()].filter((name) => (nodeByName.get(name)?.slots.length ?? 0) === 0).sort();
+  const seenStandaloneNames = new Set(standaloneRoots);
+  for (const name of sharedLeafNames) {
+    if (seenStandaloneNames.has(name)) continue;
+    const rec = itemByKey.get(name);
+    if (!rec) continue;
+    rows.push({
+      kind: "standalone",
+      key: `shared-standalone:${name}`,
+      label: `${name} (shared)`,
+      indent: 0,
+      sharedSuffix: true,
+      itemIdx: rec.idx
+    });
+  }
+  if (showFlatTier) {
+    const flatNames = otherKeys.slice().sort();
+    if (flatNames.length > 0) {
+      rows.push({
+        kind: "flat-header",
+        key: "flat-header",
+        label: "\u2500\u2500 All components \u2500\u2500",
+        indent: 0,
+        itemIdx: -1
+      });
+      for (const name of flatNames) {
+        const rec = itemByKey.get(name);
+        if (!rec) continue;
+        rows.push({
+          kind: "flat",
+          key: `flat:${name}`,
+          label: name,
+          indent: 0,
+          itemIdx: rec.idx
+        });
+      }
+    }
+  }
+  if (filterVisibleKeys !== void 0) {
+    return rows.filter((row) => {
+      if (row.itemIdx < 0) return true;
+      const name = items[row.itemIdx]?.key;
+      if (name === void 0) return true;
+      return filterVisibleKeys.has(name);
+    });
+  }
+  return rows;
+}
+function rowColor(row, aggregate) {
+  if (row.kind === "cycle") return PALETTE2.warning;
+  if (row.kind === "group-child" && row.cycleChild) return PALETTE2.warning;
+  if (row.kind === "empty") return PALETTE2.warning;
+  if (row.kind === "group-root" && aggregate === GLYPH_ERROR) return PALETTE2.error;
+  if (row.kind === "group-root" && aggregate === GLYPH_WARN) return PALETTE2.warning;
+  return void 0;
+}
+function labelStyleFor(input) {
+  const { row, isCursor, wouldDim } = input;
+  if (isCursor) {
+    return { color: PALETTE2.info, bold: true, dim: false };
+  }
+  return {
+    color: rowColor(row, row.aggregateGlyph),
+    bold: false,
+    dim: wouldDim
+  };
+}
+function selectionGlyphStyleFor(selState, isCycleRow) {
+  if (selState === "accepted") {
+    return { glyph: "[\u2713]", color: PALETTE2.success, dim: false, bold: isCycleRow };
+  }
+  if (selState === "rejected") {
+    return { glyph: "[\u2717]", color: PALETTE2.error, dim: false, bold: isCycleRow };
+  }
+  if (selState === "undecided") {
+    return { glyph: "[ ]", color: PALETTE2.muted, dim: !isCycleRow, bold: false };
+  }
+  return { glyph: null, color: void 0, dim: false, bold: false };
+}
+function inheritanceGlyphStyleFor(input) {
+  const { status, isOwn, isCursor } = input;
+  if (status === "error") {
+    return { glyph: GLYPH_ERROR, color: PALETTE2.error, dim: !isCursor && !isOwn, bold: isCursor };
+  }
+  if (status === "warning") {
+    return { glyph: GLYPH_WARN, color: PALETTE2.warning, dim: !isCursor && !isOwn, bold: isCursor };
+  }
+  return { glyph: null, color: void 0, dim: false, bold: false };
+}
+function GroupedSidebar(props) {
+  const {
+    items,
+    cycleParticipants = /* @__PURE__ */ new Set(),
+    expandedGroups,
+    focused,
+    width,
+    title,
+    wrapLabels = false,
+    selectedIdx,
+    selectedRowIdx,
+    renderStatusByKey,
+    previewAnnotationByKey,
+    scrollOffset,
+    visibleCount,
+    alwaysExpanded,
+    showFlatTier,
+    viewMode,
+    selectionStateByKey,
+    aiFlaggedByKey,
+    dimPredicate,
+    visibleRows: providedRows,
+    graph,
+    filterVisibleKeys
+  } = props;
+  const allRows = providedRows ?? buildVisibleRows({
+    items,
+    cycleParticipants,
+    expandedGroups,
+    alwaysExpanded,
+    showFlatTier,
+    viewMode,
+    graph,
+    filterVisibleKeys
+  });
+  const windowed = scrollOffset !== void 0 && visibleCount !== void 0;
+  const start = windowed ? Math.max(0, scrollOffset ?? 0) : 0;
+  const end = windowed ? start + (visibleCount ?? allRows.length) : allRows.length;
+  const rows = windowed ? allRows.slice(start, end) : allRows;
+  return /* @__PURE__ */ jsxs18(WindowedPanel, { width, height: props.height, title, focused, children: [
+    windowed && /* @__PURE__ */ jsx21(WindowIndicator, { direction: "up", count: start }),
+    rows.map((row, i) => {
+      const absoluteRowIdx = start + i;
+      const isSelected = selectedRowIdx !== void 0 ? absoluteRowIdx === selectedRowIdx && row.itemIdx >= 0 : row.itemIdx >= 0 && row.itemIdx === selectedIdx;
+      const itemName = row.itemIdx >= 0 ? items[row.itemIdx]?.key : void 0;
+      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 selState = supportsSelectionGlyph ? selectionStateByKey.get(itemName) ?? "undecided" : void 0;
+      const isCycleRow = row.kind === "cycle";
+      const selStyle = selectionGlyphStyleFor(selState, isCycleRow);
+      const selGlyph = selStyle.glyph;
+      const selColor = selStyle.color;
+      const selDim = selStyle.dim;
+      const selBold = selStyle.bold;
+      const aiFlagged = aiFlaggedByKey !== void 0 && itemName !== void 0 && row.kind !== "flat-header" && aiFlaggedByKey.get(itemName) === true;
+      const canDim = dimPredicate !== void 0 && itemName !== void 0 && row.kind !== "cycle" && row.kind !== "group-root" && row.kind !== "flat-header" && dimPredicate(itemName);
+      const isSynthetic = row.kind === "flat-header";
+      const isCursor = isSelected;
+      const wouldDim = row.kind === "flat-header" || row.sharedSuffix === true || canDim;
+      const labelStyle = labelStyleFor({ row, isCursor, wouldDim });
+      const inheritanceStyle = inheritanceGlyphStyleFor({
+        status: showInheritance ? rs?.status : void 0,
+        isOwn: rs?.isOwn ?? false,
+        isCursor
+      });
+      return /* @__PURE__ */ jsxs18(Box17, { children: [
+        isCursor ? /* @__PURE__ */ jsx21(Text19, { color: PALETTE2.info, bold: true, children: figures4.pointer }) : /* @__PURE__ */ jsx21(Text19, { children: " " }),
+        /* @__PURE__ */ jsx21(PreviewBadge, { badge, highlighted: isSelected }),
+        selectionStateByKey !== void 0 && (selGlyph && !isSynthetic ? /* @__PURE__ */ jsx21(Text19, { color: !isSelected && selDim ? PALETTE2.muted : selColor, bold: selBold, children: " " + selGlyph }) : /* @__PURE__ */ jsx21(Text19, { children: "    " })),
+        aiFlaggedByKey !== void 0 && (aiFlagged ? /* @__PURE__ */ jsx21(Text19, { color: PALETTE2.warning, bold: true, children: " [\xD7]" }) : /* @__PURE__ */ jsx21(Text19, { children: "    " })),
+        /* @__PURE__ */ jsxs18(
+          Text19,
+          {
+            color: isSelected ? PALETTE2.info : labelStyle.dim ? PALETTE2.muted : labelStyle.color,
+            bold: isSelected || labelStyle.bold,
+            inverse: false,
+            underline: isSelected && !focused,
+            wrap: wrapLabels ? "wrap" : "truncate",
+            children: [
+              " ",
+              row.label
+            ]
+          }
+        ),
+        inheritanceStyle.glyph && /* @__PURE__ */ jsx21(Text19, { color: inheritanceStyle.dim ? PALETTE2.muted : inheritanceStyle.color, bold: inheritanceStyle.bold, children: " " + inheritanceStyle.glyph })
+      ] }, row.key);
+    }),
+    windowed && /* @__PURE__ */ jsx21(WindowIndicator, { direction: "down", count: allRows.length - end })
+  ] });
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/sidebar/components/HelpOverlay.tsx
+import React7 from "react";
+import { Box as Box18, Text as Text20 } from "ink";
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/sidebar/hooks/useImmediateInput.ts
+import { useLayoutEffect, useRef as useRef3 } from "react";
+import { useStdin } from "ink";
+function parseInput(data) {
+  const isShiftTab = data === "\x1B[Z";
+  const key = {
+    upArrow: data === "\x1B[A",
+    downArrow: data === "\x1B[B",
+    leftArrow: data === "\x1B[D",
+    rightArrow: data === "\x1B[C",
+    pageDown: data === "\x1B[6~",
+    pageUp: data === "\x1B[5~",
+    return: data === "\r" || data === "\n",
+    escape: data === "\x1B",
+    ctrl: false,
+    shift: isShiftTab,
+    tab: data === "	" || isShiftTab,
+    shiftTab: isShiftTab,
+    backspace: data === "\x7F" || data === "\b",
+    delete: data === "\x1B[3~",
+    meta: data === "\x1B"
+  };
+  let input = data;
+  if (data.length === 1) {
+    const code = data.charCodeAt(0);
+    if (code >= 1 && code <= 26) {
+      key.ctrl = true;
+      input = String.fromCharCode(code + 96);
+    }
+  }
+  if (key.upArrow || key.downArrow || key.leftArrow || key.rightArrow || key.pageUp || key.pageDown || key.return || key.escape || key.tab || key.backspace || key.delete) {
+    if (!key.ctrl) input = "";
+  }
+  return { input, key };
+}
+var inputRegistries = /* @__PURE__ */ new WeakMap();
+function registerInputHandler(stdin, setRawMode, handler) {
+  let registry = inputRegistries.get(stdin);
+  if (!registry) {
+    const handlers = /* @__PURE__ */ new Set();
+    const onData = (data) => {
+      const str = Buffer.isBuffer(data) ? data.toString("utf8") : data;
+      const { input, key } = parseInput(str);
+      for (const registered of [...handlers]) registered(input, key);
+    };
+    registry = { handlers, onData, setRawMode };
+    inputRegistries.set(stdin, registry);
+    setRawMode(true);
+    stdin.on("data", onData);
+  }
+  registry.handlers.add(handler);
+  return () => {
+    const current = inputRegistries.get(stdin);
+    if (!current) return;
+    current.handlers.delete(handler);
+    if (current.handlers.size === 0) {
+      stdin.off("data", current.onData);
+      current.setRawMode(false);
+      inputRegistries.delete(stdin);
+    }
+  };
+}
+function useImmediateInput(handler, enabled = true) {
+  const { stdin, setRawMode } = useStdin();
+  const handlerRef = useRef3(handler);
+  handlerRef.current = handler;
+  useLayoutEffect(() => {
+    if (!enabled) return;
+    const unregister = registerInputHandler(stdin, setRawMode, (input, key) => handlerRef.current(input, key));
+    return unregister;
+  }, [enabled, stdin, setRawMode]);
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/sidebar/hooks/use-terminal-size.ts
+import { useStdout as useStdout2 } from "ink";
+import { useEffect as useEffect6, useState as useState9 } from "react";
+function readTerminalSize(stdout) {
+  return {
+    columns: stdout?.columns ?? 80,
+    rows: stdout?.rows ?? process.stdout.rows ?? 40
+  };
+}
+function useTerminalSize() {
+  const { stdout } = useStdout2();
+  const [size, setSize] = useState9(() => readTerminalSize(stdout));
+  useEffect6(() => {
+    const updateSize = () => setSize(readTerminalSize(stdout));
+    stdout?.on("resize", updateSize);
+    updateSize();
+    return () => {
+      stdout?.off("resize", updateSize);
+    };
+  }, [stdout]);
+  return size;
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/sidebar/components/HelpOverlay.tsx
+import { Fragment as Fragment2, jsx as jsx22, jsxs as jsxs19 } from "react/jsx-runtime";
+function HelpOverlay(props) {
+  const { onClose } = props;
+  const { columns: terminalColumns, rows: terminalRows } = useTerminalSize();
+  const panelWidth = Math.max(10, Math.min(64, terminalColumns - 2));
+  const panelHeight = terminalPanelHeight(terminalRows, 2);
+  const titleRule = Math.max(0, Math.floor((panelWidth - 10) / 2));
+  useImmediateInput((input, key) => {
+    if (input === "h" || key.escape) onClose();
+  }, props.handleInput !== false);
+  if (props.sections) {
+    return /* @__PURE__ */ jsxs19(
+      Box18,
+      {
+        flexDirection: "column",
+        borderStyle: "round",
+        padding: 1,
+        width: panelWidth,
+        height: panelHeight,
+        overflowY: "hidden",
+        children: [
+          /* @__PURE__ */ jsx22(Text20, { bold: true, children: "\u2500".repeat(titleRule) + " Help " + "\u2500".repeat(titleRule) }),
+          props.sections.map((section) => /* @__PURE__ */ jsxs19(React7.Fragment, { children: [
+            /* @__PURE__ */ jsx22(Text20, { children: " " }),
+            /* @__PURE__ */ jsx22(Text20, { bold: true, children: section.title }),
+            section.entries.map((entry) => /* @__PURE__ */ jsx22(Text20, { children: entry.keys ? "  " + entry.keys.padEnd(16) + " " + entry.label : "  " + entry.label }, entry.keys + entry.label))
+          ] }, section.title))
+        ]
+      }
+    );
+  }
+  const mode = props.mode;
+  return /* @__PURE__ */ jsxs19(
+    Box18,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      padding: 1,
+      width: panelWidth,
+      height: panelHeight,
+      overflowY: "hidden",
+      children: [
+        /* @__PURE__ */ jsx22(Text20, { bold: true, children: "\u2500".repeat(titleRule) + " Help " + "\u2500".repeat(titleRule) }),
+        /* @__PURE__ */ jsx22(Text20, { children: " " }),
+        /* @__PURE__ */ jsx22(Text20, { bold: true, children: "Navigation" }),
+        /* @__PURE__ */ jsx22(Text20, { children: "  \u2191 / k / PgUp     Scroll up" }),
+        /* @__PURE__ */ jsx22(Text20, { children: "  \u2193 / j / PgDn     Scroll down" }),
+        /* @__PURE__ */ jsx22(Text20, { children: "  g / Home         Jump to top" }),
+        /* @__PURE__ */ jsx22(Text20, { children: "  G / End          Jump to bottom" }),
+        mode === "review" && /* @__PURE__ */ jsxs19(Fragment2, { children: [
+          /* @__PURE__ */ jsx22(Text20, { children: " " }),
+          /* @__PURE__ */ jsx22(Text20, { bold: true, children: "[Review mode only]" }),
+          /* @__PURE__ */ jsx22(Text20, { children: "  Tab              Toggle sidebar/detail" }),
+          /* @__PURE__ */ jsx22(Text20, { children: "  a                Accept component" }),
+          /* @__PURE__ */ jsx22(Text20, { children: "  r                Reject component" }),
+          /* @__PURE__ */ jsx22(Text20, { children: "  e                Edit proposal" }),
+          /* @__PURE__ */ jsx22(Text20, { children: "  s                Toggle source code" }),
+          /* @__PURE__ */ jsx22(Text20, { children: "  A                Approve all" }),
+          /* @__PURE__ */ jsx22(Text20, { children: "  F                Open finalize dialog" }),
+          /* @__PURE__ */ jsx22(Text20, { children: "  Ctrl+S           Save draft" }),
+          /* @__PURE__ */ jsx22(Text20, { children: "  Ctrl+Z           Undo" }),
+          /* @__PURE__ */ jsx22(Text20, { children: "  Ctrl+Y           Redo" }),
+          /* @__PURE__ */ jsx22(Text20, { children: "  Esc              Exit edit / close" })
+        ] }),
+        /* @__PURE__ */ jsx22(Text20, { children: " " }),
+        /* @__PURE__ */ jsx22(Text20, { children: "  h                Close help" }),
+        /* @__PURE__ */ jsx22(Text20, { children: "  q                Quit" })
+      ]
+    }
+  );
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/sidebar/components/SearchMatchSummary.tsx
+import { Box as Box19, Text as Text21 } from "ink";
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/sidebar/autocomplete.ts
+function longestCommonPrefix(names) {
+  if (names.length === 0) return "";
+  let prefixLen = names[0].length;
+  for (let i = 1; i < names.length; i++) {
+    const other = names[i];
+    let j = 0;
+    while (j < prefixLen && j < other.length && names[0][j].toLowerCase() === other[j].toLowerCase()) {
+      j++;
+    }
+    prefixLen = j;
+    if (prefixLen === 0) break;
+  }
+  return names[0].slice(0, prefixLen);
+}
+function computeAutocomplete(query, names) {
+  const q = query.toLowerCase();
+  const candidates = names.filter((n) => n.toLowerCase().startsWith(q));
+  if (candidates.length === 0) {
+    return { completion: query, candidates: [] };
+  }
+  if (candidates.length === 1) {
+    return { completion: candidates[0], candidates: [] };
+  }
+  const lcp = longestCommonPrefix(candidates);
+  const completion = lcp.length >= query.length ? lcp : query;
+  const sorted = [...candidates].sort();
+  return { completion, candidates: sorted };
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/sidebar/sidebar-input.ts
+function handleSidebarSearchInput(input, key, { query, names, setQuery, setCandidates }) {
+  if (key.tab) {
+    const { completion, candidates } = computeAutocomplete(query, names);
+    setQuery(completion);
+    setCandidates(candidates);
+    return true;
+  }
+  if (key.backspace) {
+    setCandidates([]);
+    setQuery((current) => current.slice(0, -1));
+    return true;
+  }
+  if (input && input.length === 1 && input >= " " && input !== "\r" && input !== "\n") {
+    setCandidates([]);
+    setQuery((current) => current + input);
+    return true;
+  }
+  return false;
+}
+function formatSearchMatchSummary(matches, total) {
+  return `  (${matches}/${total} matches)`;
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/sidebar/components/SearchMatchSummary.tsx
+import { Fragment as Fragment3, jsx as jsx23, jsxs as jsxs20 } from "react/jsx-runtime";
+function SearchMatchSummary({
+  open,
+  query,
+  matches,
+  total,
+  autocompleteCandidates,
+  hidden = false,
+  marginTop
+}) {
+  if (hidden) return null;
+  return /* @__PURE__ */ jsxs20(Fragment3, { children: [
+    open && /* @__PURE__ */ jsxs20(Box19, { marginTop, flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs20(Text21, { children: [
+        `/${query}`,
+        /* @__PURE__ */ jsx23(Text21, { color: PALETTE2.info, children: "\u258E" }),
+        query && /* @__PURE__ */ jsx23(Text21, { color: PALETTE2.muted, children: formatSearchMatchSummary(matches, total) }),
+        /* @__PURE__ */ jsx23(Text21, { children: "  \xB7 [Esc] leave" })
+      ] }),
+      autocompleteCandidates.length > 1 && /* @__PURE__ */ jsx23(Text21, { color: PALETTE2.muted, children: `  possibilities: ${autocompleteCandidates.join(" \xB7 ").slice(0, 120)}` })
+    ] }),
+    !open && query && /* @__PURE__ */ jsx23(Box19, { marginTop, children: /* @__PURE__ */ jsx23(Text21, { children: `/${query}${formatSearchMatchSummary(matches, total)} \xB7 [Esc] clear` }) })
+  ] });
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/sidebar/sidebar-help.ts
+function createSidebarViewsHelpSection(includeBreaking) {
+  const entries = [
+    { keys: "L", label: "Flat view" },
+    { keys: "i", label: "Focus lineage" }
+  ];
+  if (includeBreaking) entries.push({ keys: "w", label: "Only breaking" });
+  entries.push(
+    { keys: "o", label: "Only cycles" },
+    { keys: "space", label: "Expand/collapse group" },
+    { keys: "E / C", label: "Expand/collapse all" }
+  );
+  return { title: "Sidebar views", entries };
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/use-scope-gate.ts
+import { useEffect as useEffect7, useMemo as useMemo2, useRef as useRef4, useState as useState12 } from "react";
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/graph/search-neighborhood.ts
+function computeDirectNeighborhood(matches, graph) {
+  const matchSet = new Set(matches);
+  const out = new Set(matchSet);
+  if (matchSet.size === 0) return out;
+  for (const node of graph) {
+    const targets = [];
+    for (const slot of node.slots) {
+      for (const t of slot.allowedComponents ?? []) targets.push(t);
+    }
+    if (matchSet.has(node.name)) {
+      for (const t of targets) out.add(t);
+    }
+    for (const t of targets) {
+      if (matchSet.has(t)) {
+        out.add(node.name);
+        break;
+      }
+    }
+  }
+  return out;
+}
+function findAllAncestors(target, graph) {
+  const out = /* @__PURE__ */ new Set([target]);
+  const parentsOf = /* @__PURE__ */ new Map();
+  for (const node of graph) {
+    for (const slot of node.slots) {
+      for (const child of slot.allowedComponents ?? []) {
+        const list = parentsOf.get(child);
+        if (list) {
+          if (!list.includes(node.name)) list.push(node.name);
+        } else {
+          parentsOf.set(child, [node.name]);
+        }
+      }
+    }
+  }
+  const queue = [target];
+  while (queue.length > 0) {
+    const cur = queue.shift();
+    const parents = parentsOf.get(cur);
+    if (!parents) continue;
+    for (const p of parents) {
+      if (out.has(p)) continue;
+      out.add(p);
+      queue.push(p);
+    }
+  }
+  return out;
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/graph/fuzzy-search.ts
+function match(query, text) {
+  if (query.length === 0) return { score: 0 };
+  if (text.length === 0) return null;
+  const queryLower = query.toLowerCase();
+  const textLower = text.toLowerCase();
+  let score = 0;
+  let qi = 0;
+  let lastMatchIndex = -2;
+  for (let ti = 0; ti < text.length && qi < query.length; ti++) {
+    if (textLower[ti] === queryLower[qi]) {
+      score += 10;
+      if (text[ti] === query[qi]) {
+        score += 5;
+      }
+      if (ti === 0 && qi === 0) {
+        score += 15;
+      }
+      if (ti === lastMatchIndex + 1) {
+        score += 5;
+      }
+      lastMatchIndex = ti;
+      qi++;
+    }
+  }
+  if (qi < query.length) return null;
+  score -= text.length * 0.1;
+  return { score };
+}
+function fuzzyMatches(query, text) {
+  return match(query, text) !== null;
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/sidebar/ai-flag.ts
+function isAiFlagged(row) {
+  return row.needsReview === true || row.aiDecision === "rejected" || row.aiDecision === "failed";
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/graph/lineage.ts
+function findDirectParents2(target, components) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const c2 of components) {
+    if (c2.name === target) continue;
+    for (const slot of c2.slots) {
+      const allowed = slot.allowedComponents ?? [];
+      if (!allowed.includes(target)) continue;
+      const key = `${c2.name}\0${slot.name}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push({ parent: c2.name, slotName: slot.name });
+    }
+  }
+  out.sort((a, b) => a.parent.localeCompare(b.parent) || a.slotName.localeCompare(b.slotName));
+  return out;
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/graph/scope-gate-cascade.ts
+function buildCycleUnits(slotCycles) {
+  const parent = /* @__PURE__ */ new Map();
+  const find = (x) => {
+    let cur = x;
+    while (parent.get(cur) !== cur) {
+      cur = parent.get(cur);
+    }
+    let walk = x;
+    while (parent.get(walk) !== cur) {
+      const next = parent.get(walk);
+      parent.set(walk, cur);
+      walk = next;
+    }
+    return cur;
+  };
+  const union = (a, b) => {
+    const ra = find(a);
+    const rb = find(b);
+    if (ra !== rb) parent.set(ra, rb);
+  };
+  for (const cycle of slotCycles) {
+    for (const node of cycle.path) {
+      if (!parent.has(node)) parent.set(node, node);
+    }
+    for (let i = 1; i < cycle.path.length; i++) {
+      union(cycle.path[0], cycle.path[i]);
+    }
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const node of parent.keys()) {
+    const root = find(node);
+    let group = groups.get(root);
+    if (!group) {
+      group = /* @__PURE__ */ new Set();
+      groups.set(root, group);
+    }
+    group.add(node);
+  }
+  const out = /* @__PURE__ */ new Map();
+  for (const group of groups.values()) {
+    for (const node of group) {
+      out.set(node, group);
+    }
+  }
+  return out;
+}
+function slotTargets(node, byName) {
+  const c2 = byName.get(node);
+  if (!c2) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const slot of c2.slots) {
+    for (const target of slot.allowedComponents ?? []) {
+      if (!byName.has(target)) continue;
+      if (seen.has(target)) continue;
+      seen.add(target);
+      out.push(target);
+    }
+  }
+  return out;
+}
+function computeCycleAwareAcceptCascade(target, components, cycleUnits) {
+  const byName = new Map(components.map((c2) => [c2.name, c2]));
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [];
+  const enqueue = (name) => {
+    if (visited.has(name)) return;
+    visited.add(name);
+    queue.push(name);
+    const unit = cycleUnits.get(name);
+    if (unit) {
+      for (const member of unit) {
+        if (!visited.has(member)) {
+          visited.add(member);
+          queue.push(member);
+        }
+      }
+    }
+  };
+  enqueue(target);
+  while (queue.length > 0) {
+    const cur = queue.shift();
+    for (const next of slotTargets(cur, byName)) {
+      enqueue(next);
+    }
+  }
+  return visited;
+}
+function computeCycleAwareRejectCascade(target, components, cycleUnits) {
+  const toReject = /* @__PURE__ */ new Set();
+  const targetUnit = cycleUnits.get(target);
+  const initialSeeds = targetUnit ? [...targetUnit] : [target];
+  for (const seed of initialSeeds) toReject.add(seed);
+  const stack = [...toReject];
+  while (stack.length > 0) {
+    const cur = stack.pop();
+    for (const { parent } of findDirectParents2(cur, components)) {
+      if (toReject.has(parent)) continue;
+      toReject.add(parent);
+      stack.push(parent);
+      const unit = cycleUnits.get(parent);
+      if (unit) {
+        for (const member of unit) {
+          if (!toReject.has(member)) {
+            toReject.add(member);
+            stack.push(member);
+          }
+        }
+      }
+    }
+  }
+  const acceptCascade2 = computeCycleAwareAcceptCascade(target, components, cycleUnits);
+  const toDeselect = /* @__PURE__ */ new Set();
+  for (const n of acceptCascade2) {
+    if (toReject.has(n)) continue;
+    toDeselect.add(n);
+  }
+  const cyclePartners = [];
+  if (targetUnit) {
+    for (const m of targetUnit) {
+      if (m !== target) cyclePartners.push(m);
+    }
+    cyclePartners.sort();
+  }
+  return { toReject, toDeselect, cyclePartners };
+}
+function collectReachableCycleUnits(seeds, components, cycleUnits) {
+  const out = /* @__PURE__ */ new Set();
+  if (cycleUnits.size === 0) return out;
+  const byName = new Map(components.map((c2) => [c2.name, c2]));
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [...seeds];
+  while (queue.length > 0) {
+    const cur = queue.shift();
+    if (visited.has(cur)) continue;
+    visited.add(cur);
+    const unit = cycleUnits.get(cur);
+    if (unit) {
+      for (const member of unit) {
+        out.add(member);
+        if (!visited.has(member)) queue.push(member);
+      }
+    }
+    for (const next of slotTargets(cur, byName)) {
+      if (!visited.has(next)) queue.push(next);
+    }
+  }
+  return out;
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/graph/slot-graph.ts
+var REJECTED_STATUSES = /* @__PURE__ */ new Set(["error", "rejected"]);
+function buildComponentGraph3(components, opts) {
+  const stripRejectedEdges = opts?.stripRejectedEdges === true;
+  return components.map((row) => {
+    if (stripRejectedEdges && row.status !== void 0 && REJECTED_STATUSES.has(row.status)) {
+      return { name: row.key, slots: [] };
+    }
+    const slotDefs = row.entry.$slots ?? {};
+    const slots = Object.entries(slotDefs).map(([slotName, slotDef]) => ({
+      name: slotName,
+      allowedComponents: Array.isArray(slotDef?.$allowedComponents) ? slotDef.$allowedComponents.filter((v) => typeof v === "string") : []
+    }));
+    return { name: row.key, slots };
+  });
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/graph/index.ts
+function sidebarItems(components) {
+  return components.map((c2) => ({
+    key: c2.name,
+    entry: toSidebarEntry(c2),
+    status: isAiFlagged(c2) ? "warning" : "ok"
+  }));
+}
+function toSidebarEntry(c2) {
+  const $slots = {};
+  for (const s of c2.slots ?? []) $slots[s.name] = { $allowedComponents: s.allowedComponents };
+  const entry = {
+    $type: "component",
+    $properties: { __scopeGate: { $type: "string", $category: "content" } }
+  };
+  if (Object.keys($slots).length > 0) entry.$slots = $slots;
+  return entry;
+}
+function buildScopeGraph(components) {
+  const nodes = buildComponentGraph3(sidebarItems(components));
+  let cycles;
+  try {
+    cycles = findSlotCycles3(nodes);
+  } catch {
+    cycles = [];
+  }
+  const cycleParticipants = /* @__PURE__ */ new Set();
+  for (const cycle of cycles) for (const name of cycle.path) cycleParticipants.add(name);
+  return {
+    nodes,
+    cycles,
+    cycleParticipants,
+    cycleUnits: buildCycleUnits(cycles),
+    closures: computeAllClosures(nodes)
+  };
+}
+function acceptCascade(graph, target) {
+  return [...computeCycleAwareAcceptCascade(target, graph.nodes, graph.cycleUnits)];
+}
+function rejectCascade(graph, target) {
+  const { toReject, toDeselect } = computeCycleAwareRejectCascade(target, graph.nodes, graph.cycleUnits);
+  return { toReject: [...toReject], toDeselect: [...toDeselect] };
+}
+function reachableCycleMembers(graph, seeds) {
+  return [...collectReachableCycleUnits(seeds, graph.nodes, graph.cycleUnits)];
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/keymap.ts
+var NONE = { type: "none" };
+function resolveKey(mode, key, ctx) {
+  switch (mode) {
+    case "help":
+      return key.input === "h" || key.escape ? { type: "close-help" } : NONE;
+    case "reject-prompt":
+      if (key.input === "y" || key.input === "Y") return { type: "answer-reject-prompt", confirm: true };
+      if (key.input === "n" || key.input === "N" || key.escape) return { type: "answer-reject-prompt", confirm: false };
+      return NONE;
+    case "search":
+      if (key.escape) return { type: "close-search" };
+      if (key.return) return { type: "submit-search" };
+      return { type: "search-input" };
+    case "cycles":
+      if (key.escape || key.input === "c") return { type: "close-panel" };
+      if (key.upArrow) return { type: "move", delta: -1 };
+      if (key.downArrow) return { type: "move", delta: 1 };
+      if (key.return) return { type: "jump-to-selected" };
+      return NONE;
+    case "flags":
+      if (key.upArrow) return { type: "move", delta: -1 };
+      if (key.downArrow) return { type: "move", delta: 1 };
+      if (key.return) return { type: "jump-to-selected" };
+      return NONE;
+    case "main":
+      return resolveMain(key, ctx);
+  }
+}
+function resolveMain(key, ctx) {
+  const { input } = key;
+  const inMain = ctx.focusedColumn === "main";
+  if (input === "q" || key.escape) {
+    if (key.escape && ctx.jumpFilterActive) return { type: "clear-jump-filter" };
+    if (key.escape && ctx.searchActive) return { type: "clear-search" };
+    return { type: "quit" };
+  }
+  if (input === "h") return { type: "open-panel", panel: "help" };
+  if (input === "f" || input === "F") return { type: "confirm" };
+  if (input === "c") return ctx.hasCycles ? { type: "open-panel", panel: "cycles" } : NONE;
+  if (input === "d") return { type: "toggle-dependencies" };
+  if (input === "x") return ctx.hasFlagReasons ? { type: "open-panel", panel: "flags" } : NONE;
+  if (input === "/") return { type: "open-panel", panel: "search" };
+  if (input === "o") return ctx.hasCycles ? { type: "toggle-cycle-filter" } : NONE;
+  if (input === "i" && !key.tab && !key.ctrl) return { type: "toggle-jump-filter" };
+  if (input === " ") return inMain ? { type: "toggle-group" } : NONE;
+  if (input === "E") return inMain ? { type: "expand-all" } : NONE;
+  if (input === "C") return inMain ? { type: "collapse-all" } : NONE;
+  if (input === "a") return inMain ? { type: "accept" } : NONE;
+  if (input === "r") return { type: "reject" };
+  if (input === "L") return { type: "toggle-view" };
+  if (input === "A") return { type: "toggle-all" };
+  if (input === "Y") return { type: "accept-unflagged" };
+  if (key.tab) {
+    if (ctx.singleColumn) return NONE;
+    return { type: "switch-column", delta: key.shiftTab ? -1 : 1 };
+  }
+  if (key.return) return inMain ? NONE : { type: "jump-to-selected" };
+  if (key.upArrow) return ctx.focusedListEmpty ? NONE : { type: "move", delta: -1 };
+  if (key.downArrow) return ctx.focusedListEmpty ? NONE : { type: "move", delta: 1 };
+  return NONE;
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/sidebar/group-collapse.ts
+function resolveGroupRoot(key, closures, cycleSet) {
+  if (cycleSet.has(key)) return key;
+  if (closures.has(key)) return key;
+  for (const [root, closure] of closures.entries()) {
+    if (closure.nodes.some((n) => n.name === key)) return root;
+  }
+  return void 0;
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/sidebar/hooks/sidebar-search-state.ts
+import { useState as useState10 } from "react";
+function useSidebarSearchState() {
+  const [searchOpen, setSearchOpen] = useState10(false);
+  const [searchQuery, setSearchQuery] = useState10("");
+  const [autocompleteCandidates, setAutocompleteCandidates] = useState10([]);
+  const [jumpFilterTarget, setJumpFilterTarget] = useState10(null);
+  const [columnOneView, setColumnOneView] = useState10("grouped");
+  const [activeFilters, setActiveFilters] = useState10(/* @__PURE__ */ new Set());
+  const [showHelp, setShowHelp] = useState10(false);
+  return {
+    searchOpen,
+    setSearchOpen,
+    searchQuery,
+    setSearchQuery,
+    autocompleteCandidates,
+    setAutocompleteCandidates,
+    jumpFilterTarget,
+    setJumpFilterTarget,
+    columnOneView,
+    setColumnOneView,
+    activeFilters,
+    setActiveFilters,
+    showHelp,
+    setShowHelp
+  };
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/sidebar/hooks/useOverlayPanel.ts
+import { useCallback, useState as useState11 } from "react";
+function useOverlayPanel(opts) {
+  const { toggleKey, onClose } = opts;
+  const [isOpen, setIsOpen] = useState11(false);
+  const open = useCallback(() => {
+    setIsOpen(true);
+  }, []);
+  const close = useCallback(() => {
+    setIsOpen((prev) => {
+      if (prev && onClose) onClose();
+      return false;
+    });
+  }, [onClose]);
+  const handleInput = useCallback(
+    (input, key) => {
+      if (!isOpen) return false;
+      if (input === toggleKey || key.escape === true) {
+        if (onClose) onClose();
+        setIsOpen(false);
+        return true;
+      }
+      return false;
+    },
+    [isOpen, toggleKey, onClose]
+  );
+  return { isOpen, open, close, handleInput };
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/sidebar/lineage-layout.ts
+var VISIBLE_COUNT = 200;
+var MAX_PANEL_ROWS = 200;
+var SIDEBAR_MIN = 4;
+var MIN_PANEL_ROWS = 4;
+var FALLBACK_ROWS = 40;
+var HEADER_ROWS = 2;
+var COUNTER_STRIP_ROWS = 2;
+var FOCUSED_DETAIL_ROWS = 2;
+var LEGEND_ROWS = 3;
+var FIXED_OVERHEAD = HEADER_ROWS + COUNTER_STRIP_ROWS + FOCUSED_DETAIL_ROWS + LEGEND_ROWS;
+var PANEL_BOX_CHROME = 6;
+var BASE_CHROME_OVERHEAD = 18;
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function computeLineageLayout({ rows, panelOpen, entryCount }) {
+  const sidebarVisible = clamp(rows - BASE_CHROME_OVERHEAD, SIDEBAR_MIN, VISIBLE_COUNT);
+  if (!panelOpen) {
+    return { sidebarVisible, panelMaxRows: MAX_PANEL_ROWS };
+  }
+  const terminalFit = rows - FIXED_OVERHEAD - PANEL_BOX_CHROME;
+  let panelBase = Math.min(MAX_PANEL_ROWS, terminalFit);
+  if (entryCount !== void 0 && entryCount > 0) {
+    panelBase = Math.min(panelBase, entryCount);
+  }
+  const panelMaxRows = clamp(panelBase, MIN_PANEL_ROWS, MAX_PANEL_ROWS);
+  return { sidebarVisible, panelMaxRows };
+}
+function computeSidebarBudget({ rows, panelOpen, entryCount }) {
+  const sidebarVisibleCount = clamp(rows - BASE_CHROME_OVERHEAD, SIDEBAR_MIN, VISIBLE_COUNT);
+  const { panelMaxRows } = computeLineageLayout({ rows, panelOpen, entryCount });
+  return { sidebarVisibleCount, panelMaxRows };
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/sidebar/sidebar-navigation.ts
+function collectExpandedGroupRoots(closures, cycleParticipants) {
+  const roots = /* @__PURE__ */ new Set();
+  for (const [name, closure] of closures.entries()) {
+    if (closure.nodes.length > 1) roots.add(name);
+  }
+  for (const name of cycleParticipants) roots.add(name);
+  return roots;
+}
+function computeSidebarViewToggle({
+  currentView,
+  currentKey,
+  currentScroll,
+  visibleCount,
+  items,
+  cycleParticipants,
+  expandedGroups,
+  graph,
+  showFlatTier = false
+}) {
+  const view = currentView === "grouped" ? "flat" : "grouped";
+  const rows = buildVisibleRows({
+    items,
+    cycleParticipants,
+    expandedGroups,
+    showFlatTier,
+    viewMode: view,
+    graph
+  });
+  let cursor = 0;
+  if (currentKey) {
+    for (let i = 0; i < rows.length; i++) {
+      const row = rows[i];
+      if (row.itemIdx < 0) continue;
+      if (items[row.itemIdx]?.key === currentKey) {
+        cursor = i;
+        break;
+      }
+    }
+  }
+  const scroll = cursor < currentScroll ? cursor : cursor >= currentScroll + visibleCount ? cursor - visibleCount + 1 : currentScroll;
+  return { view, cursor, scroll };
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/sidebar/step-filters.ts
+function computeFilterKeys(input) {
+  const active = new Set(input.filters);
+  if (active.size === 0) return void 0;
+  const out = /* @__PURE__ */ new Set();
+  if (active.has("cycles")) for (const k of input.data.cycles ?? []) out.add(k);
+  if (active.has("broken")) for (const k of input.data.broken ?? []) out.add(k);
+  if (active.has("deleted")) for (const k of input.data.deleted ?? []) out.add(k);
+  return out;
+}
+function intersectFilterKeys(a, b) {
+  if (a === void 0) return b;
+  if (b === void 0) return a;
+  const out = /* @__PURE__ */ new Set();
+  for (const k of a) if (b.has(k)) out.add(k);
+  return out;
+}
+function buildFlatDimPredicate(input) {
+  const hasSearch = input.searchQuery.length > 0;
+  const isFlat = input.viewMode === "flat";
+  const keys = isFlat ? input.filterVisibleKeys : void 0;
+  if (!hasSearch && keys === void 0) return void 0;
+  return (name) => {
+    if (hasSearch && !fuzzyMatches(input.searchQuery, name)) return true;
+    if (keys !== void 0 && !keys.has(name)) return true;
+    return false;
+  };
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/state.ts
+function apply(state, entries) {
+  const next = new Map(state);
+  for (const [name, decision] of entries) next.set(name, decision);
+  return next;
+}
+function reduceDecisions(state, action, components, graph) {
+  switch (action.type) {
+    case "accept": {
+      if (state.get(action.name) === "accepted") return state;
+      return apply(
+        state,
+        acceptCascade(graph, action.name).map((name) => [name, "accepted"])
+      );
+    }
+    case "reject": {
+      if (state.get(action.name) === "rejected") return state;
+      const { toReject, toDeselect } = rejectCascade(graph, action.name);
+      return apply(state, [
+        ...toReject.map((name) => [name, "rejected"]),
+        ...toDeselect.map((name) => [name, "undecided"])
+      ]);
+    }
+    case "toggle-all": {
+      const nonCycle = components.filter((c2) => !graph.cycleParticipants.has(c2.name)).map((c2) => c2.name);
+      const anyNotAccepted = nonCycle.some((name) => state.get(name) !== "accepted");
+      if (anyNotAccepted) {
+        return apply(state, [
+          ...nonCycle.map((name) => [name, "accepted"]),
+          ...reachableCycleMembers(graph, nonCycle).map((name) => [name, "accepted"])
+        ]);
+      }
+      return apply(state, [
+        ...nonCycle.map((name) => [name, "rejected"]),
+        ...components.filter((c2) => graph.cycleParticipants.has(c2.name) && state.get(c2.name) === "accepted").map((c2) => [c2.name, "undecided"])
+      ]);
+    }
+    case "accept-unflagged": {
+      const seeds = components.filter((c2) => !graph.cycleParticipants.has(c2.name) && !isAiFlagged(c2)).map((c2) => c2.name);
+      return apply(state, [
+        ...seeds.map((name) => [name, "accepted"]),
+        ...reachableCycleMembers(graph, seeds).map((name) => [name, "accepted"])
+      ]);
+    }
+  }
+}
+function rejectNeedsConfirmation(graph, name, state) {
+  if (state.get(name) === "rejected") return false;
+  const { toReject, toDeselect } = rejectCascade(graph, name);
+  const ancestors = toReject.filter((n) => n !== name);
+  return ancestors.length + toDeselect.length >= 2;
+}
+function partitionDecisions(components, state) {
+  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 };
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/use-scope-gate.ts
+function useScopeGate({ components, onConfirm, onQuit }) {
+  const { columns: totalWidth, rows: terminalRows } = useTerminalSize();
+  const columnPlan = useMemo2(() => computeColumnWidths(totalWidth), [totalWidth]);
+  const [decisions, setDecisions] = useState12(/* @__PURE__ */ new Map());
+  const [nav, setNav] = useState12({ cursor: 0, scrollOffset: 0 });
+  const [focusedColumn, setFocusedColumn] = useState12("main");
+  const [addedComponentsCursor, setAddedComponentsCursor] = useState12(0);
+  const [showDependencies, setShowDependencies] = useState12(false);
+  const [cyclesPanelOpen, setCyclesPanelOpen] = useState12(false);
+  const [cyclesCursor, setCyclesCursor] = useState12(0);
+  const aiRationalePanel = useOverlayPanel({ toggleKey: "x" });
+  const [aiCursor, setAiCursor] = useState12(0);
+  const [pendingRejectCascade, setPendingRejectCascade] = useState12(null);
+  const search = useSidebarSearchState();
+  const {
+    searchOpen,
+    setSearchOpen,
+    searchQuery,
+    setSearchQuery,
+    setAutocompleteCandidates,
+    jumpFilterTarget,
+    setJumpFilterTarget,
+    columnOneView,
+    setColumnOneView,
+    activeFilters,
+    setActiveFilters,
+    showHelp,
+    setShowHelp
+  } = search;
+  const groupedItems = useMemo2(() => sidebarItems(components), [components]);
+  const graph = useMemo2(() => buildScopeGraph(components), [components]);
+  const { cycles: slotCycles, cycleParticipants, cycleUnits, closures } = graph;
+  const hasCycles = slotCycles.length > 0;
+  const cyclesJumpables = useMemo2(
+    () => slotCycles.map((c2, i) => ({ cycleIndex: i, jumpTarget: c2.path[0] })),
+    [slotCycles]
+  );
+  const [expandedGroups, setExpandedGroups] = useState12(() => {
+    const seed = new Set(closures.keys());
+    for (const p of cycleParticipants) seed.add(p);
+    return seed;
+  });
+  const seededGroupsRef = useRef4(closures.size > 0 || cycleParticipants.size > 0);
+  useEffect7(() => {
+    if (seededGroupsRef.current) return;
+    if (closures.size === 0 && cycleParticipants.size === 0) return;
+    seededGroupsRef.current = true;
+    const seed = new Set(closures.keys());
+    for (const p of cycleParticipants) seed.add(p);
+    setExpandedGroups(seed);
+  }, [closures, cycleParticipants]);
+  const hasGroupRoots = useMemo2(() => {
+    if (cycleParticipants.size > 0) return true;
+    for (const c2 of closures.values()) if (c2.nodes.length > 1) return true;
+    return false;
+  }, [closures, cycleParticipants]);
+  const toggleExpanded = (rootName) => {
+    setExpandedGroups((prev) => {
+      const next = new Set(prev);
+      if (next.has(rootName)) next.delete(rootName);
+      else next.add(rootName);
+      return next;
+    });
+  };
+  const brokenKeys = useMemo2(() => new Set(components.filter(isAiFlagged).map((c2) => c2.name)), [components]);
+  const dependencyFilterKeys = useMemo2(() => {
+    if (!showDependencies) return void 0;
+    const keys = /* @__PURE__ */ new Set();
+    for (const [root, closure] of closures) {
+      if (closure.nodes.length <= 1 || decisions.get(root) !== "accepted") continue;
+      for (const node of closure.nodes) keys.add(node.name);
+    }
+    for (const unit of cycleUnits.values()) {
+      if (![...unit].some((name) => decisions.get(name) === "accepted")) continue;
+      for (const name of unit) keys.add(name);
+    }
+    return keys;
+  }, [closures, cycleUnits, showDependencies, decisions]);
+  const filterVisibleKeys = useMemo2(() => {
+    if (jumpFilterTarget) return findAllAncestors(jumpFilterTarget, graph.nodes);
+    const categoryKeys = computeFilterKeys({
+      filters: activeFilters,
+      data: { cycles: cycleParticipants, broken: brokenKeys }
+    });
+    const searchKeys = (() => {
+      if (!searchQuery) return void 0;
+      const matches = groupedItems.map((it) => it.key).filter((k) => fuzzyMatches(searchQuery, k));
+      if (matches.length === 0) return void 0;
+      return computeDirectNeighborhood(matches, graph.nodes);
+    })();
+    return intersectFilterKeys(intersectFilterKeys(categoryKeys, searchKeys), dependencyFilterKeys);
+  }, [
+    jumpFilterTarget,
+    activeFilters,
+    cycleParticipants,
+    brokenKeys,
+    searchQuery,
+    groupedItems,
+    graph,
+    dependencyFilterKeys
+  ]);
+  const visibleRows = useMemo2(
+    () => buildVisibleRows({
+      items: groupedItems,
+      cycleParticipants,
+      expandedGroups,
+      showFlatTier: false,
+      viewMode: columnOneView,
+      graph: graph.nodes,
+      filterVisibleKeys
+    }),
+    [groupedItems, cycleParticipants, expandedGroups, columnOneView, graph, filterVisibleKeys]
+  );
+  const total = visibleRows.length;
+  const safeCursor = Math.min(nav.cursor, Math.max(0, total - 1));
+  const currentRow = visibleRows[safeCursor];
+  const currentRowKey = currentRow && currentRow.itemIdx >= 0 ? groupedItems[currentRow.itemIdx]?.key : void 0;
+  const selectionStateByKey = useMemo2(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const c2 of components) map.set(c2.name, decisions.get(c2.name) ?? "undecided");
+    return map;
+  }, [components, decisions]);
+  const aiFlaggedByKey = useMemo2(() => new Map(components.map((c2) => [c2.name, isAiFlagged(c2)])), [components]);
+  const dimPredicate = useMemo2(
+    () => buildFlatDimPredicate({ viewMode: columnOneView, searchQuery, filterVisibleKeys }),
+    [columnOneView, searchQuery, filterVisibleKeys]
+  );
+  const { sidebarVisibleCount: visibleCount, panelMaxRows } = computeSidebarBudget({
+    rows: terminalRows || FALLBACK_ROWS,
+    panelOpen: false,
+    entryCount: 0
+  });
+  const panelLayout = useMemo2(() => computePanelLayout(visibleCount), [visibleCount]);
+  useEffect7(() => {
+    setNav((prev) => {
+      const maxIdx = Math.max(0, visibleRows.length - 1);
+      const nextCursor = Math.min(prev.cursor, maxIdx);
+      const nextScroll = Math.min(prev.scrollOffset, maxIdx);
+      if (nextCursor === prev.cursor && nextScroll === prev.scrollOffset) return prev;
+      return { cursor: nextCursor, scrollOffset: nextScroll };
+    });
+  }, [visibleRows]);
+  const searchMatches = useMemo2(() => {
+    if (!searchQuery) return [];
+    return components.filter((c2) => fuzzyMatches(searchQuery, c2.name)).map((c2) => c2.name);
+  }, [components, searchQuery]);
+  const aiExcluded = components.filter(isAiFlagged);
+  const aiRows = useMemo2(
+    () => aiExcluded.filter((c2) => c2.aiReason !== null && c2.aiReason !== void 0 && c2.aiReason !== "").map((c2) => ({ label: `${c2.name} \u2014 ${c2.aiReason}`, jumpTarget: c2.name })),
+    [aiExcluded]
+  );
+  const addedComponents = useMemo2(
+    () => buildAddedComponentsList(components, selectionStateByKey, cycleParticipants),
+    [components, selectionStateByKey, cycleParticipants]
+  );
+  const counters = useMemo2(
+    () => computeCounters(components, closures, selectionStateByKey),
+    [components, closures, selectionStateByKey]
+  );
+  const safeAddedComponentsCursor = Math.min(addedComponentsCursor, Math.max(0, addedComponents.length - 1));
+  const focusedRowKey = () => {
+    const row = visibleRows[safeCursor];
+    if (!row) return void 0;
+    switch (row.kind) {
+      case "standalone":
+      case "empty":
+      case "group-root":
+      case "group-child":
+      case "flat":
+      case "cycle":
+        return row.itemIdx >= 0 ? groupedItems[row.itemIdx]?.key : void 0;
+      default:
+        return void 0;
+    }
+  };
+  const jumpCursorTo = (name) => {
+    let idx = -1;
+    for (let i = 0; i < visibleRows.length; i++) {
+      const row = visibleRows[i];
+      if (row.itemIdx < 0) continue;
+      if (groupedItems[row.itemIdx]?.key === name) {
+        idx = i;
+        break;
+      }
+    }
+    if (idx < 0) return;
+    setNav(({ scrollOffset: prev }) => {
+      let nextScroll = prev;
+      if (idx < prev) nextScroll = idx;
+      else if (idx >= prev + visibleCount) nextScroll = idx - visibleCount + 1;
+      return { cursor: idx, scrollOffset: nextScroll };
+    });
+  };
+  const decide = (action) => setDecisions((prev) => reduceDecisions(prev, action, components, graph));
+  const requestReject = (name) => {
+    if (decisions.get(name) === "rejected") return;
+    if (rejectNeedsConfirmation(graph, name, decisions)) {
+      const { toReject, toDeselect } = rejectCascade(graph, name);
+      setPendingRejectCascade({
+        target: name,
+        ancestors: toReject.filter((n) => n !== name).sort(),
+        descendants: [...toDeselect].sort()
+      });
+      return;
+    }
+    decide({ type: "reject", name });
+  };
+  const mode = showHelp ? "help" : pendingRejectCascade ? "reject-prompt" : searchOpen ? "search" : cyclesPanelOpen ? "cycles" : aiRationalePanel.isOpen ? "flags" : "main";
+  const context = {
+    focusedColumn,
+    singleColumn: columnPlan.layout === "single",
+    hasCycles,
+    hasFlagReasons: aiRows.length > 0,
+    jumpFilterActive: jumpFilterTarget !== null,
+    searchActive: searchQuery.length > 0,
+    focusedListEmpty: focusedColumn === "added-components" ? addedComponents.length === 0 : total === 0
+  };
+  const submitSearch = () => {
+    const closeSearch = () => {
+      setSearchOpen(false);
+      setSearchQuery("");
+      setAutocompleteCandidates([]);
+    };
+    if (!searchQuery || searchMatches.length === 0) {
+      closeSearch();
+      return;
+    }
+    const cursorName = currentRow && currentRow.itemIdx >= 0 ? groupedItems[currentRow.itemIdx]?.key : void 0;
+    const rowName = (i) => {
+      const r = visibleRows[i];
+      return r && r.itemIdx >= 0 ? groupedItems[r.itemIdx]?.key : void 0;
+    };
+    let target;
+    for (let i = safeCursor; i < visibleRows.length && !target; i++) {
+      const n = rowName(i);
+      if (n && n !== cursorName && fuzzyMatches(searchQuery, n)) target = n;
+    }
+    for (let i = 0; i < visibleRows.length && !target; i++) {
+      const n = rowName(i);
+      if (n && fuzzyMatches(searchQuery, n)) target = n;
+    }
+    if (target) jumpCursorTo(target);
+    setSearchOpen(false);
+  };
+  const move = (delta) => {
+    if (mode === "cycles") {
+      setCyclesCursor((c2) => Math.max(0, Math.min(Math.max(0, cyclesJumpables.length - 1), c2 + delta)));
+      return;
+    }
+    if (mode === "flags") {
+      setAiCursor((c2) => Math.max(0, Math.min(Math.max(0, aiRows.length - 1), c2 + delta)));
+      return;
+    }
+    if (focusedColumn === "added-components") {
+      setAddedComponentsCursor((c2) => Math.max(0, Math.min(addedComponents.length - 1, c2 + delta)));
+      return;
+    }
+    setNav(({ cursor: c2, scrollOffset: prev }) => {
+      if (delta < 0) {
+        const next2 = c2 <= 0 ? 0 : c2 - 1;
+        return { cursor: next2, scrollOffset: Math.min(prev, next2) };
+      }
+      const next = c2 >= total - 1 ? total - 1 : c2 + 1;
+      return { cursor: next, scrollOffset: next >= prev + visibleCount ? next - visibleCount + 1 : prev };
+    });
+  };
+  const perform = (action) => {
+    switch (action.type) {
+      case "none":
+        return;
+      case "quit":
+        onQuit();
+        return;
+      case "confirm":
+        onConfirm(partitionDecisions(components, decisions));
+        return;
+      case "close-help":
+        setShowHelp(false);
+        return;
+      case "answer-reject-prompt":
+        if (action.confirm && pendingRejectCascade) decide({ type: "reject", name: pendingRejectCascade.target });
+        setPendingRejectCascade(null);
+        return;
+      case "close-panel":
+        setCyclesPanelOpen(false);
+        return;
+      case "close-search":
+        setSearchOpen(false);
+        setSearchQuery("");
+        setAutocompleteCandidates([]);
+        return;
+      case "submit-search":
+        submitSearch();
+        return;
+      case "search-input":
+        return;
+      case "clear-jump-filter":
+        setJumpFilterTarget(null);
+        return;
+      case "clear-search":
+        setSearchQuery("");
+        setAutocompleteCandidates([]);
+        return;
+      case "move":
+        move(action.delta);
+        return;
+      case "jump-to-selected":
+        if (mode === "cycles") {
+          const target = cyclesJumpables[cyclesCursor];
+          if (target) jumpCursorTo(target.jumpTarget);
+          setCyclesPanelOpen(false);
+        } else if (mode === "flags") {
+          const row = aiRows[aiCursor];
+          if (row) jumpCursorTo(row.jumpTarget);
+          aiRationalePanel.close();
+        } else {
+          const entry = addedComponents[safeAddedComponentsCursor];
+          if (entry) jumpCursorTo(entry.name);
+          setFocusedColumn("main");
+        }
+        return;
+      case "accept": {
+        const key = focusedRowKey();
+        if (key) decide({ type: "accept", name: key });
+        return;
+      }
+      case "reject": {
+        const key = focusedColumn === "added-components" ? addedComponents[safeAddedComponentsCursor]?.name : focusedRowKey();
+        if (key) requestReject(key);
+        return;
+      }
+      case "toggle-all":
+        decide({ type: "toggle-all" });
+        return;
+      case "accept-unflagged":
+        decide({ type: "accept-unflagged" });
+        return;
+      case "toggle-group": {
+        const key = focusedRowKey();
+        const rootName = key ? resolveGroupRoot(key, closures, cycleParticipants) : void 0;
+        if (rootName) toggleExpanded(rootName);
+        return;
+      }
+      case "expand-all":
+        setExpandedGroups(collectExpandedGroupRoots(closures, cycleParticipants));
+        return;
+      case "collapse-all":
+        setExpandedGroups(/* @__PURE__ */ new Set());
+        return;
+      case "switch-column": {
+        const order = ["main", "added-components"];
+        const at = order.indexOf(focusedColumn);
+        setFocusedColumn(order[(at + action.delta + order.length) % order.length]);
+        return;
+      }
+      case "open-panel":
+        if (action.panel === "help") setShowHelp(true);
+        else if (action.panel === "search") setSearchOpen(true);
+        else if (action.panel === "cycles") {
+          setCyclesPanelOpen(true);
+          setCyclesCursor(0);
+          aiRationalePanel.close();
+        } else {
+          aiRationalePanel.open();
+          setAiCursor(0);
+          setCyclesPanelOpen(false);
+        }
+        return;
+      case "toggle-dependencies":
+        setShowDependencies((current) => !current);
+        setNav({ cursor: 0, scrollOffset: 0 });
+        return;
+      case "toggle-cycle-filter":
+        setActiveFilters((prev) => {
+          const next = new Set(prev);
+          if (next.has("cycles")) next.delete("cycles");
+          else next.add("cycles");
+          return next;
+        });
+        return;
+      case "toggle-jump-filter": {
+        const target = focusedColumn === "main" ? focusedRowKey() : addedComponents[safeAddedComponentsCursor]?.name;
+        if (target) setJumpFilterTarget((prev) => prev === target ? null : target);
+        return;
+      }
+      case "toggle-view": {
+        const next = computeSidebarViewToggle({
+          currentView: columnOneView,
+          currentKey: currentRowKey,
+          currentScroll: nav.scrollOffset,
+          visibleCount,
+          items: groupedItems,
+          cycleParticipants,
+          expandedGroups,
+          graph: graph.nodes
+        });
+        setColumnOneView(next.view);
+        setNav({ cursor: next.cursor, scrollOffset: next.scroll });
+        return;
+      }
+    }
+  };
+  useImmediateInput((input, key) => {
+    if (mode === "flags" && aiRationalePanel.handleInput(input, key)) return;
+    if (mode === "search") {
+      const action = resolveKey(mode, { input, ...key }, context);
+      if (action.type === "search-input") {
+        handleSidebarSearchInput(input, key, {
+          query: searchQuery,
+          names: components.map((c2) => c2.name),
+          setQuery: setSearchQuery,
+          setCandidates: setAutocompleteCandidates
+        });
+        return;
+      }
+      perform(action);
+      return;
+    }
+    perform(resolveKey(mode, { input, ...key }, context));
+  });
+  return {
+    // layout
+    totalWidth,
+    columnPlan,
+    panelLayout,
+    visibleCount,
+    panelMaxRows,
+    // sidebar
+    groupedItems,
+    graph,
+    hasGroupRoots,
+    expandedGroups,
+    toggleExpanded,
+    visibleRows,
+    safeCursor,
+    scrollOffset: nav.scrollOffset,
+    selectionStateByKey,
+    aiFlaggedByKey,
+    dimPredicate,
+    columnOneView,
+    focusedColumn,
+    // panels
+    showHelp,
+    closeHelp: () => setShowHelp(false),
+    cyclesPanelOpen,
+    cyclesCursor,
+    slotCycles,
+    aiRationalePanelOpen: aiRationalePanel.isOpen,
+    aiCursor,
+    aiRows,
+    aiExcludedCount: aiExcluded.length,
+    pendingRejectCascade,
+    // added column
+    addedComponents,
+    safeAddedComponentsCursor,
+    counters,
+    // search
+    search,
+    searchMatches
+  };
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/screen.tsx
+import { Fragment as Fragment4, jsx as jsx24, jsxs as jsxs21 } from "react/jsx-runtime";
+var HELP_SECTIONS = [
+  {
+    title: "Navigation",
+    entries: [
+      { keys: "\u2191 / \u2193", label: "Move cursor" },
+      { keys: "Tab / Shift-Tab", label: "Switch column" },
+      { keys: "Enter", label: "Jump to row in main column" }
+    ]
+  },
+  {
+    title: "Selection",
+    entries: [
+      { keys: "a", label: "Accept" },
+      { keys: "r", label: "Reject" },
+      { keys: "A", label: "Toggle all" },
+      { keys: "Y", label: "Accept non-flagged" }
+    ]
+  },
+  createSidebarViewsHelpSection(false),
+  {
+    title: "Panels",
+    entries: [
+      { keys: "c", label: "Cycle list" },
+      { keys: "d", label: "Show slot dependencies in main list" },
+      { keys: "x", label: "Review flags" }
+    ]
+  },
+  { title: "Search", entries: [{ keys: "/", label: "Search" }] },
+  {
+    title: "General",
+    entries: [
+      { keys: "f", label: "Continue" },
+      { keys: "h", label: "Close help" },
+      { keys: "q", label: "Quit" }
+    ]
+  }
+];
+function ScopeGateScreen(props) {
+  if (props.components.length === 0) {
+    return /* @__PURE__ */ jsx24(Box20, { paddingX: 2, paddingY: 1, children: /* @__PURE__ */ jsx24(Text22, { color: PALETTE2.error, children: "Error: no components found for this session \u2014 please re-run analyze extract." }) });
+  }
+  return /* @__PURE__ */ jsx24(ScopeGateView, { ...props });
+}
+function ScopeGateView({ components, onConfirm, onQuit }) {
+  const gate = useScopeGate({ components, onConfirm, onQuit });
+  const { search, graph, columnPlan, panelLayout, counters } = gate;
+  if (gate.showHelp) {
+    return /* @__PURE__ */ jsx24(HelpOverlay, { sections: HELP_SECTIONS, handleInput: false, onClose: gate.closeHelp });
+  }
+  return /* @__PURE__ */ jsxs21(Box20, { flexDirection: "column", paddingX: 2, children: [
+    /* @__PURE__ */ jsxs21(Box20, { flexDirection: "row", flexWrap: "wrap", children: [
+      /* @__PURE__ */ jsx24(CounterStrip, { counters, totalWidth: gate.totalWidth }),
+      gate.aiExcludedCount > 0 && /* @__PURE__ */ jsxs21(Text22, { color: PALETTE2.muted, children: [
+        `${gate.aiExcludedCount} component${gate.aiExcludedCount === 1 ? "" : "s"} flagged by AI`,
+        gate.aiRows.length > 0 && /* @__PURE__ */ jsx24(Text22, { color: PALETTE2.info, children: " \u2014 press [x] to see why" })
+      ] })
+    ] }),
+    graph.cycles.length > 0 && /* @__PURE__ */ jsx24(Box20, { marginTop: 1, children: /* @__PURE__ */ jsx24(Text22, { color: PALETTE2.muted, children: "If you must have components with cycles, select them together into the generate step and then use the editor to fix them." }) }),
+    /* @__PURE__ */ jsxs21(Box20, { flexDirection: "row", alignItems: "stretch", children: [
+      gate.aiRationalePanelOpen ? /* @__PURE__ */ jsx24(
+        GotoBanner,
+        {
+          title: `Review flags (${gate.aiExcludedCount})`,
+          rows: gate.aiRows,
+          cursor: gate.aiCursor,
+          maxRows: gate.panelMaxRows,
+          width: columnPlan.main,
+          footerHint: "[\u2191/\u2193] move \xB7 [Enter] jump \xB7 [x/Esc] close"
+        }
+      ) : /* @__PURE__ */ jsx24(
+        GroupedSidebar,
+        {
+          items: gate.groupedItems,
+          cycleParticipants: graph.cycleParticipants,
+          selectedIdx: gate.visibleRows[gate.safeCursor]?.itemIdx ?? -1,
+          selectedRowIdx: gate.safeCursor,
+          onSelect: () => {
+          },
+          expandedGroups: gate.expandedGroups,
+          onToggleExpanded: gate.toggleExpanded,
+          width: columnPlan.main,
+          height: panelLayout.height,
+          title: "All components",
+          wrapLabels: true,
+          focused: gate.focusedColumn === "main",
+          scrollOffset: gate.scrollOffset,
+          visibleCount: gate.visibleCount,
+          showFlatTier: false,
+          selectionStateByKey: gate.selectionStateByKey,
+          aiFlaggedByKey: gate.aiFlaggedByKey,
+          dimPredicate: gate.dimPredicate,
+          visibleRows: gate.visibleRows,
+          viewMode: gate.columnOneView,
+          graph: graph.nodes
+        }
+      ),
+      columnPlan.layout === "two-column" && /* @__PURE__ */ jsxs21(Fragment4, { children: [
+        /* @__PURE__ */ jsx24(Box20, { width: 2, flexShrink: 0 }),
+        /* @__PURE__ */ jsx24(
+          AddedColumn,
+          {
+            width: columnPlan.added,
+            entries: gate.addedComponents,
+            cursor: gate.safeAddedComponentsCursor,
+            focused: gate.focusedColumn === "added-components",
+            height: panelLayout.height,
+            title: `Accepted Components (${counters.accepted}/${counters.total})`,
+            aiFlaggedByKey: gate.aiFlaggedByKey,
+            visibleCount: panelLayout.sideVisibleCount
+          }
+        )
+      ] })
+    ] }),
+    gate.cyclesPanelOpen && /* @__PURE__ */ jsx24(CyclesPanel, { cycles: gate.slotCycles, cursor: gate.cyclesCursor }),
+    gate.pendingRejectCascade && /* @__PURE__ */ jsx24(RejectPrompt, { pending: gate.pendingRejectCascade }),
+    /* @__PURE__ */ jsx24(
+      SearchMatchSummary,
+      {
+        open: search.searchOpen,
+        query: search.searchQuery,
+        matches: search.searchQuery ? gate.searchMatches.length : 0,
+        total: components.length,
+        autocompleteCandidates: search.autocompleteCandidates,
+        marginTop: 1
+      }
+    ),
+    /* @__PURE__ */ jsx24(
+      CompactControlBar,
+      {
+        hasGroupRoots: gate.hasGroupRoots,
+        searchActive: search.searchOpen || search.searchQuery.length > 0
+      }
+    )
+  ] });
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/use-scope-gate-flow.ts
+import { useEffect as useEffect8, useMemo as useMemo3, useRef as useRef5, useState as useState13 } from "react";
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/cache-check.ts
+import { execFile as execFile3 } from "node:child_process";
+function buildCacheCheckArgs(input) {
+  const args = ["__generate", "components", "--agent", input.agent, "--session", input.sessionId];
+  if (input.tokensPath) args.push("--tokens", input.tokensPath);
+  if (input.agentModel) args.push("--model", input.agentModel);
+  if (input.noCache) args.push("--no-cache");
+  for (const prompt of input.promptOverrides) args.push("--prompt", prompt);
+  if (input.existingEntitiesPath) args.push("--existing-entities-path", input.existingEntitiesPath);
+  args.push("--cache-status", "--restore-cache");
+  return args;
+}
+function parseCacheComponents(stdout) {
+  const line = /^cache-components=(.+)$/m.exec(stdout)?.[1];
+  if (!line) return [];
+  try {
+    const names = JSON.parse(line);
+    return Array.isArray(names) ? names.filter((name) => typeof name === "string") : [];
+  } catch {
+    return [];
+  }
+}
+var runLegacyCli = (args) => new Promise((resolve10) => {
+  execFile3("node", [findLegacyCliPath(), ...args], (error, stdout, stderr) => {
+    resolve10({ exitCode: error?.code ? Number(error.code) : 0, stdout, stderr });
+  });
+});
+async function checkGenerationCache(input, run2 = runLegacyCli) {
+  if (input.noCache) return [];
+  try {
+    const result = await run2(buildCacheCheckArgs(input));
+    if (result.exitCode !== 0) return [];
+    return parseCacheComponents(result.stdout);
+  } catch {
+    return [];
+  }
+}
+
+// packages/experience-design-system-cli/src/tui/import/steps/07-scope-gate/load.ts
+function loadScopeGate(sessionId) {
+  try {
+    const db = openPipelineDb();
+    try {
+      const components = loadScopeComponents(db, sessionId);
+      if (components.length === 0) {
+        return { ok: false, message: "No components found for this session. Please run the import again." };
+      }
+      return { ok: true, components };
+    } finally {
+      db.close();
+    }
+  } catch (error) {
+    return {
+      ok: false,
+      message: `Could not read the extracted components: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+
+// 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 sessionId = input?.sessionId;
+  const loaded = useMemo3(() => sessionId ? deps.load(sessionId) : void 0, [sessionId]);
+  const cacheCheck = useRef5(void 0);
+  const [confirmed, setConfirmed] = useState13();
+  const [scope, setScope] = useState13();
+  useEffect8(() => {
+    if (!input || !loaded?.ok || cacheCheck.current) return;
+    cacheCheck.current = deps.checkCache(input.cache);
+  }, [input, loaded]);
+  useEffect8(() => {
+    if (!confirmed || !cacheCheck.current) return;
+    let current = true;
+    void cacheCheck.current.then((cachedNames) => {
+      const accepted = new Set(confirmed.accepted);
+      if (current) setScope({ ...confirmed, cachedNames: cachedNames.filter((name) => accepted.has(name)) });
+    });
+    return () => {
+      current = false;
+    };
+  }, [confirmed]);
+  if (!input || !loaded) return void 0;
+  if (!loaded.ok) return { status: "failed", message: loaded.message };
+  if (scope) return { status: "confirmed", scope };
+  if (confirmed) return { status: "preparing" };
+  return { status: "deciding", load: loaded, confirm: setConfirmed };
+}
+
+// packages/experience-design-system-cli/src/tui/import/spawn-v1-import.ts
+import { spawn as spawn7 } from "node:child_process";
+
+// packages/experience-design-system-cli/src/commands/import-options.ts
+function importOptionArgs(options) {
+  return [
+    ...options.agent ? ["--agent", options.agent] : [],
+    ...options.prompt.flatMap((value) => ["--prompt", value]),
+    ...options.cache ? [] : ["--no-cache"]
+  ];
+}
+
+// packages/experience-design-system-types/dist/src/handoff/index.js
+import * as z5 from "zod/mini";
+var HANDOFF_ENV = "EDS_IMPORT_HANDOFF";
+var NonEmpty = z5.string().check(z5.minLength(1));
+var TokensSchema = z5.object({
+  /**
+   * What to do about an existing `tokens.json`.
+   * reuse: keep it. regenerate: build it again with the cache off. generate: nothing was asked, build it as usual.
+   */
+  strategy: z5.enum(["reuse", "regenerate", "generate"])
+});
+var ExtractionSchema = z5.object({
+  sessionId: NonEmpty,
+  outDir: NonEmpty,
+  tokensPath: z5.string(),
+  tokenSessionId: z5.nullable(z5.string()),
+  tokenCount: z5.number(),
+  existingEntitiesPath: z5.nullable(z5.string()),
+  /** Never 'running': the wizard starts its background cache check only once this has settled. */
+  existingEntitiesStatus: z5.enum(["idle", "complete", "failed"]),
+  /** The only phases the scope gate can start from. */
+  compositionPhase: z5.enum(["done", "cache-hit"])
+});
+var ScopeSchema = z5.object({
+  /** The components the user kept at the scope gate. The wizard saves these, then generates them. */
+  accepted: z5.array(z5.string()),
+  /** Everything else at the gate, which counts as rejected. */
+  rejected: z5.array(z5.string()),
+  /**
+   * Components the generation cache already holds, found by the check that ran while the gate was open and which has
+   * finished (and restored them) before the wizard starts. Empty when the cache is off or the check failed.
+   */
+  cachedNames: z5.array(z5.string())
+});
+var ImportHandoffSchema = z5.object({
+  /** The user skipped the credentials screen, so nothing is fetched from or pushed to Contentful. */
+  credentialsSkipped: z5.boolean(),
+  tokens: TokensSchema,
+  /** Present once the CLI has run the extraction stage; the wizard then starts at the scope gate. */
+  extraction: z5.optional(ExtractionSchema),
+  /** Present once the user has confirmed the scope gate; the wizard then saves the decisions and starts generating. */
+  scope: z5.optional(ScopeSchema)
+});
+function serializeHandoff(handoff) {
+  return JSON.stringify(handoff);
+}
+
+// packages/experience-design-system-cli/src/tui/import/spawn-v1-import.ts
+function buildArgs2(options) {
+  const args = ["import"];
+  if (options.projectPath) {
+    args.push("--project", options.projectPath);
+  }
+  if (options.tokens) {
+    args.push("--tokens", options.tokens);
+  }
+  args.push(...importOptionArgs({ agent: options.agent, prompt: options.prompt ?? [], cache: options.cache ?? true }));
+  return args;
+}
+function buildEnv(options, base = process.env) {
+  return { ...base, ...options.handoff ? { [HANDOFF_ENV]: serializeHandoff(options.handoff) } : {} };
+}
+async function spawnV1Import(options = {}) {
+  const cliPath = findLegacyCliPath();
+  const args = buildArgs2(options);
+  return new Promise((resolvePromise) => {
+    const child = spawn7("node", [cliPath, ...args], {
+      stdio: "inherit",
+      env: buildEnv(options)
+    });
+    child.on("close", (code) => {
+      resolvePromise({ exitCode: code ?? 1, result: void 0, stdout: "", stderr: "" });
+    });
+    child.on("error", (err) => {
+      resolvePromise({ exitCode: 1, result: void 0, stdout: "", stderr: err.message });
+    });
+  });
+}
+
+// packages/experience-design-system-cli/src/tui/import/terminal-input.ts
+function getTerminalHandle() {
+  return process.stdin._handle;
+}
+async function stopReadingTerminal() {
+  await new Promise((resolve10) => setImmediate(resolve10));
+  const handle = getTerminalHandle();
+  if (!handle?.readStop) return;
+  handle.reading = false;
+  handle.readStop();
+}
+function startReadingTerminal() {
+  const handle = getTerminalHandle();
+  if (!handle?.readStart) return;
+  handle.reading = true;
+  handle.readStart();
+}
+
+// packages/experience-design-system-cli/src/tui/help/PageContainer.tsx
+import { useEffect as useEffect9, useState as useState14 } from "react";
+import { Box as Box21, Text as Text23, useInput as useInput9 } from "ink";
+
+// packages/experience-design-system-cli/src/tui/debug-store.ts
+import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
+import { existsSync as existsSync5, readdirSync as readdirSync2 } from "node:fs";
+import { join as join12 } from "node:path";
+
+// packages/experience-design-system-cli/src/tui/settings/debug-mode/debug-mode-store.ts
+var DEFAULT_DEBUG_MODE_SETTING = {
+  enabled: true
+};
+async function readDebugModeSetting() {
+  const { debugMode } = await readSettings2();
+  return { ...DEFAULT_DEBUG_MODE_SETTING, ...debugMode };
+}
+async function writeDebugModeSetting(setting) {
+  await updateSettings2({ debugMode: setting });
+}
+
+// packages/experience-design-system-cli/src/tui/debug-store.ts
+var pendingRun;
+function generateRunId() {
+  const now = /* @__PURE__ */ new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+}
+function datePrefix(now = /* @__PURE__ */ new Date()) {
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${pad(now.getMonth() + 1)}-${pad(now.getDate())}-${now.getFullYear()}`;
+}
+function slugify(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function generateSessionId3() {
+  const today = datePrefix();
+  const root = debugSessionsDir2();
+  const existing = existsSync5(root) ? readdirSync2(root) : [];
+  const seqPattern = new RegExp(`^${today}-session-(\\d+)$`);
+  const maxSeq = existing.reduce((max, entry) => {
+    const match2 = seqPattern.exec(entry);
+    return match2 ? Math.max(max, Number(match2[1])) : max;
+  }, 0);
+  return `${today}-session-${maxSeq + 1}`;
+}
+var SESSION_ID = generateSessionId3();
+function sessionDebugDir() {
+  return join12(debugSessionsDir2(), SESSION_ID);
+}
+function currentDebugSessionDir() {
+  return sessionDebugDir();
+}
+void isDebugModeEnabled().then((enabled) => {
+  if (!enabled) return void 0;
+  return mkdir3(sessionDebugDir(), { recursive: true });
+});
+async function isDebugModeEnabled() {
+  try {
+    return (await readDebugModeSetting()).enabled;
+  } catch {
+    return true;
+  }
+}
+function redact(value) {
+  const clone = { ...value };
+  if ("cma_token" in clone) {
+    const raw = clone.cma_token;
+    clone.cma_token = typeof raw === "string" && raw.length > 0 ? `[present, ${raw.length} chars]` : "[not set]";
+  }
+  return clone;
+}
+function startDebugRun({
+  flow,
+  step,
+  menuOption,
+  inputs
+}) {
+  const runId = generateRunId();
+  const startedAt = Date.now();
+  const redactedInputs = redact(inputs);
+  isDebugModeEnabled().then((enabled) => {
+    if (!enabled) return;
+    pendingRun = { flow, step, runId, menuOption, inputs: redactedInputs, startedAt };
+  });
+}
+async function finishDebugRun({
+  outputs,
+  status,
+  exitMethod
+}) {
+  const run2 = pendingRun;
   if (!run2) return;
   pendingRun = void 0;
   const durationMs = Date.now() - run2.startedAt;
@@ -6896,8 +9719,8 @@ function nextAttemptFilename(dir, menuOption) {
   const existing = existsSync5(dir) ? readdirSync2(dir) : [];
   const attemptPattern = new RegExp(`^${today}-${optionSlug}-attempt-(\\d+)\\.md$`);
   const maxAttempt = existing.reduce((max, entry) => {
-    const match = attemptPattern.exec(entry);
-    return match ? Math.max(max, Number(match[1])) : max;
+    const match2 = attemptPattern.exec(entry);
+    return match2 ? Math.max(max, Number(match2[1])) : max;
   }, 0);
   return `${today}-${optionSlug}-attempt-${maxAttempt + 1}.md`;
 }
@@ -6971,19 +9794,19 @@ async function readHelpInfo() {
 }
 
 // packages/experience-design-system-cli/src/tui/help/PageContainer.tsx
-import { Fragment as Fragment2, jsx as jsx13, jsxs as jsxs10 } from "react/jsx-runtime";
+import { Fragment as Fragment5, jsx as jsx25, jsxs as jsxs22 } from "react/jsx-runtime";
 function Section({ title, rows }) {
-  return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx13(Text11, { bold: true, color: PALETTE.accent, children: title }),
-    rows.map((row) => /* @__PURE__ */ jsxs10(Box10, { gap: 1, children: [
-      /* @__PURE__ */ jsx13(Box10, { width: 14, flexShrink: 0, children: /* @__PURE__ */ jsx13(Text11, { color: PALETTE.muted, children: row.label }) }),
-      /* @__PURE__ */ jsx13(Text11, { children: row.value })
+  return /* @__PURE__ */ jsxs22(Box21, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx25(Text23, { bold: true, color: PALETTE.accent, children: title }),
+    rows.map((row) => /* @__PURE__ */ jsxs22(Box21, { gap: 1, children: [
+      /* @__PURE__ */ jsx25(Box21, { width: 14, flexShrink: 0, children: /* @__PURE__ */ jsx25(Text23, { color: PALETTE.muted, children: row.label }) }),
+      /* @__PURE__ */ jsx25(Text23, { children: row.value })
     ] }, row.label))
   ] });
 }
 function HelpScreen({ onDone }) {
-  const [info, setInfo] = useState9();
-  useEffect6(() => {
+  const [info, setInfo] = useState14();
+  useEffect9(() => {
     startDebugRun({ flow: "help", step: "01-help", menuOption: "Help", inputs: {} });
     void readHelpInfo().then(setInfo);
   }, []);
@@ -7001,14 +9824,14 @@ function HelpScreen({ onDone }) {
       return;
     }
   });
-  return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", paddingX: 2, paddingY: 1, gap: 1, children: [
-    /* @__PURE__ */ jsx13(Text11, { bold: true, children: "Help" }),
-    info ? /* @__PURE__ */ jsxs10(Fragment2, { children: [
-      /* @__PURE__ */ jsx13(Section, { title: "Where things are stored", rows: info.storage }),
-      /* @__PURE__ */ jsx13(Section, { title: "Troubleshooting", rows: info.troubleshooting }),
-      /* @__PURE__ */ jsx13(Text11, { color: PALETTE.muted, children: "Hit a problem? Turn on Debug Mode in Settings, reproduce it, then share the session folder above. The CMA token is redacted from those logs." })
-    ] }) : /* @__PURE__ */ jsx13(Text11, { color: PALETTE.accent, children: "Loading..." }),
-    /* @__PURE__ */ jsx13(
+  return /* @__PURE__ */ jsxs22(Box21, { flexDirection: "column", paddingX: 2, paddingY: 1, gap: 1, children: [
+    /* @__PURE__ */ jsx25(Text23, { bold: true, children: "Help" }),
+    info ? /* @__PURE__ */ jsxs22(Fragment5, { children: [
+      /* @__PURE__ */ jsx25(Section, { title: "Where things are stored", rows: info.storage }),
+      /* @__PURE__ */ jsx25(Section, { title: "Troubleshooting", rows: info.troubleshooting }),
+      /* @__PURE__ */ jsx25(Text23, { color: PALETTE.muted, children: "Hit a problem? Turn on Debug Mode in Settings, reproduce it, then share the session folder above. The CMA token is redacted from those logs." })
+    ] }) : /* @__PURE__ */ jsx25(Text23, { color: PALETTE.accent, children: "Loading..." }),
+    /* @__PURE__ */ jsx25(
       ControlHints,
       {
         hints: [
@@ -7021,14 +9844,14 @@ function HelpScreen({ onDone }) {
 }
 
 // packages/experience-design-system-cli/src/tui/settings/PageContainer.tsx
-import { useState as useState10 } from "react";
-import { Box as Box11, Text as Text12, useInput as useInput10 } from "ink";
-import { jsx as jsx14, jsxs as jsxs11 } from "react/jsx-runtime";
+import { useState as useState15 } from "react";
+import { Box as Box22, Text as Text24, useInput as useInput10 } from "ink";
+import { jsx as jsx26, jsxs as jsxs23 } from "react/jsx-runtime";
 function SettingsScreen({
   onNavigate,
   onBack
 }) {
-  const [focusIdx, setFocusIdx] = useState10(0);
+  const [focusIdx, setFocusIdx] = useState15(0);
   const items = [
     { label: "Configuration", screen: "settings-configuration" },
     { label: "Opt-in Analytics", screen: "settings-opt-in-analytics" },
@@ -7054,15 +9877,15 @@ function SettingsScreen({
       onBack();
     }
   });
-  return /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
-    /* @__PURE__ */ jsx14(Text12, { bold: true, children: "Settings" }),
-    /* @__PURE__ */ jsx14(Text12, { children: " " }),
-    items.map((item, i) => /* @__PURE__ */ jsxs11(Text12, { color: i === focusIdx ? "cyan" : void 0, children: [
+  return /* @__PURE__ */ jsxs23(Box22, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
+    /* @__PURE__ */ jsx26(Text24, { bold: true, children: "Settings" }),
+    /* @__PURE__ */ jsx26(Text24, { children: " " }),
+    items.map((item, i) => /* @__PURE__ */ jsxs23(Text24, { color: i === focusIdx ? "cyan" : void 0, children: [
       i === focusIdx ? "> " : "  ",
       item.label
     ] }, item.label)),
-    /* @__PURE__ */ jsx14(Text12, { children: " " }),
-    /* @__PURE__ */ jsx14(
+    /* @__PURE__ */ jsx26(Text24, { children: " " }),
+    /* @__PURE__ */ jsx26(
       ControlHints,
       {
         hints: [
@@ -7076,8 +9899,8 @@ function SettingsScreen({
 }
 
 // packages/experience-design-system-cli/src/tui/settings/contentful-configuration/ContentfulConfigScreen.tsx
-import { useEffect as useEffect7, useState as useState11 } from "react";
-import { Box as Box12, Text as Text13, useInput as useInput11 } from "ink";
+import { useEffect as useEffect10, useState as useState16 } from "react";
+import { Box as Box23, Text as Text25, useInput as useInput11 } from "ink";
 import TextInput4 from "ink-text-input";
 
 // packages/experience-design-system-cli/src/tui/settings/utils/v1-store.ts
@@ -7109,7 +9932,7 @@ async function writeCredentials(config) {
 }
 
 // packages/experience-design-system-cli/src/tui/settings/contentful-configuration/ContentfulConfigScreen.tsx
-import { Fragment as Fragment3, jsx as jsx15, jsxs as jsxs12 } from "react/jsx-runtime";
+import { Fragment as Fragment6, jsx as jsx27, jsxs as jsxs24 } from "react/jsx-runtime";
 var FIELD_ORDER = [
   "spaceId",
   "environmentId",
@@ -7137,14 +9960,14 @@ var FIELD_LABELS = {
   defaultTokenFile: "Default token file (optional)"
 };
 function ConfigurationScreen({ onDone }) {
-  const [stage, setStage] = useState11("loading");
-  const [config, setConfig] = useState11(null);
-  const [activeField, setActiveField] = useState11("spaceId");
-  const [notice, setNotice] = useState11(null);
-  const [lastSaved, setLastSaved] = useState11(null);
-  const [editing, setEditing] = useState11(false);
-  const [valueBeforeEdit, setValueBeforeEdit] = useState11("");
-  useEffect7(() => {
+  const [stage, setStage] = useState16("loading");
+  const [config, setConfig] = useState16(null);
+  const [activeField, setActiveField] = useState16("spaceId");
+  const [notice, setNotice] = useState16(null);
+  const [lastSaved, setLastSaved] = useState16(null);
+  const [editing, setEditing] = useState16(false);
+  const [valueBeforeEdit, setValueBeforeEdit] = useState16("");
+  useEffect10(() => {
     readCredentials().then((cfg) => {
       setConfig(cfg);
       setStage("form");
@@ -7221,26 +10044,26 @@ function ConfigurationScreen({ onDone }) {
     }
   });
   if (stage === "loading") {
-    return /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
-      /* @__PURE__ */ jsx15(Text13, { bold: true, children: "Configuration" }),
-      /* @__PURE__ */ jsx15(Text13, { children: " " }),
-      /* @__PURE__ */ jsx15(Text13, { color: PALETTE.accent, children: "Loading..." })
+    return /* @__PURE__ */ jsxs24(Box23, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
+      /* @__PURE__ */ jsx27(Text25, { bold: true, children: "Configuration" }),
+      /* @__PURE__ */ jsx27(Text25, { children: " " }),
+      /* @__PURE__ */ jsx27(Text25, { color: PALETTE.accent, children: "Loading..." })
     ] });
   }
-  return /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
-    /* @__PURE__ */ jsx15(Text13, { bold: true, children: "Configuration" }),
-    /* @__PURE__ */ jsx15(Text13, { children: " " }),
-    /* @__PURE__ */ jsx15(Box12, { flexDirection: "column", children: FIELD_ORDER.map((field) => {
+  return /* @__PURE__ */ jsxs24(Box23, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
+    /* @__PURE__ */ jsx27(Text25, { bold: true, children: "Configuration" }),
+    /* @__PURE__ */ jsx27(Text25, { children: " " }),
+    /* @__PURE__ */ jsx27(Box23, { flexDirection: "column", children: FIELD_ORDER.map((field) => {
       const isActive = activeField === field;
       const value = fieldValue(field);
       const display = field === "cmaToken" ? "\u2022".repeat(value.length) : value;
-      return /* @__PURE__ */ jsxs12(Box12, { gap: 1, children: [
-        /* @__PURE__ */ jsx15(Text13, { color: isActive ? PALETTE.accent : void 0, children: isActive ? "\u276F" : " " }),
-        /* @__PURE__ */ jsxs12(Text13, { bold: isActive, children: [
+      return /* @__PURE__ */ jsxs24(Box23, { gap: 1, children: [
+        /* @__PURE__ */ jsx27(Text25, { color: isActive ? PALETTE.accent : void 0, children: isActive ? "\u276F" : " " }),
+        /* @__PURE__ */ jsxs24(Text25, { bold: isActive, children: [
           FIELD_LABELS[field],
           ":"
         ] }),
-        isActive && editing ? /* @__PURE__ */ jsx15(
+        isActive && editing ? /* @__PURE__ */ jsx27(
           TextInput4,
           {
             value,
@@ -7248,19 +10071,19 @@ function ConfigurationScreen({ onDone }) {
             onSubmit: () => setEditing(false),
             mask: field === "cmaToken" ? "\u2022" : void 0
           }
-        ) : /* @__PURE__ */ jsx15(Text13, { children: display || /* @__PURE__ */ jsx15(Text13, { color: PALETTE.muted, children: "(empty)" }) })
+        ) : /* @__PURE__ */ jsx27(Text25, { children: display || /* @__PURE__ */ jsx27(Text25, { color: PALETTE.muted, children: "(empty)" }) })
       ] }, field);
     }) }),
-    notice && /* @__PURE__ */ jsxs12(Fragment3, { children: [
-      /* @__PURE__ */ jsx15(Text13, { children: " " }),
-      /* @__PURE__ */ jsxs12(Text13, { color: notice.kind === "success" ? PALETTE.success : PALETTE.error, children: [
+    notice && /* @__PURE__ */ jsxs24(Fragment6, { children: [
+      /* @__PURE__ */ jsx27(Text25, { children: " " }),
+      /* @__PURE__ */ jsxs24(Text25, { color: notice.kind === "success" ? PALETTE.success : PALETTE.error, children: [
         notice.kind === "success" ? "\u2713" : "\u2717",
         " ",
         notice.text
       ] })
     ] }),
-    /* @__PURE__ */ jsx15(Text13, { children: " " }),
-    /* @__PURE__ */ jsx15(
+    /* @__PURE__ */ jsx27(Text25, { children: " " }),
+    /* @__PURE__ */ jsx27(
       ControlHints,
       {
         hints: editing ? [
@@ -7281,8 +10104,8 @@ function ConfigurationScreen({ onDone }) {
 }
 
 // packages/experience-design-system-cli/src/tui/settings/opt-in-analytics/screen.tsx
-import { useEffect as useEffect8, useState as useState12 } from "react";
-import { Box as Box13, Text as Text14, useInput as useInput12 } from "ink";
+import { useEffect as useEffect11, useState as useState17 } from "react";
+import { Box as Box24, Text as Text26, useInput as useInput12 } from "ink";
 
 // packages/experience-design-system-cli/src/tui/settings/opt-in-analytics/analytics-store.ts
 async function readAnalyticsSetting() {
@@ -7300,11 +10123,11 @@ async function writeAnalyticsSetting(setting) {
 }
 
 // packages/experience-design-system-cli/src/tui/settings/opt-in-analytics/screen.tsx
-import { Fragment as Fragment4, jsx as jsx16, jsxs as jsxs13 } from "react/jsx-runtime";
+import { Fragment as Fragment7, jsx as jsx28, jsxs as jsxs25 } from "react/jsx-runtime";
 function OptInAnalyticsScreen({ onDone }) {
-  const [loading, setLoading] = useState12(true);
-  const [enabled, setEnabled] = useState12(true);
-  useEffect8(() => {
+  const [loading, setLoading] = useState17(true);
+  const [enabled, setEnabled] = useState17(true);
+  useEffect11(() => {
     readAnalyticsSetting().then((setting) => {
       setEnabled(setting.enabled);
       setLoading(false);
@@ -7331,21 +10154,21 @@ function OptInAnalyticsScreen({ onDone }) {
       onDone();
     }
   });
-  return /* @__PURE__ */ jsxs13(Box13, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
-    /* @__PURE__ */ jsx16(Text14, { bold: true, children: "Settings \u203A Opt-in Analytics" }),
-    /* @__PURE__ */ jsx16(Text14, { children: " " }),
-    loading ? /* @__PURE__ */ jsx16(Text14, { color: PALETTE.muted, children: "Loading\u2026" }) : /* @__PURE__ */ jsxs13(Fragment4, { children: [
-      /* @__PURE__ */ jsxs13(Text14, { children: [
+  return /* @__PURE__ */ jsxs25(Box24, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
+    /* @__PURE__ */ jsx28(Text26, { bold: true, children: "Settings \u203A Opt-in Analytics" }),
+    /* @__PURE__ */ jsx28(Text26, { children: " " }),
+    loading ? /* @__PURE__ */ jsx28(Text26, { color: PALETTE.muted, children: "Loading\u2026" }) : /* @__PURE__ */ jsxs25(Fragment7, { children: [
+      /* @__PURE__ */ jsxs25(Text26, { children: [
         "Share anonymous usage data:",
         " ",
-        /* @__PURE__ */ jsx16(Text14, { bold: true, color: enabled ? PALETTE.success : PALETTE.muted, children: enabled ? "On" : "Off" })
+        /* @__PURE__ */ jsx28(Text26, { bold: true, color: enabled ? PALETTE.success : PALETTE.muted, children: enabled ? "On" : "Off" })
       ] }),
-      /* @__PURE__ */ jsx16(Text14, { children: " " }),
-      /* @__PURE__ */ jsx16(Text14, { color: PALETTE.muted, children: "Shares which CLI commands are used and where imports succeed or fail." }),
-      /* @__PURE__ */ jsx16(Text14, { color: PALETTE.muted, children: "Never includes source code, file paths, credentials, or authored content." })
+      /* @__PURE__ */ jsx28(Text26, { children: " " }),
+      /* @__PURE__ */ jsx28(Text26, { color: PALETTE.muted, children: "Shares which CLI commands are used and where imports succeed or fail." }),
+      /* @__PURE__ */ jsx28(Text26, { color: PALETTE.muted, children: "Never includes source code, file paths, credentials, or authored content." })
     ] }),
-    /* @__PURE__ */ jsx16(Text14, { children: " " }),
-    /* @__PURE__ */ jsx16(
+    /* @__PURE__ */ jsx28(Text26, { children: " " }),
+    /* @__PURE__ */ jsx28(
       ControlHints,
       {
         hints: [
@@ -7358,13 +10181,13 @@ function OptInAnalyticsScreen({ onDone }) {
 }
 
 // packages/experience-design-system-cli/src/tui/upgrade/PageContainer.tsx
-import { useEffect as useEffect9, useState as useState13 } from "react";
-import { Box as Box14, Text as Text15, useInput as useInput13 } from "ink";
-import { jsx as jsx17, jsxs as jsxs14 } from "react/jsx-runtime";
+import { useEffect as useEffect12, useState as useState18 } from "react";
+import { Box as Box25, Text as Text27, useInput as useInput13 } from "ink";
+import { jsx as jsx29, jsxs as jsxs26 } from "react/jsx-runtime";
 var UPGRADE_COMMANDS = ["git pull", "pnpm install", "pnpm build"];
 function UpgradeScreen({ onDone }) {
-  const [upgradeCheck, setUpgradeCheck] = useState13();
-  useEffect9(() => {
+  const [upgradeCheck, setUpgradeCheck] = useState18();
+  useEffect12(() => {
     startDebugRun({
       flow: "upgrade",
       step: "01-upgrade",
@@ -7384,12 +10207,12 @@ function UpgradeScreen({ onDone }) {
       return;
     }
   });
-  return /* @__PURE__ */ jsxs14(Box14, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
-    /* @__PURE__ */ jsx17(Text15, { bold: true, children: "Upgrade" }),
-    /* @__PURE__ */ jsx17(Text15, { children: " " }),
+  return /* @__PURE__ */ jsxs26(Box25, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
+    /* @__PURE__ */ jsx29(Text27, { bold: true, children: "Upgrade" }),
+    /* @__PURE__ */ jsx29(Text27, { children: " " }),
     renderBody(upgradeCheck),
-    /* @__PURE__ */ jsx17(Text15, { children: " " }),
-    /* @__PURE__ */ jsxs14(Text15, { bold: true, color: PALETTE.accent, children: [
+    /* @__PURE__ */ jsx29(Text27, { children: " " }),
+    /* @__PURE__ */ jsxs26(Text27, { bold: true, color: PALETTE.accent, children: [
       FOCUS_MARKER,
       " Go Back"
     ] })
@@ -7397,45 +10220,45 @@ function UpgradeScreen({ onDone }) {
 }
 function renderBody(upgradeCheck) {
   if (!upgradeCheck) {
-    return /* @__PURE__ */ jsx17(Text15, { color: PALETTE.muted, children: "Checking for updates\u2026" });
+    return /* @__PURE__ */ jsx29(Text27, { color: PALETTE.muted, children: "Checking for updates\u2026" });
   }
   if (upgradeCheck.status === "error") {
-    return /* @__PURE__ */ jsx17(Text15, { color: PALETTE.warning, children: "Couldn't check for updates \u2014 check your network connection and try again." });
+    return /* @__PURE__ */ jsx29(Text27, { color: PALETTE.warning, children: "Couldn't check for updates \u2014 check your network connection and try again." });
   }
   if (upgradeCheck.status === "up-to-date") {
-    return /* @__PURE__ */ jsxs14(Text15, { color: PALETTE.success, children: [
+    return /* @__PURE__ */ jsxs26(Text27, { color: PALETTE.success, children: [
       "You're already on the latest version (v",
       upgradeCheck.current,
       ")."
     ] });
   }
-  return /* @__PURE__ */ jsxs14(Box14, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsxs14(Text15, { color: PALETTE.muted, children: [
-      /* @__PURE__ */ jsxs14(Text15, { bold: true, color: PALETTE.success, children: [
+  return /* @__PURE__ */ jsxs26(Box25, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs26(Text27, { color: PALETTE.muted, children: [
+      /* @__PURE__ */ jsxs26(Text27, { bold: true, color: PALETTE.success, children: [
         "v",
         upgradeCheck.latest
       ] }),
       " ",
       "is available (you're on ",
-      /* @__PURE__ */ jsxs14(Text15, { bold: true, children: [
+      /* @__PURE__ */ jsxs26(Text27, { bold: true, children: [
         "v",
         upgradeCheck.current
       ] }),
       "). Exit this program, cd into the root of your local clone of contentful/experience-design-system-sdk-public, then run:"
     ] }),
-    /* @__PURE__ */ jsx17(Text15, { children: " " }),
-    /* @__PURE__ */ jsx17(Box14, { flexDirection: "column", borderStyle: "round", borderColor: PALETTE.border, paddingX: 1, children: UPGRADE_COMMANDS.map((cmd) => /* @__PURE__ */ jsx17(Text15, { bold: true, children: cmd }, cmd)) })
+    /* @__PURE__ */ jsx29(Text27, { children: " " }),
+    /* @__PURE__ */ jsx29(Box25, { flexDirection: "column", borderStyle: "round", borderColor: PALETTE.border, paddingX: 1, children: UPGRADE_COMMANDS.map((cmd) => /* @__PURE__ */ jsx29(Text27, { bold: true, children: cmd }, cmd)) })
   ] });
 }
 
 // packages/experience-design-system-cli/src/tui/settings/debug-mode/screen.tsx
-import { useEffect as useEffect10, useState as useState14 } from "react";
-import { Box as Box15, Text as Text16, useInput as useInput14 } from "ink";
-import { jsx as jsx18, jsxs as jsxs15 } from "react/jsx-runtime";
+import { useEffect as useEffect13, useState as useState19 } from "react";
+import { Box as Box26, Text as Text28, useInput as useInput14 } from "ink";
+import { jsx as jsx30, jsxs as jsxs27 } from "react/jsx-runtime";
 function DebugModeScreen({ onDone }) {
-  const [loading, setLoading] = useState14(true);
-  const [enabled, setEnabled] = useState14(true);
-  useEffect10(() => {
+  const [loading, setLoading] = useState19(true);
+  const [enabled, setEnabled] = useState19(true);
+  useEffect13(() => {
     readDebugModeSetting().then((setting) => {
       setEnabled(setting.enabled);
       setLoading(false);
@@ -7462,16 +10285,16 @@ function DebugModeScreen({ onDone }) {
       onDone();
     }
   });
-  return /* @__PURE__ */ jsxs15(Box15, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
-    /* @__PURE__ */ jsx18(Text16, { bold: true, children: "Settings \u203A Debug Mode" }),
-    /* @__PURE__ */ jsx18(Text16, { children: " " }),
-    loading ? /* @__PURE__ */ jsx18(Text16, { color: PALETTE.muted, children: "Loading\u2026" }) : /* @__PURE__ */ jsxs15(Text16, { children: [
+  return /* @__PURE__ */ jsxs27(Box26, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [
+    /* @__PURE__ */ jsx30(Text28, { bold: true, children: "Settings \u203A Debug Mode" }),
+    /* @__PURE__ */ jsx30(Text28, { children: " " }),
+    loading ? /* @__PURE__ */ jsx30(Text28, { color: PALETTE.muted, children: "Loading\u2026" }) : /* @__PURE__ */ jsxs27(Text28, { children: [
       "Debug logging:",
       " ",
-      /* @__PURE__ */ jsx18(Text16, { bold: true, color: enabled ? PALETTE.success : PALETTE.muted, children: enabled ? "On" : "Off" })
+      /* @__PURE__ */ jsx30(Text28, { bold: true, color: enabled ? PALETTE.success : PALETTE.muted, children: enabled ? "On" : "Off" })
     ] }),
-    /* @__PURE__ */ jsx18(Text16, { children: " " }),
-    /* @__PURE__ */ jsx18(
+    /* @__PURE__ */ jsx30(Text28, { children: " " }),
+    /* @__PURE__ */ jsx30(
       ControlHints,
       {
         hints: [
@@ -7484,19 +10307,34 @@ function DebugModeScreen({ onDone }) {
 }
 
 // packages/experience-design-system-cli/app.tsx
-import { Fragment as Fragment5, jsx as jsx19 } from "react/jsx-runtime";
+import { Fragment as Fragment8, jsx as jsx31 } from "react/jsx-runtime";
 function App({ importOptions, onLaunchImport, importExitCode }) {
   const returnedFromImport = importExitCode !== void 0;
-  const [screen, setScreen] = useState15(returnedFromImport ? "import" : "start");
-  const [showImportResult, setShowImportResult] = useState15(returnedFromImport);
-  const [projectPath, setProjectPath] = useState15();
-  const [tokensPath, setTokensPath] = useState15();
-  const [scannedFiles, setScannedFiles] = useState15();
-  const [pendingLaunch, setPendingLaunch] = useState15();
-  const [extractionRun, setExtractionRun] = useState15();
+  const [screen, setScreen] = useState20(returnedFromImport ? "import" : "start");
+  const [showImportResult, setShowImportResult] = useState20(returnedFromImport);
+  const [projectPath, setProjectPath] = useState20();
+  const [tokensPath, setTokensPath] = useState20();
+  const [scannedFiles, setScannedFiles] = useState20();
+  const [pendingLaunch, setPendingLaunch] = useState20();
+  const [extractionRun, setExtractionRun] = useState20();
   const extraction = useExtraction(extractionRun?.input);
-  const [importDefaults, setImportDefaults] = useState15();
-  useEffect11(() => {
+  const [scopeRun, setScopeRun] = useState20();
+  const scopeFlow = useScopeGateFlow(
+    scopeRun && {
+      sessionId: scopeRun.extraction.sessionId,
+      cache: {
+        sessionId: scopeRun.extraction.sessionId,
+        tokensPath: scopeRun.extraction.tokensPath,
+        agent: scopeRun.input.agent,
+        ...scopeRun.input.agentModel ? { agentModel: scopeRun.input.agentModel } : {},
+        promptOverrides: scopeRun.input.promptOverrides,
+        existingEntitiesPath: scopeRun.extraction.existingEntitiesPath,
+        noCache: scopeRun.input.noCache
+      }
+    }
+  );
+  const [importDefaults, setImportDefaults] = useState20();
+  useEffect14(() => {
     if (screen !== "import") {
       setImportDefaults(void 0);
       return;
@@ -7550,15 +10388,25 @@ function App({ importOptions, onLaunchImport, importExitCode }) {
       }
     });
   };
-  useEffect11(() => {
+  useEffect14(() => {
     if (!extractionRun || extraction?.status !== "done" || !extraction.result.ok) return;
-    const { launch, credentialsSkipped, tokenStrategy } = extractionRun;
     setExtractionRun(void 0);
+    setScopeRun({ ...extractionRun, extraction: extraction.result.extraction });
+  }, [extraction, extractionRun]);
+  useEffect14(() => {
+    if (!scopeRun || scopeFlow?.status !== "confirmed") return;
+    const { launch, credentialsSkipped, tokenStrategy, extraction: produced } = scopeRun;
+    setScopeRun(void 0);
     onLaunchImport?.({
       ...launch,
-      handoff: { credentialsSkipped, tokens: { strategy: tokenStrategy }, extraction: extraction.result.extraction }
+      handoff: {
+        credentialsSkipped,
+        tokens: { strategy: tokenStrategy },
+        extraction: produced,
+        scope: scopeFlow.scope
+      }
     });
-  }, [extraction, extractionRun]);
+  }, [scopeFlow, scopeRun]);
   const goToStart = () => setScreen("start");
   const goToSettings = () => setScreen("settings");
   const resetImport = () => {
@@ -7567,6 +10415,7 @@ function App({ importOptions, onLaunchImport, importExitCode }) {
     setScannedFiles(void 0);
     setPendingLaunch(void 0);
     setExtractionRun(void 0);
+    setScopeRun(void 0);
   };
   const finishImportResult = () => {
     setShowImportResult(false);
@@ -7579,13 +10428,13 @@ function App({ importOptions, onLaunchImport, importExitCode }) {
   };
   switch (screen) {
     case "import":
-      if (showImportResult) return /* @__PURE__ */ jsx19(ImportScreen, { exitCode: importExitCode, onDone: finishImportResult });
-      if (importDefaults === void 0) return /* @__PURE__ */ jsx19(Fragment5, {});
+      if (showImportResult) return /* @__PURE__ */ jsx31(ImportScreen, { exitCode: importExitCode, onDone: finishImportResult });
+      if (importDefaults === void 0) return /* @__PURE__ */ jsx31(Fragment8, {});
       if (projectPath === void 0) {
-        return /* @__PURE__ */ jsx19(WelcomeScreen, { onContinue: setProjectPath, onQuit: leaveImport, initialPath: importDefaults.componentDir });
+        return /* @__PURE__ */ jsx31(WelcomeScreen, { onContinue: setProjectPath, onQuit: leaveImport, initialPath: importDefaults.componentDir });
       }
       if (tokensPath === void 0) {
-        return /* @__PURE__ */ jsx19(
+        return /* @__PURE__ */ jsx31(
           TokenInputScreen,
           {
             initialPath: importDefaults.tokenFile,
@@ -7595,7 +10444,7 @@ function App({ importOptions, onLaunchImport, importExitCode }) {
         );
       }
       if (scannedFiles === void 0) {
-        return /* @__PURE__ */ jsx19(
+        return /* @__PURE__ */ jsx31(
           PathValidationScreen,
           {
             projectPath,
@@ -7607,10 +10456,10 @@ function App({ importOptions, onLaunchImport, importExitCode }) {
       }
       if (extractionRun) {
         if (extraction?.status === "done" && !extraction.result.ok) {
-          return /* @__PURE__ */ jsx19(ErrorStep, { stepName: extraction.result.step, message: extraction.result.message, onExit: leaveImport });
+          return /* @__PURE__ */ jsx31(ErrorStep, { stepName: extraction.result.step, message: extraction.result.message, onExit: leaveImport });
         }
         if (extraction?.status === "running") {
-          return /* @__PURE__ */ jsx19(
+          return /* @__PURE__ */ jsx31(
             ExtractionScreen,
             {
               progress: extraction.progress,
@@ -7619,10 +10468,35 @@ function App({ importOptions, onLaunchImport, importExitCode }) {
             }
           );
         }
-        return /* @__PURE__ */ jsx19(Fragment5, {});
+        return /* @__PURE__ */ jsx31(Fragment8, {});
+      }
+      if (scopeRun && scopeFlow) {
+        if (scopeFlow.status === "failed") {
+          return /* @__PURE__ */ jsx31(ErrorStep, { stepName: "scope gate", message: scopeFlow.message, onExit: leaveImport });
+        }
+        if (scopeFlow.status === "deciding") {
+          return /* @__PURE__ */ jsx31(
+            ScopeGateScreen,
+            {
+              components: scopeFlow.load.components,
+              onConfirm: scopeFlow.confirm,
+              onQuit: leaveImport
+            }
+          );
+        }
+        const numbers = stepNumbers({ hasRawTokens: scopeRun.input.rawTokensPath !== "" });
+        return /* @__PURE__ */ jsx31(
+          RunningStep,
+          {
+            stepNumber: numbers.stepNumber + 1,
+            totalSteps: numbers.totalSteps,
+            title: "Preparing",
+            description: "Checking which components are already generated..."
+          }
+        );
       }
       if (pendingLaunch?.cached) {
-        return /* @__PURE__ */ jsx19(
+        return /* @__PURE__ */ jsx31(
           TokenReuseScreen,
           {
             tokensPath: pendingLaunch.cached.tokensPath,
@@ -7633,7 +10507,7 @@ function App({ importOptions, onLaunchImport, importExitCode }) {
           }
         );
       }
-      return /* @__PURE__ */ jsx19(
+      return /* @__PURE__ */ jsx31(
         CredentialsScreen,
         {
           initial: importDefaults.credentials,
@@ -7642,26 +10516,26 @@ function App({ importOptions, onLaunchImport, importExitCode }) {
         }
       );
     case "help":
-      return /* @__PURE__ */ jsx19(HelpScreen, { onDone: goToStart });
+      return /* @__PURE__ */ jsx31(HelpScreen, { onDone: goToStart });
     case "upgrade":
-      return /* @__PURE__ */ jsx19(UpgradeScreen, { onDone: goToStart });
+      return /* @__PURE__ */ jsx31(UpgradeScreen, { onDone: goToStart });
     case "settings":
-      return /* @__PURE__ */ jsx19(SettingsScreen, { onNavigate: setScreen, onBack: goToStart });
+      return /* @__PURE__ */ jsx31(SettingsScreen, { onNavigate: setScreen, onBack: goToStart });
     case "settings-configuration":
-      return /* @__PURE__ */ jsx19(ConfigurationScreen, { onDone: goToSettings });
+      return /* @__PURE__ */ jsx31(ConfigurationScreen, { onDone: goToSettings });
     case "settings-opt-in-analytics":
-      return /* @__PURE__ */ jsx19(OptInAnalyticsScreen, { onDone: goToSettings });
+      return /* @__PURE__ */ jsx31(OptInAnalyticsScreen, { onDone: goToSettings });
     case "settings-debug-mode":
-      return /* @__PURE__ */ jsx19(DebugModeScreen, { onDone: goToSettings });
+      return /* @__PURE__ */ jsx31(DebugModeScreen, { onDone: goToSettings });
     case "start":
-      return /* @__PURE__ */ jsx19(HomeScreen, { onNavigate: setScreen });
+      return /* @__PURE__ */ jsx31(HomeScreen, { onNavigate: setScreen });
   }
 }
 var CLEAR_SCREEN = "\x1B[2J\x1B[H";
 async function renderUntilImportRequestedOrExit(renderApp, importOptions, importExitCode) {
   let requestedImport;
   const instance = renderApp(
-    /* @__PURE__ */ jsx19(
+    /* @__PURE__ */ jsx31(
       App,
       {
         importOptions,