@aifabrix/builder 2.44.3 → 2.44.5

package/lib/commands/wizard-core.js

@@ -275,7 +275,8 @@ async function handleTypeDetection(dataplaneUrl, authConfig, openapiSpec) {
  * @param {string} [options.systemIdOrKey] - System ID or key (optional)
  * @param {string} [options.sourceType] - Source type (use 'known-platform' to call platforms config endpoint)
  * @param {string} [options.platformKey] - Platform key for known-platform (e.g. 'hubspot')
- * @param {string} [options.appName] - App name for writing debug.log when debug=true
+ * @param {string} [options.appName] - Integration app key; for create-system, used as systemIdOrKey
+ *   when not set so kv paths match the folder (avoids spec-title keys like "companies")
  * @returns {Promise<Object>} Generated configuration
  */
 async function callGenerateApi(dataplaneUrl, authConfig, options, prefs) {
@@ -291,13 +292,19 @@ async function callGenerateApi(dataplaneUrl, authConfig, options, prefs) {
     });
     return await getPlatformConfig(dataplaneUrl, authConfig, options.platformKey, platformPayload);
   }
+  // Headless/interactive create-system uses appName as integration folder key; OpenAPI title alone
+  // can yield a wrong system key (e.g. title "Companies" → "companies"). Prefer appName when set.
+  let systemIdOrKeyForPayload = options.systemIdOrKey;
+  if (options.mode === 'create-system' && options.appName) {
+    systemIdOrKeyForPayload = systemIdOrKeyForPayload || options.appName;
+  }
   const configPayload = buildConfigPayload({
     openapiSpec: options.openapiSpec,
     detectedType: options.detectedType,
     mode: options.mode,
     prefs,
     credentialIdOrKey: options.credentialIdOrKey,
-    systemIdOrKey: options.systemIdOrKey,
+    systemIdOrKey: systemIdOrKeyForPayload,
     entityName: options.entityName,
     systemDisplayName: options.systemDisplayName
   });
@@ -410,6 +417,39 @@ async function tryUpdateReadmeFromDeploymentDocs(appPath, appName, dataplaneUrl,
   }
 }
 
+/**
+ * Writes rbac.yaml / rbac.json from datasource resourceType + capabilities (same as `af repair --rbac`).
+ * @param {Object} generatedFiles - Result of generateWizardFiles (appPath, systemFilePath, datasourceFilePaths)
+ * @param {string} format - Project format: yaml | json
+ */
+function logWizardFileSaveFooter(appName, generatedFiles) {
+  logger.log(chalk.green('\n\u2713 Wizard completed successfully!'));
+  logger.log(chalk.green(`\nFiles created in: ${generatedFiles.appPath}`));
+  logger.log(chalk.blue('\nNext steps:'));
+  logger.log(chalk.gray(`  1. Review the generated files in integration/${appName}/`));
+  logger.log(chalk.gray('  2. Update env.template with your authentication details'));
+  logger.log(chalk.gray(`  3. Deploy using: node deploy.js or aifabrix deploy ${appName}`));
+}
+
+function mergeRbacAfterWizardFilesWritten(generatedFiles, format) {
+  const { mergeRbacFromDatasources, extractRbacFromSystem } = require('./repair-rbac');
+  const { loadConfigFile } = require('../utils/config-format');
+  const systemParsedForRbac = loadConfigFile(generatedFiles.systemFilePath);
+  const datasourceFileNames = (generatedFiles.datasourceFilePaths || []).map((p) => path.basename(p));
+  const rbacChanges = [];
+  const rbacUpdated = mergeRbacFromDatasources(
+    generatedFiles.appPath,
+    systemParsedForRbac,
+    datasourceFileNames,
+    extractRbacFromSystem,
+    { format: format === 'json' ? 'json' : 'yaml', dryRun: false, changes: rbacChanges }
+  );
+  if (rbacUpdated && rbacChanges.length) {
+    rbacChanges.forEach((c) => logger.log(chalk.gray(`  RBAC: ${c}`)));
+    logger.log(chalk.green('  RBAC file updated from datasource capabilities (enableRBAC).'));
+  }
+}
+
 /**
  * Handle file saving step
  * @async
@@ -418,17 +458,24 @@ async function tryUpdateReadmeFromDeploymentDocs(appPath, appName, dataplaneUrl,
  * @param {Object} systemConfig - System configuration
  * @param {Object[]} datasourceConfigs - Datasource configurations
  * @param {string} systemKey - System key
- * @param {string} dataplaneUrl - Dataplane URL
- * @param {Object} authConfig - Authentication configuration
+ * @param {{ dataplaneUrl: string, authConfig: Object, enableRBAC?: boolean }} ctx - Dataplane auth + optional RBAC generation
  * @returns {Promise<Object>} Generated files information
  */
