@algolia/wizard 0.8.0-rc.67.55 → 0.9.0-rc.49.79

package/dist/main.js

@@ -4,7 +4,7 @@
 import { render } from "ink";
 
 // src/ui/App.tsx
-import { Box as Box13, Text as Text13, useApp, useInput as useInput6, useWindowSize as useWindowSize7 } from "ink";
+import { Box as Box15, Text as Text15, useApp, useInput as useInput6, useWindowSize as useWindowSize8 } from "ink";
 
 // src/core/store.ts
 import { create } from "zustand";
@@ -12,32 +12,86 @@ import { nanoid } from "nanoid";
 
 // src/lib/algoliaCli.ts
 import { spawn } from "node:child_process";
-import { createRequire } from "node:module";
-var require2 = createRequire(import.meta.url);
-function algoliaCliEntry() {
-  return require2.resolve("@algolia/cli/bin/run.js");
+import { z } from "zod";
+function npxArgs(args) {
+  return ["--yes", "@algolia/cli@latest", ...args];
 }
-function runAlgoliaCli(args) {
+var shell = process.platform === "win32";
+function lineSplitter(emit) {
+  let buffer = "";
+  return {
+    push(chunk) {
+      buffer += chunk;
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) emit(line.replace(/\r$/, ""));
+    },
+    flush() {
+      if (buffer) emit(buffer.replace(/\r$/, ""));
+      buffer = "";
+    }
+  };
+}
+var wizardSink = (stream, line) => {
+  if (!line.trim()) return;
+  useWizard.getState().pushCliOutput(stream, line);
+};
+var stderrSink = (stream, line) => {
+  if (stream === "stdout") return;
+  wizardSink(stream, line);
+};
+function runAlgoliaCli(args, { onOutput } = {}) {
+  const store = useWizard.getState();
+  const logId = store.logStart("tool", `algolia ${args.join(" ")}`);
   return new Promise((resolve4, reject) => {
-    const child = spawn(process.execPath, [algoliaCliEntry(), ...args]);
+    const child = spawn("npx", npxArgs(args), { shell });
     let stdout = "";
     let stderr = "";
-    child.stdout.on("data", (chunk) => stdout += chunk);
-    child.stderr.on("data", (chunk) => stderr += chunk);
+    const splitters = {
+      stdout: lineSplitter((line) => onOutput?.("stdout", line)),
+      stderr: lineSplitter((line) => onOutput?.("stderr", line))
+    };
+    child.stdout.on("data", (chunk) => {
+      const text = String(chunk);
+      stdout += text;
+      splitters.stdout.push(text);
+    });
+    child.stderr.on("data", (chunk) => {
+      const text = String(chunk);
+      stderr += text;
+      splitters.stderr.push(text);
+    });
     child.on("error", reject);
     child.on("close", (code) => {
+      splitters.stdout.flush();
+      splitters.stderr.flush();
       if (code === 0) {
         resolve4(stdout);
       } else {
-        const detail = stderr.trim() || stdout.trim();
+        const failed = stderr.trim();
+        let detail = "";
+        if (failed) {
+          detail = `: ${failed}`;
+        } else if (stdout.trim()) {
+          detail = " (no stderr; stdout withheld \u2014 it may contain credentials)";
+        }
         reject(
           new Error(
-            `Algolia CLI \`${args.join(" ")}\` failed (exit ${code})${detail ? `: ${detail}` : ""}`
+            `Algolia CLI \`${args.join(" ")}\` failed (exit ${code})${detail}`
           )
         );
       }
     });
-  });
+  }).then(
+    (out) => {
+      useWizard.getState().logEnd(logId, "success");
+      return out;
+    },
+    (err) => {
+      useWizard.getState().logEnd(logId, "error");
+      throw err;
+    }
+  );
 }
 async function getUser() {
   let raw;
@@ -52,19 +106,23 @@ async function getUser() {
     return null;
   }
 }
