@contentful/experience-design-system-cli 2.42.1-dev-build-774b3e20.0 → 2.42.1-dev-build-fb965e69.0

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.42.1-dev-build-774b3e20.0",
+  "version": "2.42.1-dev-build-fb965e69.0",
   "description": "Contentful Experiences design system import CLI",
   "license": "MIT",
   "type": "module",

package/dist/src/commands/import-options.d.ts

@@ -1,10 +1,18 @@
 export interface ImportOptions {
     agent?: string;
     prompt: string[];
+    cache: boolean;
+    debugResume?: string;
+    debugFrom?: string;
+    debugOutput?: string;
 }
 interface RawImportOptions {
     agent?: string;
     prompt?: string[];
+    cache?: boolean;
+    debugResume?: string | boolean;
+    debugFrom?: string;
+    debugOutput?: string;
 }
 export declare function toImportOptions(raw: RawImportOptions): ImportOptions;
 export {};

package/dist/src/tui/debug-store.d.ts

@@ -18,6 +18,8 @@ export declare function startDebugSessionIn(base: string, { replace }?: {
  * folder that cannot be created) the files stay in `<project>/.contentful`, as before.
  */
 export declare function startImportRun(projectPath: string): Promise<string>;
+/** Append an event to the current debug session; disabled or failed logging must not stop the import. */
+export declare function recordDebugEvent(event: string, payload?: Record<string, unknown>): Promise<void>;
 export declare function startDebugRun({ flow, step, menuOption, inputs, }: {
     flow: string;
     step: string;

package/dist/src/tui/import/cancellation.d.ts

@@ -0,0 +1,26 @@
+export declare function throwIfAborted(signal?: AbortSignal): void;
+export declare function isAbortError(error: unknown): boolean;
+export interface ImportAttempt {
+    id: number;
+    controller: AbortController;
+}
+export interface ImportAttemptOwner {
+    begin(): ImportAttempt;
+    cancel(): void;
+    isCurrent(attempt: ImportAttempt): boolean;
+    current(): ImportAttempt | undefined;
+}
+export declare function createImportAttemptOwner(): ImportAttemptOwner;
+export declare function awaitForCurrentImportAttempt<T>(attempt: ImportAttempt, isCurrent: (attempt: ImportAttempt) => boolean, operation: () => Promise<T>): Promise<{
+    current: false;
+} | {
+    current: true;
+    value: T;
+}>;
+export declare function trackImportWork<T>(work: Promise<T>): Promise<T>;
+export declare function cancelAndDrainImportWork(): Promise<void>;
+export declare function linkAbortSignal(parent?: AbortSignal): {
+    controller: AbortController;
+    dispose: () => void;
+};
+export declare function awaitWithSignal<T>(promise: Promise<T>, signal?: AbortSignal): Promise<T>;

package/dist/src/tui/import/debug-resume-screen.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { type DebugResumeState, type DebugResumeStep } from './debug-resume.js';
+export declare function DebugResumeScreen({ state, onChoose, onQuit, }: {
+    state: DebugResumeState;
+    onChoose: (step: DebugResumeStep) => void;
+    onQuit: () => void;
+}): React.ReactElement;

package/dist/src/tui/import/debug-resume.d.ts

@@ -0,0 +1,53 @@
+import * as z from 'zod/mini';
+import { type ScopeDecisions } from '@contentful/experience-design-system-backend-pipeline';
+import { type ExtractionHandoff } from '@contentful/experience-design-system-types/handoff';
+import type { ExtractionInput } from './steps/06-extraction/types.js';
+export declare const DEBUG_RESUME_STEPS: readonly ["scope", "details", "generation", "tokens", "review"];
+export type DebugResumeStep = (typeof DEBUG_RESUME_STEPS)[number];
+declare const CheckpointSchema: z.ZodMiniObject<{
+    version: z.ZodMiniLiteral<1>;
+    projectPath: z.ZodMiniString<string>;
+    rawTokensPath: z.ZodMiniString<string>;
+    agent: z.ZodMiniString<string>;
+    agentModel: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    promptOverrides: z.ZodMiniArray<z.ZodMiniString<string>>;
+    extraction: z.ZodMiniCustom<{
+        sessionId: string;
+        outDir: string;
+        tokensPath: string;
+        tokenSessionId: string | null;
+        tokenCount: number;
+        existingEntitiesPath: string | null;
+        existingEntitiesStatus: "failed" | "idle" | "complete";
+        compositionPhase: "done" | "cache-hit";
+    }, {
+        sessionId: string;
+        outDir: string;
+        tokensPath: string;
+        tokenSessionId: string | null;
+        tokenCount: number;
+        existingEntitiesPath: string | null;
+        existingEntitiesStatus: "failed" | "idle" | "complete";
+        compositionPhase: "done" | "cache-hit";
+    }>;
+}, z.core.$strip>;
+type DebugImportCheckpoint = z.infer<typeof CheckpointSchema>;
+export interface DebugResumeState {
+    checkpoint: DebugImportCheckpoint;
+    decisions?: ScopeDecisions;
+    detailComplete: boolean;
+    generationComplete: boolean;
+    tokenMappingComplete: boolean;
+}
+export declare function debugCheckpointDirectory(sessionId: string): string;
+export declare function saveDebugImportCheckpoint(input: ExtractionInput, extraction: ExtractionHandoff): Promise<void>;
+export declare function saveDebugTokenMappingComplete(sessionId: string, detailRunId: string | undefined): Promise<void>;
+/** Explicit debugging reopens saved evidence; it does not compare it with current disk or prompt contents. */
+export declare function loadDebugResume(session: string, fallback?: {
+    outDir: string;
+    agent: string;
+    agentModel?: string;
+    promptOverrides: string[];
+}): Promise<DebugResumeState>;
+export declare function assertDebugResumeStep(state: DebugResumeState, step: DebugResumeStep): void;
+export {};

package/dist/src/tui/import/shared/agent-activity.d.ts

@@ -0,0 +1,2 @@
+import type { AgentInvocationActivity } from '@contentful/experience-design-system-backend-pipeline';
+export declare function describeAgentActivity(activity?: AgentInvocationActivity): string | undefined;

package/dist/src/tui/import/shared/running-step/logic.d.ts

@@ -1,27 +1,18 @@
 export interface Progress {
     done: number;
     total: number;
+    label?: string;
 }
 export interface RunningLine {
+    id?: string;
     text: string;
+    detail?: string;
     complete?: boolean;
-    /** Set for a row that ended badly. A warning carries on without it; a failure does not. Otherwise `complete` decides. */
-    state?: 'warning' | 'failed';
+    failed?: boolean;
+    pending?: boolean;
     progress?: Progress;
-    /** How long the row took, once it has finished. */
-    ms?: number;
 }
-export type LineState = 'running' | 'done' | 'warning' | 'failed';
-/** What a row looks like. A row that ended badly is never shown as running or as done. */
-export declare function lineState(line: RunningLine): LineState;
-export declare function formatDuration(ms: number): string;
-/**
- * How long each row took, by position, for the rows that have finished. A row's time is how long the run had been going
- * when it was first seen finished, and it does not change after that. Rows keep their position for the whole run, so a row
- * that appears later is added at the end.
- */
-export declare function trackFinished(previous: ReadonlyArray<number | undefined>, rows: readonly RunningLine[], elapsedMs: number): Array<number | undefined>;
-/** The rows with the time each finished row took, by position. */
-export declare function withTimes(rows: RunningLine[], rowMs: ReadonlyArray<number | undefined>): RunningLine[];
+/** A moving segment indicates activity without inventing a percentage or completion estimate. */
+export declare function activitySegment(seconds: number, width?: number, size?: number): number;
 export declare function progressPercent(progress: Progress): number;
 export declare function formatElapsed(totalSeconds: number): string;

package/dist/src/tui/import/shared/running-step/running-step.d.ts

@@ -4,7 +4,8 @@ import type { ImportStepId } from '@tui/shared/components/StepHeader.js';
 interface RunningStepProps {
     step: ImportStepId;
     description: string;
+    elapsedLabel?: string;
     lines?: readonly RunningLine[];
 }
-export declare function RunningStep({ step, description, lines, }: RunningStepProps): React.ReactElement;
+export declare function RunningStep({ step, description, elapsedLabel, lines, }: RunningStepProps): React.ReactElement;
 export {};

package/dist/src/tui/import/shared/running-step/use-elapsed.d.ts

@@ -1 +1,2 @@
+export declare function useElapsedSeconds(active?: boolean): number;
 export declare function useElapsed(): string;

package/dist/src/tui/import/steps/03-path-validation/logic.d.ts

@@ -8,6 +8,7 @@ export type ScanResult = {
     counts: FileCounts;
     filePaths: string[];
     warnings: string[];
+    sourceInventory?: import('@contentful/experience-design-system-backend-pipeline').SourceEvidenceInventory;
 } | {
     ok: false;
     failure: ScanFailureCode;

package/dist/src/tui/import/steps/03-path-validation/screen.d.ts

@@ -7,6 +7,7 @@ interface PathValidationScreenProps {
     onConfirm: (result: {
         projectPath: string;
         filePaths: string[];
+        sourceInventory?: import('@contentful/experience-design-system-backend-pipeline').SourceEvidenceInventory;
     }) => void;
     onChangePath: () => void;
     onBack: () => void;

package/dist/src/tui/import/steps/06-extraction/logic.d.ts

@@ -1,5 +1,5 @@
+import type { RunningLine } from '../../shared/running-step/logic.js';
 import type { ExtractAndComposeProgress } from '@contentful/experience-design-system-backend-pipeline';
-import { type RunningLine } from '../../shared/running-step/logic.js';
 import type { ExtractionInput, ExtractionProgress, ExtractionResult } from './types.js';
 /** Structured progress events emitted by the orchestrator (extraction + composition). */
 export type ProgressEvent = ExtractAndComposeProgress;
@@ -25,11 +25,8 @@ export declare function initialProgress(input: {
     hasRawTokens: boolean;
 }): ExtractionProgress;
 export declare function applyProgressEvent(progress: ExtractionProgress, event: ProgressEvent): ExtractionProgress;
-/**
- * The rows the screen shows, in the order the wizard showed them. Rows that do not apply are left out. `rowMs` is how long
- * each finished row took, by position (see `trackFinished`).
- */
-export declare function progressRows(progress: ExtractionProgress, agent: string, rowMs?: ReadonlyArray<number | undefined>): RunningLine[];
+/** The rows the screen shows, in the order the wizard showed them. Rows that do not apply are left out. */
+export declare function progressRows(progress: ExtractionProgress, agent: string): RunningLine[];
 /** True when every job is already done, so the screen would only flash. The wizard shows nothing in this case. */
 export declare function isFullCacheHit(progress: ExtractionProgress): boolean;
 export declare function noComponentsMessage(projectPath: string): string;

package/dist/src/tui/import/steps/06-extraction/run-tokens-only.d.ts

@@ -1,5 +1,6 @@
 import { checkAgentAuth, runGenerateTokensSession } from '@contentful/experience-design-system-backend-pipeline';
 export interface TokensOnlyInput {
+    signal?: AbortSignal;
     rawTokensPath: string;
     /** Where tokens.json is written: this import run's folder. */
     outDir: string;

package/dist/src/tui/import/steps/06-extraction/run.d.ts

@@ -1,10 +1,10 @@
-import { checkAgentAuth, runExtractAndComposeSession, runGenerateTokensSession } from '@contentful/experience-design-system-backend-pipeline';
+import { checkAgentAuth, type ExistingContentfulEntities, runExtractAndComposeSession, runGenerateTokensSession } from '@contentful/experience-design-system-backend-pipeline';
 import { runSelection } from './selection.js';
 import type { ExtractionInput, ExtractionProgress, ExtractionResult } from './types.js';
 /** The outside world the stage talks to, so the order of events can be tested without a network, an agent or a CLI. */
 export interface ExtractionDeps {
     checkAgentAuth: typeof checkAgentAuth;
-    fetchEntities: (credentials: NonNullable<ExtractionInput['credentials']>, outDir: string) => Promise<string | null>;
+    fetchEntities: (credentials: NonNullable<ExtractionInput['credentials']>, outDir: string, onCapture?: (entities: ExistingContentfulEntities) => void, onActivity?: (activity: string) => void) => Promise<string | null>;
     runExtractAndComposeSession: typeof runExtractAndComposeSession;
     runGenerateTokensSession: typeof runGenerateTokensSession;
     runSelection: typeof runSelection;
@@ -14,13 +14,13 @@ export interface ExtractionDeps {
  * subprocess:
  *
  *   entities fetch ───────────────────┐
- *   extract + compose (in-process)    │
- *     └─ onSessionCreated(id) ────────┴─ selection agent (waits for fetch) ──┐
- *     └──────────────────────── returns (composition done) ─────────────────┴─ result
- *   token generation            (only when the tokens are not being reused)
+ *   extract + compose (in-process) ── returns complete source evidence ──┐
+ *   token generation            (only when the tokens are not being reused)│
+ *   entities fetch ──────────────────────────────────────────────────────┤
+ *   selection (after extraction returns; waits for entities) ────────────┴─ result
  *
- * Selection starts the moment the orchestrator mints the sessionId, so it
- * overlaps with composition. When more than one job fails, the error reported
- * is the first of: extract, no components, selection, token generation.
+ * Selection consumes the completed saved source envelope, so it starts only
+ * after extraction and composition return. When multiple jobs fail, the
+ * reported error priority is: extract, no components, selection, token generation.
  */
 export declare function runExtraction(input: ExtractionInput, onProgress: (progress: ExtractionProgress) => void, deps?: ExtractionDeps): Promise<ExtractionResult>;

package/dist/src/tui/import/steps/06-extraction/screen.d.ts

@@ -3,8 +3,6 @@ import type { ExtractionProgress } from './types.js';
 interface ExtractionScreenProps {
     progress: ExtractionProgress;
     agent: string;
-    /** How long each finished row took, by position. */
-    rowMs?: ReadonlyArray<number | undefined>;
 }
-export declare function ExtractionScreen({ progress, agent, rowMs }: ExtractionScreenProps): React.ReactElement;
+export declare function ExtractionScreen({ progress, agent }: ExtractionScreenProps): React.ReactElement;
 export {};

package/dist/src/tui/import/steps/06-extraction/selection.d.ts

@@ -1,11 +1,17 @@
-import { type AgentName } from '@contentful/experience-design-system-backend-pipeline';
+import { type AgentName, type SourceEvidenceHandle, type RendererReferenceInput, type ExplorationProgressEvent } from '@contentful/experience-design-system-backend-pipeline';
 export interface SelectionOptions {
+    rendererReference?: RendererReferenceInput;
+    onActivity?: (event: ExplorationProgressEvent) => void;
+    signal?: AbortSignal;
     sessionId: string;
     agent: AgentName;
     model?: string;
     promptText?: string;
     promptPath?: string;
     noCache: boolean;
+    sourceEvidenceHandle?: SourceEvidenceHandle;
+    promptOverrides?: string[];
+    existingEntitiesPath?: string | null;
 }
 /**
  * The selection agent run, as the legacy wizard ran it.

package/dist/src/tui/import/steps/06-extraction/types.d.ts

@@ -1,5 +1,8 @@
 import type { ExtractionHandoff } from '@contentful/experience-design-system-types/handoff';
 export interface ExtractionInput {
+    sourceInventory?: import('@contentful/experience-design-system-backend-pipeline').SourceEvidenceInventory;
+    evidenceFilePaths?: readonly string[];
+    signal?: AbortSignal;
     projectPath: string;
     /** Where the stage writes tokens.json and the other files. Defaults to `<projectPath>/.contentful`. */
     outDir?: string;
@@ -26,11 +29,21 @@ export interface ExtractionProgress {
     scan: {
         scanned: number;
         total: number | null;
+        componentsFound?: number;
     } | null;
+    sourceActivity?: {
+        phase: 'analyzing' | 'validating' | 'capturing' | 'captured' | 'publishing' | 'complete';
+        activity: string;
+    };
     composition: CompositionPhase;
+    compositionActivity?: string;
     selection: 'running' | 'complete';
+    exploration?: import('@contentful/experience-design-system-backend-pipeline').ExplorationProgressEvent;
     existingEntities: JobStatus;
+    existingEntitiesActivity?: string;
     tokens: JobStatus;
+    tokenActivity?: import('@contentful/experience-design-system-backend-pipeline').GenerateTokensProgress;
+    tokenCount?: number;
 }
 /** The label the error screen shows, as the wizard labelled it. */
 type ExtractionStepName = 'analyze extract' | 'selection agent' | 'generate tokens' | 'print tokens' | `${string} auth check`;

package/dist/src/tui/import/steps/06-extraction/use-extraction.d.ts

@@ -2,7 +2,6 @@ import type { ExtractionInput, ExtractionProgress, ExtractionResult } from './ty
 export type ExtractionState = {
     status: 'running';
     progress: ExtractionProgress;
-    rowMs: Array<number | undefined>;
 } | {
     status: 'done';
     result: ExtractionResult;

package/dist/src/tui/import/steps/07-scope-gate/graph/index.d.ts

@@ -20,7 +20,9 @@ export interface SidebarItem {
     status: NodeStatus;
 }
 /** What the sidebar draws a row from: an entry standing in for the component (its slots are what matter), and its status. */
-export declare function sidebarItems(components: ScopeComponent[]): SidebarItem[];
+export declare function sidebarItems(components: ScopeComponent[], displayNodes?: ComponentGraphNode[]): SidebarItem[];
+/** Source relationships guide navigation; they do not establish slot restrictions or selection cascades. */
+export declare function buildRelationshipNodes(components: ScopeComponent[]): ComponentGraphNode[];
 export declare function buildScopeGraph(components: ScopeComponent[]): ScopeGraph;
 /** Names that change when `target` is accepted. Pulls in everything it needs, whole cycles together. */
 export declare function acceptCascade(graph: ScopeGraph, target: string): string[];

package/dist/src/tui/import/steps/07-scope-gate/screen.d.ts

@@ -2,9 +2,10 @@ import React from 'react';
 import type { ScopeComponent, ScopeDecisions } from './types.js';
 interface ScopeGateScreenProps {
     components: ScopeComponent[];
+    savedDecisions?: ScopeDecisions;
     tokensPath?: string;
     onConfirm: (decisions: ScopeDecisions) => void;
     onQuit: () => void;
 }
-export declare function ScopeGateScreen({ components, tokensPath, onConfirm, onQuit, }: ScopeGateScreenProps): React.ReactElement;
+export declare function ScopeGateScreen(props: ScopeGateScreenProps): React.ReactElement;
 export {};

package/dist/src/tui/import/steps/07-scope-gate/sidebar/ai-flag.d.ts

@@ -1,5 +1,4 @@
 export type AiFlaggable = {
     aiDecision?: 'accepted' | 'rejected' | 'failed' | null;
-    needsReview?: boolean;
 };
 export declare function isAiFlagged(row: AiFlaggable): boolean;

package/dist/src/tui/import/steps/07-scope-gate/sidebar/components/GroupedSidebar.d.ts

@@ -27,6 +27,7 @@ export interface GroupedSidebarProps {
     alwaysExpanded?: boolean;
     showFlatTier?: boolean;
     selectionStateByKey?: Map<string, 'accepted' | 'rejected' | 'undecided'>;
+    displayLabelByKey?: Map<string, string>;
     aiFlaggedByKey?: Map<string, boolean>;
     dimPredicate?: (componentKey: string) => boolean;
     viewMode?: 'grouped' | 'flat';
@@ -56,6 +57,7 @@ export declare function buildVisibleRows(props: {
     viewMode?: 'grouped' | 'flat';
     graph: ComponentGraphNode[];
     filterVisibleKeys?: Set<string>;
+    edgeLabel?: string;
 }): VisibleRow[];
 export declare function GroupedSidebar(props: GroupedSidebarProps): React.ReactElement;
 export {};

package/dist/src/tui/import/steps/07-scope-gate/state.d.ts

@@ -1,6 +1,8 @@
 import { type ScopeGraph } from './graph/index.js';
-import type { Decision, ScopeComponent, ScopeDecisions } from './types.js';
-export type DecisionState = Map<string, Decision>;
+import type { Decision, ScopeComponent, ScopeDecisions, ScopeProvenance } from './types.js';
+export type DecisionState = Map<string, Decision> & {
+    acceptedProvenance?: Map<string, ScopeProvenance>;
+};
 export type DecisionAction = {
     type: 'accept';
     name: string;
@@ -12,6 +14,7 @@ export type DecisionAction = {
 } | {
     type: 'accept-unflagged';
 };
+export declare function createDecisionState(components: ScopeComponent[], saved?: ScopeDecisions): DecisionState;
 export declare function reduceDecisions(state: DecisionState, action: DecisionAction, components: ScopeComponent[], graph: ScopeGraph): DecisionState;
 /** Whether rejecting `name` touches 2 or more other components, so the screen has to ask first. */
 export declare function rejectNeedsConfirmation(graph: ScopeGraph, name: string, state: DecisionState): boolean;

package/dist/src/tui/import/steps/07-scope-gate/types.d.ts

@@ -1,4 +1,5 @@
-import type { ScopeComponentRow } from '@contentful/experience-design-system-backend-pipeline';
+import type { ScopeComponentRow, ScopeDecisions, ScopeDecisionProvenance } from '@contentful/experience-design-system-backend-pipeline';
+export type { ScopeDecisions };
 /**
  * One row of the gate. The loader always fills in the slots, but the screen is handed whatever the caller has, and
  * legacy's screen accepted rows without them (and without the AI fields), so those stay optional here.
@@ -10,14 +11,11 @@ export type ScopeComponent = Omit<ScopeComponentRow, 'aiDecision' | 'aiReason' |
     slots?: ScopeComponentRow['slots'];
 };
 export type Decision = 'accepted' | 'rejected' | 'undecided';
-/** What the user confirmed. Becomes `ImportHandoff.scope`; the legacy wizard saves it and starts generation. */
-export interface ScopeDecisions {
-    accepted: string[];
-    rejected: string[];
-}
+export type ScopeProvenance = ScopeDecisionProvenance;
 export type ScopeGateLoad = {
     ok: true;
     components: ScopeComponent[];
+    savedDecisions?: ScopeDecisions;
 } | {
     ok: false;
     message: string;

package/dist/src/tui/import/steps/07-scope-gate/use-scope-gate-flow.d.ts

@@ -21,7 +21,10 @@ interface Deps {
 }
 /** `input` is undefined until the extraction stage has produced a session, so the hook can be called unconditionally. */
 export declare function useScopeGateFlow(input: {
+    attemptId: number;
+    signal: AbortSignal;
     sessionId: string;
     cache: CacheCheckInput;
+    initialDecisions?: ScopeDecisions;
 } | undefined, deps?: Deps): ScopeGateFlow | undefined;
 export {};

package/dist/src/tui/import/steps/07-scope-gate/use-scope-gate.d.ts

@@ -1,8 +1,9 @@
 import type { ScopeComponent, ScopeDecisions } from './types.js';
 interface UseScopeGateOptions {
     components: ScopeComponent[];
-    tokenCount: number;
-    tokensWidth: number;
+    savedDecisions?: ScopeDecisions;
+    tokenCount?: number;
+    tokensWidth?: number;
     onConfirm: (decisions: ScopeDecisions) => void;
     onQuit: () => void;
 }
@@ -12,7 +13,7 @@ export interface PendingRejectCascade {
     ancestors: string[];
     descendants: string[];
 }
-export declare function useScopeGate({ components, tokenCount, tokensWidth, onConfirm, onQuit }: UseScopeGateOptions): {
+export declare function useScopeGate({ components, savedDecisions, tokenCount, tokensWidth, onConfirm, onQuit, }: UseScopeGateOptions): {
     totalWidth: number;
     columnPlan: {
         layout: "single" | "two-column";
@@ -24,7 +25,9 @@ export declare function useScopeGate({ components, tokenCount, tokensWidth, onCo
     panelMaxRows: number;
     groupedItems: import("./graph/index.js").SidebarItem[];
     graph: import("./graph/index.js").ScopeGraph;
+    displayNodes: import("./graph/composite-closure.js").ComponentGraphNode[];
     hasGroupRoots: boolean;
+    hasSourceRelationships: boolean;
     expandedGroups: Set<string>;
     toggleExpanded: (rootName: string) => void;
     visibleRows: import("./sidebar/components/GroupedSidebar.js").VisibleRow[];
@@ -48,6 +51,7 @@ export declare function useScopeGate({ components, tokenCount, tokensWidth, onCo
         jumpTarget: string;
     }[];
     aiExcludedCount: number;
+    hasAdvisoryNotes: boolean;
     pendingRejectCascade: PendingRejectCascade | null;
     safeTokensCursor: number;
     counters: {

package/dist/src/tui/import/steps/08-generation/logic.d.ts

@@ -1,4 +1,4 @@
-import { type RunningLine } from '../../shared/running-step/logic.js';
+import type { RunningLine } from '../../shared/running-step/logic.js';
 import type { GenerationInput, GenerationProgress, GenerationResult } from './types.js';
 /** What the debug log says the stage started with. The counts are logged, not the lists of names. */
 export declare function generationLogInputs(input: GenerationInput): Record<string, unknown>;
@@ -21,5 +21,4 @@ export declare function describeGeneration(input: {
     agent: string;
     hasTokens: boolean;
 }): string;
-/** `rowMs` is how long each finished row took, by position (see `trackFinished`). */
-export declare function progressRows(progress: GenerationProgress, agent: string, rowMs?: ReadonlyArray<number | undefined>): RunningLine[];
+export declare function progressRows(progress: GenerationProgress, agent: string): RunningLine[];

package/dist/src/tui/import/steps/08-generation/map-tokens.d.ts

@@ -11,4 +11,4 @@ export interface MapTokensPlan {
  * one, or restored from the saved tokens.json when an existing catalog was reused (there is no token session then).
  * Then it counts the design props that are tokens and the raw tokens. Reads and writes the pipeline database.
  */
-export declare function prepareMapTokens(input: Pick<GenerationInput, 'tokenSessionId' | 'tokensPath'>, generatedSessionId: string): Promise<MapTokensPlan>;
+export declare function prepareMapTokens(input: Pick<GenerationInput, 'tokenSessionId' | 'tokensPath' | 'signal'>, generatedSessionId: string): Promise<MapTokensPlan>;

package/dist/src/tui/import/steps/08-generation/run.d.ts

@@ -1,4 +1,4 @@
-import { checkAgentAuth, runGenerateComponentsSession, runMapTokens } from '@contentful/experience-design-system-backend-pipeline';
+import { checkAgentAuth, runGenerateComponentsSession, runExplorationDetailSession, runMapTokens } from '@contentful/experience-design-system-backend-pipeline';
 import { prepareMapTokens } from './map-tokens.js';
 import { saveDecisions } from './save-decisions.js';
 import type { GenerationInput, GenerationProgress, GenerationResult } from './types.js';
@@ -8,5 +8,13 @@ export interface GenerationDeps {
     runGenerate: typeof runGenerateComponentsSession;
     runMapTokens: typeof runMapTokens;
     prepareMapTokens: typeof prepareMapTokens;
+    prepareMapOptions: typeof buildMapTokensOptions;
+    runDetail?: typeof runExplorationDetailSession;
 }
 export declare function runGeneration(input: GenerationInput, onProgress: (progress: GenerationProgress) => void, deps?: GenerationDeps): Promise<GenerationResult>;
+declare function buildMapTokensOptions(input: GenerationInput, signal?: AbortSignal): Promise<{
+    skillContentOverride?: string;
+    skillPathOverride?: string;
+    existingEntitiesInline?: string;
+}>;
+export {};

package/dist/src/tui/import/steps/08-generation/save-decisions.d.ts

@@ -1,8 +1,6 @@
 import type { GenerationInput } from './types.js';
 /**
- * Applies the scope decisions to the session and writes the review snapshot that `generate components` reads to leave
- * out rejected components. Without the snapshot the generator would process rejected components anyway.
- * Uses `applyScopeDecisions` and `writeScopeDecisionsSnapshot` from backend-pipeline, which are identical to legacy's.
- * Both write to the pipeline database, so this runs only after the cache check has finished restoring into it.
+ * Saves human scope decisions in the database. Completed exploration consumes that scope directly;
+ * the snapshot writer only creates a review artifact for legacy sessions without exploration.
  */
-export declare function saveDecisions(input: Pick<GenerationInput, 'sessionId' | 'decisions'>): Promise<void>;
+export declare function saveDecisions(input: Pick<GenerationInput, 'sessionId' | 'decisions' | 'signal'>): Promise<void>;

package/dist/src/tui/import/steps/08-generation/screen.d.ts

@@ -5,8 +5,6 @@ interface GenerationScreenProps {
     agent: string;
     acceptedCount: number;
     hasTokens: boolean;
-    /** How long each finished row took, by position. */
-    rowMs?: ReadonlyArray<number | undefined>;
 }
-export declare function GenerationScreen({ progress, agent, acceptedCount, hasTokens, rowMs, }: GenerationScreenProps): React.ReactElement;
+export declare function GenerationScreen({ progress, agent, acceptedCount, hasTokens, }: GenerationScreenProps): React.ReactElement;
 export {};

package/dist/src/tui/import/steps/08-generation/types.d.ts

@@ -1,11 +1,11 @@
 import type { GenerationHandoff } from '@contentful/experience-design-system-types/handoff';
+import type { ExplorationProgressEvent, ScopeDecisions } from '@contentful/experience-design-system-backend-pipeline';
 export interface GenerationInput {
+    debugResumeFrom?: 'details' | 'generation' | 'tokens';
+    signal?: AbortSignal;
     /** The extraction session the scope was decided on. */
     sessionId: string;
-    decisions: {
-        accepted: string[];
-        rejected: string[];
-    };
+    decisions: ScopeDecisions;
     /**
      * The cache check that ran while the scope gate was open, which restores cached definitions into the pipeline
      * database. The stage waits for it before saving the decisions, since both write to that database.
@@ -26,21 +26,27 @@ export interface GenerationInput {
 }
 /** One line per thing the screen shows, in the order it shows them. */
 export interface GenerationProgress {
-    /**
-     * Components finished, out of the total, and the one being worked on. `failed` counts the finished ones that failed: the
-     * run carries on through the rest and only fails at the end. Null until the first progress line.
-     */
+    stage: 'preparing' | 'saving-decisions' | 'authenticating' | 'exploring' | 'generating' | 'preparing-token-mapping' | 'mapping-tokens' | 'complete';
+    exploration?: ExplorationProgressEvent;
+    activeComponents: Array<{
+        name: string;
+        attempt: number;
+        maxAttempts: number;
+        exploringModel?: boolean;
+    }>;
+    failedComponents: number;
+    /** Components finished, out of the total, and the one being worked on. Null until the first progress line. */
     components: {
         done: number;
         total: number;
         current: string;
-        failed: number;
     } | null;
     mapTokens: 'idle' | 'running' | 'complete';
     /** Whether token mapping will run at all; unknown until the generated components have been looked at. */
     mapTokensEligible: boolean | null;
+    resumedComponents?: number;
 }
-export type GenerationStepName = 'save decisions' | 'generate components' | 'map tokens' | `${string} auth check`;
+export type GenerationStepName = 'save decisions' | 'explore selected components' | 'generate components' | 'map tokens' | `${string} auth check`;
 export type GenerationResult = {
     ok: true;
     generation: GenerationHandoff;

package/dist/src/tui/import/steps/08-generation/use-generation.d.ts

@@ -2,7 +2,6 @@ import type { GenerationInput, GenerationProgress, GenerationResult } from './ty
 export type GenerationState = {
     status: 'running';
     progress: GenerationProgress;
-    rowMs: Array<number | undefined>;
 } | {
     status: 'done';
     result: GenerationResult;