-async function handleFileSaving(appName, systemConfig, datasourceConfigs, systemKey, dataplaneUrl, authConfig) {
+async function handleFileSaving(appName, systemConfig, datasourceConfigs, systemKey, ctx) {
+  const { dataplaneUrl, authConfig, enableRBAC = false } = ctx || {};
   logger.log(chalk.blue('\n\uD83D\uDCCB Step 7: Save Files'));
   const spinner = ora('Saving files...').start();
   try {
     const config = require('../core/config');
     const format = (await config.getFormat()) || 'yaml';
     const generatedFiles = await generateWizardFiles(appName, systemConfig, datasourceConfigs, systemKey, { aiGeneratedReadme: null, format });
+    if (enableRBAC && generatedFiles.appPath && generatedFiles.systemFilePath) {
+      try {
+        mergeRbacAfterWizardFilesWritten(generatedFiles, format);
+      } catch (e) {
+        logger.log(chalk.yellow(`  Could not generate RBAC file: ${e.message}`));
+      }
+    }
     if (systemKey && dataplaneUrl && authConfig && generatedFiles.appPath) {
       try {
         await tryUpdateReadmeFromDeploymentDocs(generatedFiles.appPath, appName, dataplaneUrl, authConfig, systemKey);
@@ -437,12 +484,7 @@ async function handleFileSaving(appName, systemConfig, datasourceConfigs, system
       }
     }
     spinner.stop();
-    logger.log(chalk.green('\n\u2713 Wizard completed successfully!'));
-    logger.log(chalk.green(`\nFiles created in: ${generatedFiles.appPath}`));
-    logger.log(chalk.blue('\nNext steps:'));
-    logger.log(chalk.gray(`  1. Review the generated files in integration/${appName}/`));
-    logger.log(chalk.gray('  2. Update env.template with your authentication details'));
-    logger.log(chalk.gray(`  3. Deploy using: node deploy.js or aifabrix deploy ${appName}`));
+    logWizardFileSaveFooter(appName, generatedFiles);
     return generatedFiles;
   } catch (error) {
     spinner.stop();

package/lib/commands/wizard-dataplane.js

@@ -73,10 +73,12 @@ function createDataplaneNotFoundError() {
  * @returns {Promise<string>} Dataplane URL
  * @throws {Error} If dataplane URL cannot be retrieved
  */
-async function tryFallbackDataplaneUrl(controllerUrl, environment, authConfig) {
+async function tryFallbackDataplaneUrl(controllerUrl, environment, authConfig, silent) {
   try {
     const fallbackUrl = await getDataplaneUrl(controllerUrl, 'dataplane', environment, authConfig);
-    logger.log(formatSuccessLine(`Dataplane URL: ${fallbackUrl}`));
+    if (!silent) {
+      logger.log(formatSuccessLine(`Dataplane URL: ${fallbackUrl}`));
+    }
     return fallbackUrl;
   } catch (fallbackError) {
     if (isNotFoundError(fallbackError)) {
@@ -93,19 +95,25 @@ async function tryFallbackDataplaneUrl(controllerUrl, environment, authConfig) {
  * @param {string} controllerUrl - Controller URL
  * @param {string} environment - Environment key
  * @param {Object} authConfig - Authentication configuration
+ * @param {{ silent?: boolean }} [opts] - When silent, skip progress/success lines (e.g. cert sync right after a run).
  * @returns {Promise<string>} Dataplane URL
  * @throws {Error} If dataplane URL cannot be discovered
  */
-async function discoverDataplaneUrl(controllerUrl, environment, authConfig) {
-  logger.log(infoLine('🌐 Getting dataplane URL from controller...'));
+async function discoverDataplaneUrl(controllerUrl, environment, authConfig, opts = {}) {
+  const silent = opts.silent === true;
+  if (!silent) {
+    logger.log(infoLine('🌐 Getting dataplane URL from controller...'));
+  }
   try {
     const dataplaneAppKey = await findDataplaneServiceAppKey(controllerUrl, environment, authConfig);
     if (dataplaneAppKey) {
       const dataplaneUrl = await getDataplaneUrl(controllerUrl, dataplaneAppKey, environment, authConfig);
-      logger.log(formatSuccessLine(`Dataplane URL: ${dataplaneUrl}`));
+      if (!silent) {
+        logger.log(formatSuccessLine(`Dataplane URL: ${dataplaneUrl}`));
+      }
       return dataplaneUrl;
     }
-    return await tryFallbackDataplaneUrl(controllerUrl, environment, authConfig);
+    return await tryFallbackDataplaneUrl(controllerUrl, environment, authConfig, silent);
   } catch (error) {
     if (error.message.includes('Could not discover dataplane URL')) {
       throw error;

package/lib/commands/wizard-entity-selection.js

@@ -10,30 +10,87 @@ const { discoverEntities } = require('../api/wizard.api');
 const { validateEntityNameForOpenApi } = require('../validation/wizard-datasource-validation');
 const { promptForEntitySelection } = require('../generator/wizard-prompts');
 
+/**
+ * If wizard.yaml entity name matches discover-entities list, use it; else warn.
+ * @param {string} trimmed - Trimmed entity name from prefill
+ * @param {Array<{name: string}>} entities - Discovered entities
+ * @returns {string|null} Resolved name or null to prompt
+ */
+function resolvePrefillEntityName(trimmed, entities) {
+  const prefillCheck = validateEntityNameForOpenApi(trimmed, entities);
+  if (prefillCheck.valid) {
+    logger.log(chalk.gray(
+      `Using entity from wizard.yaml (${trimmed}). Skipping entity prompts.`
+    ));
+    logger.log(chalk.green(`\u2713 Selected entity: ${trimmed}`));
+    return trimmed;
+  }
+  logger.log(chalk.yellow(
+    `Warning: wizard.yaml source.entityName '${trimmed}' is not in the discover-entities list; choose manually.`
+  ));
+  return null;
+}
+
+/**
+ * Prompt for entity and validate against list.
+ * @param {Array<{name: string}>} entities - Discovered entities
+ * @returns {Promise<string>} Valid entity name
+ */
+async function promptForValidatedEntity(entities) {
+  const entityName = await promptForEntitySelection(entities);
+  const validation = validateEntityNameForOpenApi(entityName, entities);
+  if (!validation.valid) {
+    throw new Error(`Invalid entity '${entityName}'. Available: ${entities.map(e => e.name).join(', ')}`);
+  }
+  logger.log(chalk.green(`\u2713 Selected entity: ${entityName}`));
+  return entityName;
+}
+
+/**
+ * Discover entities and select one (single-entity shortcut, prefill, or prompt).
+ * @param {string} dataplaneUrl - Dataplane URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {Object} openapiSpec - OpenAPI specification
+ * @param {string} [prefillEntityName] - From wizard.yaml `source.entityName` when valid
+ * @returns {Promise<string|null>} Selected entity name or null (skip)
+ */
+async function discoverAndSelectEntity(dataplaneUrl, authConfig, openapiSpec, prefillEntityName) {
+  const response = await discoverEntities(dataplaneUrl, authConfig, openapiSpec);
+  const entities = response?.data?.entities;
+  if (!Array.isArray(entities) || entities.length === 0) return null;
+
+  logger.log(chalk.blue('\n\uD83D\uDCCB Step 4.5: Select Entity'));
+
+  if (entities.length === 1) {
+    const only = entities[0].name;
+    logger.log(chalk.green(`\u2713 Only one entity discovered; using: ${only}`));
+    return only;
+  }
+
+  const trimmed =
+    typeof prefillEntityName === 'string' ? prefillEntityName.trim() : '';
+  if (trimmed) {
+    const resolved = resolvePrefillEntityName(trimmed, entities);
+    if (resolved) return resolved;
+  }
+
+  return promptForValidatedEntity(entities);
+}
+
 /**
  * Handle entity selection step (OpenAPI multi-entity).
- * Calls discover-entities; if entities found, prompts user to select one.
+ * Calls discover-entities; prompts unless prefill or a single entity applies.
  * @async
  * @param {string} dataplaneUrl - Dataplane URL
  * @param {Object} authConfig - Authentication configuration
  * @param {Object} openapiSpec - OpenAPI specification
+ * @param {string} [prefillEntityName] - From wizard.yaml `source.entityName` when valid
  * @returns {Promise<string|null>} Selected entity name or null (skip)
  */
-async function handleEntitySelection(dataplaneUrl, authConfig, openapiSpec) {
+async function handleEntitySelection(dataplaneUrl, authConfig, openapiSpec, prefillEntityName) {
   if (!openapiSpec || typeof openapiSpec !== 'object') return null;
   try {
-    const response = await discoverEntities(dataplaneUrl, authConfig, openapiSpec);
-    const entities = response?.data?.entities;
-    if (!Array.isArray(entities) || entities.length === 0) return null;
-
-    logger.log(chalk.blue('\n\uD83D\uDCCB Step 4.5: Select Entity'));
-    const entityName = await promptForEntitySelection(entities);
-    const validation = validateEntityNameForOpenApi(entityName, entities);
-    if (!validation.valid) {
-      throw new Error(`Invalid entity '${entityName}'. Available: ${entities.map(e => e.name).join(', ')}`);
-    }
-    logger.log(chalk.green(`\u2713 Selected entity: ${entityName}`));
-    return entityName;
+    return await discoverAndSelectEntity(dataplaneUrl, authConfig, openapiSpec, prefillEntityName);
   } catch (error) {
     logger.log(chalk.yellow(`Warning: Entity discovery failed, using default: ${error.message}`));
     return null;

package/lib/commands/wizard-headless.js

@@ -111,8 +111,11 @@ async function executeWizardFromConfig(wizardConfig, dataplaneUrl, authConfig, o
     systemConfig,
     datasourceConfigs,
     systemKey || appName,
-    dataplaneUrl,
-    authConfig
+    {
+      dataplaneUrl,
+      authConfig,
+      enableRBAC: Boolean(preferences?.enableRBAC)
+    }
   );
 }
 

package/lib/commands/wizard-helpers.js

@@ -47,6 +47,12 @@ function buildSourceForSave(source) {
     out.token = source.token ? '(set)' : undefined;
   }
   if (source.type === 'known-platform' && source.platform) out.platform = source.platform;
+  if (
+    (source.type === 'openapi-file' || source.type === 'openapi-url') &&
+    source.entityName
+  ) {
+    out.entityName = source.entityName;
+  }
   return out;
 }
 
@@ -75,7 +81,13 @@ function buildWizardStateForSave(opts) {
 function formatSourceLine(source) {
   if (!source) return null;
   const s = source;
-  return s.type + (s.filePath ? ` (${s.filePath})` : s.url ? ` (${s.url})` : s.platform ? ` (${s.platform})` : '');
+  let line =
+    s.type +
+    (s.filePath ? ` (${s.filePath})` : s.url ? ` (${s.url})` : s.platform ? ` (${s.platform})` : '');
+  if (s.entityName && (s.type === 'openapi-file' || s.type === 'openapi-url')) {
+    line += ` [entity: ${s.entityName}]`;
+  }
+  return line;
 }
 
 /**

package/lib/commands/wizard.js

@@ -26,6 +26,7 @@ const {
   validateAndCheckAppDirectory,
   formatDataplaneRejectedTokenMessage,
   extractSessionId,
+  handleSourceSelection,
   handleOpenApiParsing,
   handleCredentialSelection,
   handleTypeDetection,
@@ -50,6 +51,149 @@ const {
 } = require('./wizard-helpers');
 const { humanizeAppKey } = require('../generator/wizard-prompts-secondary');
 
+/**
+ * Map resolved source type/data onto wizard state.source.
+ * @param {Object} state - Mutable wizard state
+ * @param {string} sourceType - Source type key
+ * @param {unknown} sourceData - Raw source payload from prompts
+ */
+function applySourceSelectionToState(state, sourceType, sourceData) {
+  state.source = { type: sourceType };
+  if (sourceType === 'openapi-file') state.source.filePath = sourceData;
+  else if (sourceType === 'openapi-url') state.source.url = sourceData;
+  else if (sourceType === 'mcp-server') state.source.serverUrl = JSON.parse(sourceData).serverUrl;
+  else if (sourceType === 'known-platform') state.source.platform = sourceData;
+}
+
+/**
+ * Interactive or prefill source selection (Step 2).
+ * @returns {Promise<{ sourceType: string, sourceData: unknown }>}
+ */
+async function resolveWizardSourcePhase(dataplaneUrl, sessionId, authConfig, platforms, prefill) {
+  if (prefill?.source?.type) {
+    logger.log(chalk.gray(
+      `Using source from wizard.yaml (${prefill.source.type}). Skipping source prompts.`
+    ));
+    return handleSourceSelection(dataplaneUrl, sessionId, authConfig, prefill.source);
+  }
+  return handleInteractiveSourceSelection(dataplaneUrl, sessionId, authConfig, platforms);
+}
+
+/**
+ * Credential selection with optional prefill (Step 3).
+ * @returns {Promise<string>} credentialIdOrKey for generation step
+ */
+async function resolveWizardCredentialPhase(dataplaneUrl, authConfig, prefill, state) {
+  if (prefill?.credential) {
+    state.credential = prefill.credential;
+    return handleCredentialSelection(dataplaneUrl, authConfig, prefill.credential);
+  }
+  const credentialAction = await promptForCredentialAction();
+  const configCredential = await resolveCredentialConfig(dataplaneUrl, authConfig, credentialAction);
+  state.credential = configCredential;
+  return handleCredentialSelection(dataplaneUrl, authConfig, configCredential);
+}
+
+/**
+ * Collect user intent and UI preferences (Step 5), with optional wizard.yaml prefill.
+ * @returns {Promise<{ userIntent: string, preferences: Object, hasPrefillIntent: boolean }>}
+ */
+async function collectIntentAndPreferences(preferencesPrefill) {
+  const prefillPrefs = preferencesPrefill;
+  const hasPrefillIntent =
+    prefillPrefs &&
+    typeof prefillPrefs.intent === 'string' &&
+    prefillPrefs.intent.trim().length > 0;
+
+  if (hasPrefillIntent) {
+    logger.log(chalk.gray(
+      'Using preferences from wizard.yaml (intent and toggles). Skipping preference prompts.'
+    ));
+    const level = prefillPrefs.fieldOnboardingLevel;
+    const validLevel = level === 'standard' || level === 'minimal' ? level : 'full';
+    return {
+      userIntent: prefillPrefs.intent.trim(),
+      preferences: {
+        fieldOnboardingLevel: validLevel,
+        mcp: Boolean(prefillPrefs.enableMCP),
+        abac: Boolean(prefillPrefs.enableABAC),
+        rbac: Boolean(prefillPrefs.enableRBAC)
+      },
+      hasPrefillIntent: true
+    };
+  }
+
+  const userIntent = await promptForUserIntent();
+  const preferences = await promptForUserPreferences();
+  return { userIntent, preferences, hasPrefillIntent: false };
+}
+
+/**
+ * Run Step 5 (generate), Step 6–7 (review), and save files; updates state.preferences.
+ * @param {Object} payload
+ * @param {string} payload.appKey - Application key
+ * @param {string} payload.dataplaneUrl - Dataplane URL
+ * @param {Object} payload.authConfig - Auth configuration
+ * @param {string} payload.sessionId - Wizard session ID
+ * @param {Object} payload.state - Mutable wizard state
+ * @param {Object} payload.flowOpts - Flow options (mode, systemIdOrKey, debug, prefill, etc.)
+ * @param {Object} payload.genInput - Generation inputs (openapiSpec, detectedType, credential…)
+ * @returns {Promise<Object|null>} Updated state or null if review cancelled
+ */
+async function completeWizardGenerateReviewSave(payload) {
+  const {
+    appKey,
+    dataplaneUrl,
+    authConfig,
+    sessionId,
+    state,
+    flowOpts,
+    genInput
+  } = payload;
+  const { mode, systemIdOrKey, debug, prefill } = flowOpts;
+  const genResult = await handleInteractiveConfigGeneration({
+    dataplaneUrl,
+    authConfig,
+    mode,
+    openapiSpec: genInput.openapiSpec,
+    detectedType: genInput.detectedType,
+    credentialIdOrKey: genInput.credentialIdOrKey,
+    systemIdOrKey,
+    sourceType: genInput.sourceType,
+    sourceData: genInput.sourceData,
+    entityName: genInput.entityName,
+    appName: appKey,
+    debug,
+    systemDisplayName: flowOpts.systemDisplayName,
+    preferencesPrefill: prefill?.preferences
+  });
+  const { systemConfig, datasourceConfigs, systemKey, preferences: savedPrefs } = genResult;
+  state.preferences = savedPrefs || {};
+
+  const finalConfigs = await handleConfigurationReview(
+    dataplaneUrl,
+    authConfig,
+    sessionId,
+    systemConfig,
+    datasourceConfigs,
+    { appKey, debug }
+  );
+  if (!finalConfigs) return null;
+
+  await handleFileSaving(
+    appKey,
+    finalConfigs.systemConfig,
+    finalConfigs.datasourceConfigs,
+    systemKey || appKey,
+    {
+      dataplaneUrl,
+      authConfig,
+      enableRBAC: Boolean(savedPrefs?.enableRBAC)
+    }
+  );
+  return state;
+}
+
 /**
  * Create wizard session with given mode and optional systemIdOrKey (no prompts)
  * @async
@@ -125,12 +269,15 @@ async function handleInteractiveSourceSelection(dataplaneUrl, sessionId, authCon
  * @param {Object} options.detectedType - Detected type info
  * @param {string} [options.credentialIdOrKey] - Credential ID or key (optional)
  * @param {string} [options.systemIdOrKey] - System ID or key (optional)
+ * @param {Object} [options.preferencesPrefill] - From wizard.yaml `preferences` (skip Step 5 prompts when intent is set)
  * @returns {Promise<Object>} Generated configuration and preferences { systemConfig, datasourceConfigs, systemKey, preferences }
  */
 async function handleInteractiveConfigGeneration(options) {
   logger.log(chalk.blue('\n\uD83D\uDCCB Step 5: User Preferences'));
-  const userIntent = await promptForUserIntent();
-  const preferences = await promptForUserPreferences();
+
+  const { userIntent, preferences, hasPrefillIntent } = await collectIntentAndPreferences(
+    options.preferencesPrefill
+  );
 
   const configPrefs = {
     intent: userIntent,
@@ -138,6 +285,9 @@ async function handleInteractiveConfigGeneration(options) {
     enableMCP: preferences.mcp,
     enableABAC: preferences.abac,
     enableRBAC: preferences.rbac,
+    enableOpenAPIGeneration: hasPrefillIntent
+      ? options.preferencesPrefill?.enableOpenAPIGeneration !== false
+      : true,
     debug: options.debug === true
   };
 
@@ -222,62 +372,43 @@ async function handleConfigurationReview(dataplaneUrl, authConfig, sessionId, sy
  * @returns {Promise<Object>} Collected state (source, credential, preferences) for wizard.yaml save
  */
 async function doWizardSteps(appKey, dataplaneUrl, authConfig, sessionId, flowOpts, state) {
-  const { mode, systemIdOrKey, platforms, debug } = flowOpts;
-  const { sourceType, sourceData } = await handleInteractiveSourceSelection(
-    dataplaneUrl, sessionId, authConfig, platforms
+  const { platforms, prefill } = flowOpts;
+
+  const { sourceType, sourceData } = await resolveWizardSourcePhase(
+    dataplaneUrl,
+    sessionId,
+    authConfig,
+    platforms,
+    prefill
   );
-  state.source = { type: sourceType };
-  if (sourceType === 'openapi-file') state.source.filePath = sourceData;
-  else if (sourceType === 'openapi-url') state.source.url = sourceData;
-  else if (sourceType === 'mcp-server') state.source.serverUrl = JSON.parse(sourceData).serverUrl;
-  else if (sourceType === 'known-platform') state.source.platform = sourceData;
+  applySourceSelectionToState(state, sourceType, sourceData);
 
   const openapiSpec = await handleOpenApiParsing(dataplaneUrl, authConfig, sourceType, sourceData);
-  const credentialAction = await promptForCredentialAction();
-  const configCredential = await resolveCredentialConfig(dataplaneUrl, authConfig, credentialAction);
-  state.credential = configCredential;
-  const credentialIdOrKey = await handleCredentialSelection(dataplaneUrl, authConfig, configCredential);
+  const credentialIdOrKey = await resolveWizardCredentialPhase(dataplaneUrl, authConfig, prefill, state);
 
   const detectedType = await handleTypeDetection(dataplaneUrl, authConfig, openapiSpec);
+  const prefillEntityName = prefill?.source?.entityName;
   const entityName = openapiSpec && sourceType !== 'known-platform'
-    ? await handleEntitySelection(dataplaneUrl, authConfig, openapiSpec) : null;
-  const genResult = await handleInteractiveConfigGeneration({
-    dataplaneUrl,
-    authConfig,
-    mode,
-    openapiSpec,
-    detectedType,
-    credentialIdOrKey,
-    systemIdOrKey,
-    sourceType,
-    sourceData,
-    entityName: entityName || undefined,
-    appName: appKey,
-    debug,
-    systemDisplayName: flowOpts.systemDisplayName
-  });
-  const { systemConfig, datasourceConfigs, systemKey, preferences: savedPrefs } = genResult;
-  state.preferences = savedPrefs || {};
-
-  const finalConfigs = await handleConfigurationReview(
+    ? await handleEntitySelection(dataplaneUrl, authConfig, openapiSpec, prefillEntityName) : null;
+  if (entityName && state.source) {
+    state.source.entityName = entityName;
+  }
+  return completeWizardGenerateReviewSave({
+    appKey,
     dataplaneUrl,
     authConfig,
     sessionId,
-    systemConfig,
-    datasourceConfigs,
-    { appKey, debug }
-  );
-  if (!finalConfigs) return null;
-
-  await handleFileSaving(
-    appKey,
-    finalConfigs.systemConfig,
-    finalConfigs.datasourceConfigs,
-    systemKey || appKey,
-    dataplaneUrl,
-    authConfig
-  );
-  return state;
+    state,
+    flowOpts,
+    genInput: {
+      openapiSpec,
+      detectedType,
+      credentialIdOrKey,
+      sourceType,
+      sourceData,
+      entityName: entityName || undefined
+    }
+  });
 }
 
 async function runWizardStepsAfterSession(appKey, dataplaneUrl, authConfig, sessionId, flowOpts) {
@@ -317,7 +448,7 @@ async function runWizardStepsAfterSession(appKey, dataplaneUrl, authConfig, sess
  * @returns {Promise<void>} Resolves when wizard flow completes
  */
 async function executeWizardFlow(appKey, dataplaneUrl, authConfig, flowOpts = {}) {
-  const { mode, systemIdOrKey, configPath, debug, systemDisplayName } = flowOpts;
+  const { mode, systemIdOrKey, configPath, debug, systemDisplayName, prefill } = flowOpts;
 
   if (debug) {
     logger.log(chalk.gray(`[DEBUG] Wizard debug mode enabled for app: ${appKey}`));
@@ -333,7 +464,8 @@ async function executeWizardFlow(appKey, dataplaneUrl, authConfig, flowOpts = {}
     platforms,
     configPath,
     debug: flowOpts.debug,
-    systemDisplayName
+    systemDisplayName,
+    prefill
   });
   if (!state) return;
 
@@ -348,6 +480,11 @@ async function executeWizardFlow(appKey, dataplaneUrl, authConfig, flowOpts = {}
  * @param {string} [appName] - App name (for log message)
  * @returns {Promise<Object|null>} Loaded config or null
  */
+/**
+ * Load wizard.yaml when present. Returns full valid config, or invalid-but-parsed config for interactive prefill.
+ *
+ * @returns {Promise<{ valid: true, config: Object } | { valid: false, config: Object, errors: string[] } | null>}
+ */
 async function loadWizardConfigIfExists(configPath, appName) {
   if (!configPath) return null;
   const displayPath = appName ? `integration/${appName}/wizard.yaml` : configPath;
@@ -360,10 +497,16 @@ async function loadWizardConfigIfExists(configPath, appName) {
     const result = await validateWizardConfig(configPath, { validateFilePaths: false });
     if (result.valid && result.config) {
       logger.log(chalk.green(`Loaded saved state from ${displayPath}. Resuming with saved choices.`));
-      return result.config;
+      return { valid: true, config: result.config };
     }
     if (result.errors?.length) {
-      logger.log(chalk.yellow(`Loaded ${displayPath} but it has errors; prompting for missing fields.`));
+      logger.log(chalk.yellow(
+        `Loaded ${displayPath} but it does not fully validate; prefilling from file where possible.`
+      ));
+      result.errors.forEach(err => logger.log(chalk.gray(`  • ${err}`)));
+    }
+    if (result.config) {
+      return { valid: false, config: result.config, errors: result.errors || [] };
     }
   } catch (e) {
     logger.log(chalk.gray(`Could not load wizard config from ${displayPath}: ${e.message}`));
@@ -470,15 +613,16 @@ async function handleWizardWithSavedConfig(options, loadedConfig, displayPath) {
 }
 
 async function handleWizardInteractive(options) {
+  const prefill = options.wizardPrefill;
   const allowAddDatasource = !options.app;
   const mode = allowAddDatasource ? await promptForMode(undefined, true) : 'create-system';
   const resolved = mode === 'create-system'
-    ? await resolveCreateNewPath(options, null)
-    : await resolveAddDatasourcePath(options, null);
+    ? await resolveCreateNewPath(options, prefill || null)
+    : await resolveAddDatasourcePath(options, prefill || null);
   if (!resolved) return;
   const { appKey, configPath, dataplaneUrl, authConfig } = resolved;
   const systemIdOrKey = mode === 'add-datasource' ? resolved.systemIdOrKey : undefined;
-  const systemDisplayName = options.systemDisplayName || options.displayName ||
+  const systemDisplayName = options.systemDisplayName || options.displayName || prefill?.systemDisplayName ||
     (mode === 'create-system' ? humanizeAppKey(appKey) : undefined);
   try {
     await executeWizardFlow(appKey, dataplaneUrl, authConfig, {
@@ -486,7 +630,8 @@ async function handleWizardInteractive(options) {
       systemIdOrKey,
       configPath,
       debug: options.debug,
-      systemDisplayName
+      systemDisplayName,
+      prefill: prefill || undefined
     });
     logger.log(chalk.gray(`To change settings, edit integration/${appKey}/wizard.yaml and run: aifabrix wizard ${appKey}`));
   } catch (error) {
@@ -504,9 +649,12 @@ async function handleWizard(options = {}) {
     return await handleWizardSilent(options);
   }
   logger.log(chalk.blue('\n\uD83E\uDDD9 AI Fabrix External System Wizard\n'));
-  const loadedConfig = await loadWizardConfigIfExists(options.configPath, options.app);
-  if (loadedConfig) {
-    return await handleWizardWithSavedConfig(options, loadedConfig, displayPath);
+  const loadResult = await loadWizardConfigIfExists(options.configPath, options.app);
+  if (loadResult?.valid && loadResult.config) {
+    return await handleWizardWithSavedConfig(options, loadResult.config, displayPath);
+  }
+  if (loadResult?.config && loadResult.valid === false) {
+    return await handleWizardInteractive({ ...options, wizardPrefill: loadResult.config });
   }
   return await handleWizardInteractive(options);
 }