-function runAuthLogin() {
-  return new Promise((resolve4, reject) => {
-    const child = spawn(
-      process.execPath,
-      [algoliaCliEntry(), "auth", "login", "--default"],
-      { stdio: "inherit" }
-    );
-    child.on("error", reject);
-    child.on("close", (code) => {
-      if (code === 0) resolve4();
-      else reject(new Error(`Algolia authentication failed (exit ${code}).`));
-    });
+var loginResultSchema = z.object({
+  success: z.boolean(),
+  email: z.string().optional()
+});
+async function runAuthLogin() {
+  const raw = await runAlgoliaCli(["auth", "login", "--non-interactive"], {
+    onOutput: stderrSink
   });
+  let parsed;
+  try {
+    parsed = loginResultSchema.safeParse(JSON.parse(raw));
+  } catch {
+    parsed = void 0;
+  }
+  if (parsed?.success && !parsed.data.success) {
+    throw new Error("Algolia sign-in did not report success.");
+  }
 }
 
 // src/lib/auth.ts
@@ -171,6 +229,7 @@ function describeInputValue(value) {
   return Array.isArray(value) ? value.join(", ") : value;
 }
 var NOTICE_INTERVAL_MS = 2e3;
+var CLI_OUTPUT_LIMIT = 200;
 var useWizard = create((set, get) => ({
   phase: "idle",
   homeScreen: "home",
@@ -182,22 +241,21 @@ var useWizard = create((set, get) => ({
   notices: [],
   _noticeQueue: [],
   _noticeTimer: null,
+  cliOutput: [],
+  targetIndex: null,
   logs: [],
   error: null,
   inputReq: null,
   _resolve: null,
-  // Advances past the welcome screen. Only meaningful from 'idle' — once the
-  // workflow is running there's nothing left to confirm.
-  // Reset `homeScreen` so preflight shows Welcome, not the Learn more sub-view.
+  // `endAuth` lands on 'preflight', not 'idle': sign-in happens after the
+  // welcome screen, so going back would gate the run a second time.
+  beginAuth: () => set({ phase: "authenticating", cliOutput: [] }),
+  endAuth: () => set((s) => s.phase === "authenticating" ? { phase: "preflight" } : {}),
   confirmStart: () => set(
     (s) => s.phase === "idle" ? { phase: "preflight", homeScreen: "home" } : {}
   ),
-  // Welcome sub-view navigation; leaves `phase` untouched so the workflow stays paused.
   openLearnMore: () => set({ homeScreen: "learnMore" }),
   backToHome: () => set({ homeScreen: "home" }),
-  // Resolves once the phase leaves 'idle', whether that happens before or
-  // after this is called (the welcome screen's enter handler is what
-  // drives the transition via `confirmStart`).
   waitForStart: () => new Promise((resolve4) => {
     if (get().phase !== "idle") {
       resolve4();
@@ -220,15 +278,19 @@ var useWizard = create((set, get) => ({
   syncSteps: (steps, currentStepIndex) => set({ steps, currentStepIndex }),
   setActiveStep: (index) => {
     get()._clearNoticeQueue();
-    set({ phase: "running", currentStepIndex: index, output: "", notices: [] });
+    set({
+      phase: "running",
+      currentStepIndex: index,
+      output: "",
+      notices: [],
+      cliOutput: []
+    });
   },
   setUser: (user) => set({ user }),
   appendToken: (text) => set((s) => ({ output: s.output + text })),
   clearOutput: () => set({ output: "" }),
-  // Renders the first notice of a burst immediately, then holds later
-  // arrivals in `_noticeQueue` and drains one per `NOTICE_INTERVAL_MS` —
-  // the timer stays armed through an empty drain so the cooldown always
-  // covers the time since the last render, even across bursts.
+  // The timer stays armed through an empty drain, so the spacing covers the
+  // time since the last render even across bursts.
   pushNotice: (notice) => {
     const { notices, _noticeQueue, _noticeTimer } = get();
     if (_noticeTimer === null) {
@@ -261,6 +323,13 @@ var useWizard = create((set, get) => ({
     get()._clearNoticeQueue();
     set({ notices: [] });
   },
+  pushCliOutput: (stream, text) => set((s) => ({
+    cliOutput: [...s.cliOutput, { id: nanoid(), stream, text }].slice(
+      -CLI_OUTPUT_LIMIT
+    )
+  })),
+  clearCliOutput: () => set({ cliOutput: [] }),
+  setTargetIndex: (index) => set({ targetIndex: index }),
   logStart: (kind, name, input) => {
     const id = nanoid();
     set((s) => ({
@@ -283,9 +352,6 @@ var useWizard = create((set, get) => ({
       _resolve: resolve4
     });
   }),
-  // Logs what the user picked — not the prompt text that was shown, which
-  // may repeat or duplicate on-screen content and isn't the useful signal
-  // here.
   submitInput: async (value) => {
     await markInteraction();
     get()._resolve?.(value);
@@ -305,6 +371,8 @@ var useWizard = create((set, get) => ({
       currentStepIndex: 0,
       output: "",
       notices: [],
+      cliOutput: [],
+      targetIndex: null,
       logs: [],
       error: null,
       inputReq: null,
@@ -313,16 +381,100 @@ var useWizard = create((set, get) => ({
   }
 }));
 
+// src/ui/CliOutput.tsx
+import { Box, Text, useWindowSize } from "ink";
+
+// src/ui/theme.ts
+var MARKER = {
+  pending: "\u25CB",
+  running: "\u25D0",
+  done: "\u2713",
+  error: "\u2716"
+};
+var BRAND = "#003DFF";
+var SECONDARY = "#5468FF";
+var DANGER = "#F86E7E";
+var COLORS = {
+  brand: BRAND,
+  primary: "#E6EDF3",
+  secondary: SECONDARY,
+  strong: "#FFFFFF",
+  muted: "#8B949E",
+  dim: "#484F58",
+  highlight: { bg: "#12331C", fg: "#4ADE80" },
+  badge: "#E3B341",
+  danger: DANGER,
+  success: "#4ADE80",
+  bg: {
+    main: "#0B0E14",
+    sidebar: "#14171E"
+  },
+  border: "#30363D",
+  accent: "#76A0FF",
+  status: {
+    pending: "gray",
+    running: "#76A0FF",
+    done: "#4ADE80",
+    error: DANGER
+  }
+};
+
+// src/ui/CliOutput.tsx
+import { jsxs } from "react/jsx-runtime";
+var CLI_MARKER = "\u203A";
+var RESERVED_ROWS = 16;
+var MAX_ROWS = 12;
+var PANEL_TEXT_WIDTH = 45;
+var URL_PATTERN = /https?:\/\//;
+function rowCost(text) {
+  return URL_PATTERN.test(text) ? Math.max(1, Math.ceil(text.length / PANEL_TEXT_WIDTH)) : 1;
+}
+function CliOutput() {
+  const cliOutput = useWizard((s) => s.cliOutput);
+  const { rows } = useWindowSize();
+  if (!cliOutput.length) return null;
+  const rowBudget = Math.min(Math.max(rows - RESERVED_ROWS, 3), MAX_ROWS);
+  const visible = [];
+  let usedRows = 0;
+  for (let i = cliOutput.length - 1; i >= 0; i--) {
+    const cost = rowCost(cliOutput[i].text);
+    if (usedRows + cost > rowBudget && visible.length > 0) break;
+    visible.unshift(cliOutput[i]);
+    usedRows += cost;
+  }
+  const hidden = cliOutput.length - visible.length;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+    hidden > 0 && /* @__PURE__ */ jsxs(Text, { color: COLORS.dim, children: [
+      "\u2191 ",
+      hidden,
+      " earlier line(s)"
+    ] }),
+    visible.map((line) => /* @__PURE__ */ jsxs(
+      Text,
+      {
+        color: line.stream === "stderr" ? COLORS.muted : COLORS.dim,
+        wrap: URL_PATTERN.test(line.text) ? "wrap" : "truncate",
+        children: [
+          CLI_MARKER,
+          " ",
+          line.text
+        ]
+      },
+      line.id
+    ))
+  ] });
+}
+
 // src/ui/Notices.tsx
-import { Box as Box2, Text as Text2, useWindowSize as useWindowSize2 } from "ink";
+import { Box as Box3, Text as Text3, useWindowSize as useWindowSize3 } from "ink";
 import { useEffect as useEffect2, useState as useState2 } from "react";
 
 // src/ui/Table.tsx
-import { Box, Text, measureElement, useWindowSize } from "ink";
+import { Box as Box2, Text as Text2, measureElement, useWindowSize as useWindowSize2 } from "ink";
 import { useEffect, useRef, useState } from "react";
 import { jsx } from "react/jsx-runtime";
 function Table({ columns, rows }) {
-  const { columns: termCols } = useWindowSize();
+  const { columns: termCols } = useWindowSize2();
   const ref = useRef(null);
   const [width, setWidth] = useState(0);
   useEffect(() => {
@@ -330,7 +482,7 @@ function Table({ columns, rows }) {
   }, [termCols, columns, rows]);
   if (rows.length === 0) return null;
   const lines = formatTable(columns, rows, width || void 0);
-  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", ref, children: lines.map((line, i) => /* @__PURE__ */ jsx(Text, { wrap: "truncate", children: line }, `tbl-${i}`)) });
+  return /* @__PURE__ */ jsx(Box2, { flexDirection: "column", ref, children: lines.map((line, i) => /* @__PURE__ */ jsx(Text2, { wrap: "truncate", children: line }, `tbl-${i}`)) });
 }
 function formatTable(columns, rows, width) {
   const natural = columns.map(
@@ -370,48 +522,13 @@ function resize(widths, budget) {
 }
 var truncate = (s, width) => s.length <= width ? s : width <= 1 ? s.slice(0, width) : `${s.slice(0, width - 1)}\u2026`;
 
-// src/ui/theme.ts
-var MARKER = {
-  pending: "\u25CB",
-  running: "\u25D0",
-  done: "\u2713",
-  error: "\u2716"
-};
-var BRAND = "#003DFF";
-var SECONDARY = "#5468FF";
-var DANGER = "#F86E7E";
-var COLORS = {
-  brand: BRAND,
-  primary: "#E6EDF3",
-  secondary: SECONDARY,
-  strong: "#FFFFFF",
-  muted: "#8B949E",
-  dim: "#484F58",
-  highlight: { bg: "#12331C", fg: "#4ADE80" },
-  badge: "#E3B341",
-  danger: DANGER,
-  success: "#4ADE80",
-  bg: {
-    main: "#0B0E14",
-    sidebar: "#14171E"
-  },
-  border: "#30363D",
-  accent: "#76A0FF",
-  status: {
-    pending: "gray",
-    running: "#76A0FF",
-    done: "#4ADE80",
-    error: DANGER
-  }
-};
-
 // src/ui/Notices.tsx
-import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
 var AGENT_MARKER = "\u2726";
-var RESERVED_ROWS = 14;
-var PANEL_TEXT_WIDTH = 45;
+var RESERVED_ROWS2 = 14;
+var PANEL_TEXT_WIDTH2 = 45;
 function messageLineCount(text) {
-  return Math.max(1, Math.ceil(text.length / PANEL_TEXT_WIDTH));
+  return Math.max(1, Math.ceil(text.length / PANEL_TEXT_WIDTH2));
 }
 function noticeLineCount(notice) {
   const messageLines = (notice.messages ?? []).reduce((sum, m) => {
@@ -422,7 +539,7 @@ function noticeLineCount(notice) {
   return messageLines + tableLines;
 }
 function fitVisibleNotices(notices, windowRows) {
-  const budget = Math.max(windowRows - RESERVED_ROWS, 3);
+  const budget = Math.max(windowRows - RESERVED_ROWS2, 3);
   let used = 0;
   let count = 0;
   for (let i = notices.length - 1; i >= 0; i--) {
@@ -455,7 +572,7 @@ function parseHex(hex) {
 }
 function Notices() {
   const notices = useWizard((s) => s.notices);
-  const { rows: windowRows } = useWindowSize2();
+  const { rows: windowRows } = useWindowSize3();
   const visible = fitVisibleNotices(notices, windowRows);
   const [pulseStep, setPulseStep] = useState2(0);
   useEffect2(() => {
@@ -472,14 +589,14 @@ function Notices() {
   }, []);
   if (!visible.length) return null;
   const pulseColor = PULSE_COLORS[pulseStep];
-  return /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", gap: 1, marginBottom: 1, children: visible.map((notice, i) => {
+  return /* @__PURE__ */ jsx2(Box3, { flexDirection: "column", gap: 1, marginBottom: 1, children: visible.map((notice, i) => {
     const isLatest = i === visible.length - 1;
-    return /* @__PURE__ */ jsxs(Box2, { flexDirection: "column", children: [
+    return /* @__PURE__ */ jsxs2(Box3, { flexDirection: "column", children: [
       notice.messages?.map((m, j) => {
         const line = typeof m === "string" ? { text: m } : m;
         const prefix = j === 0 ? `${AGENT_MARKER} ` : "  ";
-        return /* @__PURE__ */ jsxs(
-          Text2,
+        return /* @__PURE__ */ jsxs2(
+          Text3,
           {
             color: isLatest && !line.color ? pulseColor : line.color ?? COLORS.dim,
             bold: line.bold,
@@ -497,41 +614,42 @@ function Notices() {
 }
 
 // src/ui/PromptInput.tsx
-import { Box as Box5, Text as Text5, useInput as useInput2 } from "ink";
+import { Box as Box7, Text as Text7, useInput as useInput2 } from "ink";
 import TextInput from "ink-text-input";
-import { useState as useState4 } from "react";
+import { useState as useState5 } from "react";
 
 // src/ui/NextAction.tsx
-import { Box as Box3, Text as Text3 } from "ink";
-import { Fragment, jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+import { Box as Box4, Text as Text4 } from "ink";
+import { Fragment, jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
 function NextAction({
   action,
   keyHint,
   hierarchy = "primary"
 }) {
-  return /* @__PURE__ */ jsxs2(Box3, { flexDirection: "row", gap: 1, children: [
-    hierarchy === "primary" && /* @__PURE__ */ jsx3(Text3, { color: COLORS.success, bold: true, children: `> ${action}` }),
-    hierarchy === "secondary" && /* @__PURE__ */ jsxs2(Fragment, { children: [
-      /* @__PURE__ */ jsx3(Text3, { color: COLORS.success, bold: true, children: `>` }),
-      /* @__PURE__ */ jsx3(Text3, { color: COLORS.primary, bold: true, children: action })
+  return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "row", gap: 1, children: [
+    hierarchy === "primary" && /* @__PURE__ */ jsx3(Text4, { color: COLORS.success, bold: true, children: `> ${action}` }),
+    hierarchy === "secondary" && /* @__PURE__ */ jsxs3(Fragment, { children: [
+      /* @__PURE__ */ jsx3(Text4, { color: COLORS.success, bold: true, children: `>` }),
+      /* @__PURE__ */ jsx3(Text4, { color: COLORS.primary, bold: true, children: action })
     ] }),
-    /* @__PURE__ */ jsxs2(Box3, { children: [
-      /* @__PURE__ */ jsx3(Text3, { color: COLORS.muted, children: "press " }),
-      /* @__PURE__ */ jsx3(Text3, { color: COLORS.muted, children: `[` }),
-      /* @__PURE__ */ jsx3(Text3, { color: COLORS.primary, children: keyHint }),
-      /* @__PURE__ */ jsx3(Text3, { color: COLORS.muted, children: `]` })
+    /* @__PURE__ */ jsxs3(Box4, { children: [
+      /* @__PURE__ */ jsx3(Text4, { color: COLORS.muted, children: "press " }),
+      /* @__PURE__ */ jsx3(Text4, { color: COLORS.muted, children: `[` }),
+      /* @__PURE__ */ jsx3(Text4, { color: COLORS.primary, children: keyHint }),
+      /* @__PURE__ */ jsx3(Text4, { color: COLORS.muted, children: `]` })
     ] })
   ] });
 }
 
 // src/ui/SelectPrompt.tsx
-import { Box as Box4, Text as Text4, measureElement as measureElement2, useInput, useWindowSize as useWindowSize3 } from "ink";
-import { useLayoutEffect, useRef as useRef2, useState as useState3 } from "react";
-import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
-var CANCEL = "cancel";
-var ARROW_WIDTH = 4;
-var COLUMN_GAP = 2;
-var BAR_PADDING = 2;
+import { Box as Box6, Text as Text6, useInput, useWindowSize as useWindowSize5 } from "ink";
+import { useLayoutEffect as useLayoutEffect2, useRef as useRef3, useState as useState4 } from "react";
+
+// src/ui/ScrollView.tsx
+import { Box as Box5, Text as Text5, measureElement as measureElement2, useWindowSize as useWindowSize4 } from "ink";
+import { useCallback, useLayoutEffect, useRef as useRef2, useState as useState3 } from "react";
+import { jsxs as jsxs4 } from "react/jsx-runtime";
+var INDICATOR_ROWS = 2;
 function fittedWidth(node, columns) {
   let left = 0;
   for (let n = node; n; n = n.parentNode) {
@@ -539,6 +657,89 @@ function fittedWidth(node, columns) {
   }
   return Math.max(Math.min(measureElement2(node).width, columns - left), 0);
 }
+function useScrollWindow({
+  itemCount,
+  rowHeight = 1,
+  followBottom = false
+}) {
+  const viewportRef = useRef2(null);
+  const { columns } = useWindowSize4();
+  const [size, setSize] = useState3(
+    null
+  );
+  useLayoutEffect(() => {
+    if (!viewportRef.current) return;
+    const width = fittedWidth(viewportRef.current, columns);
+    const { height } = measureElement2(viewportRef.current);
+    setSize(
+      (prev) => prev?.width === width && prev.height === height ? prev : { width, height }
+    );
+  });
+  const capacity = size === null || itemCount * rowHeight <= size.height ? itemCount : Math.max(Math.floor((size.height - INDICATOR_ROWS) / rowHeight), 1);
+  const maxOffset = Math.max(itemCount - capacity, 0);
+  const [offset, setOffset] = useState3(0);
+  const prevMaxOffsetRef = useRef2(0);
+  useLayoutEffect(() => {
+    const wasAtBottom = offset >= prevMaxOffsetRef.current;
+    prevMaxOffsetRef.current = maxOffset;
+    setOffset(
+      (o) => followBottom && wasAtBottom ? maxOffset : Math.min(o, maxOffset)
+    );
+  }, [maxOffset, followBottom]);
+  const scrollBy = useCallback(
+    (delta) => {
+      setOffset((o) => Math.min(Math.max(o + delta, 0), maxOffset));
+    },
+    [maxOffset]
+  );
+  const revealIndex = useCallback(
+    (index) => {
+      setOffset((o) => {
+        if (index < o) return index;
+        if (index >= o + capacity) {
+          return Math.min(index - capacity + 1, maxOffset);
+        }
+        return o;
+      });
+    },
+    [capacity, maxOffset]
+  );
+  const visibleCount = Math.min(capacity, Math.max(itemCount - offset, 0));
+  return {
+    viewportRef,
+    width: size?.width ?? columns,
+    offset,
+    capacity,
+    maxOffset,
+    hiddenAbove: Math.min(offset, itemCount),
+    hiddenBelow: Math.max(itemCount - offset - visibleCount, 0),
+    scrollBy,
+    revealIndex
+  };
+}
+function ScrollView({ scroll, children }) {
+  return /* @__PURE__ */ jsxs4(Box5, { ref: scroll.viewportRef, flexDirection: "column", flexGrow: 1, children: [
+    scroll.hiddenAbove > 0 && /* @__PURE__ */ jsxs4(Text5, { color: COLORS.dim, children: [
+      "\u2191 ",
+      scroll.hiddenAbove,
+      " more"
+    ] }),
+    children,
+    scroll.hiddenBelow > 0 && /* @__PURE__ */ jsxs4(Text5, { color: COLORS.dim, children: [
+      "\u2193 ",
+      scroll.hiddenBelow,
+      " more"
+    ] })
+  ] });
+}
+
+// src/ui/SelectPrompt.tsx
+import { jsx as jsx4, jsxs as jsxs5 } from "react/jsx-runtime";
+var CANCEL = "cancel";
+var ARROW_WIDTH = 4;
+var COLUMN_GAP = 2;
+var BAR_PADDING = 2;
+var ROW_HEIGHT = 3;
 function SelectPrompt({
   options,
   onSelect,
@@ -552,10 +753,10 @@ function SelectPrompt({
   secondary,
   defaultSelectedIndex = 0
 }) {
-  const [index, setIndex] = useState3(
+  const [index, setIndex] = useState4(
     () => defaultSelectedIndex > 0 && defaultSelectedIndex < options.length ? defaultSelectedIndex : 0
   );
-  const [checked, setChecked] = useState3(() => /* @__PURE__ */ new Set());
+  const [checked, setChecked] = useState4(() => /* @__PURE__ */ new Set());
   const hasCancel = Boolean(multi || cancelable);
   const rows = hasCancel ? [...options, "Cancel"] : options;
   const cancelIndex = hasCancel ? options.length : -1;
@@ -563,14 +764,14 @@ function SelectPrompt({
   if (rows.length > 1) hints.push({ key: "[\u2191] [\u2193]", label: "move" });
   if (multi) hints.push({ key: "[space]", label: "select" });
   hints.push({ key: "[enter]", label: "confirm" });
-  const containerRef = useRef2(null);
-  const { columns } = useWindowSize3();
-  const [width, setWidth] = useState3(columns);
-  useLayoutEffect(() => {
-    if (containerRef.current) {
-      setWidth(fittedWidth(containerRef.current, columns));
-    }
-  }, [columns]);
+  const containerRef = useRef3(null);
+  const { columns } = useWindowSize5();
+  const [width, setWidth] = useState4(columns);
+  useLayoutEffect2(() => {
+    if (!containerRef.current) return;
+    const measured = fittedWidth(containerRef.current, columns);
+    setWidth((prev) => prev === measured ? prev : measured);
+  });
   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,
@@ -586,6 +787,15 @@ function SelectPrompt({
   const barWidth = Math.min(labelWidth + badgeWidth + BAR_PADDING, width);
   const barLabelWidth = Math.max(barWidth - BAR_PADDING - badgeWidth, 0);
   const textWidth = inner - labelWidth;
+  const scroll = useScrollWindow({
+    itemCount: rows.length,
+    rowHeight: ROW_HEIGHT
+  });
+  const { revealIndex } = scroll;
+  useLayoutEffect2(() => {
+    revealIndex(index);
+  }, [index, revealIndex]);
+  const visible = rows.slice(scroll.offset, scroll.offset + scroll.capacity);
   useInput((input, key) => {
     if (rows.length === 0) return;
     if (key.upArrow || input === "k") {
@@ -609,62 +819,65 @@ function SelectPrompt({
       }
     }
   });
-  return /* @__PURE__ */ jsx4(Box4, { ref: containerRef, flexGrow: 1, children: /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", gap: 1, width, children: [
-    error && /* @__PURE__ */ jsx4(Text4, { color: COLORS.danger, children: error }),
-    messages?.map((m, i) => /* @__PURE__ */ jsx4(Text4, { color: COLORS.muted, children: m }, `msg-${i}`)),
-    table && /* @__PURE__ */ jsx4(Table, { columns: table.columns, rows: table.rows }),
-    /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", children: [
-      question && /* @__PURE__ */ jsx4(Text4, { color: COLORS.muted, children: question }),
-      helpText && /* @__PURE__ */ jsx4(Text4, { color: COLORS.dim, children: helpText })
+  return /* @__PURE__ */ jsx4(Box6, { ref: containerRef, flexGrow: 1, children: /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", gap: 1, width, children: [
+    /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", gap: 1, flexShrink: 0, children: [
+      error && /* @__PURE__ */ jsx4(Text6, { color: COLORS.danger, children: error }),
+      messages?.map((m, i) => /* @__PURE__ */ jsx4(Text6, { color: COLORS.muted, children: m }, `msg-${i}`)),
+      table && /* @__PURE__ */ jsx4(Table, { columns: table.columns, rows: table.rows }),
+      /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", children: [
+        question && /* @__PURE__ */ jsx4(Text6, { color: COLORS.muted, children: question }),
+        helpText && /* @__PURE__ */ jsx4(Text6, { color: COLORS.dim, children: helpText })
+      ] })
     ] }),
-    /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", children: rows.map((option, i) => {
+    /* @__PURE__ */ jsx4(ScrollView, { scroll, children: visible.map((option, visibleIndex) => {
+      const i = scroll.offset + visibleIndex;
       const highlighted = i === index;
       const isCancel = i === cancelIndex;
       const bullet = multi && !isCancel ? checked.has(i) ? "\u25CF " : "\u25CB " : "";
       const sec = isCancel ? void 0 : secondary?.[i];
       const labelColor = highlighted ? COLORS.highlight.fg : void 0;
-      const label = /* @__PURE__ */ jsxs3(Text4, { color: labelColor, wrap: "truncate", children: [
+      const label = /* @__PURE__ */ jsxs5(Text6, { color: labelColor, wrap: "truncate", children: [
         highlighted ? "\u276F   " : "    ",
         bullet,
         option
       ] });
       const isText = sec?.kind === "text";
-      return /* @__PURE__ */ jsxs3(
-        Box4,
+      return /* @__PURE__ */ jsxs5(
+        Box6,
         {
           width: isText ? "100%" : barWidth,
           paddingX: 1,
           paddingY: 1,
           backgroundColor: highlighted ? COLORS.highlight.bg : void 0,
           children: [
-            /* @__PURE__ */ jsx4(Box4, { width: isText ? labelWidth : barLabelWidth, children: label }),
-            isText && textWidth > 0 && /* @__PURE__ */ jsx4(Box4, { width: textWidth, children: /* @__PURE__ */ jsx4(
-              Text4,
+            /* @__PURE__ */ jsx4(Box6, { width: isText ? labelWidth : barLabelWidth, children: label }),
+            isText && textWidth > 0 && /* @__PURE__ */ jsx4(Box6, { width: textWidth, children: /* @__PURE__ */ jsx4(
+              Text6,
               {
                 wrap: "truncate",
                 color: highlighted ? COLORS.primary : COLORS.muted,
                 children: sec.value
               }
             ) }),
-            sec?.kind === "badge" && /* @__PURE__ */ jsx4(Box4, { width: badgeWidth, justifyContent: "flex-end", children: /* @__PURE__ */ jsx4(Text4, { color: COLORS.badge, wrap: "truncate", children: sec.value }) })
+            sec?.kind === "badge" && /* @__PURE__ */ jsx4(Box6, { width: badgeWidth, justifyContent: "flex-end", children: /* @__PURE__ */ jsx4(Text6, { color: COLORS.badge, wrap: "truncate", children: sec.value }) })
           ]
         },
         `row-${i}`
       );
     }) }),
-    /* @__PURE__ */ jsx4(Text4, { children: hints.map(({ key, label }, i) => /* @__PURE__ */ jsxs3(Text4, { children: [
+    /* @__PURE__ */ jsx4(Box6, { flexShrink: 0, children: /* @__PURE__ */ jsx4(Text6, { children: hints.map(({ key, label }, i) => /* @__PURE__ */ jsxs5(Text6, { children: [
       i > 0 ? "   " : "",
-      /* @__PURE__ */ jsx4(Text4, { color: COLORS.primary, children: key }),
-      /* @__PURE__ */ jsxs3(Text4, { color: COLORS.dim, children: [
+      /* @__PURE__ */ jsx4(Text6, { color: COLORS.primary, children: key }),
+      /* @__PURE__ */ jsxs5(Text6, { color: COLORS.dim, children: [
         " ",
         label
       ] })
-    ] }, label)) })
+    ] }, label)) }) })
   ] }) });
 }
 
 // src/ui/PromptInput.tsx
-import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+import { jsx as jsx5, jsxs as jsxs6 } from "react/jsx-runtime";
 var ACCEPT_REJECT_OPTIONS = ["Accept", "Reject"];
 function EnterToContinuePrompt({
   question,
@@ -675,10 +888,10 @@ function EnterToContinuePrompt({
     if (key.return) onDecide(true);
     else if (key.escape) onDecide(false);
   });
-  return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", gap: 1, children: [
-    messages?.map((m, i) => /* @__PURE__ */ jsx5(Text5, { color: COLORS.muted, children: m }, `msg-${i}`)),
-    question && /* @__PURE__ */ jsx5(Text5, { color: COLORS.primary, children: question }),
-    /* @__PURE__ */ jsxs4(Box5, { gap: 1, flexDirection: "column", children: [
+  return /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", gap: 1, children: [
+    messages?.map((m, i) => /* @__PURE__ */ jsx5(Text7, { color: COLORS.muted, children: m }, `msg-${i}`)),
+    question && /* @__PURE__ */ jsx5(Text7, { color: COLORS.primary, children: question }),
+    /* @__PURE__ */ jsxs6(Box7, { gap: 1, flexDirection: "column", children: [
       /* @__PURE__ */ jsx5(NextAction, { action: "continue", keyHint: "enter" }),
       /* @__PURE__ */ jsx5(NextAction, { action: "decline", keyHint: "esc", hierarchy: "secondary" })
     ] })
@@ -686,13 +899,13 @@ function EnterToContinuePrompt({
 }
 function PromptInput() {
   const { phase, inputReq, submitInput } = useWizard();
-  const [draft, setDraft] = useState4("");
+  const [draft, setDraft] = useState5("");
   if (phase === "done" || phase === "error") {
-    return /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx5(Text5, { color: "gray", dimColor: true, children: "Press Enter or Esc to exit" }) });
+    return /* @__PURE__ */ jsx5(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx5(Text7, { color: "gray", dimColor: true, children: "Press Enter or Esc to exit" }) });
   }
   if (phase !== "awaitingInput" || !inputReq) return null;
   if (inputReq.promptType === "multipleChoice") {
-    return /* @__PURE__ */ jsx5(Box5, { children: /* @__PURE__ */ jsx5(
+    return /* @__PURE__ */ jsx5(Box7, { flexGrow: 1, children: /* @__PURE__ */ jsx5(
       SelectPrompt,
       {
         question: inputReq.prompt,
@@ -709,7 +922,7 @@ function PromptInput() {
     ) });
   }
   if (inputReq.promptType === "multiSelect") {
-    return /* @__PURE__ */ jsx5(Box5, { children: /* @__PURE__ */ jsx5(
+    return /* @__PURE__ */ jsx5(Box7, { flexGrow: 1, children: /* @__PURE__ */ jsx5(
       SelectPrompt,
       {
         multi: true,
@@ -724,7 +937,7 @@ function PromptInput() {
     ) });
   }
   if (inputReq.promptType === "notice") {
-    return /* @__PURE__ */ jsx5(Box5, { children: /* @__PURE__ */ jsx5(
+    return /* @__PURE__ */ jsx5(Box7, { flexGrow: 1, children: /* @__PURE__ */ jsx5(
       SelectPrompt,
       {
         question: inputReq.prompt,
@@ -746,7 +959,7 @@ function PromptInput() {
   }
   if (inputReq.promptType === "acceptReject") {
     const labels = inputReq.options?.length ? inputReq.options : ACCEPT_REJECT_OPTIONS;
-    return /* @__PURE__ */ jsx5(Box5, { children: /* @__PURE__ */ jsx5(
+    return /* @__PURE__ */ jsx5(Box7, { flexGrow: 1, children: /* @__PURE__ */ jsx5(
       SelectPrompt,
       {
         question: inputReq.prompt,
@@ -757,11 +970,11 @@ function PromptInput() {
       }
     ) });
   }
-  return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", children: [
-    inputReq.error && /* @__PURE__ */ jsx5(Text5, { color: COLORS.danger, children: inputReq.error }),
-    inputReq.messages?.map((m, i) => /* @__PURE__ */ jsx5(Text5, { color: COLORS.muted, children: m }, `msg-${i}`)),
-    /* @__PURE__ */ jsxs4(Box5, { children: [
-      /* @__PURE__ */ jsxs4(Text5, { color: COLORS.primary, children: [
+  return /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", children: [
+    inputReq.error && /* @__PURE__ */ jsx5(Text7, { color: COLORS.danger, children: inputReq.error }),
+    inputReq.messages?.map((m, i) => /* @__PURE__ */ jsx5(Text7, { color: COLORS.muted, children: m }, `msg-${i}`)),
+    /* @__PURE__ */ jsxs6(Box7, { children: [
+      /* @__PURE__ */ jsxs6(Text7, { color: COLORS.primary, children: [
         inputReq.prompt,
         " "
       ] }),
@@ -783,7 +996,7 @@ function PromptInput() {
 // src/ui/Welcome.tsx
 import { dirname as dirname2, join as join3 } from "node:path";
 import { fileURLToPath } from "node:url";
-import { Box as Box6, Spacer, Text as Text6, useInput as useInput3, useWindowSize as useWindowSize4 } from "ink";
+import { Box as Box8, Spacer, Text as Text8, useInput as useInput3, useWindowSize as useWindowSize6 } from "ink";
 
 // src/ui/copy/welcome.ts
 var sidebarItems = [
@@ -796,12 +1009,12 @@ var sidebarItems = [
     description: "push 100 records to Algolia in seconds"
   },
   {
-    title: "detect your stack",
-    description: "React, Vue, Angular, Rails, Django, Laravel & more"
+    title: "detect your framework",
+    description: "React, Vue, Angular, Vanilla JS"
   },
   {
     title: "scaffold a search UI",
-    description: "a styled InstantSearch UI, wired into your app or templates"
+    description: "a styled InstantSearch component, wired into your app"
   },
   {
     title: "ship it",
@@ -811,27 +1024,27 @@ var sidebarItems = [
 
 // src/ui/Welcome.tsx
 import Image, { InkPictureProvider } from "ink-picture";
-import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+import { jsx as jsx6, jsxs as jsxs7 } from "react/jsx-runtime";
 var IMAGE_PATH = join3(dirname2(fileURLToPath(import.meta.url)), "algolia.png");
 function SidebarItem({
   title,
   description
 }) {
-  return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsxs5(Box6, { gap: 1, children: [
-      /* @__PURE__ */ jsx6(Text6, { color: COLORS.success, children: "\u2192" }),
-      /* @__PURE__ */ jsx6(Text6, { color: COLORS.strong, bold: true, children: title })
+  return /* @__PURE__ */ jsxs7(Box8, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs7(Box8, { gap: 1, children: [
+      /* @__PURE__ */ jsx6(Text8, { color: COLORS.success, children: "\u2192" }),
+      /* @__PURE__ */ jsx6(Text8, { color: COLORS.strong, bold: true, children: title })
     ] }),
-    /* @__PURE__ */ jsxs5(Box6, { flexDirection: "row", gap: 2, children: [
+    /* @__PURE__ */ jsxs7(Box8, { flexDirection: "row", gap: 2, children: [
       /* @__PURE__ */ jsx6(Spacer, {}),
-      /* @__PURE__ */ jsx6(Text6, { color: COLORS.muted, children: description })
+      /* @__PURE__ */ jsx6(Text8, { color: COLORS.muted, children: description })
     ] })
   ] });
 }
 function Welcome() {
   const confirmStart = useWizard((s) => s.confirmStart);
   const openLearnMore = useWizard((s) => s.openLearnMore);
-  const { rows } = useWindowSize4();
+  const { rows } = useWindowSize6();
   useInput3((input, key) => {
     if (key.return) confirmStart();
     else if (input === "i") openLearnMore();
@@ -850,15 +1063,15 @@ function Welcome() {
   if (rows < 30) {
     layout = scales["small"];
   }
-  return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "row", justifyContent: "space-between", width: "100%", children: [
+  return /* @__PURE__ */ jsxs7(Box8, { flexDirection: "row", justifyContent: "space-between", width: "100%", children: [
     /* @__PURE__ */ jsx6(
-      Box6,
+      Box8,
       {
         paddingY: layout.main.padding.y,
         paddingX: layout.main.padding.x,
         flexDirection: "column",
         justifyContent: "center",
-        children: /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", gap: 2, children: [
+        children: /* @__PURE__ */ jsxs7(Box8, { flexDirection: "column", gap: 2, children: [
           /* @__PURE__ */ jsx6(InkPictureProvider, { children: /* @__PURE__ */ jsx6(
             Image,
             {
@@ -870,16 +1083,16 @@ function Welcome() {
               protocol: "halfBlock"
             }
           ) }),
-          /* @__PURE__ */ jsx6(Text6, { color: COLORS.muted, children: "\u2726 From zero \u2192 working search in ~10 minutes" }),
-          /* @__PURE__ */ jsxs5(Box6, { gap: 1, flexDirection: "column", children: [
+          /* @__PURE__ */ jsx6(Text8, { color: COLORS.muted, children: "\u2726 From zero \u2192 working search in ~10 minutes" }),
+          /* @__PURE__ */ jsxs7(Box8, { gap: 1, flexDirection: "column", children: [
             /* @__PURE__ */ jsx6(NextAction, { action: "start wizard", keyHint: "enter" }),
             /* @__PURE__ */ jsx6(NextAction, { action: "learn more", keyHint: "i", hierarchy: "secondary" })
           ] })
         ] })
       }
     ),
-    /* @__PURE__ */ jsxs5(
-      Box6,
+    /* @__PURE__ */ jsxs7(
+      Box8,
       {
         backgroundColor: COLORS.bg.sidebar,
         width: 40,
@@ -889,7 +1102,7 @@ function Welcome() {
         flexDirection: "column",
         justifyContent: "center",
         children: [
-          /* @__PURE__ */ jsx6(Text6, { color: COLORS.muted, children: "WHAT THIS WIZARD WILL DO" }),
+          /* @__PURE__ */ jsx6(Text8, { color: COLORS.muted, children: "WHAT THIS WIZARD WILL DO" }),
           sidebarItems.map((i, idx) => /* @__PURE__ */ jsx6(SidebarItem, { title: i.title, description: i.description }, idx))
         ]
       }
@@ -899,7 +1112,7 @@ function Welcome() {
 
 // src/ui/LearnMore.tsx
 import { Fragment as Fragment2 } from "react";
-import { Box as Box7, Text as Text7, useInput as useInput4, useWindowSize as useWindowSize5 } from "ink";
+import { Box as Box9, Text as Text9, useInput as useInput4, useWindowSize as useWindowSize7 } from "ink";
 
 // src/ui/copy/learn-more.ts
 var accessIntro = "Everything runs locally on your machine. Nothing is written or sent without an explicit yes from you.";
@@ -907,7 +1120,7 @@ var accessItems = [
   {
     tag: "READ",
     title: "Project files",
-    description: "reads your dependency manifests (package.json, pyproject.toml, Gemfile, go.mod, pom.xml\u2026), configs & source to detect your stack. Read-only; nothing is uploaded."
+    description: "reads package.json, configs & source to detect your stack. Read-only; nothing is uploaded."
   },
   {
     tag: "WRITE",
@@ -936,7 +1149,7 @@ var policyLinks = [
 ];
 
 // src/ui/LearnMore.tsx
-import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
+import { jsx as jsx7, jsxs as jsxs8 } from "react/jsx-runtime";
 var TAG_COLORS = {
   READ: COLORS.success,
   WRITE: COLORS.badge,
@@ -952,25 +1165,25 @@ function NeverLine({
 }) {
   const used = segments.reduce((n, s) => n + s.text.length, 0);
   const rightPad = Math.max(0, width - 2 - NEVER_BOX_PAD_X - used);
-  return /* @__PURE__ */ jsxs6(Text7, { children: [
-    /* @__PURE__ */ jsx7(Text7, { color: COLORS.danger, children: "\u2502" }),
+  return /* @__PURE__ */ jsxs8(Text9, { children: [
+    /* @__PURE__ */ jsx7(Text9, { color: COLORS.danger, children: "\u2502" }),
     " ".repeat(NEVER_BOX_PAD_X),
-    segments.map((s, i) => /* @__PURE__ */ jsx7(Text7, { color: s.color, bold: s.bold, children: s.text }, i)),
+    segments.map((s, i) => /* @__PURE__ */ jsx7(Text9, { color: s.color, bold: s.bold, children: s.text }, i)),
     " ".repeat(rightPad),
-    /* @__PURE__ */ jsx7(Text7, { color: COLORS.danger, children: "\u2502" })
+    /* @__PURE__ */ jsx7(Text9, { color: COLORS.danger, children: "\u2502" })
   ] });
 }
 function LearnMore() {
   const confirmStart = useWizard((s) => s.confirmStart);
   const backToHome = useWizard((s) => s.backToHome);
-  const { columns } = useWindowSize5();
+  const { columns } = useWindowSize7();
   const dividerWidth = Math.max(0, columns - PADDING_X * 2);
   useInput4((_input, key) => {
     if (key.escape) backToHome();
     else if (key.return) confirmStart();
   });
-  return /* @__PURE__ */ jsxs6(
-    Box7,
+  return /* @__PURE__ */ jsxs8(
+    Box9,
     {
       flexDirection: "column",
       paddingX: PADDING_X,
@@ -978,20 +1191,20 @@ function LearnMore() {
       width: "100%",
       gap: 1,
       children: [
-        /* @__PURE__ */ jsx7(Text7, { color: COLORS.strong, bold: true, children: "What algolia wizard accesses" }),
-        /* @__PURE__ */ jsx7(Text7, { color: COLORS.muted, children: accessIntro }),
-        /* @__PURE__ */ jsx7(Box7, { flexDirection: "column", children: accessItems.map((item) => /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", marginTop: 1, children: [
-          /* @__PURE__ */ jsx7(Text7, { color: COLORS.border, children: "\u2500".repeat(dividerWidth) }),
-          /* @__PURE__ */ jsxs6(Box7, { flexDirection: "row", gap: 1, marginTop: 1, children: [
-            /* @__PURE__ */ jsx7(Box7, { width: TAG_COLUMN_WIDTH, flexShrink: 0, children: /* @__PURE__ */ jsx7(Text7, { color: TAG_COLORS[item.tag], bold: true, children: `[${item.tag}]` }) }),
-            /* @__PURE__ */ jsx7(Box7, { flexDirection: "column", children: /* @__PURE__ */ jsxs6(Text7, { children: [
-              /* @__PURE__ */ jsx7(Text7, { color: COLORS.strong, bold: true, children: item.title }),
-              /* @__PURE__ */ jsx7(Text7, { color: COLORS.muted, children: ` \u2014 ${item.description}` })
+        /* @__PURE__ */ jsx7(Text9, { color: COLORS.strong, bold: true, children: "What algolia wizard accesses" }),
+        /* @__PURE__ */ jsx7(Text9, { color: COLORS.muted, children: accessIntro }),
+        /* @__PURE__ */ jsx7(Box9, { flexDirection: "column", children: accessItems.map((item) => /* @__PURE__ */ jsxs8(Box9, { flexDirection: "column", marginTop: 1, children: [
+          /* @__PURE__ */ jsx7(Text9, { color: COLORS.border, children: "\u2500".repeat(dividerWidth) }),
+          /* @__PURE__ */ jsxs8(Box9, { flexDirection: "row", gap: 1, marginTop: 1, children: [
+            /* @__PURE__ */ jsx7(Box9, { width: TAG_COLUMN_WIDTH, flexShrink: 0, children: /* @__PURE__ */ jsx7(Text9, { color: TAG_COLORS[item.tag], bold: true, children: `[${item.tag}]` }) }),
+            /* @__PURE__ */ jsx7(Box9, { flexDirection: "column", children: /* @__PURE__ */ jsxs8(Text9, { children: [
+              /* @__PURE__ */ jsx7(Text9, { color: COLORS.strong, bold: true, children: item.title }),
+              /* @__PURE__ */ jsx7(Text9, { color: COLORS.muted, children: ` \u2014 ${item.description}` })
             ] }) })
           ] })
         ] }, item.tag)) }),
-        /* @__PURE__ */ jsxs6(Box7, { marginTop: 1, flexDirection: "column", children: [
-          /* @__PURE__ */ jsx7(Text7, { color: COLORS.danger, children: `\u256D${"\u2500".repeat(Math.max(0, dividerWidth - 2))}\u256E` }),
+        /* @__PURE__ */ jsxs8(Box9, { marginTop: 1, flexDirection: "column", children: [
+          /* @__PURE__ */ jsx7(Text9, { color: COLORS.danger, children: `\u256D${"\u2500".repeat(Math.max(0, dividerWidth - 2))}\u256E` }),
           /* @__PURE__ */ jsx7(NeverLine, { width: dividerWidth }),
           /* @__PURE__ */ jsx7(
             NeverLine,
@@ -1000,7 +1213,7 @@ function LearnMore() {
               segments: [{ text: "I NEVER", color: COLORS.danger, bold: true }]
             }
           ),
-          neverItems.map((item) => /* @__PURE__ */ jsxs6(Fragment2, { children: [
+          neverItems.map((item) => /* @__PURE__ */ jsxs8(Fragment2, { children: [
             /* @__PURE__ */ jsx7(NeverLine, { width: dividerWidth }),
             /* @__PURE__ */ jsx7(
               NeverLine,
@@ -1015,23 +1228,23 @@ function LearnMore() {
             )
           ] }, item)),
           /* @__PURE__ */ jsx7(NeverLine, { width: dividerWidth }),
-          /* @__PURE__ */ jsx7(Text7, { color: COLORS.danger, children: `\u2570${"\u2500".repeat(Math.max(0, dividerWidth - 2))}\u256F` })
+          /* @__PURE__ */ jsx7(Text9, { color: COLORS.danger, children: `\u2570${"\u2500".repeat(Math.max(0, dividerWidth - 2))}\u256F` })
         ] }),
-        /* @__PURE__ */ jsx7(Box7, { marginTop: 1, flexDirection: "column", children: policyLinks.map((link) => /* @__PURE__ */ jsxs6(Box7, { flexDirection: "row", gap: 1, children: [
-          /* @__PURE__ */ jsx7(Text7, { color: COLORS.strong, bold: true, children: `${link.label}:` }),
-          /* @__PURE__ */ jsx7(Text7, { color: COLORS.accent, children: link.url })
+        /* @__PURE__ */ jsx7(Box9, { marginTop: 1, flexDirection: "column", children: policyLinks.map((link) => /* @__PURE__ */ jsxs8(Box9, { flexDirection: "row", gap: 1, children: [
+          /* @__PURE__ */ jsx7(Text9, { color: COLORS.strong, bold: true, children: `${link.label}:` }),
+          /* @__PURE__ */ jsx7(Text9, { color: COLORS.accent, children: link.url })
         ] }, link.label)) }),
-        /* @__PURE__ */ jsxs6(Box7, { marginTop: 1, flexDirection: "row", gap: 3, children: [
-          /* @__PURE__ */ jsxs6(Box7, { flexDirection: "row", gap: 1, children: [
-            /* @__PURE__ */ jsx7(Text7, { color: COLORS.muted, children: "[" }),
-            /* @__PURE__ */ jsx7(Text7, { color: COLORS.primary, children: "esc" }),
-            /* @__PURE__ */ jsx7(Text7, { color: COLORS.muted, children: "] back" })
+        /* @__PURE__ */ jsxs8(Box9, { marginTop: 1, flexDirection: "row", gap: 3, children: [
+          /* @__PURE__ */ jsxs8(Box9, { flexDirection: "row", gap: 1, children: [
+            /* @__PURE__ */ jsx7(Text9, { color: COLORS.muted, children: "[" }),
+            /* @__PURE__ */ jsx7(Text9, { color: COLORS.primary, children: "esc" }),
+            /* @__PURE__ */ jsx7(Text9, { color: COLORS.muted, children: "] back" })
           ] }),
-          /* @__PURE__ */ jsxs6(Box7, { flexDirection: "row", gap: 1, children: [
-            /* @__PURE__ */ jsx7(Text7, { color: COLORS.muted, children: "[" }),
-            /* @__PURE__ */ jsx7(Text7, { color: COLORS.primary, children: "enter" }),
-            /* @__PURE__ */ jsx7(Text7, { color: COLORS.muted, children: "]" }),
-            /* @__PURE__ */ jsx7(Text7, { color: COLORS.success, bold: true, children: "start wizard" })
+          /* @__PURE__ */ jsxs8(Box9, { flexDirection: "row", gap: 1, children: [
+            /* @__PURE__ */ jsx7(Text9, { color: COLORS.muted, children: "[" }),
+            /* @__PURE__ */ jsx7(Text9, { color: COLORS.primary, children: "enter" }),
+            /* @__PURE__ */ jsx7(Text9, { color: COLORS.muted, children: "]" }),
+            /* @__PURE__ */ jsx7(Text9, { color: COLORS.success, bold: true, children: "start wizard" })
           ] })
         ] })
       ]
@@ -1040,10 +1253,10 @@ function LearnMore() {
 }
 
 // src/ui/Sidebar.tsx
-import { Box as Box10, Text as Text10 } from "ink";
+import { Box as Box12, Text as Text12 } from "ink";
 
 // src/ui/Steps.tsx
-import { Box as Box8, Text as Text8 } from "ink";
+import { Box as Box10, Text as Text10 } from "ink";
 import Spinner from "ink-spinner";
 
 // src/core/persistence.ts
@@ -1072,11 +1285,11 @@ async function clearWorkflowState(workflowId) {
 }
 
 // src/ui/Steps.tsx
-import { jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
+import { jsx as jsx8, jsxs as jsxs9 } from "react/jsx-runtime";
 function Steps() {
   const { steps } = useWizard();
   const visibleSteps = steps.filter(isStepVisible);
-  return /* @__PURE__ */ jsx8(Box8, { flexDirection: "column", gap: 1, children: visibleSteps.map((s) => /* @__PURE__ */ jsx8(Box8, { flexDirection: "column", children: /* @__PURE__ */ jsxs7(Text8, { color: COLORS.status[s.status], children: [
+  return /* @__PURE__ */ jsx8(Box10, { flexDirection: "column", gap: 1, children: visibleSteps.map((s) => /* @__PURE__ */ jsx8(Box10, { flexDirection: "column", children: /* @__PURE__ */ jsxs9(Text10, { color: COLORS.status[s.status], children: [
     s.status === "running" ? /* @__PURE__ */ jsx8(Spinner, { type: "dots" }) : MARKER[s.status],
     " ",
     s.title
@@ -1086,7 +1299,7 @@ function CurrentStep() {
   const { steps } = useWizard();
   const currentStep = steps.filter(isStepVisible).find((s) => s.status === "running");
   if (!currentStep) return null;
-  return /* @__PURE__ */ jsxs7(Text8, { color: COLORS.status.running, children: [
+  return /* @__PURE__ */ jsxs9(Text10, { color: COLORS.status.running, children: [
     /* @__PURE__ */ jsx8(Spinner, { type: "dots" }),
     " ",
     ` ${currentStep.title}`
@@ -1094,19 +1307,19 @@ function CurrentStep() {
 }
 
 // src/ui/Progress.tsx
-import { Box as Box9, Text as Text9 } from "ink";
-import { jsx as jsx9, jsxs as jsxs8 } from "react/jsx-runtime";
+import { Box as Box11, Text as Text11 } from "ink";
+import { jsx as jsx9, jsxs as jsxs10 } from "react/jsx-runtime";
 function Progress() {
   const { steps, currentStepIndex } = useWizard();
   const visibleSteps = steps.filter(isStepVisible);
   if (visibleSteps.length === 0) return null;
   const visibleCountThroughCurrent = steps.slice(0, currentStepIndex + 1).filter(isStepVisible).length;
   const activeStepNumber = Math.max(1, visibleCountThroughCurrent);
-  return /* @__PURE__ */ jsxs8(Box9, { flexDirection: "row", gap: 1, children: [
-    /* @__PURE__ */ jsx9(Text9, { color: COLORS.muted, children: "STEP" }),
-    /* @__PURE__ */ jsx9(Text9, { bold: true, children: activeStepNumber }),
-    /* @__PURE__ */ jsx9(Text9, { bold: true, children: "/" }),
-    /* @__PURE__ */ jsx9(Text9, { bold: true, children: visibleSteps.length })
+  return /* @__PURE__ */ jsxs10(Box11, { flexDirection: "row", gap: 1, children: [
+    /* @__PURE__ */ jsx9(Text11, { color: COLORS.muted, children: "STEP" }),
+    /* @__PURE__ */ jsx9(Text11, { bold: true, children: activeStepNumber }),
+    /* @__PURE__ */ jsx9(Text11, { bold: true, children: "/" }),
+    /* @__PURE__ */ jsx9(Text11, { bold: true, children: visibleSteps.length })
   ] });
 }
 
@@ -1117,10 +1330,10 @@ var sidebarCommands = [
 ];
 
 // src/ui/Sidebar.tsx
-import { jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
+import { jsx as jsx10, jsxs as jsxs11 } from "react/jsx-runtime";
 function Sidebar() {
-  return /* @__PURE__ */ jsxs9(
-    Box10,
+  return /* @__PURE__ */ jsxs11(
+    Box12,
     {
       backgroundColor: "#14171E",
       width: 30,
@@ -1129,16 +1342,16 @@ function Sidebar() {
       flexDirection: "column",
       justifyContent: "space-between",
       children: [
-        /* @__PURE__ */ jsxs9(Box10, { flexDirection: "column", gap: 1, children: [
-          /* @__PURE__ */ jsx10(Text10, { color: COLORS.muted, children: "PROGRESS" }),
+        /* @__PURE__ */ jsxs11(Box12, { flexDirection: "column", gap: 1, children: [
+          /* @__PURE__ */ jsx10(Text12, { color: COLORS.muted, children: "PROGRESS" }),
           /* @__PURE__ */ jsx10(Steps, {})
         ] }),
-        /* @__PURE__ */ jsxs9(Box10, { flexDirection: "column", gap: 1, children: [
+        /* @__PURE__ */ jsxs11(Box12, { flexDirection: "column", gap: 1, children: [
           /* @__PURE__ */ jsx10(Progress, {}),
-          /* @__PURE__ */ jsx10(Box10, { flexDirection: "column", children: sidebarCommands.map((c) => {
-            return /* @__PURE__ */ jsxs9(Box10, { flexDirection: "row", gap: 1, children: [
-              /* @__PURE__ */ jsx10(Text10, { color: COLORS.primary, children: `[${c.keyHint}]` }),
-              /* @__PURE__ */ jsx10(Text10, { color: COLORS.muted, children: c.description })
+          /* @__PURE__ */ jsx10(Box12, { flexDirection: "column", children: sidebarCommands.map((c) => {
+            return /* @__PURE__ */ jsxs11(Box12, { flexDirection: "row", gap: 1, children: [
+              /* @__PURE__ */ jsx10(Text12, { color: COLORS.primary, children: `[${c.keyHint}]` }),
+              /* @__PURE__ */ jsx10(Text12, { color: COLORS.muted, children: c.description })
             ] });
           }) })
         ] })
@@ -1148,12 +1361,12 @@ function Sidebar() {
 }
 
 // src/ui/Ribbon.tsx
-import { Box as Box11, Text as Text11 } from "ink";
-import { jsx as jsx11, jsxs as jsxs10 } from "react/jsx-runtime";
+import { Box as Box13, Text as Text13 } from "ink";
+import { jsx as jsx11, jsxs as jsxs12 } from "react/jsx-runtime";
 function Ribbon() {
   const firstCommand = sidebarCommands[0];
-  return /* @__PURE__ */ jsxs10(
-    Box11,
+  return /* @__PURE__ */ jsxs12(
+    Box13,
     {
       backgroundColor: "#14171E",
       flexDirection: "row",
@@ -1163,9 +1376,9 @@ function Ribbon() {
       children: [
         /* @__PURE__ */ jsx11(Progress, {}),
         /* @__PURE__ */ jsx11(CurrentStep, {}),
-        /* @__PURE__ */ jsxs10(Box11, { flexDirection: "row", gap: 1, children: [
-          /* @__PURE__ */ jsx11(Text11, { color: COLORS.primary, children: `[${firstCommand.keyHint}]` }),
-          /* @__PURE__ */ jsx11(Text11, { color: COLORS.muted, children: firstCommand.description })
+        /* @__PURE__ */ jsxs12(Box13, { flexDirection: "row", gap: 1, children: [
+          /* @__PURE__ */ jsx11(Text13, { color: COLORS.primary, children: `[${firstCommand.keyHint}]` }),
+          /* @__PURE__ */ jsx11(Text13, { color: COLORS.muted, children: firstCommand.description })
         ] })
       ]
     }
@@ -1176,9 +1389,8 @@ function Ribbon() {
 import { useState as useState6 } from "react";
 
 // src/ui/Logs.tsx
-import { useLayoutEffect as useLayoutEffect2, useRef as useRef3, useState as useState5 } from "react";
-import { Box as Box12, Text as Text12, measureElement as measureElement3, useInput as useInput5, useWindowSize as useWindowSize6 } from "ink";
-import { jsx as jsx12, jsxs as jsxs11 } from "react/jsx-runtime";
+import { Box as Box14, Text as Text14, useInput as useInput5 } from "ink";
+import { jsx as jsx12, jsxs as jsxs13 } from "react/jsx-runtime";
 var KIND_COLOR = {
   tool: COLORS.primary,
   prompt: COLORS.badge
@@ -1208,75 +1420,32 @@ function formatTimestamp(ms) {
 }
 function Logs() {
   const logs = useWizard((s) => s.logs);
-  const { rows, columns } = useWindowSize6();
-  const viewportRef = useRef3(null);
-  const [viewportHeight, setViewportHeight] = useState5(0);
-  const [viewportWidth, setViewportWidth] = useState5(0);
-  const [scrollOffset, setScrollOffset] = useState5(0);
-  const prevMaxOffsetRef = useRef3(0);
-  useLayoutEffect2(() => {
-    if (!viewportRef.current) return;
-    const { width, height } = measureElement3(viewportRef.current);
-    setViewportHeight(height);
-    setViewportWidth(width);
-  }, [rows, columns, logs.length === 0]);
-  let capacity = viewportHeight;
-  for (let i = 0; i < 2; i++) {
-    const hasAbove = scrollOffset > 0;
-    const hasBelow = scrollOffset + capacity < logs.length;
-    capacity = Math.max(
-      viewportHeight - (hasAbove ? 1 : 0) - (hasBelow ? 1 : 0),
-      0
-    );
-  }
-  const capacityAtBottom = logs.length > viewportHeight ? Math.max(viewportHeight - 1, 0) : viewportHeight;
-  const maxOffset = Math.max(logs.length - capacityAtBottom, 0);
-  useLayoutEffect2(() => {
-    const wasAtBottom = scrollOffset >= prevMaxOffsetRef.current;
-    prevMaxOffsetRef.current = maxOffset;
-    setScrollOffset((o) => wasAtBottom ? maxOffset : Math.min(o, maxOffset));
-  }, [maxOffset]);
+  const scroll = useScrollWindow({ itemCount: logs.length, followBottom: true });
   useInput5((_input, key) => {
-    if (!key.upArrow && !key.downArrow) return;
-    setScrollOffset(
-      (o) => key.upArrow ? Math.max(o - 1, 0) : Math.min(o + 1, maxOffset)
-    );
+    if (key.upArrow) scroll.scrollBy(-1);
+    else if (key.downArrow) scroll.scrollBy(1);
   });
-  const visible = logs.slice(scrollOffset, scrollOffset + capacity);
-  const hiddenAbove = scrollOffset;
-  const hiddenBelow = logs.length - scrollOffset - visible.length;
-  return /* @__PURE__ */ jsxs11(Box12, { flexDirection: "column", paddingX: 4, paddingY: 2, flexGrow: 1, children: [
-    logs.length === 0 && /* @__PURE__ */ jsx12(Text12, { color: COLORS.dim, children: "No logs yet." }),
-    /* @__PURE__ */ jsxs11(Box12, { ref: viewportRef, flexDirection: "column", flexGrow: 1, children: [
-      hiddenAbove > 0 && /* @__PURE__ */ jsxs11(Text12, { color: COLORS.dim, children: [
-        "\u2191 ",
-        hiddenAbove,
-        " more"
-      ] }),
-      visible.map((entry) => {
-        const timestamp = `[${formatTimestamp(entry.startedAt)}]`;
-        const durationText = entry.kind === "tool" && entry.durationMs !== void 0 ? `${entry.durationMs}ms` : "";
-        const rawPreview = rawInputText(entry.input);
-        const partCount = 2 + (rawPreview ? 1 : 0) + (durationText ? 1 : 0);
-        const gaps = (partCount - 1) * ROW_GAP;
-        let budget = viewportWidth - timestamp.length - durationText.length - gaps;
-        const name = truncate2(entry.name, budget);
-        budget -= name.length;
-        const preview = rawPreview ? truncate2(rawPreview, budget) : "";
-        return /* @__PURE__ */ jsxs11(Box12, { flexDirection: "row", gap: ROW_GAP, children: [
-          /* @__PURE__ */ jsx12(Text12, { color: COLORS.dim, children: timestamp }),
-          /* @__PURE__ */ jsx12(Text12, { color: logNameColor(entry), wrap: "truncate", children: name }),
-          preview && /* @__PURE__ */ jsx12(Text12, { color: COLORS.dim, wrap: "truncate", children: preview }),
-          durationText && /* @__PURE__ */ jsx12(Text12, { color: COLORS.dim, children: durationText })
-        ] }, entry.id);
-      }),
-      hiddenBelow > 0 && /* @__PURE__ */ jsxs11(Text12, { color: COLORS.dim, children: [
-        "\u2193 ",
-        hiddenBelow,
-        " more"
-      ] })
-    ] }),
-    /* @__PURE__ */ jsx12(Text12, { color: COLORS.dim, children: "\u2191/\u2193 scroll" })
+  const visible = logs.slice(scroll.offset, scroll.offset + scroll.capacity);
+  return /* @__PURE__ */ jsxs13(Box14, { flexDirection: "column", paddingX: 4, paddingY: 2, flexGrow: 1, children: [
+    logs.length === 0 && /* @__PURE__ */ jsx12(Text14, { color: COLORS.dim, children: "No logs yet." }),
+    /* @__PURE__ */ jsx12(ScrollView, { scroll, children: visible.map((entry) => {
+      const timestamp = `[${formatTimestamp(entry.startedAt)}]`;
+      const durationText = entry.kind === "tool" && entry.durationMs !== void 0 ? `${entry.durationMs}ms` : "";
+      const rawPreview = rawInputText(entry.input);
+      const partCount = 2 + (rawPreview ? 1 : 0) + (durationText ? 1 : 0);
+      const gaps = (partCount - 1) * ROW_GAP;
+      let budget = scroll.width - timestamp.length - durationText.length - gaps;
+      const name = truncate2(entry.name, budget);
+      budget -= name.length;
+      const preview = rawPreview ? truncate2(rawPreview, budget) : "";
+      return /* @__PURE__ */ jsxs13(Box14, { flexDirection: "row", gap: ROW_GAP, children: [
+        /* @__PURE__ */ jsx12(Text14, { color: COLORS.dim, children: timestamp }),
+        /* @__PURE__ */ jsx12(Text14, { color: logNameColor(entry), wrap: "truncate", children: name }),
+        preview && /* @__PURE__ */ jsx12(Text14, { color: COLORS.dim, wrap: "truncate", children: preview }),
+        durationText && /* @__PURE__ */ jsx12(Text14, { color: COLORS.dim, children: durationText })
+      ] }, entry.id);
+    }) }),
+    /* @__PURE__ */ jsx12(Text14, { color: COLORS.dim, children: "\u2191/\u2193 scroll" })
   ] });
 }
 
@@ -1468,11 +1637,11 @@ function track(event, payload) {
 }
 
 // src/ui/App.tsx
-import { jsx as jsx13, jsxs as jsxs12 } from "react/jsx-runtime";
+import { jsx as jsx13, jsxs as jsxs14 } from "react/jsx-runtime";
 function App() {
   const { phase, error, homeScreen, currentStepIndex, steps, inputReq } = useWizard();
   const { exit } = useApp();
-  const { columns, rows } = useWindowSize7();
+  const { columns, rows } = useWindowSize8();
   const [showLogs, setShowLogs] = useState6(false);
   const finished = phase === "done" || phase === "error";
   const currentStep = steps[currentStepIndex];
@@ -1485,7 +1654,7 @@ function App() {
     { isActive: finished }
   );
   useInput6((_input, key) => {
-    if (phase === "idle" || phase === "preflight") return;
+    if (phase === "idle" || phase === "authenticating") return;
     if (key.tab) {
       setShowLogs(!showLogs);
       track("AI Wizard Interaction", {
@@ -1495,66 +1664,75 @@ function App() {
       });
     }
   });
-  const escOwnedElsewhere = phase === "idle" || phase === "awaitingInput" && inputReq?.promptType === "enterToContinue";
+  const escOwnedElsewhere = phase === "idle" || phase === "authenticating" || phase === "awaitingInput" && inputReq?.promptType === "enterToContinue";
   useInput6((_input, key) => {
     if (escOwnedElsewhere) return;
     if (key.escape) {
       track("AI Wizard Interaction", {
         context: "global",
         key: "esc",
-        // No step is active until `startWorkflow` — report the phase instead.
         currentStep: currentStep?.id ?? phase
       });
       exit();
     }
   });
-  const mainWindowVisible = phase === "running" || phase === "awaitingInput" || phase === "error" || phase === "done";
+  const mainWindowVisible = phase === "authenticating" || phase === "preflight" || phase === "running" || phase === "awaitingInput" || phase === "error" || phase === "done";
   const flexDirection = columns > 90 ? "row" : "column";
   const showSidebar = flexDirection === "row";
-  return /* @__PURE__ */ jsxs12(
-    Box13,
-    {
-      backgroundColor: COLORS.bg.main,
-      flexDirection: "row",
-      width: columns,
-      minHeight: rows,
-      children: [
-        mainWindowVisible && /* @__PURE__ */ jsxs12(
-          Box13,
-          {
-            flexDirection,
-            width: "100%",
-            justifyContent: "space-between",
-            children: [
-              showLogs ? /* @__PURE__ */ jsx13(Logs, {}) : (
-                /* Fill the width beside the sidebar; row layout only (would grow vertically when stacked). */
-                /* @__PURE__ */ jsxs12(
-                  Box13,
+  const scrollsPastViewport = phase === "idle" && homeScreen === "learnMore";
+  return (
+    /* Clamped to exactly the viewport: a taller frame makes Ink clear and repaint
+       the whole screen, and the scrolling throws off its cursor arithmetic —
+       flicker and leftover rows. */
+    /* @__PURE__ */ jsxs14(
+      Box15,
+      {
+        backgroundColor: COLORS.bg.main,
+        flexDirection: "row",
+        width: columns,
+        height: scrollsPastViewport ? void 0 : rows,
+        overflow: scrollsPastViewport ? "visible" : "hidden",
+        children: [
+          mainWindowVisible && /* @__PURE__ */ jsxs14(
+            Box15,
+            {
+              flexDirection,
+              width: "100%",
+              maxHeight: rows,
+              justifyContent: "space-between",
+              children: [
+                showLogs ? /* @__PURE__ */ jsx13(Logs, {}) : /* @__PURE__ */ jsxs14(
+                  Box15,
                   {
                     flexDirection: "column",
                     paddingX: 4,
                     paddingY: 2,
                     width: showSidebar ? 70 : "100%",
-                    flexGrow: showSidebar ? 1 : 0,
+                    flexGrow: 1,
                     children: [
+                      phase === "authenticating" && /* @__PURE__ */ jsxs14(Box15, { flexDirection: "column", marginBottom: 1, children: [
+                        /* @__PURE__ */ jsx13(Text15, { color: COLORS.strong, bold: true, children: "Signing in to Algolia" }),
+                        /* @__PURE__ */ jsx13(Text15, { color: COLORS.muted, children: "A browser window will open \u2014 complete sign-in there." })
+                      ] }),
+                      /* @__PURE__ */ jsx13(CliOutput, {}),
                       /* @__PURE__ */ jsx13(Notices, {}),
                       /* @__PURE__ */ jsx13(PromptInput, {}),
-                      phase === "running" && showSidebar && /* @__PURE__ */ jsx13(Box13, { marginTop: 1, children: /* @__PURE__ */ jsx13(CurrentStep, {}) }),
-                      phase === "error" && error && /* @__PURE__ */ jsx13(Box13, { marginTop: 1, children: /* @__PURE__ */ jsxs12(Text13, { color: COLORS.status.error, children: [
+                      phase === "running" && showSidebar && /* @__PURE__ */ jsx13(Box15, { marginTop: 1, children: /* @__PURE__ */ jsx13(CurrentStep, {}) }),
+                      phase === "error" && error && /* @__PURE__ */ jsx13(Box15, { marginTop: 1, children: /* @__PURE__ */ jsxs14(Text15, { color: COLORS.status.error, children: [
                         "\u2716 ",
                         error
                       ] }) })
                     ]
                   }
-                )
-              ),
-              showSidebar ? /* @__PURE__ */ jsx13(Sidebar, {}) : /* @__PURE__ */ jsx13(Ribbon, {})
-            ]
-          }
-        ),
-        (phase === "idle" || phase === "preflight") && (homeScreen === "learnMore" ? /* @__PURE__ */ jsx13(LearnMore, {}) : /* @__PURE__ */ jsx13(Welcome, {}))
-      ]
-    }
+                ),
+                showSidebar ? /* @__PURE__ */ jsx13(Sidebar, {}) : /* @__PURE__ */ jsx13(Ribbon, {})
+              ]
+            }
+          ),
+          phase === "idle" && (homeScreen === "learnMore" ? /* @__PURE__ */ jsx13(LearnMore, {}) : /* @__PURE__ */ jsx13(Welcome, {}))
+        ]
+      }
+    )
   );
 }
 
@@ -1568,7 +1746,8 @@ var configFile = () => join5(stateDir(), "config.json");
 var DEFAULT_CONFIG = {
   version: 1,
   aiConsent: false,
-  workflowsRun: []
+  workflowsRun: [],
+  searchApiKeys: {}
 };
 async function loadConfig() {
   try {
@@ -1587,6 +1766,38 @@ async function recordWorkflowRun(workflowId, completedAt) {
   config.workflowsRun.push({ workflowId, completedAt });
   await saveConfig(config);
 }
+function isStoredSearchKey(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const { appId, key } = value;
+  return typeof appId === "string" && !!appId && typeof key === "string" && !!key;
+}
+function storedSearchKeys(config) {
+  const stored = config.searchApiKeys;
+  if (typeof stored !== "object" || stored === null || Array.isArray(stored)) {
+    return {};
+  }
+  return stored;
+}
+async function getStoredSearchKey(index, appId) {
+  const entry = storedSearchKeys(await loadConfig())[index];
+  if (!isStoredSearchKey(entry) || entry.appId !== appId) return void 0;
+  return entry.key;
+}
+async function storeSearchKey(index, appId, key) {
+  const config = await loadConfig();
+  config.searchApiKeys = {
+    ...storedSearchKeys(config),
+    [index]: { appId, key }
+  };
+  await saveConfig(config);
+}
+async function forgetSearchKey(index) {
+  const config = await loadConfig();
+  const remaining = { ...storedSearchKeys(config) };
+  delete remaining[index];
+  config.searchApiKeys = remaining;
+  await saveConfig(config);
+}
 
 // src/core/orchestrator.ts
 function defineStep(step) {
@@ -1790,61 +2001,138 @@ async function runWorkflow(workflow, appId) {
   }
 }
 
-// src/lib/algoliaProfile.ts
-import { readFile as readFile3 } from "node:fs/promises";
-import { createRequire as createRequire2 } from "node:module";
-import { homedir as homedir2 } from "node:os";
-import { join as join6 } from "node:path";
-import { parse as parseToml } from "toml";
-var require3 = createRequire2(import.meta.url);
-function configPath() {
-  const base = process.env.XDG_CONFIG_HOME || join6(homedir2(), ".config");
-  return join6(base, "algolia", "config.toml");
-}
-function profilesFromConfig(tomlText) {
-  let parsed;
+// src/lib/algoliaApp.ts
+import { z as z4 } from "zod";
+var applicationSchema = z4.object({
+  id: z4.string().min(1),
+  name: z4.string().default(""),
+  plan: z4.string().optional()
+});
+var listSchema = z4.array(
+  z4.object({
+    id: z4.string().min(1),
+    name: z4.string().default(""),
+    plan_label: z4.string().optional()
+  }).transform(({ id, name, plan_label }) => ({ id, name, plan: plan_label }))
+);
+async function currentApplication() {
+  let raw;
   try {
-    parsed = parseToml(tomlText);
+    raw = await runAlgoliaCli(["application", "current", "-o", "json"]);
   } catch {
-    return [];
+    return null;
+  }
+  const parsed = applicationSchema.safeParse(parseJson(raw));
+  return parsed.success ? parsed.data : null;
+}
+async function requireApplication() {
+  const app = await currentApplication();
+  if (!app) {
+    throw new Error(
+      "No Algolia application is selected. Run `npx @algolia/cli@latest application select` and restart the wizard."
+    );
+  }
+  return app;
+}
+async function listApplications() {
+  const raw = await runAlgoliaCli(["application", "list", "-o", "json"]);
+  const parsed = listSchema.safeParse(parseJson(raw));
+  if (!parsed.success) {
+    throw new Error("Could not read the list of Algolia applications.");
+  }
+  return parsed.data;
+}
+async function selectApplication(id) {
+  const raw = await runAlgoliaCli(
+    ["application", "select", "--non-interactive", "--app-id", id],
+    { onOutput: stderrSink }
+  );
+  const parsed = applicationSchema.safeParse(parseJson(raw));
+  if (!parsed.success) {
+    throw new Error(
+      `Selected application ${id}, but the Algolia CLI returned an unreadable result.`
+    );
   }
-  const profiles = Object.entries(parsed).filter(
-    ([, t]) => typeof t.application_id === "string" && typeof t.api_key === "string"
-  ).map(([name, t]) => ({
-    name,
-    appId: t.application_id,
-    apiKey: t.api_key,
-    isDefault: t.default === true
-  }));
-  profiles.sort((a, b) => Number(b.isDefault) - Number(a.isDefault));
-  return profiles.map(({ name, appId, apiKey }) => ({ name, appId, apiKey }));
-}
-async function loadActiveProfile() {
-  let profiles;
+  return parsed.data;
+}
+function parseJson(text) {
   try {
-    profiles = profilesFromConfig(await readFile3(configPath(), "utf8"));
+    return JSON.parse(text);
   } catch {
-    profiles = [];
+    return void 0;
   }
-  const profile = profiles[0];
-  if (!profile) {
+}
+
+// src/lib/algoliaAppPicker.ts
+function secondaryFor(app) {
+  return app.plan ? { kind: "badge", value: app.plan } : void 0;
+}
+function labelFor(app) {
+  return app.name.trim() ? `${app.name} \u2014 ${app.id}` : app.id;
+}
+function selectAndReport(app) {
+  useWizard.getState().pushCliOutput(
+    "stdout",
+    `Selecting ${labelFor(app)} \u2014 provisioning its API key\u2026`
+  );
+  return selectApplication(app.id);
+}
+async function promptForApplication() {
+  const store = useWizard.getState();
+  const apps = await listApplications();
+  if (apps.length === 0) {
     throw new Error(
-      "No Algolia profile is configured. Run `npx @algolia/cli auth login` to authenticate."
+      "This Algolia account has no applications. Create one in the Algolia dashboard, or with `npx @algolia/cli@latest application create`, then restart the wizard."
     );
   }
-  return profile;
+  if (apps.length === 1) {
+    const only = apps[0];
+    logger.info(
+      { app: only.id },
+      "single application on the account; selecting it"
+    );
+    return selectAndReport(only);
+  }
+  const messages = ["Which Algolia application should the wizard work in?"];
+  for (; ; ) {
+    const choice = await store.requestUserInput({
+      prompt: "Select an application",
+      promptType: "multipleChoice",
+      options: apps.map(labelFor),
+      secondary: apps.map(secondaryFor),
+      messages
+    });
+    const chosen = apps.find((app) => labelFor(app) === choice);
+    if (!chosen) {
+      throw new Error("Application picker received an unexpected selection");
+    }
+    try {
+      return await selectAndReport(chosen);
+    } catch (err) {
+      logger.warn(
+        { app: chosen.id, err: err.message },
+        "application select failed; re-prompting"
+      );
+      messages.push(
+        `Could not select \u201C${labelFor(chosen)}\u201D. It may have been removed \u2014 pick another.`
+      );
+    }
+  }
+}
+async function ensureApplication() {
+  return await currentApplication() ?? await promptForApplication();
 }
 
 // src/workflows/default.ts
-import { z as z25 } from "zod";
+import { z as z27 } from "zod";
 
 // src/actions/listIndices.ts
-import { z as z3 } from "zod";
-var indicesListSchema = z3.object({
-  items: z3.array(
-    z3.object({
-      name: z3.string(),
-      entries: z3.number().default(0)
+import { z as z5 } from "zod";
+var indicesListSchema = z5.object({
+  items: z5.array(
+    z5.object({
+      name: z5.string(),
+      entries: z5.number().default(0)
     })
   )
 });
@@ -1915,12 +2203,12 @@ import "zod";
 
 // src/lib/tools/listFiles.ts
 import { tool } from "ai";
-import z4 from "zod";
+import z6 from "zod";
 import { readdir } from "node:fs/promises";
 
 // src/lib/tools/path.ts
 import { lstat } from "node:fs/promises";
-import { resolve as resolve2, relative, isAbsolute, dirname as dirname3, join as join7, sep } from "node:path";
+import { resolve as resolve2, relative, isAbsolute, dirname as dirname3, join as join6, sep } from "node:path";
 function resolveInRoot(ctx, path) {
   const target = resolve2(ctx.cwd, path);
   const rel = relative(ctx.root, target);
@@ -1936,7 +2224,7 @@ async function hasSymlinkParent(ctx, target) {
   let current = ctx.root;
   const parts = relative(ctx.root, dirname3(target)).split(sep).filter(Boolean);
   for (const part of parts) {
-    current = join7(current, part);
+    current = join6(current, part);
     try {
       if ((await lstat(current)).isSymbolicLink()) return true;
     } catch (err) {
@@ -1951,7 +2239,7 @@ async function hasSymlinkParent(ctx, target) {
 function listFilesTool(ctx) {
   return tool({
     description: "List files in the current working directory",
-    inputSchema: z4.object(),
+    inputSchema: z6.object(),
     execute: async () => {
       logger.info("called listFiles tool");
       if (++ctx.counts.list > ctx.limits.list) {
@@ -1967,13 +2255,13 @@ function listFilesTool(ctx) {
 
 // src/lib/tools/changeDirectory.ts
 import { tool as tool2 } from "ai";
-import z5 from "zod";
+import z7 from "zod";
 import { stat } from "node:fs/promises";
 function changeDirectoryTool(ctx) {
   return tool2({
     description: "Change the current working directory. Subsequent file operations resolve relative to it. Returns the new working directory.",
-    inputSchema: z5.object({
-      path: z5.string().describe("Directory to change into")
+    inputSchema: z7.object({
+      path: z7.string().describe("Directory to change into")
     }),
     execute: async ({ path }) => {
       logger.info({ path }, "called changeDirectory tool");
@@ -1995,13 +2283,13 @@ function changeDirectoryTool(ctx) {
 
 // src/lib/tools/reportStatus.ts
 import { tool as tool3 } from "ai";
-import z6 from "zod";
+import z8 from "zod";
 function reportStatusTool(output) {
   return tool3({
     description: "Report the status of your execution. Return a reason in case of failure.",
-    inputSchema: z6.object({
-      status: z6.enum(["success", "fail"]),
-      reason: z6.string().optional(),
+    inputSchema: z8.object({
+      status: z8.enum(["success", "fail"]),
+      reason: z8.string().optional(),
       output
     }),
     execute: async ({ status, reason, output: output2 }) => {
@@ -2013,8 +2301,8 @@ function reportStatusTool(output) {
 
 // src/lib/tools/readFile.ts
 import { tool as tool4 } from "ai";
-import z7 from "zod";
-import { readFile as readFile4 } from "node:fs/promises";
+import z9 from "zod";
+import { readFile as readFile3 } from "node:fs/promises";
 
 // src/lib/tools/env.ts
 import { basename } from "node:path";
@@ -2041,8 +2329,8 @@ function redactEnvValues(content) {
 function readFileTool(ctx) {
   return tool4({
     description: "Read the contents of a file at the given path",
-    inputSchema: z7.object({
-      filePath: z7.string().describe("Path to the file to read")
+    inputSchema: z9.object({
+      filePath: z9.string().describe("Path to the file to read")
     }),
     execute: async ({ filePath }) => {
       if (++ctx.counts.read > ctx.limits.read) {
@@ -2052,7 +2340,7 @@ function readFileTool(ctx) {
       const resolved = resolveInRoot(ctx, filePath);
       if (!resolved.ok) return resolved.error;
       try {
-        const content = await readFile4(resolved.target, "utf8");
+        const content = await readFile3(resolved.target, "utf8");
         return isEnvFile(resolved.target) ? redactEnvValues(content) : content;
       } catch (err) {
         return `Error reading ${filePath}: ${err.message}`;
@@ -2063,15 +2351,15 @@ function readFileTool(ctx) {
 
 // src/lib/tools/writeFile.ts
 import { tool as tool5 } from "ai";
-import z8 from "zod";
+import z10 from "zod";
 import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
 import { dirname as dirname4 } from "node:path";
 function writeFileTool(ctx) {
   return tool5({
     description: "Write content to a file at the given path, overwriting it. To set Algolia credentials in an env file, use writeCredentials instead of this tool.",
-    inputSchema: z8.object({
-      filePath: z8.string().describe("Path to the file to write"),
-      content: z8.string().describe("Content to write to the file")
+    inputSchema: z10.object({
+      filePath: z10.string().describe("Path to the file to write"),
+      content: z10.string().describe("Content to write to the file")
     }),
     execute: async ({ filePath, content }) => {
       logger.info({ filePath }, "called writeFile tool");
@@ -2096,9 +2384,125 @@ function writeFileTool(ctx) {
 
 // src/lib/tools/writeAlgoliaCredentials.ts
 import { tool as tool6 } from "ai";
-import z9 from "zod";
-import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile4 } from "node:fs/promises";
+import z12 from "zod";
+import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile4 } from "node:fs/promises";
 import { dirname as dirname5 } from "node:path";
+
+// src/lib/algoliaApiKey.ts
+import { z as z11 } from "zod";
+var WRITE_ACLS = [
+  "addObject",
+  "deleteObject",
+  "settings",
+  "editSettings",
+  "listIndexes"
+];
+var WRITE_ACL_SET = new Set(WRITE_ACLS);
+var apiKeySchema = z11.object({
+  value: z11.string().min(1),
+  acl: z11.array(z11.string()).default([]),
+  indexes: z11.array(z11.string()).default([])
+});
+var apiKeyListSchema = z11.object({
+  items: z11.array(apiKeySchema).optional(),
+  keys: z11.array(apiKeySchema).optional()
+}).transform((o) => o.items ?? o.keys ?? []);
+var createdKeySchema = z11.object({
+  key: z11.string().min(1).optional(),
+  value: z11.string().min(1).optional()
+}).transform((o) => o.key ?? o.value);
+function canReuseForWrites(key, index) {
+  return WRITE_ACLS.every((acl) => key.acl.includes(acl)) && key.acl.every((acl) => WRITE_ACL_SET.has(acl)) && key.indexes.includes(index);
+}
+async function resolveWriteKey(index) {
+  const stdout = await runAlgoliaCli(["apikeys", "list", "-o", "json"]);
+  const existing = apiKeyListSchema.parse(JSON.parse(stdout)).find((key) => canReuseForWrites(key, index))?.value;
+  if (existing) {
+    logger.info({ index }, "reusing existing write API key");
+    return existing;
+  }
+  logger.info({ index }, "no reusable write key found; creating one");
+  const created = await runAlgoliaCli([
+    "apikeys",
+    "create",
+    "--indices",
+    index,
+    "--acl",
+    WRITE_ACLS.join(","),
+    "--description",
+    `wizard write key for ${index}`,
+    "-o",
+    "json"
+  ]);
+  const writeKey = createdKeySchema.parse(JSON.parse(created));
+  if (!writeKey) throw new Error("apikeys create returned no key value");
+  return writeKey;
+}
+async function createSearchOnlyKey(index) {
+  logger.info({ index }, "creating a search-only API key");
+  const stdout = await runAlgoliaCli([
+    "apikeys",
+    "create",
+    "--acl",
+    "search",
+    "--indices",
+    index,
+    "--description",
+    `Algolia Wizard search-only key for ${index}`,
+    "-o",
+    "json"
+  ]);
+  let payload;
+  try {
+    payload = JSON.parse(stdout);
+  } catch {
+    throw new Error("apikeys create returned output that is not valid JSON");
+  }
+  const created = createdKeySchema.parse(payload);
+  if (!created) throw new Error("apikeys create returned no key value");
+  return created;
+}
+async function apiKeyExists(key) {
+  try {
+    await runAlgoliaCli(["apikeys", "get", key, "-o", "json"]);
+    return true;
+  } catch (err) {
+    return !/does not exist|not found|404/i.test(err.message);
+  }
+}
+async function resolveSearchOnlyKey(index, appId, envKey) {
+  if (envKey) {
+    await recordSearchKey(index, appId, envKey);
+    return { key: envKey, source: "env" };
+  }
+  const stored = await getStoredSearchKey(index, appId);
+  if (stored) {
+    if (await apiKeyExists(stored)) {
+      logger.info({ index, appId }, "reusing the stored search-only API key");
+      return { key: stored, source: "config" };
+    }
+    logger.warn(
+      { index, appId },
+      "the stored search-only API key no longer exists; creating a replacement"
+    );
+    await forgetSearchKey(index);
+  }
+  const key = await createSearchOnlyKey(index);
+  await recordSearchKey(index, appId, key);
+  return { key, source: "created" };
+}
+async function recordSearchKey(index, appId, key) {
+  try {
+    await storeSearchKey(index, appId, key);
+  } catch (err) {
+    logger.warn(
+      { err: err.message, index },
+      "could not record the search-only API key; a later run may create another"
+    );
+  }
+}
+
+// src/lib/tools/writeAlgoliaCredentials.ts
 var APP_ID_VAR = "ALGOLIA_APPLICATION_ID";
 var API_KEY_VAR = "ALGOLIA_WRITE_API_KEY";
 function appendEnv(content, entries) {
@@ -2112,9 +2516,9 @@ function hasEnv(content, name) {
 }
 function writeCredentialsTool(ctx) {
   return tool6({
-    description: `Write the active Algolia credentials (${APP_ID_VAR} and ${API_KEY_VAR}) into the given env file. The credentials are read from the local Algolia CLI profile; you only pass the path to the env file (e.g. ".env"). If the file already defines ${APP_ID_VAR} or ${API_KEY_VAR}, the write is skipped and existing values are left untouched.`,
-    inputSchema: z9.object({
-      filePath: z9.string().describe(
+    description: `Write the active Algolia credentials (${APP_ID_VAR} and ${API_KEY_VAR}) into the given env file. The credentials come from the selected Algolia application, with a write key scoped to the target index; you only pass the path to the env file (e.g. ".env"). If the file already defines ${APP_ID_VAR} or ${API_KEY_VAR}, the write is skipped and existing values are left untouched.`,
+    inputSchema: z12.object({
+      filePath: z12.string().describe(
         'Path to the env file to write credentials into (e.g. ".env")'
       )
     }),
@@ -2122,11 +2526,17 @@ function writeCredentialsTool(ctx) {
       logger.info({ filePath }, "called writeCredentials tool");
       const resolved = resolveInRoot(ctx, filePath);
       if (resolved.ok === false) return resolved.error;
-      let profile;
+      const targetIndex = useWizard.getState().targetIndex;
+      if (!targetIndex) {
+        return "Error: no target index is set for this run, so a scoped write key cannot be provisioned.";
+      }
+      let appId;
+      let writeKey;
       try {
-        profile = await loadActiveProfile();
-      } catch {
-        return "Error: no Algolia profile is configured, so credentials cannot be written. Ask the user to authenticate with the Algolia CLI first.";
+        appId = (await requireApplication()).id;
+        writeKey = await resolveWriteKey(targetIndex);
+      } catch (err) {
+        return `Error: could not resolve Algolia credentials (${err.message}). Ask the user to authenticate with the Algolia CLI first.`;
       }
       try {
         if (await hasSymlinkParent(ctx, resolved.target)) {
@@ -2134,7 +2544,7 @@ function writeCredentialsTool(ctx) {
         }
         let existing = "";
         try {
-          existing = await readFile5(resolved.target, "utf8");
+          existing = await readFile4(resolved.target, "utf8");
         } catch (err) {
           if (err.code !== "ENOENT") throw err;
         }
@@ -2145,8 +2555,8 @@ function writeCredentialsTool(ctx) {
           return `Skipped: ${filePath} already defines ${present.join(" and ")}. Leaving existing credentials untouched.`;
         }
         const envWithCredentials = appendEnv(existing, [
-          [APP_ID_VAR, profile.appId],
-          [API_KEY_VAR, profile.apiKey]
+          [APP_ID_VAR, appId],
+          [API_KEY_VAR, writeKey]
         ]);
         await mkdir4(dirname5(resolved.target), { recursive: true });
         await writeFile4(resolved.target, envWithCredentials, "utf8");
@@ -2160,746 +2570,16 @@ function writeCredentialsTool(ctx) {
 
 // src/lib/tools/searchFiles.ts
 import { tool as tool7 } from "ai";
-import z10 from "zod";
-import { readdir as readdir3, readFile as readFile8 } from "node:fs/promises";
-import { join as join10 } from "node:path";
-
-// src/lib/languages.ts
-import { readdir as readdir2, readFile as readFile7 } from "node:fs/promises";
-import { existsSync as existsSync2 } from "node:fs";
-import { join as join9 } from "node:path";
-
-// src/lib/tools/utils/packageManager.ts
-import { readFile as readFile6 } from "node:fs/promises";
-import { existsSync } from "node:fs";
-import { join as join8 } from "node:path";
-var LOCKFILES = [
-  ["pnpm-lock.yaml", "pnpm"],
-  ["yarn.lock", "yarn"],
-  ["bun.lockb", "bun"],
-  ["bun.lock", "bun"],
-  ["package-lock.json", "npm"]
-];
-async function readPackageJson(cwd = process.cwd()) {
-  return JSON.parse(await readFile6(join8(cwd, "package.json"), "utf8"));
-}
-function packageManagerFrom(pkg) {
-  return pkg.packageManager?.split("@")[0] ?? "npm";
-}
-function packageManagerFromLockfile(cwd) {
-  return LOCKFILES.find(([file]) => existsSync(join8(cwd, file)))?.[1];
-}
-async function detectPackageManager(cwd) {
-  try {
-    const pkg = await readPackageJson(cwd);
-    if (pkg.packageManager) return packageManagerFrom(pkg);
-  } catch {
-  }
-  return packageManagerFromLockfile(cwd) ?? "npm";
-}
-
-// src/lib/shell.ts
-function shellQuote(value) {
-  return "'" + value.replace(/'/g, "'\\''") + "'";
-}
-
-// src/lib/languages.ts
-var ENTRYPOINT_TOKEN = "{entrypoint}";
-var INGEST_DIR = ".algolia-wizard";
-var SWIFT_PACKAGE_DIR = `${INGEST_DIR}/Ingest`;
-var CSHARP_PROJECT = `${INGEST_DIR}/ingest/ingest.csproj`;
-var VISIBLE_INGEST_DIR = "algolia-wizard";
-var PY_VENV = `${INGEST_DIR}/.venv`;
-var PY_VENV_PYTHON = `${PY_VENV}/bin/python`;
-var PY_REQUIREMENTS = `${INGEST_DIR}/requirements.txt`;
-var LANGUAGE_PROFILES = {
-  javascript: {
-    id: "javascript",
-    displayName: "JavaScript/TypeScript",
-    aliases: [
-      "javascript",
-      "js",
-      "typescript",
-      "ts",
-      "node",
-      "nodejs",
-      "node.js",
-      "bun",
-      "deno",
-      "ecmascript",
-      "jsx",
-      "tsx"
-    ],
-    manifests: ["package.json"],
-    // The concrete npm-family manager is resolved by detectPackageManager (it
-    // honours the package.json `packageManager` field, which lockfiles can't
-    // express), so one spec covers all four and `resolveToolchain` rewrites the
-    // binary below.
-    packageManagers: [
-      {
-        id: "npm",
-        dependency: { mode: "agent-declares", file: "package.json" },
-        installSteps: [{ argv: ["npm", "install"] }],
-        ingest: {
-          kind: "auto",
-          argv: ["node", ENTRYPOINT_TOKEN],
-          entrypointExtensions: [".mjs", ".cjs", ".js"]
-        }
-      }
-    ],
-    sdk: { packageName: "algoliasearch", versionPin: "^5", docKey: "js" },
-    ingestEntrypointExample: `${INGEST_DIR}/ingest.mjs`,
-    // package.json scripts are repo-defined, so they're resolved at run time by
-    // repoVerification rather than listed here.
-    verification: [],
-    envReadInstruction: "Read them from `process.env`.",
-    skipDirs: ["node_modules", "dist", "build", "coverage", ".next", "out"]
-  },
-  python: {
-    id: "python",
-    displayName: "Python",
-    aliases: ["python", "python3", "py", "cpython"],
-    manifests: [
-      "pyproject.toml",
-      "requirements.txt",
-      "setup.py",
-      "setup.cfg",
-      "Pipfile"
-    ],
-    // Deliberately one path for every Python repo: a wizard-owned venv under
-    // .algolia-wizard. Reusing the project's uv/poetry environment would mean
-    // mutating the developer's real dependency manifest and lockfile, and the
-    // declare-here/install-there split is the main way ingestion silently ends
-    // up without the SDK installed. The tradeoff: the script can import the
-    // Algolia client and anything it declares itself, but not the project's own
-    // packages (see the optional root-requirements step below).
-    packageManagers: [
-      {
-        id: "pip-venv",
-        dependency: { mode: "agent-declares", file: PY_REQUIREMENTS },
-        installSteps: [
-          { argv: ["python3", "-m", "venv", PY_VENV] },
-          {
-            argv: [PY_VENV_PYTHON, "-m", "pip", "install", "-r", PY_REQUIREMENTS]
-          },
-          // Best-effort access to the project's own dependencies (DB drivers,
-          // ORMs) when the repo pins them the classic way.
-          {
-            argv: [
-              PY_VENV_PYTHON,
-              "-m",
-              "pip",
-              "install",
-              "-r",
-              "requirements.txt"
-            ],
-            requiresFile: "requirements.txt",
-            optional: true
-          }
-        ],
-        ingest: {
-          kind: "auto",
-          argv: [PY_VENV_PYTHON, ENTRYPOINT_TOKEN],
-          entrypointExtensions: [".py"]
-        }
-      }
-    ],
-    sdk: {
-      packageName: "algoliasearch",
-      versionPin: ">=4,<5",
-      docKey: "python"
-    },
-    ingestEntrypointExample: `${INGEST_DIR}/ingest.py`,
-    localSourceCaveat: {
-      unless: "requirements.txt",
-      message: "The ingestion script runs in its own environment under .algolia-wizard/, so it can install the Algolia client but not this project's packages (no requirements.txt to install from). If the script needs your database driver or ORM, add those packages to .algolia-wizard/requirements.txt and re-run the install."
-    },
-    verification: [
-      {
-        // -x skips the venv this same directory holds; without it the check
-        // compiles every installed package instead of the generated script.
-        label: "python compileall",
-        argv: ["python3", "-m", "compileall", "-q", "-x", "[.]venv", INGEST_DIR],
-        requiresFile: INGEST_DIR
-      }
-    ],
-    envReadInstruction: "Read them from `os.environ`.",
-    skipDirs: [
-      "venv",
-      "__pycache__",
-      "site-packages",
-      "dist",
-      "build",
-      "htmlcov"
-    ]
-  },
-  ruby: {
-    id: "ruby",
-    displayName: "Ruby",
-    aliases: ["ruby", "rb", "rails", "ruby on rails", "rubyonrails"],
-    manifests: ["Gemfile", "*.gemspec"],
-    packageManagers: [
-      {
-        id: "bundler",
-        dependency: { mode: "agent-declares", file: "Gemfile" },
-        installSteps: [{ argv: ["bundle", "install"] }],
-        ingest: {
-          kind: "auto",
-          argv: ["bundle", "exec", "ruby", ENTRYPOINT_TOKEN],
-          entrypointExtensions: [".rb"]
-        }
-      }
-    ],
-    sdk: { packageName: "algolia", versionPin: "~> 3.0", docKey: "ruby" },
-    ingestEntrypointExample: `${INGEST_DIR}/ingest.rb`,
-    // Ruby has no directory-level syntax check (`ruby -c` is one file at a
-    // time), so verification relies on the agent's own review here.
-    verification: [],
-    envReadInstruction: "Read them from `ENV.fetch('NAME')`.",
-    skipDirs: ["vendor", "tmp", "log", "coverage"]
-  },
-  php: {
-    id: "php",
-    displayName: "PHP",
-    aliases: ["php", "laravel", "symfony"],
-    manifests: ["composer.json"],
-    packageManagers: [
-      {
-        id: "composer",
-        // `composer require` both declares and installs, and unlike editing
-        // composer.json by hand it can't leave composer.lock out of date (which
-        // makes a later `composer install` refuse to run).
-        dependency: { mode: "wizard-installs" },
-        installSteps: [
-          {
-            argv: [
-              "composer",
-              "require",
-              "algolia/algoliasearch-client-php:^4",
-              "--no-interaction",
-              // Repo post-install scripts are the project's code, not ours to
-              // trigger; Laravel's package:discover also fails in a bare tree.
-              "--no-scripts"
-            ]
-          }
-        ],
-        ingest: {
-          kind: "auto",
-          argv: ["php", ENTRYPOINT_TOKEN],
-          entrypointExtensions: [".php"]
-        }
-      }
-    ],
-    sdk: {
-      packageName: "algolia/algoliasearch-client-php",
-      versionPin: "^4",
-      docKey: "php"
-    },
-    ingestEntrypointExample: `${INGEST_DIR}/ingest.php`,
-    verification: [],
-    envReadInstruction: "Read them from `getenv('NAME')`.",
-    skipDirs: ["vendor", "node_modules"]
-  },
-  go: {
-    id: "go",
-    displayName: "Go",
-    aliases: ["go", "golang"],
-    manifests: ["go.mod"],
-    packageManagers: [
-      {
-        id: "gomod",
-        // Imports in the generated file are the declaration; `go mod tidy`
-        // resolves and fetches them — which only works because the script lives
-        // outside INGEST_DIR (see VISIBLE_INGEST_DIR).
-        dependency: { mode: "code-imports" },
-        installSteps: [{ argv: ["go", "mod", "tidy"] }],
-        ingest: {
-          kind: "auto",
-          argv: ["go", "run", ENTRYPOINT_TOKEN],
-          entrypointExtensions: [".go"]
-        }
-      }
-    ],
-    sdk: {
-      packageName: "github.com/algolia/algoliasearch-client-go/v4",
-      versionPin: "v4",
-      docKey: "go"
-    },
-    ingestEntrypointExample: `${VISIBLE_INGEST_DIR}/ingest.go`,
-    verification: [
-      { label: "go vet", argv: ["go", "vet", "./..."], requiresFile: "go.mod" }
-    ],
-    envReadInstruction: "Read them from `os.Getenv`.",
-    skipDirs: ["vendor", "bin"]
-  },
-  java: {
-    id: "java",
-    displayName: "Java",
-    aliases: ["java"],
-    manifests: ["pom.xml", "build.gradle", "build.gradle.kts"],
-    packageManagers: [
-      {
-        id: "maven",
-        detectFiles: ["pom.xml"],
-        sdkVersionPin: "[4,5)",
-        dependency: { mode: "agent-declares", file: "pom.xml" },
-        installSteps: [{ argv: ["mvn", "-q", "-DskipTests", "compile"] }],
-        // The main class is a wizard constant the instructions require the agent
-        // to use, so execution can't be redirected by agent output. Runnable only
-        // because the install step above compiles src/main/java first — which is
-        // why the entrypoint lives there rather than under .algolia-wizard/.
-        ingest: {
-          kind: "auto",
-          argv: [
-            "mvn",
-            "-q",
-            "org.codehaus.mojo:exec-maven-plugin:3.5.0:java",
-            "-Dexec.mainClass=AlgoliaWizardIngest"
-          ],
-          entrypointExtensions: [".java"]
-        }
-      },
-      {
-        id: "gradle",
-        detectFiles: ["build.gradle", "build.gradle.kts"],
-        dependency: {
-          mode: "agent-declares",
-          file: "build.gradle",
-          alternatives: ["build.gradle.kts"]
-        },
-        installSteps: [],
-        // Auto-running means executing the repo's own ./gradlew wrapper; out of
-        // scope for now, so the wizard writes the code and prints the command.
-        ingest: {
-          kind: "manual",
-          entrypointExtensions: [".java"],
-          runCommand: "./gradlew runAlgoliaIngest",
-          requiresBuildTask: "runAlgoliaIngest"
-        }
-      }
-    ],
-    sdk: {
-      packageName: "com.algolia:algoliasearch",
-      versionPin: "4.+",
-      docKey: "java",
-      alsoRequires: "The class must be named AlgoliaWizardIngest, in the default package (no `package` statement), with a `public static void main`."
-    },
-    // Not under .algolia-wizard/: Maven and Gradle only compile src/main/<lang>,
-    // so a class outside it never makes it onto the classpath and the run command
-    // fails with "class not found".
-    ingestEntrypointExample: "src/main/java/AlgoliaWizardIngest.java",
-    verification: [
-      {
-        label: "mvn compile",
-        argv: ["mvn", "-q", "-DskipTests", "compile"],
-        requiresFile: "pom.xml"
-      }
-    ],
-    envReadInstruction: "Read them from `System.getenv`.",
-    skipDirs: ["target", "build", "out"]
-  },
-  kotlin: {
-    id: "kotlin",
-    displayName: "Kotlin",
-    aliases: ["kotlin", "kt", "ktor"],
-    manifests: ["build.gradle.kts", "build.gradle", "pom.xml"],
-    packageManagers: [
-      {
-        id: "gradle",
-        detectFiles: ["build.gradle.kts", "build.gradle"],
-        dependency: {
-          mode: "agent-declares",
-          file: "build.gradle.kts",
-          alternatives: ["build.gradle"]
-        },
-        installSteps: [],
-        ingest: {
-          kind: "manual",
-          entrypointExtensions: [".kt"],
-          runCommand: "./gradlew runAlgoliaIngest",
-          requiresBuildTask: "runAlgoliaIngest"
-        }
-      },
-      // Kotlin/Maven is rare but real, and pom.xml is a Kotlin manifest — without
-      // this spec such a repo falls through to Gradle and is told to run a
-      // ./gradlew task that doesn't exist. Compiling needs the repo's own
-      // kotlin-maven-plugin, so the run stays the developer's step.
-      {
-        id: "maven",
-        detectFiles: ["pom.xml"],
-        sdkVersionPin: "[3,4)",
-        dependency: { mode: "agent-declares", file: "pom.xml" },
-        installSteps: [{ argv: ["mvn", "-q", "-DskipTests", "compile"] }],
-        ingest: {
-          kind: "manual",
-          entrypointExtensions: [".kt"],
-          runCommand: "mvn -q org.codehaus.mojo:exec-maven-plugin:3.5.0:java -Dexec.mainClass=AlgoliaWizardIngest"
-        }
-      }
-    ],
-    sdk: {
-      packageName: "com.algolia:algoliasearch-client-kotlin",
-      versionPin: "3.+",
-      docKey: "kotlin",
-      // The published client's commonMain ships only ktor-client-core; without an
-      // engine the script compiles and then fails at its first request.
-      alsoRequires: "The Kotlin client bundles no HTTP engine, so also declare one (e.g. io.ktor:ktor-client-okhttp). Name the object AlgoliaWizardIngest in the default package, with a @JvmStatic main."
-    },
-    ingestEntrypointExample: "src/main/kotlin/AlgoliaWizardIngest.kt",
-    verification: [],
-    envReadInstruction: "Read them from `System.getenv`.",
-    skipDirs: ["build", "out"]
-  },
-  scala: {
-    id: "scala",
-    displayName: "Scala",
-    aliases: ["scala", "sbt"],
-    manifests: ["build.sbt", "build.sc"],
-    packageManagers: [
-      {
-        id: "sbt",
-        dependency: { mode: "agent-declares", file: "build.sbt" },
-        installSteps: [],
-        ingest: {
-          kind: "manual",
-          entrypointExtensions: [".scala"],
-          runCommand: 'sbt "runMain AlgoliaWizardIngest"'
-        }
-      }
-    ],
-    sdk: {
-      packageName: "com.algolia:algoliasearch-scala_2.13",
-      versionPin: "2.+",
-      docKey: "scala",
-      alsoRequires: "Name the object AlgoliaWizardIngest in the default package (no `package` statement) so `runMain AlgoliaWizardIngest` resolves it."
-    },
-    ingestEntrypointExample: "src/main/scala/AlgoliaWizardIngest.scala",
-    verification: [],
-    envReadInstruction: "Read them from `sys.env`.",
-    // `project/` holds sbt's build definition, but the name is generic enough
-    // that some repos use it for source; scanning it is cheap, missing source
-    // is not.
-    skipDirs: ["target"]
-  },
-  csharp: {
-    id: "csharp",
-    displayName: "C#",
-    aliases: ["c#", "csharp", "cs", ".net", "dotnet", "net", "asp.net"],
-    manifests: ["*.csproj", "*.sln", "global.json"],
-    packageManagers: [
-      {
-        id: "dotnet",
-        // A self-contained project under .algolia-wizard keeps the ingest script
-        // out of the repo's own build graph.
-        dependency: { mode: "agent-declares", file: CSHARP_PROJECT },
-        installSteps: [{ argv: ["dotnet", "restore", CSHARP_PROJECT] }],
-        ingest: {
-          kind: "auto",
-          argv: ["dotnet", "run", "--project", ENTRYPOINT_TOKEN],
-          entrypointExtensions: [".csproj"]
-        }
-      }
-    ],
-    sdk: {
-      packageName: "Algolia.Search",
-      versionPin: "7.*",
-      docKey: "csharp"
-    },
-    ingestEntrypointExample: CSHARP_PROJECT,
-    verification: [
-      {
-        label: "dotnet build",
-        argv: ["dotnet", "build", CSHARP_PROJECT, "--nologo"],
-        requiresFile: CSHARP_PROJECT
-      }
-    ],
-    envReadInstruction: 'Read them from `Environment.GetEnvironmentVariable("NAME")`.',
-    // Deliberately not `packages`: modern .NET uses PackageReference, and
-    // `packages/` is where pnpm/Lerna/Turborepo monorepos keep all their source —
-    // skipping it would hide the entities the scan is looking for.
-    skipDirs: ["bin", "obj"]
-  },
-  swift: {
-    id: "swift",
-    displayName: "Swift",
-    aliases: ["swift", "swiftui", "ios", "vapor"],
-    manifests: ["Package.swift", "*.xcodeproj", "*.xcworkspace"],
-    packageManagers: [
-      {
-        id: "swiftpm",
-        dependency: {
-          mode: "agent-declares",
-          file: `${SWIFT_PACKAGE_DIR}/Package.swift`
-        },
-        // `swift build` resolves and fetches; a cold build of the client is slow
-        // (minutes), which is why the caller degrades to the manual command when
-        // this fails.
-        installSteps: [
-          {
-            argv: ["swift", "build", "--package-path", SWIFT_PACKAGE_DIR],
-            requiresFile: `${SWIFT_PACKAGE_DIR}/Package.swift`
-          }
-        ],
-        ingest: {
-          kind: "auto",
-          argv: ["swift", "run", "--package-path", SWIFT_PACKAGE_DIR],
-          entrypointExtensions: [".swift"]
-        }
-      }
-    ],
-    sdk: {
-      packageName: "algoliasearch-client-swift",
-      // SwiftPM range syntax, not an exact version — a bare "9.0.0" in a
-      // Package.swift dependency pins the patch.
-      versionPin: 'from: "9.0.0"',
-      docKey: "swift"
-    },
-    ingestEntrypointExample: `${SWIFT_PACKAGE_DIR}/Sources/Ingest/main.swift`,
-    verification: [
-      {
-        label: "swift build",
-        argv: ["swift", "build", "--package-path", SWIFT_PACKAGE_DIR],
-        requiresFile: `${SWIFT_PACKAGE_DIR}/Package.swift`
-      }
-    ],
-    envReadInstruction: "Read them from `ProcessInfo.processInfo.environment`.",
-    skipDirs: ["Pods", "DerivedData", "Carthage", ".build"]
-  },
-  dart: {
-    id: "dart",
-    displayName: "Dart",
-    aliases: ["dart", "flutter"],
-    manifests: ["pubspec.yaml"],
-    packageManagers: [
-      {
-        id: "flutter-pub",
-        detectFiles: [".metadata"],
-        dependency: { mode: "agent-declares", file: "pubspec.yaml" },
-        installSteps: [{ argv: ["flutter", "pub", "get"] }],
-        ingest: {
-          kind: "auto",
-          argv: ["dart", "run", ENTRYPOINT_TOKEN],
-          entrypointExtensions: [".dart"]
-        }
-      },
-      {
-        id: "pub",
-        dependency: { mode: "agent-declares", file: "pubspec.yaml" },
-        installSteps: [{ argv: ["dart", "pub", "get"] }],
-        ingest: {
-          kind: "auto",
-          argv: ["dart", "run", ENTRYPOINT_TOKEN],
-          entrypointExtensions: [".dart"]
-        }
-      }
-    ],
-    sdk: {
-      packageName: "algolia_client_search",
-      versionPin: "^1.0.0",
-      docKey: "dart"
-    },
-    ingestEntrypointExample: `${INGEST_DIR}/ingest.dart`,
-    verification: [
-      {
-        // Gated on the directory it analyzes, not just pubspec.yaml: a run that
-        // only built a search UI never created it, and `dart analyze` on a
-        // missing path fails the whole verification pass.
-        label: "dart analyze",
-        argv: ["dart", "analyze", INGEST_DIR],
-        requiresFile: INGEST_DIR
-      }
-    ],
-    envReadInstruction: "Read them from `Platform.environment`.",
-    skipDirs: ["build"]
-  }
-};
-var DEFAULT_LANGUAGE_ID = "javascript";
-var JAVASCRIPT = "javascript";
-var CURATED_LANGUAGES = Object.values(
-  LANGUAGE_PROFILES
-).map((profile) => profile.displayName);
-function isBackendLanguage(profile) {
-  return profile.id !== JAVASCRIPT;
-}
-function normalizeLanguageName(name) {
-  return name.toLowerCase().trim().replace(/[\s_-]+/g, "");
-}
-var ALIAS_TO_ID = /* @__PURE__ */ new Map();
-for (const profile of Object.values(LANGUAGE_PROFILES)) {
-  for (const alias of [profile.id, profile.displayName, ...profile.aliases]) {
-    ALIAS_TO_ID.set(normalizeLanguageName(alias), profile.id);
-  }
-}
-function resolveLanguageProfile(name) {
-  const id = ALIAS_TO_ID.get(normalizeLanguageName(name));
-  return id ? LANGUAGE_PROFILES[id] : void 0;
-}
-function isSameLanguage(a, b) {
-  const x = resolveLanguageProfile(a);
-  const y = resolveLanguageProfile(b);
-  if (x && y) return x.id === y.id;
-  if (x || y) return false;
-  const folded = normalizeLanguageName(a);
-  return folded !== "" && folded === normalizeLanguageName(b);
-}
-var BASE_SKIP_DIRS = ["node_modules", ".git", "dist"];
-var ALL_SKIP_DIRS = /* @__PURE__ */ new Set([
-  ...BASE_SKIP_DIRS,
-  ...Object.values(LANGUAGE_PROFILES).flatMap((p) => p.skipDirs)
-]);
-var ALLOWED_BINARIES = new Set(
-  Object.values(LANGUAGE_PROFILES).flatMap((profile) => [
-    ...profile.packageManagers.flatMap((pm) => [
-      ...pm.installSteps.map((s) => s.argv[0]),
-      ...pm.ingest.kind === "auto" ? [pm.ingest.argv[0]] : []
-    ]),
-    ...profile.verification.map((v) => v.argv[0])
-  ])
-);
-var JS_PACKAGE_MANAGERS = /* @__PURE__ */ new Set(["npm", "pnpm", "yarn", "bun"]);
-function isWorktreeRelativeCommand(command) {
-  return command.includes("/");
-}
-function withCommand(argv, command) {
-  return [command, ...argv.slice(1)];
-}
-function resolveDeclaredManifest(root, packageManager) {
-  const { dependency } = packageManager;
-  if (dependency.mode !== "agent-declares" || !dependency.alternatives?.length) {
-    return packageManager;
-  }
-  const present = [dependency.file, ...dependency.alternatives].find(
-    (file) => existsSync2(join9(root, file))
-  );
-  if (!present || present === dependency.file) return packageManager;
-  return { ...packageManager, dependency: { ...dependency, file: present } };
-}
-async function manifestPresent(root, manifest, listing) {
-  if (!manifest.startsWith("*.")) return existsSync2(join9(root, manifest));
-  if (!listing.entries) {
-    const entries = await readdir2(root).catch(() => []);
-    listing.entries = Array.isArray(entries) ? entries : [];
-  }
-  const suffix = manifest.slice(1);
-  return listing.entries.some((e) => e.endsWith(suffix));
-}
-async function profileManifestPresent(root, profile, listing) {
-  for (const manifest of profile.manifests) {
-    if (await manifestPresent(root, manifest, listing)) return true;
-  }
-  return false;
-}
-async function detectProfilesFromManifests(root) {
-  const listing = {};
-  const found = [];
-  for (const profile of Object.values(LANGUAGE_PROFILES)) {
-    if (await profileManifestPresent(root, profile, listing)) found.push(profile);
-  }
-  return found;
-}
-async function hasProfileManifest(root, profile) {
-  return profileManifestPresent(root, profile, {});
-}
-async function pickIngestionCandidates(root, confirmedNames) {
-  const confirmed3 = confirmedNames.map((name) => resolveLanguageProfile(name)).filter((p) => p !== void 0);
-  const onDisk = await detectProfilesFromManifests(root);
-  const onDiskIds = new Set(onDisk.map((p) => p.id));
-  const candidates = [
-    ...new Map(
-      confirmed3.filter((p) => onDiskIds.has(p.id)).map((p) => [p.id, p])
-    ).values()
-  ];
-  return { candidates, confirmed: confirmed3, onDisk };
-}
-async function resolveToolchain(root, profile) {
-  const signals = (pm) => [
-    ...pm.lockfiles ?? [],
-    ...pm.detectFiles ?? []
-  ];
-  const matched = profile.packageManagers.find(
-    (pm) => signals(pm).some((f) => existsSync2(join9(root, f)))
-  );
-  const fallback = profile.packageManagers.find((pm) => signals(pm).length === 0) ?? profile.packageManagers[0];
-  const packageManager = resolveDeclaredManifest(root, matched ?? fallback);
-  let { installSteps, ingest } = packageManager;
-  installSteps = installSteps.map(
-    (step) => isWorktreeRelativeCommand(step.argv[0]) ? { ...step, argv: withCommand(step.argv, join9(root, step.argv[0])) } : step
-  );
-  if (ingest.kind === "auto" && isWorktreeRelativeCommand(ingest.argv[0])) {
-    ingest = {
-      ...ingest,
-      argv: withCommand(ingest.argv, join9(root, ingest.argv[0]))
-    };
-  }
-  if (profile.id === "javascript") {
-    const pm = await detectPackageManager(root);
-    if (JS_PACKAGE_MANAGERS.has(pm)) {
-      installSteps = installSteps.map((step) => ({
-        ...step,
-        argv: withCommand(step.argv, pm)
-      }));
-      if (pm === "bun" && ingest.kind === "auto") {
-        ingest = { ...ingest, argv: withCommand(ingest.argv, "bun") };
-      }
-    }
-  }
-  return { profile, packageManager, installSteps, ingest };
-}
-function resolveIngestArgv(ingest, entrypoint) {
-  if (ingest.kind !== "auto") {
-    throw new Error("resolveIngestArgv called for a manual-run toolchain");
-  }
-  return ingest.argv.map(
-    (part) => part === ENTRYPOINT_TOKEN ? entrypoint : part
-  );
-}
-function describeIngestCommand(ingest, entrypoint) {
-  if (ingest.kind !== "auto") return ingest.runCommand;
-  return ingest.argv.map((part) => part === ENTRYPOINT_TOKEN ? shellQuote(entrypoint) : part).join(" ");
-}
-function ingestScriptDir(profile) {
-  const parts = profile.ingestEntrypointExample.split("/");
-  return parts.slice(0, -1).join("/") || ".";
-}
-function localSourceLimitation(root, profile) {
-  const caveat = profile.localSourceCaveat;
-  if (!caveat) return void 0;
-  return existsSync2(join9(root, caveat.unless)) ? void 0 : caveat.message;
-}
-async function missingBuildTask(root, toolchain) {
-  const { ingest, packageManager } = toolchain;
-  if (ingest.kind !== "manual" || !ingest.requiresBuildTask) return void 0;
-  if (packageManager.dependency.mode !== "agent-declares") return void 0;
-  const buildFile = join9(root, packageManager.dependency.file);
-  const contents = await readFile7(buildFile, "utf8").catch(() => void 0);
-  if (contents === void 0) return void 0;
-  return contents.includes(ingest.requiresBuildTask) ? void 0 : ingest.requiresBuildTask;
-}
-function sdkVersionPin(profile, packageManager) {
-  return packageManager.sdkVersionPin ?? profile.sdk.versionPin;
-}
-function dependencyInstruction(toolchain) {
-  const { profile, packageManager } = toolchain;
-  const { packageName } = profile.sdk;
-  const versionPin = sdkVersionPin(profile, packageManager);
-  const also = profile.sdk.alsoRequires ? ` ${profile.sdk.alsoRequires}` : "";
-  switch (packageManager.dependency.mode) {
-    case "wizard-installs":
-      return `The wizard installs ${packageName} ${versionPin} in the worktree after you finish \u2014 import it directly and do not edit dependency manifests for it.${also}`;
-    case "code-imports":
-      return `Import ${packageName} in the script; the wizard resolves and fetches it in the worktree after you finish. Do not edit dependency manifests by hand.${also}`;
-    case "agent-declares":
-      return `Declare ${packageName} ${versionPin} in "${packageManager.dependency.file}" (create the file if needed), plus any other dependency your script imports; the wizard installs them in the worktree after you finish.${also}`;
-  }
-}
-
-// src/lib/tools/searchFiles.ts
+import z13 from "zod";
+import { readdir as readdir2, readFile as readFile5 } from "node:fs/promises";
+import { join as join7 } from "node:path";
 var MAX_QUERY_LENGTH = 1e3;
 async function walkFiles(dir) {
+  const skip = /* @__PURE__ */ new Set(["node_modules", ".git", "dist"]);
   const out = [];
-  for (const e of await readdir3(dir, { withFileTypes: true })) {
-    if (e.name.startsWith(".") || ALL_SKIP_DIRS.has(e.name)) continue;
-    const full = join10(dir, e.name);
+  for (const e of await readdir2(dir, { withFileTypes: true })) {
+    if (e.name.startsWith(".") || skip.has(e.name)) continue;
+    const full = join7(dir, e.name);
     if (e.isDirectory()) out.push(...await walkFiles(full));
     else if (e.isFile()) out.push(full);
   }
@@ -2908,9 +2588,9 @@ async function walkFiles(dir) {
 function searchFilesTool(ctx) {
   return tool7({
     description: "Search file contents for a JavaScript regular expression (RegExp syntax, not grep/PCRE). Returns matching lines as file:line:text.",
-    inputSchema: z10.object({
-      query: z10.string().describe("JavaScript RegExp pattern to search for"),
-      path: z10.string().optional().describe("Directory to search in (default: cwd)")
+    inputSchema: z13.object({
+      query: z13.string().describe("JavaScript RegExp pattern to search for"),
+      path: z13.string().optional().describe("Directory to search in (default: cwd)")
     }),
     execute: async ({ query, path = "." }) => {
       logger.info({ query, path }, "called searchFiles tool");
@@ -2932,7 +2612,7 @@ function searchFilesTool(ctx) {
       for (const file of await walkFiles(resolved.target)) {
         let content;
         try {
-          content = await readFile8(file, "utf8");
+          content = await readFile5(file, "utf8");
         } catch {
           continue;
         }
@@ -2954,146 +2634,90 @@ function searchFilesTool(ctx) {
 
 // src/lib/tools/verifyImplementation.ts
 import { tool as tool8 } from "ai";
-import z11 from "zod";
-
-// src/lib/tools/repoVerification.ts
-import { existsSync as existsSync3 } from "node:fs";
-import { join as join11 } from "node:path";
+import z14 from "zod";
 
 // src/lib/tools/utils/runCommand.ts
 import { spawn as spawn2 } from "node:child_process";
-var INSTALL_TIMEOUT_MS = 15 * 6e4;
-var INGEST_TIMEOUT_MS = 15 * 6e4;
-var VERIFY_TIMEOUT_MS = 10 * 6e4;
-var KILL_GRACE_MS = 5e3;
-function runCommand(command, args, options = {}) {
-  const { cwd, env, timeoutMs = VERIFY_TIMEOUT_MS } = options;
+function runCommand(command, args, cwd) {
   return new Promise((resolve4) => {
     let output = "";
-    let settled = false;
     const child = spawn2(command, args, {
       cwd,
-      shell: false,
-      stdio: ["ignore", "pipe", "pipe"],
-      ...env ? { env: { ...process.env, ...env } } : {}
+      stdio: ["ignore", "pipe", "pipe"]
     });
-    const settle = (result) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      resolve4(result);
-    };
-    const timer = setTimeout(() => {
-      child.kill("SIGTERM");
-      setTimeout(() => child.kill("SIGKILL"), KILL_GRACE_MS).unref();
-      const seconds = Math.round(timeoutMs / 1e3);
-      settle({
-        code: 1,
-        output: `${output}
-Timed out after ${seconds}s: ${command} ${args.join(" ")}`.trim(),
-        timedOut: true
-      });
-    }, timeoutMs);
     child.stdout?.on("data", (d) => output += d);
     child.stderr?.on("data", (d) => output += d);
     child.on(
       "error",
-      (err) => settle({
-        code: 1,
-        output: `Failed to run ${command}: ${err.message}`,
-        timedOut: false
-      })
-    );
-    child.on(
-      "close",
-      (code) => settle({ code: code ?? 1, output, timedOut: false })
+      (err) => resolve4({ code: 1, output: `Failed to run ${command}: ${err.message}` })
     );
+    child.on("close", (code) => resolve4({ code: code ?? 1, output }));
   });
 }
 
+// src/lib/tools/utils/packageManager.ts
+import { readFile as readFile6 } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join as join8 } from "node:path";
+var LOCKFILES = [
+  ["pnpm-lock.yaml", "pnpm"],
+  ["yarn.lock", "yarn"],
+  ["bun.lockb", "bun"],
+  ["bun.lock", "bun"],
+  ["package-lock.json", "npm"]
+];
+async function readPackageJson(cwd = process.cwd()) {
+  return JSON.parse(await readFile6(join8(cwd, "package.json"), "utf8"));
+}
+function packageManagerFrom(pkg) {
+  return pkg.packageManager?.split("@")[0] ?? "npm";
+}
+function packageManagerFromLockfile(cwd) {
+  return LOCKFILES.find(([file]) => existsSync(join8(cwd, file)))?.[1];
+}
+async function detectPackageManager(cwd) {
+  try {
+    const pkg = await readPackageJson(cwd);
+    if (pkg.packageManager) return packageManagerFrom(pkg);
+  } catch {
+  }
+  return packageManagerFromLockfile(cwd) ?? "npm";
+}
+
 // src/lib/tools/repoVerification.ts
 var VERIFICATION_SCRIPT_CANDIDATES = ["lint", "typecheck", "check"];
-async function runCheck(command, binary, args) {
-  const { code, output } = await runCommand(binary, args, {
-    timeoutMs: VERIFY_TIMEOUT_MS
-  });
-  return { command, exitCode: code, ok: code === 0, output: output.trim() };
-}
-async function javascriptChecks() {
+async function runRepoVerificationCheck() {
   let pkg;
   try {
     pkg = await readPackageJson();
   } catch (err) {
-    return {
-      limitation: `Could not read package.json to detect verification conventions: ${err.message}`
-    };
+    const limitation = `Could not read package.json to detect verification conventions: ${err.message}`;
+    return { ok: false, checks: [], limitation };
   }
   const scripts = pkg.scripts ?? {};
   const present = VERIFICATION_SCRIPT_CANDIDATES.filter((s) => s in scripts);
   if (present.length === 0) {
-    return {
-      limitation: `No verification script found in package.json (looked for: ${VERIFICATION_SCRIPT_CANDIDATES.join(", ")}).`
-    };
+    const limitation = `No verification script found in package.json (looked for: ${VERIFICATION_SCRIPT_CANDIDATES.join(", ")}).`;
+    return { ok: false, checks: [], limitation };
   }
   const pm = await detectPackageManager(process.cwd());
-  const checks = [];
-  for (const script of present) {
-    checks.push(
-      await runCheck(`${pm} run ${script}`, pm, ["run", script])
-    );
-  }
-  return { checks };
-}
-async function registryChecks(id) {
-  const profile = LANGUAGE_PROFILES[id];
-  const runnable = profile.verification.filter(
-    (spec) => !spec.requiresFile || existsSync3(join11(process.cwd(), spec.requiresFile))
-  );
-  if (runnable.length === 0) {
-    return {
-      limitation: `No mechanical verification available for ${profile.displayName} in this repo.`
-    };
-  }
-  const checks = [];
-  for (const spec of runnable) {
-    checks.push(
-      await runCheck(spec.argv.join(" "), spec.argv[0], [...spec.argv.slice(1)])
-    );
-  }
-  return { checks };
-}
-async function runRepoVerificationCheck(languages = [DEFAULT_LANGUAGE_ID]) {
-  const ids = [...new Set(languages)];
-  if (ids.length === 0) ids.push(DEFAULT_LANGUAGE_ID);
-  const checks = [];
-  const limitations = [];
-  for (const id of ids) {
-    const result = id === JAVASCRIPT ? await javascriptChecks() : await registryChecks(id);
-    if ("checks" in result) checks.push(...result.checks);
-    else limitations.push(result.limitation);
-  }
-  if (checks.length === 0) {
-    return {
-      ok: false,
-      checks: [],
-      limitation: limitations.join(" ") || "No verification checks available."
-    };
+  const checks = [];
+  for (const script of present) {
+    const command = `${pm} run ${script}`;
+    const { code, output } = await runCommand(pm, ["run", script]);
+    checks.push({ command, exitCode: code, ok: code === 0, output: output.trim() });
   }
-  return {
-    ok: checks.every((c) => c.ok),
-    checks,
-    ...limitations.length ? { limitation: limitations.join(" ") } : {}
-  };
+  return { ok: checks.every((c) => c.ok), checks };
 }
 
 // src/lib/tools/verifyImplementation.ts
-function verifyImplementationTool(ctx) {
+function verifyImplementationTool() {
   return tool8({
-    description: "Run the repo's mechanical verification checks for generated implementation changes. Uses the conventions of the repo's languages (package.json lint/typecheck/check scripts for JavaScript, the equivalent compile/analyze command elsewhere) and returns structured pass/fail evidence for the verifier to interpret.",
-    inputSchema: z11.object(),
+    description: "Run the repo's mechanical verification check for generated implementation changes. Detects lint/typecheck/check from package.json and returns structured pass/fail evidence for the verifier to interpret.",
+    inputSchema: z14.object(),
     execute: async () => {
-      logger.info({ languages: ctx.languages }, "called verifyImplementation tool");
-      return runRepoVerificationCheck(ctx.languages);
+      logger.info("called verifyImplementation tool");
+      return runRepoVerificationCheck();
     }
   });
 }
@@ -3104,7 +2728,7 @@ import { createAnthropic } from "@ai-sdk/anthropic";
 import { nanoid as nanoid2 } from "nanoid";
 import { mkdir as mkdir5, writeFile as writeFile5 } from "node:fs/promises";
 import { dirname as dirname6 } from "node:path";
-import z12 from "zod";
+import z15 from "zod";
 var DATA_DIR = ".algolia-wizard/data";
 var RECORD_MODEL = "claude-haiku-4-5";
 var MAX_RECORDS = 100;
@@ -3116,17 +2740,17 @@ var anthropic = createAnthropic({
 function generateRecordTool(ctx) {
   return tool9({
     description: "Generate realistic sample records for an entity and write them to a JSON file in the worktree. Provide the entity name and its attributes; this tool asks a model to invent varied, realistic values, each with a unique objectID, and returns the file path to read them from at runtime. Do not invent the record values or objectIDs yourself, and do not inline the returned records into the script \u2014 call this tool and read the file it writes.",
-    inputSchema: z12.object({
-      entityName: z12.string().describe("Name of the entity to generate records for."),
-      attributes: z12.array(z12.string()).describe("Attribute names each record must contain."),
-      count: z12.number().int().min(1).max(MAX_RECORDS).default(10).describe(`How many records to generate (max ${MAX_RECORDS}).`),
-      hint: z12.string().optional().describe("Optional context to steer realistic values.")
+    inputSchema: z15.object({
+      entityName: z15.string().describe("Name of the entity to generate records for."),
+      attributes: z15.array(z15.string()).describe("Attribute names each record must contain."),
+      count: z15.number().int().min(1).max(MAX_RECORDS).default(10).describe(`How many records to generate (max ${MAX_RECORDS}).`),
+      hint: z15.string().optional().describe("Optional context to steer realistic values.")
     }),
     execute: async ({ entityName, attributes, count, hint }) => {
       logger.info({ entityName, count }, "called generateRecord tool");
       try {
-        const value = z12.union([z12.string(), z12.number(), z12.boolean(), z12.null()]);
-        const recordSchema = z12.object(
+        const value = z15.union([z15.string(), z15.number(), z15.boolean(), z15.null()]);
+        const recordSchema = z15.object(
           Object.fromEntries(attributes.map((attr) => [attr, value]))
         );
         const generateBatch = async (batchCount) => {
@@ -3136,8 +2760,8 @@ function generateRecordTool(ctx) {
               const { output } = await generateText({
                 model: anthropic(RECORD_MODEL),
                 output: Output.object({
-                  schema: z12.object({
-                    records: z12.array(recordSchema).length(batchCount)
+                  schema: z15.object({
+                    records: z15.array(recordSchema).length(batchCount)
                   })
                 }),
                 prompt: [
@@ -3195,12 +2819,12 @@ function generateRecordTool(ctx) {
 
 // src/lib/tools/notifyUser.ts
 import { tool as tool10 } from "ai";
-import z13 from "zod";
+import z16 from "zod";
 function notifyUserTool() {
   return tool10({
     description: `Give the user a brief, high-level update on what you are currently doing or about to do next. This is for the big picture (e.g. "Reading through your data models", "Writing the search UI") \u2014 not granular detail like individual tool calls, which are already logged separately. Call it when you start a new phase of work or your focus shifts, just not on every step, enough to keep the user engaged. Don't say things like "starting", just describe what you are doing. Don't mention tool calls themselves, just general direction of the work.`,
-    inputSchema: z13.object({
-      message: z13.string().describe(
+    inputSchema: z16.object({
+      message: z16.string().describe(
         "Short, plain-language description of what you are doing now."
       )
     }),
@@ -3219,17 +2843,12 @@ var DEFAULT_TOOL_LIMITS = {
   read: 20,
   match: 100
 };
-function createToolContext({
-  limits = DEFAULT_TOOL_LIMITS,
-  cwd = process.cwd(),
-  languages = [DEFAULT_LANGUAGE_ID]
-} = {}) {
+function createToolContext(limits = DEFAULT_TOOL_LIMITS, cwd = process.cwd()) {
   return {
     root: cwd,
     cwd,
     limits,
-    counts: { list: 0, search: 0, read: 0 },
-    languages: languages.length ? languages : [DEFAULT_LANGUAGE_ID]
+    counts: { list: 0, search: 0, read: 0 }
   };
 }
 
@@ -3266,7 +2885,7 @@ function createTools(ctx, { output, tools }) {
     searchFiles: withLogging("searchFiles", searchFilesTool(ctx)),
     verifyImplementation: withLogging(
       "verifyImplementation",
-      verifyImplementationTool(ctx)
+      verifyImplementationTool()
     ),
     generateRecord: withLogging("generateRecord", generateRecordTool(ctx)),
     notifyUser: withLogging("notifyUser", notifyUserTool())
@@ -3302,7 +2921,7 @@ async function runAgent(req) {
     baseURL: PROXY_BASE_URL,
     fetch: proxyFetch
   });
-  const toolContext = createToolContext({ languages: req.languages });
+  const toolContext = createToolContext();
   const readTools = ["readFile", "searchFiles", "listFiles"];
   const hasReadTools = !req.tools || req.tools.some((t) => readTools.includes(t));
   const instructions = [
@@ -3385,19 +3004,16 @@ async function runAgent(req) {
 }
 
 // src/actions/detectLanguage.ts
-import z16 from "zod";
-var detectLanguageSchema = z16.object({
-  languages: z16.array(z16.object({ name: z16.string(), version: z16.string() })),
-  frameworks: z16.array(z16.object({ name: z16.string(), version: z16.string() }))
+import z19 from "zod";
+var detectLanguageSchema = z19.object({
+  languages: z19.array(z19.object({ name: z19.string(), version: z19.string() })),
+  frameworks: z19.array(z19.object({ name: z19.string(), version: z19.string() }))
 });
 var detectLanguage = () => runAgent({
   instructions: [
     "Analyze the codebase and determine the programming languages and frameworks used",
-    "Start from the dependency manifests: package.json, pyproject.toml, requirements.txt, Gemfile, composer.json, go.mod, pom.xml, build.gradle(.kts), *.csproj, build.sbt, Package.swift, pubspec.yaml.",
-    "List the language that owns the backend/data code first \u2014 that is the one an ingestion script will be written in.",
-    "If a superset language is found, exclude the subset language. TS-over-JS. Kotlin-over-Java when Kotlin is primary.",
+    "If a superset language is found, exclude the subset language. TS-over-JS.",
     "If a meta-framework is used, exclude the framework. Next-over-React.",
-    "Frameworks include backend and server-rendering frameworks (e.g. Rails, Django, Laravel, Symfony, Spring Boot, ASP.NET Core, Flask, Gin, Ktor) as well as frontend ones (React, Vue, Angular, Svelte) and mobile ones (Flutter, SwiftUI).",
     "Return the exact version",
     "Exclude things like CSS frameworks, build tools, or testing frameworks",
     'Use as few tools as possible, but do not guess. If you cant find the answer, say "unknown"',
@@ -3409,31 +3025,31 @@ var detectLanguage = () => runAgent({
 });
 
 // src/actions/analyzeCodebase.ts
-import z17 from "zod";
+import z20 from "zod";
 var READONLY_TOOLS = [
   "listFiles",
   "changeDirectory",
   "readFile",
   "searchFiles"
 ];
-var ingestionAnalysisSchema = z17.object({
-  ingestionAnalysis: z17.array(
-    z17.object({
-      name: z17.string(),
-      paths: z17.array(z17.string()),
+var ingestionAnalysisSchema = z20.object({
+  ingestionAnalysis: z20.array(
+    z20.object({
+      name: z20.string(),
+      paths: z20.array(z20.string()),
       // indexable fields the agent found for this entity
-      attributes: z17.array(z17.string())
+      attributes: z20.array(z20.string())
     })
   )
 });
-var searchImplementationAnalysisSchema = z17.object({
-  searchImplementationAnalysis: z17.string()
+var searchImplementationAnalysisSchema = z20.object({
+  searchImplementationAnalysis: z20.string()
 });
-var verificationSchema = z17.object({
-  verification: z17.array(z17.string())
+var verificationSchema = z20.object({
+  verification: z20.array(z20.string())
 });
 var confirmedEntitiesFieldSchema = ingestionAnalysisSchema.shape.ingestionAnalysis.optional();
-var analyzeCodebaseSchema = z17.object({
+var analyzeCodebaseSchema = z20.object({
   ingestionAnalysis: ingestionAnalysisSchema.shape.ingestionAnalysis.optional(),
   searchImplementationAnalysis: searchImplementationAnalysisSchema.shape.searchImplementationAnalysis.optional(),
   verification: verificationSchema.shape.verification.optional(),
@@ -3446,7 +3062,6 @@ var MODE_CONFIG = {
       "Analyze the codebase to find the data entities (models) that should be ingested into Algolia.",
       "For each entity, return its name, the file path(s) where it is defined, and its indexable attribute keys (the fields a user would search or filter on).",
       "Inspect the source of each entity to extract real field names for attributes \u2014 do not guess or leave attributes empty.",
-      "Entities live wherever the stack keeps them: TypeScript interfaces or a Prisma schema, Django models.py, Rails app/models, Laravel Eloquent models, JPA @Entity classes, Go structs, C# entity classes, Pydantic models.",
       "Prefer domain models (e.g. Document, Product, User) over framework or infrastructure types.",
       "Use as few tools as possible, but do not guess. If you cannot find any entities, return an empty array.",
       "Ignore directories that may be related to testing, like `/fixtures`, `/tests`, etc",
@@ -3458,9 +3073,8 @@ var MODE_CONFIG = {
     instructions: [
       "Analyze the codebase to determine the single best location to add search UI functionality.",
       "Prefer a shared, always-rendered layout location (e.g. a header or navigation component) so search is reachable across the app.",
-      "It may be a client-side component or a server-rendered template \u2014 return whichever the project actually renders its UI from (e.g. /layouts/header.tsx, app/views/layouts/application.html.erb, templates/base.html, resources/views/layouts/app.blade.php, templates/base.html.twig).",
-      "Return one file path as searchImplementationAnalysis.",
-      'Use as few tools as possible, but do not guess. If the project renders no UI at all (an API-only service), say "unknown".',
+      "Return one file path as searchImplementationAnalysis (e.g. /layouts/header.tsx).",
+      'Use as few tools as possible, but do not guess. If you cannot find a clear location, say "unknown".',
       "Ignore directories that may be related to testing, like `/fixtures`, `/tests`, etc",
       "When done, call reportStatus"
     ],
@@ -3469,8 +3083,8 @@ var MODE_CONFIG = {
   verification: {
     instructions: [
       "Analyze the codebase to determine which code-quality tools are available to validate changes.",
-      "Look at the dependency manifest and config files for the project's languages: package.json scripts with tsconfig/eslint/prettier, pyproject.toml or setup.cfg (ruff, mypy, black), Gemfile with .rubocop.yml, composer.json scripts (phpstan, pint), go.mod with a golangci-lint config, Maven/Gradle verification tasks, .NET analyzers, analysis_options.yaml.",
-      'Return the tool names as an array, e.g. ["eslint", "prettier", "tsc"] or ["ruff", "mypy"].',
+      "Look at package.json scripts, config files (e.g. .eslintrc, tsconfig, prettier), and dev dependencies.",
+      'Return the tool names as an array, e.g. ["eslint", "prettier", "tsc"].',
       "Use as few tools as possible, but do not guess. If you cannot find any, return an empty array.",
       "Ignore directories that may be related to testing, like `/fixtures`, `/tests`, etc",
       "When done, call reportStatus"
@@ -3497,7 +3111,7 @@ async function runAnalysis(mode, extraInstructions = []) {
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.8.0-rc.67.55",
+  version: "0.9.0-rc.49.79",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {
@@ -3519,7 +3133,7 @@ var package_default = {
     prepare: "husky",
     prepublishOnly: "pnpm build",
     reset: "tsx ./scripts/reset-state.ts",
-    "test:toolchains": "tsx ./scripts/verify-toolchains.ts",
+    "test:fixtures": "touch .env && tsx --env-file=.env ./fixtures/run-fixtures.ts",
     "test:tools": "tsx ./tool-evals/toolEval.ts",
     test: "vitest",
     typecheck: "tsc --noEmit -p tsconfig.json"
@@ -3545,9 +3159,7 @@ var package_default = {
   dependencies: {
     "@ai-sdk/anthropic": "^3.0.81",
     "@ai-sdk/openai-compatible": "^2.0.47",
-    "@algolia/cli": "^5.11.0",
     "@hono/node-server": "^2.0.10",
-    "@mishieck/ink-titled-box": "^0.4.2",
     "@segment/analytics-node": "^3.1.0",
     ai: "^6.0.190",
     dotenv: "^17.4.2",
@@ -3560,7 +3172,6 @@ var package_default = {
     nanoid: "^5.1.15",
     pino: "^10.3.1",
     react: "^19.2.7",
-    toml: "^4.1.1",
     varlock: "^1.5.1",
     zod: "^4.4.3",
     zustand: "^5.0.14"
@@ -3600,185 +3211,82 @@ function parseEntries(raw) {
   return raw.split(",").map(clean).filter(Boolean).slice(0, MAX_ENTRIES).map((name) => ({ name, version: "unknown" }));
 }
 var summarize = (entries) => entries.length ? entries.map((e) => e.name).join(", ") : "none";
-
-// src/actions/confirmLanguage.ts
-import z19 from "zod";
-var confirmLanguageSchema = z19.object({
-  languages: detectLanguageSchema.shape.languages
-});
-var OTHER_OPTION = "Other";
-function confirmed(languages) {
-  track("AI Wizard Language Confirmed", { languages });
-  return { languages };
-}
-async function askOtherLanguage(ctx) {
-  let prompt = "enter the language for your ingestion script";
+async function askList(ctx, prompt, { required = false } = {}) {
   for (; ; ) {
     const answer = await ctx.requestUserInput({
       prompt,
       promptType: "textInput",
-      options: []
+      options: [],
+      helpText: 'Comma-separated, e.g. "TypeScript, Node".'
     });
     if (typeof answer !== "string") {
-      throw new Error("confirmLanguage received an unexpected non-text result");
+      throw new Error("askList received an unexpected non-text result");
     }
-    const name = parseEntries(answer)[0]?.name;
-    if (name) return name;
-    prompt = "please enter a language name:";
+    const entries = parseEntries(answer);
+    if (entries.length || !required) return entries;
+    prompt = "Please enter at least one entry:";
   }
 }
+
+// src/actions/confirmLanguage.ts
+import z22 from "zod";
+var confirmLanguageSchema = z22.object({
+  languages: detectLanguageSchema.shape.languages
+});
 async function confirmLanguage(ctx) {
   const detected = ctx.getStepOutput("project-scan");
-  const detectedLanguages = detected.languages ?? [];
-  const others = (chosen) => detectedLanguages.filter((l) => !isSameLanguage(l.name, chosen));
-  const primary = detectedLanguages[0];
-  if (primary) {
-    const accepted = await ctx.requestUserInput({
-      prompt: `Write the ingestion script in ${primary.name}?`,
-      promptType: "acceptReject",
-      options: [`Confirm ${primary.name}`, "Use a different language"],
-      secondary: [{ kind: "badge", value: "[DETECTED]" }, void 0],
-      messages: detectedLanguages.length > 1 ? [`Detected: ${summarize(detectedLanguages)}`] : []
-    });
-    if (accepted === true) return confirmed(detectedLanguages);
-  }
-  const options = [...CURATED_LANGUAGES];
-  for (const language of detectedLanguages) {
-    if (!options.some((o) => isSameLanguage(o, language.name))) {
-      options.push(language.name);
-    }
-  }
-  options.push(OTHER_OPTION);
-  const detectedFor = (option) => detectedLanguages.find((l) => isSameLanguage(option, l.name));
-  const secondary = options.map(
-    (o) => detectedFor(o) ? { kind: "badge", value: "[DETECTED]" } : void 0
-  );
-  const defaultSelectedIndex = Math.max(
-    options.findIndex((o) => detectedFor(o)),
-    0
-  );
-  const selection = await ctx.requestUserInput({
-    prompt: "select the language for your ingestion script",
-    promptType: "multipleChoice",
-    options,
-    secondary,
-    defaultSelectedIndex
+  const answer = await ctx.requestUserInput({
+    prompt: "Did we detect your language(s) correctly?",
+    promptType: "acceptReject",
+    options: ["Yes", "No"],
+    messages: [`Languages: ${summarize(detected.languages)}`]
   });
-  if (typeof selection !== "string") {
-    throw new Error("confirmLanguage received an unexpected non-text result");
-  }
-  const name = selection === OTHER_OPTION ? await askOtherLanguage(ctx) : selection;
-  const version = detectedFor(name)?.version ?? "unknown";
-  return confirmed([{ name, version }, ...others(name)]);
+  const languages = answer === true ? detected.languages : await askList(ctx, "List the languages your project uses:", {
+    required: true
+  });
+  track("AI Wizard Language Confirmed", {
+    languages
+  });
+  return { languages };
 }
 
 // src/actions/confirmFramework.ts
-import z20 from "zod";
-
-// src/lib/frameworks.ts
-var BACKEND_ONLY_FRAMEWORK = "Backend only / API";
-var FRAMEWORKS = [
-  // Frontend — InstantSearch component flavors.
-  { name: "Next.js", strategy: "react", aliases: ["next", "nextjs"] },
-  { name: "React", strategy: "react", aliases: ["reactjs"] },
-  { name: "Vue", strategy: "vue", aliases: ["vuejs", "nuxt", "nuxtjs"] },
-  { name: "Angular", strategy: "angular", aliases: ["angularjs"] },
-  // No Svelte InstantSearch flavor exists, so it uses InstantSearch.js.
-  { name: "Svelte", strategy: "js", aliases: ["sveltekit"] },
-  {
-    name: "Vanilla JS",
-    strategy: "js",
-    aliases: ["vanilla", "javascript", "js", "astro", "vite"]
-  },
-  // Backend — Algolia's official framework integrations. Server-rendered
-  // templates get InstantSearch.js from a CDN.
-  {
-    name: "Rails",
-    strategy: "cdn-template",
-    aliases: ["rubyonrails", "ruby on rails", "erb"]
-  },
-  { name: "Django", strategy: "cdn-template", aliases: ["jinja", "jinja2"] },
-  { name: "Laravel", strategy: "cdn-template", aliases: ["blade"] },
-  { name: "Symfony", strategy: "cdn-template", aliases: ["twig"] },
-  // Mobile — Algolia ships InstantSearch iOS/Android and Dart clients, but the
-  // wizard can't scaffold a native UI, so it points at the docs instead.
-  { name: "Flutter", strategy: "none", aliases: [] },
-  { name: "iOS", strategy: "none", aliases: ["swiftui", "uikit"] },
-  { name: "Android", strategy: "none", aliases: ["jetpack compose", "compose"] },
-  { name: BACKEND_ONLY_FRAMEWORK, strategy: "cdn-template", aliases: [] }
+import z23 from "zod";
+var confirmFrameworkSchema = z23.object({
+  frameworks: detectLanguageSchema.shape.frameworks
+});
+var CURATED_FRAMEWORKS = [
+  "Next.js",
+  "React",
+  "Vue",
+  "Angular",
+  "Svelte",
+  "Vanilla JS"
 ];
-var CURATED_FRAMEWORKS = FRAMEWORKS.map(
-  (f) => f.name
-);
+var OTHER_OPTION = "Other";
 var normalize = (s) => s.toLowerCase().replace(/[^a-z0-9]/g, "");
-var ALIAS_TO_NAME = /* @__PURE__ */ new Map();
-for (const framework of FRAMEWORKS) {
-  for (const alias of [framework.name, ...framework.aliases]) {
-    ALIAS_TO_NAME.set(normalize(alias), framework.name);
-  }
-}
-var STRATEGY_BY_NAME = new Map(FRAMEWORKS.map((f) => [f.name, f.strategy]));
-function canonicalFrameworkName(name) {
-  return ALIAS_TO_NAME.get(normalize(name));
-}
-function isSameFramework(a, b) {
-  const x = canonicalFrameworkName(a) ?? normalize(a);
-  const y = canonicalFrameworkName(b) ?? normalize(b);
+var FRAMEWORK_ALIASES = {
+  next: "nextjs",
+  nextjs: "nextjs",
+  react: "react",
+  reactjs: "react",
+  vue: "vue",
+  vuejs: "vue",
+  angular: "angular",
+  angularjs: "angular",
+  svelte: "svelte",
+  sveltekit: "svelte",
+  vanillajs: "vanillajs",
+  vanilla: "vanillajs",
+  javascript: "vanillajs",
+  js: "vanillajs"
+};
+var isSameFramework = (a, b) => {
+  const x = FRAMEWORK_ALIASES[normalize(a)] ?? normalize(a);
+  const y = FRAMEWORK_ALIASES[normalize(b)] ?? normalize(b);
   return x !== "" && x === y;
-}
-function resolveSearchStrategy(frameworkName, hasJavaScriptInStack) {
-  const canonical = frameworkName ? canonicalFrameworkName(frameworkName) : void 0;
-  const strategy = canonical ? STRATEGY_BY_NAME.get(canonical) : void 0;
-  if (strategy) return strategy;
-  return hasJavaScriptInStack ? "js" : "cdn-template";
-}
-function searchDocKey(strategy) {
-  return strategy === "cdn-template" ? "templates" : strategy;
-}
-function bundlesJavaScript(strategy) {
-  return strategy !== "cdn-template" && strategy !== "none";
-}
-function canScaffoldSearchUI(strategy) {
-  return strategy !== "none";
-}
-var ENV_PREFIXES = [
-  { aliases: ["next", "nextjs"], prefix: "NEXT_PUBLIC_" },
-  { aliases: ["nuxt", "nuxtjs"], prefix: "NUXT_PUBLIC_" },
-  { aliases: ["astro"], prefix: "PUBLIC_" },
-  { aliases: ["vite"], prefix: "VITE_" }
-];
-var DEFAULT_ENV_PREFIX = "PUBLIC_";
-function publicEnvPrefix(frameworkNames, strategy) {
-  if (!bundlesJavaScript(strategy)) return "";
-  const present = new Set(frameworkNames.map(normalize));
-  for (const { aliases, prefix } of ENV_PREFIXES) {
-    if (aliases.some((alias) => present.has(alias))) return prefix;
-  }
-  return DEFAULT_ENV_PREFIX;
-}
-function describeSearchTarget(strategy, frameworkName) {
-  switch (strategy) {
-    case "react":
-      return "React (react-instantsearch)";
-    case "vue":
-      return "Vue (vue-instantsearch)";
-    case "angular":
-      return "Angular (angular-instantsearch)";
-    case "js":
-      return "plain JavaScript (InstantSearch.js)";
-    case "cdn-template":
-      return `${frameworkName ?? "server-rendered"} templates (InstantSearch.js via CDN)`;
-    case "none":
-      return frameworkName ?? "a native mobile app";
-  }
-}
-
-// src/actions/confirmFramework.ts
-var confirmFrameworkSchema = z20.object({
-  frameworks: detectLanguageSchema.shape.frameworks
-});
-var OTHER_OPTION2 = "Other";
-function confirmed2(name, version) {
+};
+function confirmed(name, version) {
   const frameworks = [{ name, version: version ?? "unknown" }];
   track("AI Wizard Frontend Framework Confirmed", { frameworks });
   return { frameworks };
@@ -3806,7 +3314,7 @@ async function confirmFramework(ctx) {
   for (const fw of detectedFrameworks) {
     if (!options.some((o) => isSameFramework(o, fw.name))) options.push(fw.name);
   }
-  options.push(OTHER_OPTION2);
+  options.push(OTHER_OPTION);
   const detectedFor = (option) => detectedFrameworks.find((fw) => isSameFramework(option, fw.name));
   const primary = detectedFrameworks[0];
   if (primary) {
@@ -3816,7 +3324,7 @@ async function confirmFramework(ctx) {
       options: [`Confirm ${primary.name}`, "Use a different framework"],
       secondary: [{ kind: "badge", value: "[DETECTED]" }, void 0]
     });
-    if (accepted === true) return confirmed2(primary.name, primary.version);
+    if (accepted === true) return confirmed(primary.name, primary.version);
   }
   const secondary = options.map(
     (o) => detectedFor(o) ? { kind: "badge", value: "[DETECTED]" } : void 0
@@ -3826,7 +3334,7 @@ async function confirmFramework(ctx) {
     0
   );
   const selection = await ctx.requestUserInput({
-    prompt: "select the framework that renders your UI",
+    prompt: "select a framework",
     promptType: "multipleChoice",
     options,
     secondary,
@@ -3835,10 +3343,10 @@ async function confirmFramework(ctx) {
   if (typeof selection !== "string") {
     throw new Error("confirmFramework received an unexpected non-text result");
   }
-  if (selection === OTHER_OPTION2) {
-    return confirmed2(await askOtherFramework(ctx));
+  if (selection === OTHER_OPTION) {
+    return confirmed(await askOtherFramework(ctx));
   }
-  return confirmed2(selection, detectedFor(selection)?.version);
+  return confirmed(selection, detectedFor(selection)?.version);
 }
 
 // src/actions/promptUser.ts
@@ -3872,8 +3380,8 @@ async function promptUser(ctx, params) {
 }
 
 // src/actions/confirmEntities.ts
-import z21 from "zod";
-var confirmEntitiesSchema = z21.object({
+import z24 from "zod";
+var confirmEntitiesSchema = z24.object({
   // Final detection — the focused re-run may supersede project-scan's.
   ingestionAnalysis: ingestionAnalysisSchema.shape.ingestionAnalysis.optional(),
   confirmedEntities: confirmedEntitiesFieldSchema
@@ -3931,27 +3439,27 @@ async function confirmEntities(ctx) {
     onSubmit: () => {
     }
   });
-  const confirmed3 = typeof selection === "string" ? entities.filter((e) => e.name === selection) : [];
-  if (confirmed3.length === 0) {
+  const confirmed2 = typeof selection === "string" ? entities.filter((e) => e.name === selection) : [];
+  if (confirmed2.length === 0) {
     throw new Error("User cancelled entity selection \u2014 analysis halted.");
   }
-  ctx.setUserInput("confirmedEntities", confirmed3);
+  ctx.setUserInput("confirmedEntities", confirmed2);
   track("AI Wizard Entities Confirmed", {
-    entities: toEntitySummary(confirmed3)
+    entities: toEntitySummary(confirmed2)
   });
-  return { ingestionAnalysis: entities, confirmedEntities: confirmed3 };
+  return { ingestionAnalysis: entities, confirmedEntities: confirmed2 };
 }
 
 // src/actions/review.ts
-import { z as z22 } from "zod";
-var reviewSchema = z22.object({
+import { z as z25 } from "zod";
+var reviewSchema = z25.object({
   // Broad, high-level takeaways grouped by theme (e.g. ingestion, search UI),
   // not one entry per workflow step — a step's raw output can be a long,
   // multi-paragraph blob (see implement.ts's summaries.join), and mirroring
   // that 1:1 is what made the old per-step summary an unreadable wall of text.
-  summaryPoints: z22.array(z22.string()),
-  reviewPrompt: z22.string(),
-  nextSteps: z22.array(z22.string())
+  summaryPoints: z25.array(z25.string()),
+  reviewPrompt: z25.string(),
+  nextSteps: z25.array(z25.string())
 });
 function formatCompletedSteps(steps) {
   if (!steps.length) return "(no prior steps completed)";
@@ -3963,7 +3471,7 @@ ${JSON.stringify(s.output, null, 2)}`
 }
 function formatReviewSummary(result) {
   const nextStepLines = result.nextSteps.map((step) => {
-    const isIngestCommand = step.includes("algolia-wizard/") || step.includes("AlgoliaWizardIngest");
+    const isIngestCommand = step.includes(".algolia-wizard/ingest.sh");
     const isWorktreeCommand = step.includes("/worktrees/");
     return {
       text: `\u2192 ${step}`,
@@ -4002,17 +3510,16 @@ ${formatCompletedSteps(ctx.completedSteps)}`,
 };
 
 // src/actions/implement.ts
-import z24 from "zod";
+import z26 from "zod";
 
 // src/lib/worktree.ts
-import { execFile } from "node:child_process";
-import { existsSync as existsSync4 } from "node:fs";
-import { copyFile, mkdir as mkdir6, readdir as readdir4, readFile as readFile9, stat as stat2, writeFile as writeFile6 } from "node:fs/promises";
+import { execFile, spawn as spawn3 } from "node:child_process";
+import { copyFile, mkdir as mkdir6, readdir as readdir3, readFile as readFile7, stat as stat2, writeFile as writeFile6 } from "node:fs/promises";
 import {
   basename as basename2,
   dirname as dirname7,
   isAbsolute as isAbsolute2,
-  join as join12,
+  join as join9,
   relative as relative2,
   resolve as resolve3
 } from "node:path";
@@ -4046,8 +3553,8 @@ async function isWorkingTreeDirty(repoRoot) {
   return out.trim().length > 0;
 }
 async function pruneOldWorktrees(repoRoot) {
-  const dir = join12(stateDir(repoRoot), "worktrees");
-  const stale = (await readdir4(dir).catch(() => [])).filter((name) => /^wizard-implement-\d+$/.test(name)).sort().reverse().slice(MAX_WIZARD_WORKTREES - 1);
+  const dir = join9(stateDir(repoRoot), "worktrees");
+  const stale = (await readdir3(dir).catch(() => [])).filter((name) => /^wizard-implement-\d+$/.test(name)).sort().reverse().slice(MAX_WIZARD_WORKTREES - 1);
   for (const slug of stale) {
     const branch = slug.replace("wizard-implement-", WIZARD_BRANCH_PREFIX);
     try {
@@ -4057,7 +3564,7 @@ async function pruneOldWorktrees(repoRoot) {
         "worktree",
         "remove",
         "--force",
-        join12(dir, slug)
+        join9(dir, slug)
       ]);
       await git(["-C", repoRoot, "branch", "-D", branch]);
     } catch (err) {
@@ -4071,55 +3578,43 @@ async function pruneOldWorktrees(repoRoot) {
 async function createWorktree(repoRoot) {
   const branch = `${WIZARD_BRANCH_PREFIX}${Date.now()}`;
   const dirSlug = branch.replace(/\//g, "-");
-  const path = join12(stateDir(repoRoot), "worktrees", dirSlug);
+  const path = join9(stateDir(repoRoot), "worktrees", dirSlug);
   await git(["-C", repoRoot, "worktree", "prune"]);
   await pruneOldWorktrees(repoRoot);
   await mkdir6(dirname7(path), { recursive: true });
   await git(["-C", repoRoot, "worktree", "add", "-b", branch, path, "HEAD"]);
   return { path, branch };
 }
-async function spawnStep(worktreePath, argv) {
-  const { code, output } = await runCommand(argv[0], [...argv.slice(1)], {
-    cwd: worktreePath,
-    timeoutMs: INSTALL_TIMEOUT_MS
-  });
-  return { ok: code === 0, output: output.trim() };
-}
-async function installWorktreeDeps(worktreePath, toolchain) {
-  const { profile, installSteps, packageManager } = toolchain;
-  const declared = packageManager.dependency.mode === "agent-declares" ? packageManager.dependency.file : void 0;
-  const haveSomethingToInstall = await hasProfileManifest(worktreePath, profile) || declared !== void 0 && existsSync4(join12(worktreePath, declared));
-  if (!haveSomethingToInstall) {
-    return {
-      ok: true,
-      output: `no ${profile.displayName} manifest; skipped install`
-    };
-  }
-  if (installSteps.length === 0) {
-    return {
-      ok: true,
-      output: `${profile.displayName} (${toolchain.packageManager.id}) has no wizard-run install step`
-    };
-  }
-  const outputs = [];
-  for (const step of installSteps) {
-    if (step.requiresFile && !existsSync4(join12(worktreePath, step.requiresFile)))
-      continue;
-    const result = await spawnStep(worktreePath, step.argv);
-    if (result.output) outputs.push(result.output);
-    if (result.ok) continue;
-    if (step.optional) {
-      logger.warn(
-        { step: step.argv.join(" "), output: result.output },
-        "installWorktreeDeps: optional install step failed; continuing"
-      );
-      continue;
-    }
-    return { ok: false, output: outputs.join("\n").trim() };
+async function installWorktreeDeps(worktreePath) {
+  try {
+    await readPackageJson(worktreePath);
+  } catch {
+    return { ok: true, output: "no package.json; skipped install" };
   }
-  return { ok: true, output: outputs.join("\n").trim() };
+  const pm = await detectPackageManager(worktreePath);
+  return new Promise((resolve4) => {
+    let output = "";
+    const child = spawn3(pm, ["install"], {
+      cwd: worktreePath,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    child.stdout?.on("data", (d) => output += d);
+    child.stderr?.on("data", (d) => output += d);
+    child.on(
+      "error",
+      (err) => resolve4({
+        ok: false,
+        output: `Failed to run ${pm} install: ${err.message}`
+      })
+    );
+    child.on(
+      "close",
+      (code) => resolve4({ ok: code === 0, output: output.trim() })
+    );
+  });
 }
-function validateIngestEntrypoint(worktreePath, entrypoint, allowedExtensions) {
+var INGEST_RUNTIMES = ["node", "python", "python3", "bun"];
+function validateIngestEntrypoint(worktreePath, entrypoint) {
   if (!entrypoint || entrypoint.startsWith("-")) {
     return {
       ok: false,
@@ -4134,29 +3629,18 @@ function validateIngestEntrypoint(worktreePath, entrypoint, allowedExtensions) {
       reason: `entrypoint "${entrypoint}" resolves outside the worktree`
     };
   }
-  if (allowedExtensions?.length && !allowedExtensions.some((ext) => entrypoint.endsWith(ext))) {
-    return {
-      ok: false,
-      reason: `entrypoint "${entrypoint}" is not one of ${allowedExtensions.join(", ")}`
-    };
-  }
   return { ok: true, target };
 }
-async function runIngestScript(worktreePath, toolchain, entrypoint, env = {}) {
-  const { ingest, profile, packageManager } = toolchain;
-  if (ingest.kind !== "auto") {
+async function runIngestScript(worktreePath, runtime, entrypoint, env = {}) {
+  if (!INGEST_RUNTIMES.includes(runtime)) {
     return {
       ran: false,
       ok: false,
       output: "",
-      reason: `${profile.displayName} (${packageManager.id}) projects must be run manually: ${ingest.runCommand}`
+      reason: `runtime "${runtime}" is not an allowed interpreter (${INGEST_RUNTIMES.join(", ")})`
     };
   }
-  const validated = validateIngestEntrypoint(
-    worktreePath,
-    entrypoint,
-    ingest.entrypointExtensions
-  );
+  const validated = validateIngestEntrypoint(worktreePath, entrypoint);
   if (!validated.ok) {
     return { ran: false, ok: false, output: "", reason: validated.reason };
   }
@@ -4177,13 +3661,29 @@ async function runIngestScript(worktreePath, toolchain, entrypoint, env = {}) {
       reason: `entrypoint "${entrypoint}" does not exist`
     };
   }
-  const argv = resolveIngestArgv(ingest, entrypoint);
-  const { code, output } = await runCommand(argv[0], argv.slice(1), {
-    cwd: worktreePath,
-    env,
-    timeoutMs: INGEST_TIMEOUT_MS
+  return new Promise((resolveRun) => {
+    let output = "";
+    const child = spawn3(runtime, [entrypoint], {
+      cwd: worktreePath,
+      shell: false,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env, ...env }
+    });
+    child.stdout?.on("data", (d) => output += d);
+    child.stderr?.on("data", (d) => output += d);
+    child.on(
+      "error",
+      (err) => resolveRun({
+        ran: true,
+        ok: false,
+        output: `Failed to run ${runtime} ${entrypoint}: ${err.message}`
+      })
+    );
+    child.on(
+      "close",
+      (code) => resolveRun({ ran: true, ok: code === 0, output: output.trim() })
+    );
   });
-  return { ran: true, ok: code === 0, output: output.trim() };
 }
 async function copyUploadIntoWorktree(repoRoot, worktreePath, ingestDir, sourcePath) {
   const trimmed = sourcePath.trim();
@@ -4198,8 +3698,8 @@ async function copyUploadIntoWorktree(repoRoot, worktreePath, ingestDir, sourceP
   } catch {
     return { ok: false, reason: `"${sourcePath}" does not exist` };
   }
-  const relPath = join12(ingestDir, basename2(source));
-  const dest = join12(worktreePath, relPath);
+  const relPath = join9(ingestDir, basename2(source));
+  const dest = join9(worktreePath, relPath);
   try {
     await mkdir6(dirname7(dest), { recursive: true });
     await copyFile(source, dest);
@@ -4214,11 +3714,28 @@ async function copyUploadIntoWorktree(repoRoot, worktreePath, ingestDir, sourceP
 function hasEnvVar(content, name) {
   return new RegExp(`^(\\s*(?:export\\s+)?${name})\\s*=`, "m").test(content);
 }
+async function readEnvVar(worktreePath, name) {
+  let content;
+  try {
+    content = await readFile7(join9(worktreePath, ".env"), "utf8");
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+    return void 0;
+  }
+  const match = new RegExp(
+    `^[ \\t]*(?:export[ \\t]+)?${name}[ \\t]*=[ \\t]*(.*)$`,
+    "m"
+  ).exec(content);
+  if (!match) return void 0;
+  const value = match[1].trim().replace(/^(['"])(.*)\1$/, "$2").trim();
+  if (!value || value.startsWith("<")) return void 0;
+  return value;
+}
 async function writeSearchEnvValues(worktreePath, vars) {
-  const target = join12(worktreePath, ".env");
+  const target = join9(worktreePath, ".env");
   let existing = "";
   try {
-    existing = await readFile9(target, "utf8");
+    existing = await readFile7(target, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
   }
@@ -4286,178 +3803,162 @@ async function confirmDirtyWorkingTree(ctx, repoRoot) {
   }
 }
 
-// src/lib/algoliaApiKey.ts
-import { z as z23 } from "zod";
-var SAFE_ACLS = /* @__PURE__ */ new Set(["search", "browse", "listIndexes"]);
-var apiKeySchema = z23.object({
-  value: z23.string().min(1),
-  acl: z23.array(z23.string()).default([]),
-  indexes: z23.array(z23.string()).default([])
-});
-var apiKeyListSchema = z23.object({
-  items: z23.array(apiKeySchema).optional(),
-  keys: z23.array(apiKeySchema).optional()
-}).transform((o) => o.items ?? o.keys ?? []);
-var createdKeySchema = z23.object({
-  key: z23.string().min(1).optional(),
-  value: z23.string().min(1).optional()
-});
-function canReuse(key, index) {
-  return key.acl.includes("search") && key.acl.every((acl) => SAFE_ACLS.has(acl)) && (key.indexes.length === 0 || key.indexes.includes("*") || key.indexes.includes(index));
-}
-async function createSearchKey(index) {
-  const stdout = await runAlgoliaCli([
-    "apikeys",
-    "create",
-    "--indices",
-    index,
-    "--acl",
-    "search,browse",
-    "--description",
-    `wizard search-only key for ${index}`,
-    "-o",
-    "json"
-  ]);
-  const { key, value } = createdKeySchema.parse(JSON.parse(stdout));
-  const created = key ?? value;
-  if (!created) throw new Error("apikeys create returned no key value");
-  return created;
-}
-async function resolveSearchOnlyKey(index) {
-  const stdout = await runAlgoliaCli(["apikeys", "list", "-o", "json"]);
-  const existing = apiKeyListSchema.parse(JSON.parse(stdout)).find((key) => canReuse(key, index))?.value;
-  if (existing) {
-    logger.info({ index }, "reusing existing search-only API key");
-    return existing;
-  }
-  logger.info({ index }, "no reusable search-only key found; creating one");
-  return createSearchKey(index);
-}
-
 // src/lib/algoliaDocs.ts
-import { readFileSync, existsSync as existsSync5 } from "node:fs";
-import { dirname as dirname8, join as join13 } from "node:path";
+import { readFileSync, readdirSync, existsSync as existsSync2 } from "node:fs";
+import { dirname as dirname8, join as join10 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-var DOCS_SUBPATH = join13("docs", "algolia-sdk");
+var DOCS_SUBPATH = join10("docs", "algolia-sdk");
 function findDocsDir() {
   let dir = dirname8(fileURLToPath2(import.meta.url));
   for (; ; ) {
-    const candidate = join13(dir, DOCS_SUBPATH);
-    if (existsSync5(candidate)) return candidate;
+    const candidate = join10(dir, DOCS_SUBPATH);
+    if (existsSync2(candidate)) return candidate;
     const parent = dirname8(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
 }
-function getNamedDoc(name, key) {
+function loadAlgoliaDoc(language) {
+  const docsDir = findDocsDir();
+  if (!docsDir) {
+    logger.warn(
+      "algoliaDocs: docs/algolia-sdk not found; skipping SDK reference"
+    );
+    return "";
+  }
+  const files = readdirSync(docsDir).filter((f) => f.includes(language));
+  if (files.length === 0) {
+    logger.warn(
+      { language },
+      "algoliaDocs: no SDK reference found for language; skipping"
+    );
+    return "";
+  }
+  return readFileSync(join10(docsDir, files[0]), "utf8").trim();
+}
+function getNamedDoc(name, language) {
   const docsDir = findDocsDir();
   if (!docsDir) {
     logger.warn("docs/algolia-sdk not found");
     return "";
   }
-  const file = join13(docsDir, `${name}-${key}.md`);
-  if (!existsSync5(file)) {
-    logger.warn({ name, key }, "named SDK reference not found");
+  const file = join10(docsDir, `${name}-${language}.md`);
+  if (!existsSync2(file)) {
+    logger.warn({ name, language }, "named SDK reference not found");
     return "";
   }
   return readFileSync(file, "utf8").trim();
 }
+function getFrameworkSpecificDoc(frameworks) {
+  const fw = frameworks.map((f) => f.toLowerCase());
+  if (fw.includes("vue") || fw.includes("nuxt")) {
+    return loadAlgoliaDoc("vue");
+  }
+  if (fw.includes("react") || fw.includes("next.js")) {
+    return loadAlgoliaDoc("react");
+  }
+  if (fw.includes("angular")) {
+    return loadAlgoliaDoc("angular");
+  }
+  return loadAlgoliaDoc("js");
+}
+
+// src/lib/shell.ts
+function shellQuote(value) {
+  return "'" + value.replace(/'/g, "'\\''") + "'";
+}
 
 // src/actions/implement.ts
-var implementSchema = z24.object({
-  filesChanged: z24.array(z24.string()),
-  summary: z24.string(),
-  // Absolute path to the throwaway worktree holding the generated changes, so
-  // the user can open it (`cd <worktreePath>`) or inspect the diff
-  // (`git -C <worktreePath> status/diff`).
-  worktreePath: z24.string().optional(),
-  ingestCommand: z24.string().optional(),
-  // True when the user accepted the run-now prompt and the wizard executed the
-  // ingestion script; downstream steps use this to avoid telling the user to run
-  // a script that already ran.
-  ingestScriptRan: z24.boolean().optional(),
-  // Records ingested by the run-now execution, parsed from the script's
-  // machine-readable count line; absent when the script didn't run or emitted
-  // no parseable count.
-  ingestRecordCount: z24.number().optional(),
-  // Wall-clock duration of the run-now ingestion execution, in ms.
-  ingestDurationMs: z24.number().optional(),
-  ingestionSource: z24.enum(["local", "fileUpload", "generated"]),
-  // Suggested names/values, built from framework detection. The search agent is
-  // instructed to rename the prefix if it doesn't match the project's build
-  // tool, so the names it actually wrote can differ — treat these as hints, not
-  // ground truth (the agent's summary carries the final names).
-  searchEnvVars: z24.array(
-    z24.object({
-      name: z24.string(),
-      value: z24.string()
+var implementSchema = z26.object({
+  filesChanged: z26.array(z26.string()),
+  summary: z26.string(),
+  worktreePath: z26.string().optional(),
+  ingestCommand: z26.string().optional(),
+  ingestScriptRan: z26.boolean().optional(),
+  ingestRecordCount: z26.number().optional(),
+  ingestDurationMs: z26.number().optional(),
+  ingestionSource: z26.enum(["local", "fileUpload", "generated"]),
+  searchEnvVars: z26.array(
+    z26.object({
+      name: z26.string(),
+      value: z26.string()
     })
   ).optional()
 });
-var implementationOutputSchema = z24.object({
-  summary: z24.string(),
-  // Ingestion only: the script the wizard should run, as a bare path — never a
-  // command string, and never the interpreter. The command comes from the
-  // resolved language toolchain (a registry constant); this path is validated to
-  // a worktree-relative file with a runnable extension and substituted into it.
-  // So the agent contributes no part of the command that gets executed.
-  entrypoint: z24.string().optional()
+var implementationOutputSchema = z26.object({
+  summary: z26.string(),
+  // Ingestion only: a structured pair the wizard turns into an argv, never a
+  // free-form command string. `runtime` is allowlisted and `entrypoint` is
+  // validated worktree-relative, so the agent cannot inject extra commands.
+  runtime: z26.enum(INGEST_RUNTIMES).optional(),
+  entrypoint: z26.string().optional()
 });
-var verificationOutputSchema = z24.object({
-  summary: z24.string(),
-  sufficient: z24.boolean(),
-  additionalInstructions: z24.string().optional()
+var verificationOutputSchema = z26.object({
+  summary: z26.string(),
+  sufficient: z26.boolean(),
+  additionalInstructions: z26.string().optional()
 });
 var MAX_IMPLEMENT_VERIFICATION_ATTEMPTS = 3;
 var DEFAULT_IMPLEMENT_USE_CASES = ["ingestion", "search"];
-function buildSearchEnvVars(language, strategy, appId, searchKey) {
-  const prefix = publicEnvPrefix(
-    language.frameworks.map((framework) => framework.name),
-    strategy
+var INGEST_DIR = ".algolia-wizard";
+function detectUiFramework(language) {
+  const names = language.frameworks.map((f) => f.name.toLowerCase());
+  if (names.some((n) => n.includes("vue") || n.includes("nuxt"))) return "Vue";
+  if (names.some((n) => n.includes("react") || n.includes("next")))
+    return "React";
+  if (names.some((n) => n.includes("angular"))) return "Angular";
+  return "JavaScript";
+}
+function frameworksForDoc(framework) {
+  switch (framework) {
+    case "React":
+      return ["react"];
+    case "Vue":
+      return ["vue"];
+    case "Angular":
+      return ["angular"];
+    case "JavaScript":
+      return [];
+  }
+}
+function publicEnvPrefix(language) {
+  const frameworkNames = language.frameworks.map(
+    (framework) => framework.name.toLowerCase()
   );
+  if (frameworkNames.some((name) => name.includes("next"))) {
+    return "NEXT_PUBLIC_";
+  }
+  if (frameworkNames.some((name) => name.includes("nuxt"))) {
+    return "NUXT_PUBLIC_";
+  }
+  if (frameworkNames.some((name) => name.includes("astro"))) {
+    return "PUBLIC_";
+  }
+  if (frameworkNames.some((name) => name.includes("vite"))) {
+    return "VITE_";
+  }
+  return "PUBLIC_";
+}
+var APP_ID_VAR_SUFFIX = "ALGOLIA_APP_ID";
+var SEARCH_KEY_VAR_SUFFIX = "ALGOLIA_SEARCH_API_KEY";
+function appIdVar(language) {
+  return `${publicEnvPrefix(language)}${APP_ID_VAR_SUFFIX}`;
+}
+function searchKeyVar(language) {
+  return `${publicEnvPrefix(language)}${SEARCH_KEY_VAR_SUFFIX}`;
+}
+function searchEnvVars(language, appId, searchKey) {
   return [
     {
-      name: `${prefix}ALGOLIA_APP_ID`,
+      name: appIdVar(language),
       value: appId ?? "<your-algolia-app-id>"
     },
     {
-      name: `${prefix}ALGOLIA_SEARCH_API_KEY`,
+      name: searchKeyVar(language),
       value: searchKey ?? "<your-algolia-search-only-api-key>"
     }
   ];
 }
-async function resolveIngestionProfile(ctx, language, repoRoot) {
-  const { candidates, confirmed: confirmed3, onDisk } = await pickIngestionCandidates(
-    repoRoot,
-    language.languages.map((l) => l.name)
-  );
-  if (candidates.length === 0) {
-    const chosen = confirmed3[0] ?? onDisk[0] ?? LANGUAGE_PROFILES[DEFAULT_LANGUAGE_ID];
-    logger.warn(
-      {
-        confirmed: language.languages.map((l) => l.name),
-        onDisk: onDisk.map((p) => p.id),
-        chosen: chosen.id
-      },
-      "implement: no confirmed language matched a manifest on disk; falling back"
-    );
-    return chosen;
-  }
-  if (candidates.length === 1) return candidates[0];
-  const backends = candidates.filter(isBackendLanguage);
-  if (backends.length === 1) return backends[0];
-  if (backends.length === 0) return candidates[0];
-  if (isBackendLanguage(candidates[0])) return candidates[0];
-  const options = backends.map((p) => p.displayName);
-  const selection = await ctx.requestUserInput({
-    prompt: "Which language should the ingestion script use?",
-    promptType: "multipleChoice",
-    options,
-    defaultSelectedIndex: 0
-  });
-  const picked = typeof selection === "string" ? backends.find((p) => p.displayName === selection) : void 0;
-  return picked ?? backends[0];
-}
 function baseInstructions(input) {
   return [
     `Target Algolia index: ${input.targetIndex}`,
@@ -4474,9 +3975,6 @@ function sourceSpecificInstructions(input) {
       "Add env vars for any local source access (DB URL, API base, file paths) that is not a fixed repo path."
     ],
     fileUpload: [
-      // The wizard already copied the developer's file into the worktree at this
-      // exact path, so the agent must read it directly — never search for or
-      // substitute another file.
       `Records come from the developer's file, already copied into the worktree at "${input.uploadFilePath}". Read and parse that exact file.`,
       "Parse by extension: JSON = array of objects; CSV/TSV = header row maps to keys.",
       "Map parsed columns/fields to the confirmed entity attributes.",
@@ -4485,71 +3983,59 @@ function sourceSpecificInstructions(input) {
     generated: [
       "No real data source exists; use sample records for each confirmed entity.",
       "Call the generateRecord tool once per entity (entityName, attributes, count 20-50); it invents the values and unique objectIDs and writes them to a JSON file in the worktree, returning the file path. Do not write records or objectIDs yourself.",
-      "In the script, read and parse each returned JSON file path at runtime using the idiomatic file read for the language you are writing in (the SDK reference above shows one) instead of inlining the records as literals.",
+      "In the script, read and parse each returned file path at runtime (e.g. JSON.parse(readFileSync(...)) in Node/Bun, json.load(open(...)) in Python) instead of inlining the records as literals.",
       "Add a prominent TODO where the developer swaps the generated records (and the JSON file under `.algolia-wizard/data/`) for their real record source."
     ]
   };
   return byLine[input.ingestionSource];
 }
 function ingestionInstructions(input) {
-  const { ingestionProfile: profile, toolchain } = input;
-  const { ingest } = toolchain;
-  const extensions = ingest.entrypointExtensions.join(", ");
-  const runInstruction = ingest.kind === "auto" ? `Return "entrypoint": the script path relative to the worktree root (e.g. "${profile.ingestEntrypointExample}"), ending in one of ${extensions}. The wizard runs it with \`${describeIngestCommand(ingest, profile.ingestEntrypointExample)}\`, so it must be a plain path with no flags or arguments and must run as-is under that command.` : `Return "entrypoint": the script path relative to the worktree root (e.g. "${profile.ingestEntrypointExample}"), ending in one of ${extensions}. The wizard does NOT run ${profile.displayName} ${toolchain.packageManager.id} projects itself \u2014 it tells the developer to run \`${describeIngestCommand(ingest, profile.ingestEntrypointExample)}\`, so also add whatever build configuration that command needs${ingest.kind === "manual" && ingest.requiresBuildTask ? `, including a "${ingest.requiresBuildTask}" task in "${toolchain.packageManager.dependency.mode === "agent-declares" ? toolchain.packageManager.dependency.file : "the build file"}" that runs the script` : ""}.`;
   return [
     ...input.confirmed && input.confirmed.length ? [
-      `Write the ingestion script in ${profile.displayName}, at "${ingestScriptDir(profile)}/" in the repo.`,
+      `Create an ingestion script under "${input.ingestDir}/" at the repo root.`,
       `Ingest only these confirmed entities (name, source paths, attributes): ${JSON.stringify(input.confirmed)}.`,
-      `Ingesting writes to Algolia, so the script needs a write API key and App ID \u2014 read them from the ${API_KEY_VAR} and ${APP_ID_VAR} environment variables rather than hardcoding them. ${profile.envReadInstruction} The wizard sets these when it runs the script.`,
-      `Use the official Algolia ${profile.displayName} client (${profile.sdk.packageName}). Do not use the raw HTTP API, and do not use a client for another language.`,
+      `Ingesting writes to Algolia, so the script needs a write API key and App ID \u2014 read them from the ${API_KEY_VAR} and ${APP_ID_VAR} environment variables rather than hardcoding them. The wizard sets these when it runs the script.`,
+      "Use the appropriate Algolia package in the ingestion script. Do not use the raw HTTP API.",
       "After a successful ingest, the script must print exactly one line to stdout in the form `ALGOLIA_WIZARD_RECORD_COUNT=<n>`, where <n> is the total number of records pushed to Algolia. Print it last, on its own line, with no surrounding text.",
-      getNamedDoc("save-records", profile.sdk.docKey),
-      dependencyInstruction(toolchain),
+      getNamedDoc("save-records", "js"),
+      'Add algoliasearch to package.json "dependencies" with a valid version range; the wizard installs the worktree deps after you finish.',
       "The summary should be extremely concise.",
-      runInstruction,
+      `Return how to run the script as two fields, not a command string: "runtime" (one of ${INGEST_RUNTIMES.join(", ")}) and "entrypoint" (the script path relative to the worktree root, e.g. "${input.ingestDir}/ingest.mjs"). The wizard runs \`<runtime> <entrypoint>\` directly, so the entrypoint must be a plain path with no flags or arguments. Write a script one of those interpreters can run as-is.`,
       ...sourceSpecificInstructions(input)
     ] : []
   ];
 }
 function searchInstructions(input) {
-  const doc = getNamedDoc(
-    "instantsearch-setup",
-    searchDocKey(input.searchStrategy)
-  );
-  const isTemplate = input.searchStrategy === "cdn-template";
-  const placement = isTemplate ? input.searchLocation ? `Add the search UI to the server-rendered template at "${input.searchLocation}" \u2014 ideally a shared layout, so it is reachable across the app.` : `This project has no shared template to host the UI, so create a standalone page at "${input.ingestDir}/search-demo.html" the developer can open directly, and add a TODO explaining how to move the snippet into their own layout.` : `Add the search UI at ${input.searchLocation ? `"${input.searchLocation}"` : "the best shared, always-rendered layout location (e.g. a header/nav component)"} so it is reachable across the app.`;
+  const doc = getFrameworkSpecificDoc(frameworksForDoc(input.uiFramework));
   return [
     "Implement an in-app Algolia search experience.",
-    `Build the search UI for ${describeSearchTarget(input.searchStrategy, input.frameworkName)}.`,
-    "Follow the Algolia reference below for client setup and InstantSearch wiring; prefer it over prior knowledge:",
+    `Build the search UI for ${input.uiFramework}.`,
+    "Follow the Algolia JS SDK reference below for client setup and InstantSearch wiring; prefer it over prior knowledge:",
     doc,
-    placement,
-    `It needs at least a working SearchBox and Hits against the "${input.targetIndex}" index.`,
-    isTemplate ? "Load InstantSearch from a CDN with script tags as shown in the reference. Do not add JavaScript package dependencies, a bundler, or a build step." : 'Add any Algolia/InstantSearch packages you import to package.json "dependencies" with a valid version range; the wizard installs them in the worktree after you finish.',
-    isTemplate ? "Read the App ID and search-only API key from server-side configuration/environment and render them into the page (e.g. as data- attributes the script reads); never hardcode them, and never put a write/admin key in HTML." : "Read the App ID and a search-only API key from public env vars; never hardcode them. A search-only key is safe to expose client-side.",
-    // appId always resolves (loadActiveProfile throws otherwise); only the
-    // search-only key is best-effort and can fall back to a placeholder.
-    `Values: App ID "${input.appId}", search-only key ${input.searchKey ? `"${input.searchKey}"` : "(placeholder for the developer to fill in)"}.`,
-    // Names are fixed, not the agent's to rename: the wizard writes the
-    // resolved app id / search-only key into ".env" under these exact names
-    // right after this step, so a renamed prefix here would leave the code
+    `Add the search UI at ${input.searchLocation ? `"${input.searchLocation}"` : "the best shared, always-rendered layout location (e.g. a header/nav component)"} so it is reachable across the app \u2014 at least a working SearchBox and Hits against the "${input.targetIndex}" index.`,
+    // The key is provisioned only after verification passes, so the agent never
+    // sees one. It must also leave .env alone: the wizard reads that file to
+    // decide whether a key already exists, and an agent-invented value there
+    // would be reused as if it were real.
+    `Add Algolia App ID "${input.appId}"; leave the search-only key as a placeholder. Do not create or edit .env \u2014 the wizard writes the resolved key there itself.`,
+    // Not the agent's to rename: the wizard writes these exact names into
+    // ".env" right after this step, so a renamed prefix would leave the code
     // reading a var the wizard never wrote.
-    `Use exactly these env var names: ${input.searchEnvVars.map(({ name }) => name).join(", ")}.`,
+    `Use exactly these public env var names in the code: ${input.searchEnvVars.map(({ name }) => name).join(", ")}.`,
+    "Read the App ID and a search-only API key from public env vars; never hardcode them. A search-only key is safe to expose client-side.",
+    'Add any Algolia/InstantSearch packages you import to package.json "dependencies" with a valid version range; the wizard installs them in the worktree after you finish.',
     "The summary should be extremely concise; do not mention env var setup or manual testing steps \u2014 the wizard writes the resolved credentials to .env and reports that separately."
   ];
 }
 function verificationInstructions(input) {
-  const protectedDirs = [
-    .../* @__PURE__ */ new Set([input.ingestDir, ingestScriptDir(input.ingestionProfile)])
-  ];
   return [
     "Verify the Algolia implementation changes in the current worktree.",
     `Verification tools found in the codebase: ${JSON.stringify(input.findings.verification ?? [])}.`,
-    `Call verifyImplementation at least once; it runs the mechanical checks available for this repo's languages (${input.verificationLanguages.join(", ")}) and returns per-check results plus an aggregate ok.`,
+    "Call verifyImplementation at least once; it runs every repo-defined lint/typecheck/check script and returns per-check results plus an aggregate ok.",
     "For issues caused by the implementation, make minimal fixes with writeFile and re-run verifyImplementation.",
     "Do not make speculative fixes when verifyImplementation cannot run, no checks exist, or failures are unrelated to these changes \u2014 note the limitation in your summary.",
     "Do not add new Algolia functionality here; only validate and make minimal correctness fixes.",
-    `Do not modify ${protectedDirs.map((dir) => `"${dir}/"`).join(" or ")} unless verifyImplementation reports an actionable issue in its files.`,
+    `Do not modify "${input.ingestDir}/" unless verifyImplementation reports an actionable issue in its files.`,
     "Always call reportStatus with status=success once verification has run, even when sufficient=false.",
     "Set sufficient=true only when the implementation is complete and checks pass (or fail for a clearly unrelated reason).",
     "Set sufficient=false when the implementation is incomplete or has implementation-caused failures; include concrete additionalInstructions for the next pass."
@@ -4558,17 +4044,14 @@ function verificationInstructions(input) {
 var IMPLEMENT_CONFIG = {
   ingestion: {
     title: "Algolia ingestion",
-    label: "Ingestion",
     buildInstructions: ingestionInstructions
   },
   search: {
     title: "Algolia search",
-    label: "Search",
     buildInstructions: searchInstructions
   },
   verification: {
     title: "Algolia verification",
-    label: "Verification",
     buildInstructions: verificationInstructions
   }
 };
@@ -4600,10 +4083,11 @@ function buildAgentInstructions(useCase, input, extraInstructions = []) {
   ];
 }
 function formatSummary(useCase, summary) {
-  return `${IMPLEMENT_CONFIG[useCase].label}: ${summary}`;
+  const label = useCase === "ingestion" ? "Ingestion" : useCase === "search" ? "Search" : "Verification";
+  return `${label}: ${summary}`;
 }
-function buildIngestCommand(worktree, toolchain, entrypoint) {
-  return `cd ${shellQuote(worktree)} && ${describeIngestCommand(toolchain.ingest, entrypoint)}`;
+function buildIngestCommand(worktree, runtime, entrypoint) {
+  return `cd ${shellQuote(worktree)} && ${runtime} ${shellQuote(entrypoint)}`;
 }
 function parseIngestRecordCount(output) {
   const match = output.match(/ALGOLIA_WIZARD_RECORD_COUNT=(\d+)/);
@@ -4680,25 +4164,17 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
     }
   }
   const targetIndex = selected?.selection;
+  useWizard.getState().setTargetIndex(targetIndex ?? null);
   await assertGitRepoWithHead(repoRoot);
   if (await isWorkingTreeDirty(repoRoot)) {
     await confirmDirtyWorkingTree(ctx, repoRoot);
   }
   const normalized = normalizeFindingPaths(findings);
-  const confirmed3 = normalized.confirmedEntities;
+  const confirmed2 = normalized.confirmedEntities;
   const searchLocation = normalized.searchImplementationAnalysis;
   let appId;
-  let searchKey;
   if (useCases.includes("search")) {
-    appId = (await loadActiveProfile()).appId;
-    try {
-      searchKey = await resolveSearchOnlyKey(targetIndex);
-    } catch (err) {
-      logger.warn(
-        { err: err.message },
-        "implement: could not resolve a search-only API key; the agent will scaffold a placeholder"
-      );
-    }
+    appId = (await requireApplication()).id;
   }
   const worktree = existingWorktreePath ?? (await createWorktree(repoRoot)).path;
   try {
@@ -4723,66 +4199,48 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
         );
       }
     }
-    const ingestionProfile = await resolveIngestionProfile(
-      ctx,
-      language,
-      worktree
-    );
-    const toolchain = await resolveToolchain(worktree, ingestionProfile);
-    const verificationLanguages = [
-      .../* @__PURE__ */ new Set([
-        ingestionProfile.id,
-        ...(await detectProfilesFromManifests(worktree)).map((p) => p.id)
-      ])
-    ];
-    const frameworkName = language.frameworks[0]?.name;
-    const searchStrategy = resolveSearchStrategy(
-      frameworkName,
-      verificationLanguages.includes(JAVASCRIPT)
-    );
-    logger.info(
-      {
-        language: ingestionProfile.id,
-        packageManager: toolchain.packageManager.id,
-        ingest: toolchain.ingest.kind,
-        framework: frameworkName,
-        searchStrategy
-      },
-      "implement: resolved ingestion toolchain and search strategy"
-    );
     const input = {
       findings: normalized,
-      confirmed: confirmed3,
+      confirmed: confirmed2,
       searchLocation,
       targetIndex,
       language,
       appId,
-      searchKey,
-      searchEnvVars: buildSearchEnvVars(
-        language,
-        searchStrategy,
-        appId,
-        searchKey
-      ),
+      // Names only: the search-only key is provisioned after verification, so
+      // every value here is still a placeholder when the agent reads them.
+      searchEnvVars: searchEnvVars(language, appId),
       ingestDir: INGEST_DIR,
       ingestionSource,
       uploadFilePath,
-      searchStrategy,
-      frameworkName,
-      ingestionProfile,
-      toolchain,
-      verificationLanguages
+      uiFramework: detectUiFramework(language)
     };
-    const searchToolchain = !bundlesJavaScript(searchStrategy) ? void 0 : ingestionProfile.id === JAVASCRIPT ? toolchain : await resolveToolchain(worktree, LANGUAGE_PROFILES[JAVASCRIPT]);
-    const toolchainForUseCase = (useCase) => useCase === "search" ? searchToolchain : toolchain;
     const summaries = [];
     if (uploadWarning) summaries.push(uploadWarning);
+    let envSearchKey;
+    let envAppIdMismatch = false;
+    if (useCases.includes("search") && appId) {
+      const envAppId = await readEnvVar(worktree, appIdVar(language));
+      if (envAppId === appId) {
+        envSearchKey = await readEnvVar(worktree, searchKeyVar(language));
+      } else if (envAppId) {
+        envAppIdMismatch = true;
+        summaries.push(
+          `\u26A0\uFE0F .env already sets ${appIdVar(language)}=${envAppId}, but the active Algolia application is ${appId}. The wizard left those values alone \u2014 update ${appIdVar(language)} and ${searchKeyVar(language)} by hand, or searches will fail.`
+        );
+        logger.warn(
+          { envAppId, appId },
+          "implement: .env holds credentials for a different Algolia application; not reusing its search key"
+        );
+      }
+    }
+    let finalSearchEnvVars = input.searchEnvVars;
     let agentRuns = 0;
+    let ingestRuntime;
     let ingestEntrypoint;
     let ingestScriptRan = false;
     let ingestRecordCount;
     let ingestDurationMs;
-    const failedInstalls = /* @__PURE__ */ new Set();
+    let installFailed = false;
     let ingestOutcomeMessage;
     async function runImplementationUseCase(currentUseCase, extraInstructions = []) {
       if (agentRuns > 0) ctx.recordStepExecution();
@@ -4796,19 +4254,16 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
         tools: toolsForUseCase(currentUseCase, input.ingestionSource),
         outputSchema: implementationOutputSchema
       });
-      const useCaseToolchain = toolchainForUseCase(currentUseCase);
-      if (!useCaseToolchain) return result;
       ctx.notify({
         messages: [`Installing dependencies for ${currentUseCase}\u2026`]
       });
       const installLogId = ctx.logStart("installWorktreeDeps", {
-        useCase: currentUseCase,
-        language: useCaseToolchain.profile.id
+        useCase: currentUseCase
       });
-      const install = await installWorktreeDeps(worktree, useCaseToolchain);
+      const install = await installWorktreeDeps(worktree);
       ctx.logEnd(installLogId, install.ok ? "success" : "error");
       if (!install.ok) {
-        failedInstalls.add(useCaseToolchain.profile.displayName);
+        installFailed = true;
         logger.warn(
           { useCase: currentUseCase, output: install.output },
           "implement: dependency install in worktree failed; generated commands may not run until deps are installed"
@@ -4822,16 +4277,15 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
       return runAgent({
         instructions: buildAgentInstructions("verification", input),
         tools: toolsForUseCase("verification"),
-        outputSchema: verificationOutputSchema,
-        // So verifyImplementation runs this repo's checks, not just npm scripts.
-        languages: input.verificationLanguages
+        outputSchema: verificationOutputSchema
       });
     }
     if (useCases.includes("ingestion")) {
-      const { summary, entrypoint } = await runImplementationUseCase("ingestion");
+      const { summary, runtime, entrypoint } = await runImplementationUseCase("ingestion");
       summaries.push(formatSummary("ingestion", summary));
+      ingestRuntime = runtime;
       ingestEntrypoint = entrypoint;
-      if (ingestEntrypoint && toolchain.ingest.kind === "auto" && failedInstalls.size === 0) {
+      if (ingestRuntime && ingestEntrypoint && !installFailed) {
         ctx.clearNotices();
         const runNow = await ctx.requestUserInput({
           prompt: `Run the ingestion script now? This writes records to the "${targetIndex}" index.`,
@@ -4840,20 +4294,21 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
           messages: []
         }) === true;
         if (runNow) {
-          const profile = await loadActiveProfile();
+          const ingestApp = await requireApplication();
+          const writeKey = await resolveWriteKey(targetIndex);
           ctx.notify({ messages: [`Writing records to "${targetIndex}"\u2026`] });
           const scriptLogId = ctx.logStart("runIngestScript", {
-            language: ingestionProfile.id,
+            runtime: ingestRuntime,
             entrypoint: ingestEntrypoint
           });
           const startedAt = Date.now();
           const run2 = await runIngestScript(
             worktree,
-            toolchain,
+            ingestRuntime,
             ingestEntrypoint,
             {
-              [APP_ID_VAR]: profile.appId,
-              [API_KEY_VAR]: profile.apiKey
+              [APP_ID_VAR]: ingestApp.id,
+              [API_KEY_VAR]: writeKey
             }
           );
           ctx.logEnd(scriptLogId, run2.ok ? "success" : "error");
@@ -4863,7 +4318,7 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
             ingestRecordCount = parseIngestRecordCount(run2.output);
             if (ingestRecordCount != null) {
               track("AI Wizard Ingest Successful", {
-                entity_name: confirmed3?.map((e) => e.name).join(", ") || "unknown",
+                entity_name: confirmed2?.map((e) => e.name).join(", ") || "unknown",
                 record_count: ingestRecordCount,
                 duration_ms: ingestDurationMs
               });
@@ -4876,7 +4331,7 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
             outcomeMessage = `\u26A0\uFE0F The ingestion script did not run: ${run2.reason}`;
             logger.warn(
               {
-                language: ingestionProfile.id,
+                runtime: ingestRuntime,
                 entrypoint: ingestEntrypoint,
                 reason: run2.reason
               },
@@ -4899,7 +4354,7 @@ ${run2.output}` : status;
             outcomeMessage = `\u274C Ingestion failed.${run2.output ? ` ${run2.output}` : ""}`;
             logger.warn(
               {
-                language: ingestionProfile.id,
+                runtime: ingestRuntime,
                 entrypoint: ingestEntrypoint,
                 output: run2.output
               },
@@ -4916,52 +4371,19 @@ ${run2.output}` : status;
         }
       }
       const commandMessages = [`Open the worktree: cd ${shellQuote(worktree)}`];
-      if (ingestEntrypoint) {
+      if (ingestRuntime && ingestEntrypoint) {
         commandMessages.push(
-          `Ingestion command: ${buildIngestCommand(worktree, toolchain, ingestEntrypoint)}`
+          `Ingestion command: ${buildIngestCommand(worktree, ingestRuntime, ingestEntrypoint)}`
         );
-        if (toolchain.ingest.kind === "manual") {
-          commandMessages.push(
-            `The wizard does not run ${ingestionProfile.displayName} ${toolchain.packageManager.id} projects \u2014 run the command above yourself to ingest.`
-          );
-          const missingTask = await missingBuildTask(worktree, toolchain);
-          if (missingTask) {
-            const warning = `\u26A0\uFE0F The command above needs a "${missingTask}" task, which is not in ${toolchain.packageManager.dependency.mode === "agent-declares" ? toolchain.packageManager.dependency.file : "the build file"} \u2014 add it before running, or run the script through your IDE instead.`;
-            commandMessages.push(warning);
-            summaries.push(warning);
-          }
-        }
-      }
-      if (ingestionSource === "local") {
-        const limitation = localSourceLimitation(worktree, ingestionProfile);
-        if (limitation) {
-          commandMessages.push(`\u26A0\uFE0F ${limitation}`);
-          summaries.push(`\u26A0\uFE0F ${limitation}`);
-        }
       }
       await ctx.requestUserInput({
-        // No question being asked here, just an acknowledgement — the
-        // continue/decline hints below already say "continue".
         prompt: "",
         promptType: "enterToContinue",
         options: [],
         messages: ingestOutcomeMessage ? [ingestOutcomeMessage, ...commandMessages] : commandMessages
       });
     }
-    const skipSearch = useCases.includes("search") && !canScaffoldSearchUI(input.searchStrategy);
-    if (skipSearch) {
-      const target = describeSearchTarget(
-        input.searchStrategy,
-        input.frameworkName
-      );
-      summaries.push(
-        `Search UI skipped: the wizard can't scaffold a native search UI for ${target}. Your records are in the "${targetIndex}" index \u2014 build the UI with Algolia's mobile InstantSearch libraries (https://www.algolia.com/doc/guides/building-search-ui/what-is-instantsearch/ios/ for iOS, .../android for Android).`
-      );
-      track("AI Wizard Search UI Skipped", {
-        framework: input.frameworkName ?? "unknown"
-      });
-    }
-    if (useCases.includes("search") && !skipSearch) {
+    if (useCases.includes("search")) {
       let extraInstructions = [];
       const preSearchFiles = new Set(await listChangedFiles(worktree));
       for (let attempt = 1; attempt <= MAX_IMPLEMENT_VERIFICATION_ATTEMPTS; attempt++) {
@@ -5003,7 +4425,29 @@ ${run2.output}` : status;
         }
         extraInstructions = verificationRetryInstructions(verification);
       }
-      const resolvedSearchEnvVars = input.searchEnvVars.filter(
+      let searchKey;
+      let searchKeyError;
+      if (appId) {
+        try {
+          const resolved = await resolveSearchOnlyKey(
+            targetIndex,
+            appId,
+            envSearchKey
+          );
+          searchKey = resolved.key;
+          summaries.push(
+            resolved.source === "created" ? `Created a new search-only Algolia API key for the "${targetIndex}" index in app ${appId} \u2014 safe to expose in frontend code.` : `Reused the existing search-only Algolia API key for the "${targetIndex}" index in app ${appId}.`
+          );
+        } catch (err) {
+          searchKeyError = err.message;
+          logger.warn(
+            { err: searchKeyError },
+            "implement: could not provision a search-only API key; the .env value stays a placeholder"
+          );
+        }
+      }
+      finalSearchEnvVars = searchEnvVars(language, appId, searchKey);
+      const resolvedSearchEnvVars = finalSearchEnvVars.filter(
         (v) => !v.value.startsWith("<")
       );
       if (resolvedSearchEnvVars.length > 0) {
@@ -5014,13 +4458,29 @@ ${run2.output}` : status;
         if (written.length > 0) {
           summaries.push(`Wrote ${written.join(", ")} to .env.`);
         }
+        const stale = [];
+        for (const v of resolvedSearchEnvVars) {
+          if (written.includes(v.name)) continue;
+          const current = await readEnvVar(worktree, v.name);
+          if (current && current !== v.value) stale.push(v);
+        }
+        if (stale.length > 0 && !envAppIdMismatch) {
+          summaries.push(
+            `\u26A0\uFE0F .env already assigns a different value to ${stale.map((v) => `${v.name} (should be ${v.value})`).join(", ")} \u2014 the wizard left it alone. Fix it by hand, or searches will fail.`
+          );
+          logger.warn(
+            { vars: stale.map((v) => v.name) },
+            "implement: .env holds different values for the resolved search credentials; not overwriting them"
+          );
+        }
       }
-      const unresolvedSearchEnvVars = input.searchEnvVars.filter(
+      const unresolvedSearchEnvVars = finalSearchEnvVars.filter(
         (v) => v.value.startsWith("<")
       );
       if (unresolvedSearchEnvVars.length > 0) {
         summaries.push(
-          `Could not resolve a value for ${unresolvedSearchEnvVars.map((v) => v.name).join(", ")} \u2014 fill it in manually in .env.`
+          `Could not resolve a value for ${unresolvedSearchEnvVars.map((v) => v.name).join(", ")} \u2014 fill it in manually in .env.` + // Without the reason the line is a dead end.
+          (searchKeyError ? ` Reason: ${searchKeyError}` : "")
         );
       }
     } else {
@@ -5032,9 +4492,9 @@ ${run2.output}` : status;
         "implement: agent reported success but no files changed in the worktree"
       );
     }
-    if (failedInstalls.size > 0) {
+    if (installFailed) {
       summaries.push(
-        `\u26A0\uFE0F Dependency install in the worktree failed. Install the ${[...failedInstalls].join(" and ")} dependencies in the worktree before the command below, or it will fail on a missing package.`
+        '\u26A0\uFE0F Dependency install in the worktree failed. Run your package manager install in the worktree before the command below, or it will fail with "Cannot find module".'
       );
     }
     return {
@@ -5042,17 +4502,17 @@ ${run2.output}` : status;
       filesChanged,
       summary: summaries.join("\n\n"),
       worktreePath: worktree,
-      ...useCases.includes("ingestion") && ingestEntrypoint ? {
+      ...useCases.includes("ingestion") && ingestRuntime && ingestEntrypoint ? {
         ingestCommand: buildIngestCommand(
           worktree,
-          toolchain,
+          ingestRuntime,
           ingestEntrypoint
         ),
         ingestScriptRan,
         ...ingestRecordCount != null ? { ingestRecordCount } : {},
         ...ingestDurationMs != null ? { ingestDurationMs } : {}
       } : {},
-      ...useCases.includes("search") ? { searchEnvVars: input.searchEnvVars } : {}
+      ...useCases.includes("search") ? { searchEnvVars: finalSearchEnvVars } : {}
     };
   } finally {
     process.chdir(repoRoot);
@@ -5095,8 +4555,8 @@ var defaultWorkflow = {
     defineStep({
       id: "select-index",
       title: "Set up index",
-      outputSchema: z25.object({
-        selection: z25.string()
+      outputSchema: z27.object({
+        selection: z27.string()
       }),
       run: (ctx) => selectIndexStep(ctx)
     }),
@@ -5374,20 +4834,20 @@ function parseCliArgs(argv) {
 }
 
 // src/lib/resetState.ts
-import { readdir as readdir5, rm as rm2 } from "node:fs/promises";
-import { join as join14 } from "node:path";
+import { readdir as readdir4, rm as rm2 } from "node:fs/promises";
+import { join as join11 } from "node:path";
 var KEEP = ["wizard.log"];
 async function resetProjectState() {
   const dir = stateDir();
   let entries;
   try {
-    entries = await readdir5(dir);
+    entries = await readdir4(dir);
   } catch {
     return { dir, removed: [] };
   }
   const targets = entries.filter((name) => !KEEP.includes(name));
   await Promise.all(
-    targets.map((name) => rm2(join14(dir, name), { recursive: true, force: true }))
+    targets.map((name) => rm2(join11(dir, name), { recursive: true, force: true }))
   );
   return { dir, removed: targets };
 }
@@ -5442,31 +4902,38 @@ ${formatStepList(workflow)}`);
 }
 async function run(workflow) {
   const store = useWizard.getState();
-  let instance = render(/* @__PURE__ */ jsx14(App, {}), { incrementalRendering: true });
+  const instance = render(/* @__PURE__ */ jsx14(App, {}), { incrementalRendering: true });
+  await store.waitForStart();
   let user = await getUser();
   if (!user) {
-    await instance.waitUntilRenderFlush();
-    instance.cleanup();
+    store.beginAuth();
     try {
       await runAuthLogin();
     } catch (err) {
-      console.error(err instanceof Error ? err.message : String(err));
+      store.setError(err instanceof Error ? err.message : String(err));
+      await instance.waitUntilExit();
       process.exit(1);
     }
-    instance = render(/* @__PURE__ */ jsx14(App, {}), { incrementalRendering: true });
+    store.endAuth();
     user = await getUser();
     if (!user) {
       store.setError(
-        "Authentication completed but no Algolia user was returned. Try running `npx @algolia/cli auth login` directly."
+        "Authentication completed but no Algolia user was returned. Try running `npx @algolia/cli@latest auth login` directly."
       );
       await instance.waitUntilExit();
       process.exit(1);
     }
   }
   store.setUser(user);
-  const profile = await loadActiveProfile();
-  await store.waitForStart();
-  runWorkflow(workflow, profile?.appId);
+  let app;
+  try {
+    app = await ensureApplication();
+  } catch (err) {
+    store.setError(err instanceof Error ? err.message : String(err));
+    await instance.waitUntilExit();
+    process.exit(1);
+  }
+  runWorkflow(workflow, app.id);
 }
 var started = await startup();
 if (typeof started === "number") {