@algolia/wizard 0.112.0 → 0.113.0

package/dist/main.js

@@ -1216,6 +1216,7 @@ import { useLayoutEffect as useLayoutEffect4, useRef as useRef3, useState as use
 import { jsx as jsx8, jsxs as jsxs9 } from "react/jsx-runtime";
 var CANCEL = "cancel";
 var ARROW_WIDTH = 4;
+var MULTI_TOGGLE_WIDTH = "[ ] ".length;
 var COLUMN_GAP = 2;
 var BAR_PADDING = 2;
 var ROW_HEIGHT = 3;
@@ -1229,6 +1230,7 @@ function nextSelectableIndex(start, dir, rowCount, isDisabled) {
 }
 function SelectPrompt({
   options,
+  labels,
   onSelect,
   question,
   helpText,
@@ -1242,10 +1244,11 @@ function SelectPrompt({
   disabled,
   defaultSelectedIndex = 0
 }) {
-  const hasCancel = Boolean(multi || cancelable);
+  const hasCancel = Boolean(cancelable);
   const rows = hasCancel ? [...options, "Cancel"] : options;
   const cancelIndex = hasCancel ? options.length : -1;
   const isDisabled = (i) => i !== cancelIndex && Boolean(disabled?.[i]);
+  const displayLabel = (i) => i === cancelIndex ? "Cancel" : labels?.[i] ?? options[i];
   const [index, setIndex] = useState8(() => {
     const start = defaultSelectedIndex > 0 && defaultSelectedIndex < options.length ? defaultSelectedIndex : 0;
     return isDisabled(start) ? nextSelectableIndex(start, 1, rows.length, isDisabled) : start;
@@ -1253,7 +1256,7 @@ function SelectPrompt({
   const [checked, setChecked] = useState8(() => /* @__PURE__ */ new Set());
   const hints = [];
   if (rows.length > 1) hints.push({ key: "[\u2191] [\u2193]", label: "move" });
-  if (multi) hints.push({ key: "[space]", label: "select" });
+  if (multi) hints.push({ key: "[space]", label: "toggle select" });
   hints.push({ key: "[enter]", label: "confirm" });
   const containerRef = useRef3(null);
   const { columns } = useWindowSize4();
@@ -1265,7 +1268,7 @@ function SelectPrompt({
   });
   const inner = Math.max(width - BAR_PADDING, 0);
   const labelWidth = Math.min(
-    ARROW_WIDTH + (multi ? 2 : 0) + Math.max(0, ...rows.map((opt) => opt.length)) + COLUMN_GAP,
+    ARROW_WIDTH + (multi ? MULTI_TOGGLE_WIDTH : 0) + Math.max(0, ...rows.map((_, i) => displayLabel(i).length)) + COLUMN_GAP,
     inner
   );
   const badgeWidth = Math.max(
@@ -1288,7 +1291,10 @@ function SelectPrompt({
   }, [index, revealIndex]);
   const visible = rows.slice(scroll.offset, scroll.offset + scroll.capacity);
   useInput5((input, key) => {
-    if (rows.length === 0) return;
+    if (rows.length === 0) {
+      if (multi && key.return) onSelect([]);
+      return;
+    }
     if (key.upArrow || input === "k") {
       setIndex((i) => nextSelectableIndex(i, -1, rows.length, isDisabled));
     } else if (key.downArrow || input === "j") {
@@ -1307,8 +1313,10 @@ function SelectPrompt({
       } else if (!multi) {
         onSelect(options[index]);
       } else {
-        const picked = options.filter((_, i) => checked.has(i) && !isDisabled(i));
-        if (picked.length > 0) onSelect(picked);
+        const picked = options.filter(
+          (_, i) => checked.has(i) && !isDisabled(i)
+        );
+        onSelect(picked);
       }
     }
   });
@@ -1340,7 +1348,7 @@ function SelectPrompt({
       const i = scroll.offset + visibleIndex;
       const highlighted = i === index;
       const isCancel = i === cancelIndex;
-      const bullet = multi && !isCancel ? checked.has(i) ? "\u25CF " : "\u25CB " : "";
+      const bullet = multi && !isCancel ? checked.has(i) ? "[x] " : "[ ] " : "";
       const sec = isCancel ? void 0 : secondary?.[i];
       const isText = sec?.kind === "text";
       const rowDisabled = isDisabled(i);
@@ -1351,7 +1359,7 @@ function SelectPrompt({
           disabled: rowDisabled,
           width: isText ? "100%" : barWidth,
           labelWidth: isText ? labelWidth : barLabelWidth,
-          label: `${bullet}${option}`,
+          label: `${bullet}${displayLabel(i)}`,
           usePadding: true,
           children: [
             isText && textWidth > 0 && /* @__PURE__ */ jsx8(Box9, { width: textWidth, children: /* @__PURE__ */ jsx8(
@@ -1432,6 +1440,7 @@ function PromptInput() {
         table: inputReq.table,
         list: inputReq.list,
         options: inputReq.options,
+        labels: inputReq.labels,
         secondary: inputReq.secondary,
         disabled: inputReq.disabled,
         defaultSelectedIndex: inputReq.defaultSelectedIndex,
@@ -1453,7 +1462,10 @@ function PromptInput() {
         table: inputReq.table,
         list: inputReq.list,
         options: inputReq.options,
+        labels: inputReq.labels,
         error: inputReq.error,
+        secondary: inputReq.secondary,
+        cancelable: inputReq.cancelable,
         onSelect: handleSubmit
       },
       promptKey
@@ -1464,6 +1476,7 @@ function PromptInput() {
       SelectPrompt,
       {
         messages: inputReq.messages,
+        list: inputReq.list,
         options: ["Continue"],
         onSelect: handleSubmit
       },
@@ -2173,6 +2186,7 @@ function wizardErrorType(actionId, step, error) {
     }
     return "Generate UI";
   }
+  if (actionId === "build-ui") return "playbook";
   return void 0;
 }
 function commonEventProperties() {
@@ -2375,7 +2389,13 @@ async function loadSelectableApps() {
 }
 async function pickApplication(opts) {
   const store = useWizard.getState();
-  const apps = await loadSelectableApps();
+  store.setLoadingMessage("Loading applications\u2026");
+  let apps;
+  try {
+    apps = await loadSelectableApps();
+  } finally {
+    store.setLoadingMessage(null);
+  }
   const envHighlight = opts.highlight;
   const envApp = envHighlight ? apps.find((app) => app.id === envHighlight.id) : void 0;
   const highlightIndex = envApp && canSelectApplication(envApp) ? apps.indexOf(envApp) : -1;
@@ -2461,15 +2481,21 @@ async function promptToChangeApplication(currentId) {
 }
 async function ensureApplication(resumeAppId) {
   if (resumeAppId) return selectAndReport(resumeAppId);
-  const env = await findEnvApplicationId();
-  if (!env) return promptForApplication();
-  return promptForApplication({ id: env.id, file: env.file });
+  const store = useWizard.getState();
+  store.setLoadingMessage("Loading applications\u2026");
+  try {
+    const env = await findEnvApplicationId();
+    if (!env) return await promptForApplication();
+    return await promptForApplication({ id: env.id, file: env.file });
+  } finally {
+    store.setLoadingMessage(null);
+  }
 }
 
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.112.0",
+  version: "0.113.0",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {
@@ -2684,7 +2710,7 @@ async function ensureConsent() {
   config.aiConsent = true;
   await saveConfig(config);
 }
-async function makeContext(state) {
+async function makeContext(state, reentered) {
   const outputs = {};
   const completedSteps = [];
   for (const s of state.steps) {
@@ -2698,6 +2724,7 @@ async function makeContext(state) {
   return {
     outputs,
     completedSteps,
+    reentered,
     getStepOutput: (stepId) => outputs[stepId],
     requestUserInput: (prompt) => useWizard.getState().requestUserInput(prompt),
     notify: (notice) => useWizard.getState().pushNotice(notice),
@@ -2752,6 +2779,7 @@ async function rewindTo(state, targetIndex, fromIndex) {
 async function runStep(state, index, step) {
   const store = useWizard.getState();
   const record = state.steps[index];
+  const reentered = record.status === "running" || record.status === "error";
   const startedAt = Date.now();
   const appId = runAppId(state);
   trackActionStart({
@@ -2770,7 +2798,7 @@ async function runStep(state, index, step) {
   store.syncSteps([...state.steps], index);
   await persistState(state);
   await markInteraction();
-  const ctx = await makeContext(state);
+  const ctx = await makeContext(state, reentered);
   const stopSavingCost = saveCostDuringStep(state);
   let output;
   try {
@@ -2818,6 +2846,9 @@ async function startFresh(workflow, appId) {
   return initWorkflowState(workflow, nowIso(), appId);
 }
 async function resolveWorkflowState(workflow, appId, options) {
+  if (options?.resumableState === null) {
+    return startFresh(workflow, appId);
+  }
   const resumed = options?.resumableState !== void 0 ? options.resumableState : await loadResumableState(workflow);
   if (!resumed) {
     return initWorkflowState(workflow, nowIso(), appId);
@@ -6111,7 +6142,10 @@ var isSameFramework = (a, b) => {
 };
 function confirmed(name, version) {
   const frameworks = [{ name, version: version ?? "unknown" }];
-  track("AI Wizard Frontend Framework Confirmed", { frameworks, framework: name });
+  track("AI Wizard Frontend Framework Confirmed", {
+    frameworks,
+    framework: name
+  });
   return { frameworks };
 }
 async function askOtherFramework(ctx) {
@@ -6130,8 +6164,8 @@ async function askOtherFramework(ctx) {
     prompt = "please enter the framework used for your frontend:";
   }
 }
-async function confirmFramework(ctx) {
-  const detected = ctx.getStepOutput("project-scan");
+async function confirmFramework(ctx, scan) {
+  const detected = scan ?? ctx.getStepOutput("project-scan");
   const detectedFrameworks = detected.frameworks ?? [];
   const options = [...CURATED_FRAMEWORKS];
   for (const fw of detectedFrameworks) {
@@ -6421,6 +6455,7 @@ ${formatCompletedSteps(ctx.completedSteps)}`,
 import z29 from "zod";
 import { access, mkdir as mkdir5, readdir as readdir3, readFile as readFile10 } from "node:fs/promises";
 import {
+  basename as basename6,
   dirname as dirname5,
   extname,
   isAbsolute as isAbsolute4,
@@ -6594,6 +6629,17 @@ var implementSchema = z29.object({
         value: z29.string()
       })
     )
+  }).optional(),
+  uiReport: z29.object({
+    files: z29.array(
+      z29.object({
+        label: z29.string(),
+        path: z29.string()
+      })
+    ),
+    checkPassed: z29.boolean(),
+    typecheckCommand: z29.string().optional(),
+    devCommand: z29.string().optional()
   }).optional()
 });
 var implementationOutputSchema = z29.object({
@@ -6602,14 +6648,17 @@ var implementationOutputSchema = z29.object({
   // Only for the search use case: the path of whatever module the agent
   // defined the Algolia config constants in, so the wizard can check it
   // won't end up gitignored (it's public, meant to be committed).
-  searchConfigFile: z29.string().optional()
+  searchConfigFile: z29.string().optional(),
+  uiFiles: z29.array(z29.object({ label: z29.string(), path: z29.string() })).optional(),
+  devCommand: z29.string().optional()
 });
 var validationOutputSchema = z29.object({
   summary: z29.string(),
   sufficient: z29.boolean(),
   additionalInstructions: z29.string().optional(),
   unrelatedFailure: z29.string().optional(),
-  styleOnly: z29.boolean().optional()
+  styleOnly: z29.boolean().optional(),
+  typecheckCommand: z29.string().optional()
 });
 var MAX_IMPLEMENT_VALIDATION_ATTEMPTS = 3;
 var INGESTION_MAX_STEPS = 96;
@@ -6751,11 +6800,13 @@ function ingestionInstructions(input) {
 }
 function searchInstructions(input) {
   const indexedEntity = input.findings.confirmedEntities?.[0];
-  const indexedContentMessage = indexedEntity ? `Indexed content context: ${JSON.stringify({
+  const templateMessage = input.uiTemplate ? `UI template: ${JSON.stringify(input.uiTemplate)}. Implement its layout, search placeholder, hit fields, filters, and sort controls. Use only the template's index attributes. Do not infer or invent record fields from the project.` : null;
+  const indexedEntityMessage = indexedEntity ? `Indexed content context: ${JSON.stringify({
     entity: indexedEntity.name,
     attributes: indexedEntity.attributes,
     sourcePaths: indexedEntity.paths
   })}. Use the source and the existing UI that displays this entity to understand the search task, result content, and appropriate scope.` : null;
+  const indexedContentMessage = templateMessage || indexedEntityMessage;
   const mountCandidateMessage = input.searchLocation ? `The confirmed-content placement analysis suggested "${input.searchLocation}" as a mount candidate. Before editing, read that file and inspect its parent layout, sibling controls, and the relevant content UI. If the evidence confirms it, import and render the new search component there; otherwise mount it in the better existing file. In all cases, mount the component before finishing; do not leave an unrendered component.` : "The scan found no reliable mount candidate. Determine the best existing location from the layout hierarchy and the UI that displays the indexed content, then mount the new search component there; do not default to a header or navigation component or leave an unrendered component.";
   const placementMessage = "Place content-specific search beside the heading or controls for the corresponding browse/listing task. Use shared navigation only for genuinely app-wide search and only when it fits the available space and responsive layout without crowding primary actions.";
   const replacementMessage = `${SEARCH_SCOPE_RULE} Replace the usage of each same-scope search control with the new component, keep its intentional placement, and delete the code that only it uses, for example its provider, dialog, and hooks. Keep differently scoped search, filters, and navigation.`;
@@ -6788,7 +6839,10 @@ function searchInstructions(input) {
     "Give the search input frame the same height, corner radius, border color and width, background, and focus style as the input it replaces. When it replaces nothing, copy them from the form controls beside it. Read these values from their source (the theme, the component props, or the CSS). Do not keep the widget theme defaults, for example a 44px height and 4px corners, and do not invent colors. When the app theme exists only in code, take the values from that theme object.",
     "When you add UI text to a localized dictionary or message file, add the same keys, translated, to every locale the project supports.",
     "Before reporting, mount the component. Do not run a type check, build, or test command unless a later instruction allows it: the validation pass runs the type check, after the developer agrees to it. If a tool limit is reached or an error remains unresolved, keep the implementation, report status=success, and name the remaining issue in the summary so validation can drive the next pass. Report status=fail only when no search implementation can be written, with the concrete blocker as the reason.",
-    "The summary should be extremely concise; do not mention manual testing steps."
+    "The summary should be extremely concise; do not mention manual testing steps.",
+    ...input.uiTemplate ? [
+      "For the playbook recap, report uiFiles as every file you created or edited for this UI. Each entry needs a short action label and its repo-relative path. Report devCommand only when you found the project\u2019s existing command for starting the app locally. Do not invent a command, host, or port."
+    ] : []
   ];
 }
 var SEARCH_SCOPE_RULE = "An existing search control has the same scope as the new search when its results include the indexed content, for example a site-wide search dialog or command palette. A search control that returns only other content, for example settings or help pages, has a different scope.";
@@ -6875,7 +6929,9 @@ The widget reads the item and noResults templates only from each indices entry.
 }
 function cdnSearchInstructions(input) {
   const entityName = input.findings.confirmedEntities?.[0]?.name;
-  const placeholder = entityName ? `Search ${entityName} records...` : "Search indexed content...";
+  const templatePlaceholder = input.uiTemplate?.search_placeholder;
+  const entityNamePlaceholder = entityName ? `Search ${entityName} records...` : "Search indexed content...";
+  const placeholder = templatePlaceholder ?? entityNamePlaceholder;
   return [
     `The target frontend has no package.json. Add the search container to its existing HTML or template, create separate classic config and search scripts, define window.${SEARCH_CONFIG_APP_ID}, window.${SEARCH_CONFIG_SEARCH_KEY}, and window.${SEARCH_CONFIG_INDEX_NAME} in the config script, and report that script as "searchConfigFile". Never create package.json, create a component, use imports or exports, or run npm, pnpm, yarn, or bun.`,
     `Set window.${SEARCH_CONFIG_APP_ID} to "${input.appId}" and window.${SEARCH_CONFIG_INDEX_NAME} to "${input.targetIndex}".`,
@@ -6887,9 +6943,12 @@ function cdnSearchInstructions(input) {
   ];
 }
 function validationInstructions(input) {
+  const templateMessage = input.uiTemplate ? `UI template: ${JSON.stringify(input.uiTemplate)}. Confirm the implementation uses its layout, search placeholder, hit fields, filters, and sort controls with the template's exact index attributes.` : null;
+  const indexedEntityMessage = input.findings.confirmedEntities?.[0] ? `Indexed content context: ${JSON.stringify(input.findings.confirmedEntities?.[0] ?? null)}.` : null;
+  const contentMessage = (templateMessage || indexedEntityMessage) ?? "";
   return [
     "Validate the Algolia search implementation by inspecting the project source.",
-    `Indexed content context: ${JSON.stringify(input.findings.confirmedEntities?.[0] ?? null)}.`,
+    contentMessage,
     `The confirmed placement candidate was "${input.searchLocation ?? "unknown"}", but verify the actual mount rather than assuming the candidate was used.`,
     "Inspect the generated search component, its actual mount file, that file's parent layout and sibling controls, and the relevant content UI. Do not rely only on type checks or tests.",
     `Confirm that the application renders exactly one search control for the indexed content, and that the new component is not mounted twice. ${SEARCH_SCOPE_RULE} If a same-scope search control is still mounted, set sufficient=false and name the file that mounts it. Do not set sufficient=false for a differently scoped search control.`,
@@ -6920,6 +6979,9 @@ function validationInstructions(input) {
     "You can only read source files. If a required property can be checked in the source, check it there. If it can be established only in a browser (rendered contrast, keyboard behavior, 320-pixel reflow, live-region status, computed accessible name), set sufficient=true when the source shows no violation. Never request devtools, a screenshot, or a contrast tool, and never repeat a finding that an earlier pass already fixed.",
     "If a check fails only in untouched code, set unrelatedFailure to a concise failure description.",
     "Set styleOnly=true when sufficient=false and every finding is one of these: the theme palette defaults remain, a palette override loses to the theme, the highlight classes keep the theme blue, or the input frame does not match the size, radius, border, or background of the controls that it must match. If any other finding exists, for example a light panel on a dark page or a result that a click does not open, do not set styleOnly.",
+    ...input.uiTemplate ? [
+      "When you run a type check, report its exact command as typecheckCommand. Omit it when no type check ran."
+    ] : [],
     "Keep the summary to one short sentence. Put the details in additionalInstructions."
   ];
 }
@@ -6947,13 +7009,7 @@ var useCaseToolMap = {
     "reviewScript",
     "notifyUser"
   ],
-  search: [
-    ...FS_READ_TOOLS,
-    "writeFile",
-    "editFile",
-    "runShell",
-    "notifyUser"
-  ],
+  search: [...FS_READ_TOOLS, "writeFile", "editFile", "runShell", "notifyUser"],
   validation: [...FS_READ_TOOLS, "runShell", "notifyUser"]
 };
 function toolsForUseCase(useCase, ingestionSource) {
@@ -7106,7 +7162,10 @@ function ingestFailure(attempt, missingRunReason = "no successful run was record
   if (!attempt) return { reason: missingRunReason };
   if (!attempt.approved) return { reason: "you declined to run it" };
   if (ranButIndexedNothing(attempt)) {
-    return { reason: "it ran but indexed 0 records", detail: EMPTY_INGEST_DETAIL };
+    return {
+      reason: "it ran but indexed 0 records",
+      detail: EMPTY_INGEST_DETAIL
+    };
   }
   const detail = errorLine(attempt.output);
   if (attempt.timedOut) {
@@ -7286,22 +7345,19 @@ async function resolveIngestionSource(ctx, repoRoot) {
     logger.warn({ reason: copied.reason }, "implement: file upload unavailable");
   }
 }
-async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
+async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, options = {}) {
   const repoRoot = process.cwd();
-  const scan = ctx.getStepOutput("project-scan");
+  const scan = options.scan ?? ctx.getStepOutput("project-scan");
   const entities = ctx.getStepOutput(
     "confirm-entities"
   );
   const language = {
     languages: ctx.getStepOutput("confirm-language")?.languages ?? scan.languages,
-    frameworks: ctx.getStepOutput("confirm-framework")?.frameworks ?? scan.frameworks
+    frameworks: options.frameworks ?? ctx.getStepOutput("confirm-framework")?.frameworks ?? scan.frameworks
   };
   const selected = ctx.getStepOutput(
     "select-index"
   );
-  if (!selected?.selection) {
-    throw new Error(`No index was selected`);
-  }
   await assertGitRepoWithHead(repoRoot);
   let ingestionSource = "generated";
   let uploadFilePath = void 0;
@@ -7312,7 +7368,10 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
       repoRoot
     ));
   }
-  const targetIndex = selected?.selection;
+  const targetIndex = options.targetIndex ?? selected?.selection;
+  if (!targetIndex) {
+    throw new Error(`No index was selected`);
+  }
   useWizard.getState().setTargetIndex(targetIndex ?? null);
   if (useCases.includes("ingestion")) {
     await mkdir5(join11(repoRoot, INGEST_DIR), { recursive: true });
@@ -7380,7 +7439,8 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
     frontendHasPackageJson: await frontendHasPackageJson(
       repoRoot,
       searchLocation
-    )
+    ),
+    uiTemplate: options.uiTemplate
   };
   let agentRuns = 0;
   let ingestCommand;
@@ -7449,7 +7509,10 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
       tools: toolsForUseCase("validation"),
       outputSchema: validationOutputSchema,
       modelProfile: "validation" /* validation */,
-      toolContext: { ...makeToolContext(repoRoot), dependencyManifestsOnly: true }
+      toolContext: {
+        ...makeToolContext(repoRoot),
+        dependencyManifestsOnly: true
+      }
     });
   }
   if (useCases.includes("ingestion")) {
@@ -7667,6 +7730,10 @@ ${detail}` : ""}`
     }
   }
   let searchConfigFile;
+  let uiFiles;
+  let devCommand;
+  let typecheckCommand;
+  let checkPassed = false;
   if (useCases.includes("search")) {
     ingestionScript = await findIngestionScript(
       repoRoot,
@@ -7717,6 +7784,10 @@ ${detail}` : ""}`
         attempt > FIRST_IMPLEMENTATION_ATTEMPT
       );
       summaries.push(formatSummary("search", searchResult.summary));
+      if (searchResult.uiFiles?.length) {
+        uiFiles = searchResult.uiFiles;
+      }
+      devCommand ??= searchResult.devCommand;
       if (searchResult.searchConfigFile) {
         searchConfigFile = searchResult.searchConfigFile;
       }
@@ -7748,6 +7819,8 @@ ${detail}` : ""}`
       }
       const styleFindingsRemain = finalAttempt && !validation.sufficient && validation.styleOnly === true;
       if (validation.sufficient && (!validation.unrelatedFailure || finalAttempt) || styleFindingsRemain) {
+        checkPassed = buildCheckPlan.run && validation.sufficient && !validation.unrelatedFailure;
+        typecheckCommand = validation.typecheckCommand;
         if (validation.unrelatedFailure) {
           summaries.push("Validation: Unrelated check failures remain.");
         }
@@ -7819,6 +7892,19 @@ ${detail}` : ""}`
           { name: SEARCH_CONFIG_INDEX_NAME, value: targetIndex }
         ]
       }
+    } : {},
+    ...options.uiTemplate && useCases.includes("search") ? {
+      uiReport: {
+        files: uiFiles?.length ? uiFiles : [...new Set(useWizard.getState().writtenFiles)].map(
+          (file) => ({
+            label: "updated",
+            path: relative7(repoRoot, file) || basename6(file)
+          })
+        ),
+        checkPassed,
+        ...typecheckCommand ? { typecheckCommand } : {},
+        ...devCommand ? { devCommand } : {}
+      }
     } : {}
   };
 }
@@ -8022,17 +8108,18 @@ var schemaComparisonEntrySchema = z32.object({
   status: z32.string(),
   mapping_confidence: z32.number()
 });
-var settingsRecommendationSchema = z32.record(
+var settingRecommendationSchema = z32.object({
+  current: z32.any(),
+  recommended: z32.any()
+});
+var settingsRecommendationEntriesSchema = z32.record(
   z32.string(),
-  z32.object({
-    current: z32.any(),
-    recommended: z32.any()
-  })
+  settingRecommendationSchema
 );
 var assessmentResultSchema = z32.object({
   ready: z32.boolean(),
   schema_comparison: z32.array(schemaComparisonEntrySchema),
-  settings_recommendation: settingsRecommendationSchema
+  settings_recommendation: settingsRecommendationEntriesSchema
 });
 var playbookExecutionSchema = z32.object({
   uuid: z32.string(),
@@ -8051,6 +8138,18 @@ var playbookExecutionCreateResponseSchema = playbookExecutionSchema.extend({
   resumed: z32.boolean(),
   sample_data: z32.boolean()
 });
+var uiTemplateFieldSchema = z32.record(z32.string(), z32.unknown());
+var uiTemplateSchema = z32.looseObject({
+  layout: z32.string(),
+  record_label: z32.object({
+    singular: z32.string(),
+    plural: z32.string()
+  }),
+  search_placeholder: z32.string().optional(),
+  hit: uiTemplateFieldSchema,
+  filters: z32.array(uiTemplateFieldSchema),
+  sort_by: z32.array(uiTemplateFieldSchema)
+});
 
 // src/lib/dashboardApi/api.ts
 async function getPlaybooks() {
@@ -8092,8 +8191,47 @@ async function getPlaybookExecution(uuid) {
 }
 async function assessPlaybookExecution(uuid) {
   const { data } = await dashboardRequest(
-    `/api/1/playbook-integrations/playbooks/executions/${uuid}/assess`,
+    `/api/1/playbook-integrations/playbooks/executions/${uuid}/start_data_assessment`,
+    playbookExecutionSchema,
+    { method: "POST" }
+  );
+  return data;
+}
+async function updatePlaybookStepStatus(uuid, stepStatus, statusReason) {
+  const reason = statusReason?.trim();
+  const { data } = await dashboardRequest(
+    `/api/1/playbook-integrations/playbooks/executions/${uuid}/update_step_status`,
+    playbookExecutionSchema,
+    {
+      method: "PATCH",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        step_status: stepStatus,
+        ...stepStatus === "error" && reason ? { status_reason: reason } : {}
+      })
+    }
+  );
+  return data;
+}
+async function applyPlaybookExecutionSettings(uuid, settingsAccepted, settingsDeclined) {
+  const { data } = await dashboardRequest(
+    `/api/1/playbook-integrations/playbooks/executions/${uuid}/apply_index_settings`,
     playbookExecutionSchema,
+    {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        settings_accepted: settingsAccepted,
+        settings_declined: settingsDeclined
+      })
+    }
+  );
+  return data;
+}
+async function getPlaybookUiTemplate(uuid) {
+  const { data } = await dashboardRequest(
+    `/api/1/playbook-integrations/playbooks/executions/${uuid}/generate_ui_template`,
+    uiTemplateSchema,
     { method: "POST" }
   );
   return data;
@@ -8113,6 +8251,13 @@ async function selectPlaybookStep(ctx, requestedSlug) {
   if (slugs.length === 0) {
     throw new Error("No playbooks are available.");
   }
+  const nextPlaybookSlug = ctx.getUserInput("nextPlaybookSlug");
+  if (nextPlaybookSlug) {
+    ctx.setUserInput("nextPlaybookSlug", void 0);
+    if (slugs.includes(nextPlaybookSlug)) {
+      return persistSlug(ctx, nextPlaybookSlug);
+    }
+  }
   const alreadyChose = typeof ctx.getUserInput("playbookSlug") === "string";
   if (!alreadyChose && requestedSlug && slugs.includes(requestedSlug)) {
     return persistSlug(ctx, requestedSlug);
@@ -8151,7 +8296,22 @@ function formatIndexOption(index) {
 function isIndexSelectable(index) {
   return index.entries >= MIN_ENTRIES_FOR_SELECTION;
 }
-async function selectIndexStep2(ctx) {
+function persistIndex(ctx, result) {
+  ctx.setUserInput("playbookIndexName", result.indexName);
+  ctx.setUserInput("playbookSampleIndex", result.sampleIndex);
+  return result;
+}
+function alreadyChoseIndex(ctx) {
+  return typeof ctx.getUserInput("playbookIndexName") === "string" || typeof ctx.getUserInput("playbookSampleIndex") === "boolean";
+}
+function requestedIndexError(indices, requestedIndexName) {
+  const selectedIndex = indices.find((idx) => idx.name === requestedIndexName);
+  if (!selectedIndex) {
+    return `"${requestedIndexName}" is not a valid index. Choose one of the available indices.`;
+  }
+  return `"${requestedIndexName}" has no records. Choose an index with data.`;
+}
+async function selectIndexStep2(ctx, requestedIndexName) {
   let indices = ctx.getUserInput("fetchedIndices");
   !indices && ctx.notify({
     messages: ["Fetching indices from your Algolia application\u2026"]
@@ -8162,25 +8322,29 @@ async function selectIndexStep2(ctx) {
     ctx.setUserInput("fetchedIndices", indices);
   }
   const hasIndices = indices.length > 0;
-  const indexOptions = hasIndices ? indices.map(formatIndexOption) : [];
-  const options = [
-    ...indexOptions,
-    CREATE_SAMPLE_INDEX,
-    GO_BACK_OPTION,
-    SELECT_APP_OPTION
+  const choices = [
+    ...indices.map((index) => ({
+      label: formatIndexOption(index),
+      disabled: !isIndexSelectable(index)
+    })),
+    { label: CREATE_SAMPLE_INDEX, disabled: false },
+    { label: GO_BACK_OPTION, disabled: false },
+    { label: SELECT_APP_OPTION, disabled: false }
   ];
-  const disabled = hasIndices ? [
-    ...indices.map((idx) => !isIndexSelectable(idx)),
-    false,
-    // CREATE_SAMPLE_INDEX is selectable
-    false,
-    // GO_BACK_OPTION is selectable
-    false
-    // SELECT_APP_OPTION is selectable
-  ] : void 0;
+  const options = choices.map((choice) => choice.label);
+  const disabled = hasIndices ? choices.map((choice) => choice.disabled) : void 0;
   const prompt = hasIndices ? "Select an index:" : `${app.name} doesn't have any indices yet. Start from a sample data set 
 you can explore or switch to another application`;
-  let error;
+  if (!alreadyChoseIndex(ctx) && requestedIndexName) {
+    const selectedIndex = indices.find((idx) => idx.name === requestedIndexName);
+    if (selectedIndex && isIndexSelectable(selectedIndex)) {
+      return persistIndex(ctx, {
+        indexName: selectedIndex.name,
+        sampleIndex: false
+      });
+    }
+  }
+  let error = !alreadyChoseIndex(ctx) && requestedIndexName ? requestedIndexError(indices, requestedIndexName) : void 0;
   let result;
   while (result === void 0) {
     const selection = await ctx.requestUserInput({
@@ -8198,6 +8362,8 @@ you can explore or switch to another application`;
     }
     if (selection === GO_BACK_OPTION) {
       ctx.setUserInput("fetchedIndices", void 0);
+      ctx.setUserInput("playbookIndexName", void 0);
+      ctx.setUserInput("playbookSampleIndex", void 0);
       return ctx.returnToStep("select-playbook");
     }
     if (selection === SELECT_APP_OPTION) {
@@ -8223,7 +8389,7 @@ you can explore or switch to another application`;
       sampleIndex: false
     };
   }
-  return result;
+  return persistIndex(ctx, result);
 }
 
 // src/actions/playbookSteps/confirmIndex.ts
@@ -8247,7 +8413,7 @@ async function confirmIndexStep(ctx) {
     helpText: "Going back lets you choose a different index."
   });
   if (typeof selection !== "string") {
-    throw new Error("confirm-index received an unexpected result");
+    throw new Error("confirm-sample-index received an unexpected result");
   }
   if (selection === GO_BACK_OPTION2) {
     return ctx.returnToStep("select-index");
@@ -8396,6 +8562,13 @@ var POLL_NOTICES = [
 async function dataAssessmentStep(ctx) {
   const { slug: slug2 } = ctx.getStepOutput("select-playbook");
   const { indexName, existingExecution } = indexForAssessment(ctx);
+  const assessmentToRedisplay = ctx.getUserInput(
+    "assessedPlaybookExecution"
+  );
+  if (assessmentToRedisplay?.source_index_name === indexName && assessmentToRedisplay.playbook_slug === slug2) {
+    await promptReady(ctx, assessmentToRedisplay);
+    return assessmentToRedisplay;
+  }
   if (existingExecution) return existingExecution;
   try {
     showNotice(ctx, CREATING_EXECUTION_NOTICE);
@@ -8404,6 +8577,7 @@ async function dataAssessmentStep(ctx) {
     const assessed = await runAssessment(ctx, execution, indexName);
     ctx.clearNotices();
     await promptReady(ctx, assessed);
+    ctx.setUserInput("assessedPlaybookExecution", assessed);
     return assessed;
   } finally {
     ctx.clearNotices();
@@ -8414,10 +8588,10 @@ function indexForAssessment(ctx) {
   if (!selected.sampleIndex) {
     return { indexName: selected.indexName, existingExecution: null };
   }
-  const created = ctx.getStepOutput("confirm-index");
+  const created = ctx.getStepOutput("confirm-sample-index");
   if (!created) {
     throw new Error(
-      "data-assessment expected confirm-index to create a sample index"
+      "data-assessment expected confirm-sample-index to create a sample index"
     );
   }
   return {
@@ -8445,36 +8619,24 @@ function startPollNotices(ctx) {
   return () => clearTimeout(timer);
 }
 function isNotReady(execution) {
-  return execution.step_status === "error" && execution.status_reason === "not_ready";
+  return execution.step_status === "error" && !!execution.status_reason?.includes("not ready");
 }
 async function runAssessment(ctx, execution, indexName) {
   if (execution.step_status === "done") {
     return execution;
   }
   if (isNotReady(execution)) {
-    await reassessNotReady(
-      ctx,
-      execution,
-      indexName
-    );
+    await reassessNotReady(ctx, execution, indexName);
   } else {
     await startAssessment(ctx, execution, indexName);
   }
   for (; ; ) {
-    const assessed = await pollUntilAssessed(
-      ctx,
-      execution.uuid,
-      indexName
-    );
+    const assessed = await pollUntilAssessed(ctx, execution.uuid, indexName);
     if (assessed.step_status === "done") {
       return assessed;
     }
     if (isNotReady(assessed)) {
-      await reassessNotReady(
-        ctx,
-        assessed,
-        indexName
-      );
+      await reassessNotReady(ctx, assessed, indexName);
       continue;
     }
     if (assessed.step_status !== "error") {
@@ -8603,9 +8765,474 @@ function assessmentFailureMessage(execution) {
   return execution.status_reason ?? "Data assessment failed.";
 }
 
+// src/actions/playbookSteps/settingsOptimizationPrompts.ts
+var SWITCH_APPLICATION_OPTION2 = "Switch application";
+var SWITCH_INDEX_OPTION2 = "Switch index";
+var RETRY_OPTION2 = "Retry";
+async function promptSettingsRecommendations(ctx, indexName, recommendations) {
+  const selection = await ctx.requestUserInput({
+    prompt: `recommended settings for ${indexName} \u2014 toggle to apply.`,
+    promptType: "multiSelect",
+    options: recommendations.map((recommendation) => recommendation.key),
+    labels: recommendations.map((recommendation) => recommendation.label),
+    secondary: recommendations.map((recommendation) => ({
+      kind: "text",
+      value: recommendation.value
+    })),
+    cancelable: true
+  });
+  if (!Array.isArray(selection) && selection !== "cancel") {
+    throw new Error("recommendations received an unexpected selection");
+  }
+  return selection;
+}
+async function promptNothingSelected(ctx) {
+  const choice = await ctx.requestUserInput({
+    prompt: "Nothing was selected. Continue or go back to the previous step.",
+    promptType: "multipleChoice",
+    options: ["continue", "back"],
+    labels: ["Continue", "Back"]
+  });
+  if (choice !== "continue" && choice !== "back") {
+    throw new Error("settings applied received an unexpected result");
+  }
+  return choice;
+}
+async function promptSettingsApplied(ctx, accepted) {
+  const count = accepted.length;
+  const choice = await ctx.requestUserInput({
+    prompt: `${count} ${count === 1 ? "index setting" : "index settings"} applied.`,
+    promptType: "multipleChoice",
+    labels: ["Continue"],
+    options: ["continue"],
+    list: accepted.map((recommendation) => ({
+      label: recommendation.label,
+      color: "success"
+    }))
+  });
+  if (choice !== "continue") {
+    throw new Error("settings applied received an unexpected result");
+  }
+}
+async function promptNothingToOptimize(ctx, indexName, playbookSlug) {
+  await ctx.requestUserInput({
+    prompt: "Continue",
+    promptType: "notice",
+    options: [],
+    list: [
+      {
+        label: `Your index ${indexName} is already optimized for ${playbookSlug} use case. No index settings changes required.`,
+        color: "success"
+      }
+    ]
+  });
+}
+async function promptOptimizationRecovery(ctx, message) {
+  const choice = await ctx.requestUserInput({
+    prompt: "Applying index settings failed.",
+    promptType: "multipleChoice",
+    options: [SWITCH_APPLICATION_OPTION2, SWITCH_INDEX_OPTION2, RETRY_OPTION2],
+    messages: [message],
+    helpText: "Retry applies the same recommendations. Switch index or application to pick a different target for playbook."
+  });
+  if (choice === SWITCH_APPLICATION_OPTION2) {
+    return ctx.changeApplication();
+  }
+  if (choice === SWITCH_INDEX_OPTION2) {
+    return ctx.returnToStep("select-index");
+  }
+  if (choice === RETRY_OPTION2) return;
+  throw new Error("recommendations received an unexpected recovery choice");
+}
+
+// src/actions/playbookSteps/settingsOptimization.ts
+var SETTING_LABELS = {
+  searchableAttributes: "Searchable Attributes",
+  customRanking: "Custom Ranking",
+  attributesForFaceting: "Facets & Filters",
+  filters: "Filters",
+  geo: "Geolocation",
+  unretrievableAttributes: "Unretrievable"
+};
+async function settingsOptimizationStep(ctx) {
+  const execution = await requireExecution(ctx);
+  const {
+    uuid,
+    current_step,
+    step_status,
+    source_index_name,
+    playbook_slug,
+    assessment_result
+  } = execution;
+  if (isOptimizationDone(execution)) return execution;
+  if (!isOptimizationEligible(execution)) {
+    throw new Error(
+      `received an execution that cannot be optimized: ${current_step} ${step_status}`
+    );
+  }
+  const settingsRecommendation = assessment_result?.settings_recommendation ?? {};
+  const settingsToOptimize = formatSettingsToOptimize(settingsRecommendation);
+  if (settingsToOptimize.length === 0) {
+    await promptNothingToOptimize(ctx, source_index_name, playbook_slug);
+    return await applyPlaybookExecutionSettings(uuid, [], []);
+  }
+  for (; ; ) {
+    const accepted = await promptSettingsRecommendations(
+      ctx,
+      source_index_name,
+      settingsToOptimize
+    );
+    if (accepted === "cancel") {
+      return ctx.returnToStep("data-assessment");
+    }
+    if (accepted.length === 0) {
+      const choice = await promptNothingSelected(ctx);
+      if (choice === "back") continue;
+    }
+    ctx.notify({ messages: ["applying index settings\u2026"] });
+    try {
+      const declined = Object.keys(settingsRecommendation).filter(
+        (group) => !accepted.includes(group)
+      );
+      const optimized = await applyWithRecovery(ctx, uuid, accepted, declined);
+      ctx.clearNotices();
+      const acceptedRecommendations = settingsToOptimize.filter(
+        (setting) => accepted.includes(setting.key)
+      );
+      await promptSettingsApplied(ctx, acceptedRecommendations);
+      return optimized;
+    } finally {
+      ctx.clearNotices();
+    }
+  }
+}
+async function requireExecution(ctx) {
+  const saved = ctx.getStepOutput("data-assessment");
+  if (!saved) {
+    throw new Error("recommendations expected a completed data assessment");
+  }
+  if (!ctx.reentered || isOptimizationDone(saved)) return saved;
+  return getPlaybookExecution(saved.uuid);
+}
+function isOptimizationDone(execution) {
+  const isOptimizationDone2 = execution.current_step === "optimization" && execution.step_status === "done";
+  const isOnImplementStep = execution.current_step === "implement";
+  return isOptimizationDone2 || isOnImplementStep;
+}
+function isOptimizationEligible(execution) {
+  const isAssessmentDone = execution.current_step === "assessment" && execution.step_status === "done";
+  const isOptimizationInProgress = execution.current_step === "optimization" && execution.step_status !== "done";
+  return isAssessmentDone || isOptimizationInProgress;
+}
+function formatSettingsToOptimize(recommendations) {
+  return Object.entries(recommendations).filter(
+    ([, setting]) => JSON.stringify(setting.current) !== JSON.stringify(setting.recommended)
+  ).map(([key, setting]) => ({
+    key,
+    label: settingLabel(key),
+    value: formatSettingValue(setting.recommended)
+  }));
+}
+function settingLabel(key) {
+  const label = SETTING_LABELS[key];
+  if (label) return label;
+  const [first, ...rest] = key.split(/(?=[A-Z])/);
+  const capitalizedFirstWord = first.charAt(0).toUpperCase() + first.slice(1);
+  return capitalizedFirstWord + " " + rest.join(" ");
+}
+function formatSettingValue(value) {
+  if (value == null) return "not detected in this index";
+  if (Array.isArray(value)) return value.length ? value.join(", ") : "none";
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+async function applyWithRecovery(ctx, uuid, accepted, declined) {
+  return retryOnDashboardError(
+    () => applyPlaybookExecutionSettings(uuid, accepted, declined),
+    async (err) => promptOptimizationRecovery(ctx, requestFailureMessage2(err))
+  );
+}
+function requestFailureMessage2(err) {
+  const message = err.errorBody()?.message;
+  return typeof message === "string" && message.trim() ? message : "Couldn't apply index settings.";
+}
+
+// src/actions/playbookSteps/generateUi.ts
+import z36 from "zod";
+
+// src/actions/playbookSteps/generateUiPrompts.ts
+var SWITCH_APPLICATION_OPTION3 = "Switch application";
+var SWITCH_INDEX_OPTION3 = "Switch index";
+var RETRY_OPTION3 = "Retry";
+async function promptUiGenerated(ctx, report) {
+  const { files, checkPassed, devCommand } = report ?? {};
+  const list = [];
+  if (files) {
+    const editedFiles = files.map((file) => ({
+      label: file.label,
+      helpText: file.path,
+      color: "success"
+    }));
+    list.push(...editedFiles);
+  }
+  if (checkPassed) {
+    list.push({ label: "build & typecheck passed", color: "success" });
+  }
+  list.push({
+    label: "playbook UI completed",
+    color: "success"
+  });
+  if (devCommand) {
+    list.push({
+      label: "view it locally",
+      helpText: devCommand,
+      color: "success"
+    });
+  }
+  await ctx.requestUserInput({
+    prompt: "Continue",
+    promptType: "notice",
+    options: [],
+    messages: ["implemented the playbook UI"],
+    list
+  });
+}
+async function promptUiRecovery(ctx, message) {
+  const choice = await ctx.requestUserInput({
+    prompt: "Generating the playbook UI failed.",
+    promptType: "multipleChoice",
+    options: [SWITCH_APPLICATION_OPTION3, SWITCH_INDEX_OPTION3, RETRY_OPTION3],
+    messages: [message],
+    helpText: "Retry repeats the failed request. Switch index or application to pick a different target for playbook."
+  });
+  if (choice === SWITCH_APPLICATION_OPTION3) {
+    return ctx.changeApplication();
+  }
+  if (choice === SWITCH_INDEX_OPTION3) {
+    return ctx.returnToStep("select-index");
+  }
+  if (choice === RETRY_OPTION3) return;
+  throw new Error("generate UI received an unexpected recovery choice");
+}
+
+// src/actions/playbookSteps/generateUi.ts
+var generatePlaybookUiSchema = z36.object({
+  summary: z36.string(),
+  framework: z36.string().optional(),
+  layoutName: z36.string().optional()
+});
+async function generatePlaybookUiStep(ctx) {
+  const execution = await requireExecution2(ctx);
+  const { uuid, current_step, step_status, source_index_name, playbook_slug } = execution;
+  if (isUiDone(execution)) {
+    return {
+      summary: "Playbook UI already generated.",
+      framework: void 0,
+      layoutName: void 0
+    };
+  }
+  if (!isUiEligible(execution)) {
+    throw new Error(
+      `received an execution that cannot generate a UI: ${current_step} ${step_status}`
+    );
+  }
+  ctx.notify({
+    messages: ["Reviewing your codebase\u2026"]
+  });
+  const template = await loadTemplateWithRecovery(ctx, uuid);
+  const startedAt = Date.now();
+  try {
+    const scan = await projectScan(ctx);
+    const confirmed2 = await confirmFramework(ctx, scan);
+    const framework = confirmed2.frameworks[0]?.name;
+    if (!framework) {
+      throw new Error("No frontend framework was confirmed");
+    }
+    ctx.notify({
+      messages: ["Generating UI from the playbook template\u2026"]
+    });
+    const result = await implement(ctx, ["search"], {
+      targetIndex: source_index_name,
+      uiTemplate: template,
+      scan,
+      frameworks: confirmed2.frameworks
+    });
+    await markDoneWithRecovery(ctx, uuid);
+    track("Playbook UI Layout Completed", {
+      playbook_name: playbook_slug,
+      index_name: source_index_name,
+      framework,
+      duration_ms: Date.now() - startedAt,
+      // TBD: should this track only implementation time or implementation + template loading + scan time?
+      layout_name: template.layout
+    });
+    await promptUiGenerated(ctx, result.uiReport);
+    return {
+      summary: result.summary,
+      framework,
+      layoutName: template.layout
+    };
+  } catch (err) {
+    await markPlaybookUiStepFailed(execution, err);
+    throw err;
+  } finally {
+    ctx.clearNotices();
+  }
+}
+async function requireExecution2(ctx) {
+  const saved = ctx.getStepOutput("recommendations");
+  if (!saved) {
+    throw new Error("generate UI expected a completed settings optimization");
+  }
+  if (!ctx.reentered) return saved;
+  return getPlaybookExecution(saved.uuid);
+}
+function isUiDone(execution) {
+  const { current_step, step_status } = execution;
+  return current_step === "implement" && step_status === "done";
+}
+function isUiEligible(execution) {
+  const { current_step, step_status } = execution;
+  return current_step === "optimization" && step_status === "done" || current_step === "implement" && step_status !== "done";
+}
+async function loadTemplateWithRecovery(ctx, uuid) {
+  const request = () => getPlaybookUiTemplate(uuid);
+  const requestRecoveryPrompt = (err) => promptUiRecovery(
+    ctx,
+    requestFailureMessage3(err, "Couldn't load the playbook UI template.")
+  );
+  return retryOnDashboardError(request, requestRecoveryPrompt);
+}
+async function markDoneWithRecovery(ctx, uuid) {
+  const request = () => updatePlaybookStepStatus(uuid, "done");
+  const requestRecoveryPrompt = (err) => promptUiRecovery(
+    ctx,
+    requestFailureMessage3(err, "Couldn't update the playbook UI step.")
+  );
+  await retryOnDashboardError(request, requestRecoveryPrompt);
+}
+async function markPlaybookUiStepFailed(execution, err) {
+  const reason = err instanceof Error ? err.message : String(err);
+  try {
+    await updatePlaybookStepStatus(execution.uuid, "error", reason);
+  } catch (statusErr) {
+    logger.warn(
+      { err: statusErr, executionUuid: execution.uuid },
+      "failed to update playbook UI step status"
+    );
+    throw statusErr;
+  }
+}
+function requestFailureMessage3(err, fallback) {
+  const message = err.errorBody()?.message;
+  return typeof message === "string" && message.trim() ? message : fallback;
+}
+
+// src/actions/playbookSteps/summary.ts
+import { z as z37 } from "zod";
+var playbookSummarySchema = z37.object({
+  slug: z37.string(),
+  applicationId: z37.string(),
+  indexName: z37.string(),
+  writtenFileCount: z37.number().int().nonnegative()
+});
+async function playbookSummaryStep(ctx) {
+  const { slug: slug2 } = ctx.getStepOutput("select-playbook");
+  const execution = ctx.getStepOutput("data-assessment");
+  ctx.notify({
+    messages: ["Summary of the playbook execution"]
+  });
+  const { application_id, source_index_name } = execution;
+  const writtenFileCount = new Set(useWizard.getState().writtenFiles).size;
+  const nextPlaybooks = await getNextPlaybooks(slug2);
+  if (nextPlaybooks.length === 0) {
+    await emptyNextPlaybooksPrompt(
+      ctx,
+      slug2,
+      application_id,
+      source_index_name,
+      writtenFileCount
+    );
+    return {
+      slug: slug2,
+      applicationId: application_id,
+      indexName: source_index_name,
+      writtenFileCount
+    };
+  }
+  const next = await nextPlaybooksPrompt(
+    ctx,
+    slug2,
+    application_id,
+    source_index_name,
+    writtenFileCount,
+    nextPlaybooks
+  );
+  if (typeof next !== "string") {
+    throw new Error("playbookSummary received an unexpected non-text result");
+  }
+  ctx.setUserInput("nextPlaybookSlug", next);
+  ctx.setUserInput("assessedPlaybookExecution", void 0);
+  useWizard.getState().clearWrittenFiles();
+  ctx.returnToStep("select-playbook");
+}
+async function getNextPlaybooks(selectedPlaybookSlug) {
+  try {
+    const playbooks = await getPlaybooks();
+    return playbooks.filter(
+      (playbook) => playbook.slug !== selectedPlaybookSlug
+    );
+  } catch (err) {
+    logger.warn({ err }, "failed to get next playbooks");
+    return [];
+  }
+}
+function emptyNextPlaybooksPrompt(ctx, playbookSelectedSlug, applicationId, indexName, writtenFileCount) {
+  return ctx.requestUserInput({
+    prompt: "Continue",
+    promptType: "notice",
+    options: [],
+    list: [
+      {
+        label: `${playbookSelectedSlug} playbook complete`,
+        color: "success"
+      }
+    ],
+    messages: [
+      `app    ${applicationId}`,
+      `index  ${indexName}`,
+      `files  ${writtenFileCount} written`
+    ]
+  });
+}
+function nextPlaybooksPrompt(ctx, playbookSelectedSlug, applicationId, indexName, writtenFileCount, nextPlaybooks) {
+  const options = nextPlaybooks.map((playbook) => playbook.slug);
+  const secondary = nextPlaybooks.map((playbook) => ({
+    kind: "text",
+    value: `\xB7 ${playbook.description ?? playbook.title}`
+  }));
+  return ctx.requestUserInput({
+    prompt: "Choose another playbook to run:",
+    promptType: "multipleChoice",
+    options,
+    secondary,
+    list: [
+      {
+        label: `${playbookSelectedSlug} playbook complete`,
+        color: "success"
+      }
+    ],
+    messages: [
+      `app    ${applicationId}`,
+      `index  ${indexName}`,
+      `files  ${writtenFileCount} written`
+    ]
+  });
+}
+
 // src/lib/cli.ts
-var USAGE = `Usage: wizard [workflow-id] [options]
-       wizard playbook [playbook-slug] [options]
+var USAGE = `Usage: wizard [workflow-id] [--application <id>] [options]
+       wizard playbook [playbook-slug] [--application <id>] [--index <name>] [options]
 
 Options:
   --seed <step-id> Start the workflow at the step with this id, with earlier
@@ -8619,6 +9246,10 @@ Options:
                    the encrypted file it falls back to \u2014 see CONTRIBUTING.md),
                    for this project and any other, so later runs create new
                    ones. Your Algolia login is not touched.
+  --application <id>
+                   Select this Algolia application without prompting.
+  --index <name>   Playbook only. Use this index without prompting. Requires
+                   --application.
   -h, --help       Print this message.`;
 function parseCliArgs(argv) {
   const positionals = [];
@@ -8626,37 +9257,70 @@ function parseCliArgs(argv) {
   let telemetry = true;
   let resetOnRun = false;
   let help = false;
+  let applicationId;
+  let indexName;
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
-    if (arg === "--seed") {
-      const next = argv[i + 1];
-      if (next !== void 0 && !next.startsWith("-")) {
-        seed = next;
+    const next = argv[i + 1];
+    switch (arg) {
+      case "--seed":
+        if (next !== void 0 && !next.startsWith("-")) {
+          seed = next;
+          i++;
+        } else {
+          seed = null;
+        }
+        break;
+      case "--no-telemetry":
+        telemetry = false;
+        break;
+      case "--reset-on-run":
+        resetOnRun = true;
+        break;
+      case "--application":
+        applicationId = requireValue(arg, next);
         i++;
-      } else {
-        seed = null;
-      }
-    } else if (arg.startsWith("--seed=")) {
-      seed = arg.slice("--seed=".length);
-    } else if (arg === "--no-telemetry") {
-      telemetry = false;
-    } else if (arg === "--reset-on-run") {
-      resetOnRun = true;
-    } else if (arg === "--help" || arg === "-h") {
-      help = true;
-    } else if (arg.startsWith("-")) {
-      throw new Error(`Unknown option "${arg}".`);
-    } else {
-      positionals.push(arg);
+        break;
+      case "--index":
+        indexName = requireValue(arg, next);
+        i++;
+        break;
+      case "--help":
+      case "-h":
+        help = true;
+        break;
+      default:
+        if (arg.startsWith("-")) throw new Error(`Unknown option "${arg}".`);
+        positionals.push(arg);
     }
   }
-  return { positionals, seed, telemetry, resetOnRun, help };
+  return { positionals, seed, telemetry, resetOnRun, help, applicationId, indexName };
+}
+function requireValue(flag, value) {
+  if (value === void 0) {
+    throw new Error(`${flag} requires a value.`);
+  }
+  return value;
 }
 function getPlaybookSlugArg(argv = process.argv.slice(2)) {
   const { positionals } = parseCliArgs(argv);
   if (positionals[0] !== "playbook") return void 0;
   return positionals[1];
 }
+function getPlaybookIndexNameArg(argv = process.argv.slice(2)) {
+  const { positionals, indexName } = parseCliArgs(argv);
+  if (positionals[0] !== "playbook") return void 0;
+  return indexName;
+}
+function cliArgsError(args, workflowId) {
+  if (args.indexName !== void 0 && workflowId !== "playbook") {
+    return "--index can only be used with the playbook workflow.";
+  }
+  if (args.indexName !== void 0 && args.applicationId === void 0) {
+    return "--index requires --application.";
+  }
+  return void 0;
+}
 
 // src/workflows/playbook.ts
 var playbookWorkflow = {
@@ -8667,27 +9331,46 @@ var playbookWorkflow = {
     defineStep({
       id: "select-playbook",
       title: "Select playbook",
+      visible: false,
       outputSchema: selectPlaybookSchema,
       run: (ctx) => selectPlaybookStep(ctx, getPlaybookSlugArg())
     }),
     defineStep({
       id: "select-index",
-      title: "Select index",
+      title: "entity select",
       outputSchema: selectIndexSchema,
-      run: (ctx) => selectIndexStep2(ctx)
+      run: (ctx) => selectIndexStep2(ctx, getPlaybookIndexNameArg())
     }),
     defineStep({
-      id: "confirm-index",
-      title: "Confirm sample index creation",
+      id: "confirm-sample-index",
+      title: "confirm sample index",
       outputSchema: confirmIndexSchema,
       visible: false,
       run: (ctx) => confirmIndexStep(ctx)
     }),
     defineStep({
       id: "data-assessment",
-      title: "Assess index data",
+      title: "data assessment",
       outputSchema: playbookExecutionSchema,
       run: (ctx) => dataAssessmentStep(ctx)
+    }),
+    defineStep({
+      id: "recommendations",
+      title: "recommendations",
+      outputSchema: playbookExecutionSchema,
+      run: (ctx) => settingsOptimizationStep(ctx)
+    }),
+    defineStep({
+      id: "build-ui",
+      title: "build ui",
+      outputSchema: generatePlaybookUiSchema,
+      run: (ctx) => generatePlaybookUiStep(ctx)
+    }),
+    defineStep({
+      id: "done",
+      title: "done",
+      outputSchema: playbookSummarySchema,
+      run: (ctx) => playbookSummaryStep(ctx)
     })
   ]
 };
@@ -10046,6 +10729,11 @@ var dataAssessment = {
   settings_snapshot: null,
   created_at: "2026-09-22T09:00:00.000Z"
 };
+var generatePlaybookUi = {
+  summary: "Generated an order component from the playbook UI template.",
+  framework: "Next.js",
+  layoutName: "list layout"
+};
 var review = {
   summaryPoints: [
     "Ingested 25 generated Product records into wizard_seed_products.",
@@ -10068,8 +10756,20 @@ var SEEDS = {
   playbook: {
     "select-playbook": selectPlaybook,
     "select-index": selectPlaybookIndex,
-    "confirm-index": null,
-    "data-assessment": dataAssessment
+    "confirm-sample-index": null,
+    "data-assessment": dataAssessment,
+    recommendations: {
+      ...dataAssessment,
+      current_step: "optimization"
+    },
+    "build-ui": generatePlaybookUi,
+    done: {
+      slug: "orders",
+      applicationId: "SEEDAPPID",
+      indexName: "wizard_seed_orders",
+      writtenFileCount: 0,
+      nextPlaybooks: []
+    }
   }
 };
 var SEED_ALGOLIA_STATE = {
@@ -10198,10 +10898,53 @@ async function resetProjectState() {
   return { dir, removed: targets };
 }
 
+// src/lib/resumeSession.ts
+function formatRunTarget(target) {
+  return [target.playbookSlug, target.applicationId, target.indexName].filter((part) => Boolean(part)).join(" \u2022 ");
+}
+function stringField(value) {
+  return typeof value === "string" && value ? value : void 0;
+}
+function stepOutput2(state, stepId) {
+  const output = state.steps.find((step) => step.id === stepId)?.output;
+  return output && typeof output === "object" ? output : void 0;
+}
+function sessionRunTarget(state) {
+  const applicationId = runAppId(state);
+  if (state.workflowId !== "playbook") {
+    return { applicationId };
+  }
+  const playbook = stepOutput2(state, "select-playbook");
+  const index = stepOutput2(state, "select-index");
+  return {
+    applicationId,
+    playbookSlug: stringField(state.userInputs.playbookSlug) ?? stringField(playbook?.slug),
+    indexName: stringField(state.userInputs.playbookIndexName) ?? stringField(index?.indexName)
+  };
+}
+function resumeOptionLabel(session) {
+  const label = formatRunTarget(session);
+  return label ? `Resume (${label})` : "Resume";
+}
+function startNewOptionLabel(next) {
+  const label = formatRunTarget(next);
+  return label ? `Start new (${label})` : "Start new";
+}
+async function promptResumeOrStartNew(session, next) {
+  const resumeOption = resumeOptionLabel(session);
+  const startOption = startNewOptionLabel(next);
+  const answer = await useWizard.getState().requestUserInput({
+    prompt: "You have a previous session. Resume it, or start a new run?",
+    promptType: "multipleChoice",
+    options: [resumeOption, startOption]
+  });
+  return answer === resumeOption ? "resume" : "start-new";
+}
+
 // package.json with { type: 'json' }
 var package_default2 = {
   name: "@algolia/wizard",
-  version: "0.112.0",
+  version: "0.113.0",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {
@@ -10342,6 +11085,13 @@ ${USAGE}`);
     console.error(`Unknown workflow "${requestedId}". Available: ${available}`);
     return 1;
   }
+  const flagError = cliArgsError(args, workflow.id);
+  if (flagError) {
+    console.error(flagError);
+    console.error(`
+${USAGE}`);
+    return 1;
+  }
   if (await checkVersion()) {
     console.error(
       "You have loaded an old version of the Wizard. Please use @algolia/wizard@latest"
@@ -10365,10 +11115,16 @@ ${formatStepList(workflow)}`);
       return 1;
     }
   }
-  return { workflow, skipResumePrompt: args.seed !== void 0 };
+  return {
+    workflow,
+    skipResumePrompt: args.seed !== void 0,
+    applicationId: args.applicationId,
+    playbookSlug: workflow.id === "playbook" ? args.positionals[1] : void 0,
+    indexName: workflow.id === "playbook" ? args.indexName : void 0
+  };
 }
 async function run(opts) {
-  const { workflow, skipResumePrompt } = opts;
+  const { workflow, skipResumePrompt, applicationId, playbookSlug, indexName } = opts;
   const store = useWizard.getState();
   const instance = render(/* @__PURE__ */ jsx23(App, {}), { incrementalRendering: true });
   await store.waitForStart();
@@ -10405,12 +11161,21 @@ async function run(opts) {
   }
   store.setUser(user);
   let app;
-  const resumableState = await loadResumableState(workflow);
+  const session = await loadResumableState(workflow);
   try {
+    const choice = session && !skipResumePrompt ? await promptResumeOrStartNew(sessionRunTarget(session), {
+      applicationId,
+      playbookSlug,
+      indexName
+    }) : void 0;
+    const resumableState = choice === "start-new" ? null : session ?? void 0;
     app = await ensureApplication(
-      resumableState ? runAppId(resumableState) : void 0
+      resumableState ? runAppId(resumableState) : applicationId
     );
-    runWorkflow(workflow, app.id, { skipResumePrompt, resumableState });
+    runWorkflow(workflow, app.id, {
+      skipResumePrompt: true,
+      resumableState
+    });
   } catch (err) {
     await exitProcessWithError(
       store,