@algolia/wizard 0.2.0 → 0.3.0-rc.43.6

package/dist/main.js

@@ -4,27 +4,197 @@
 import { render } from "ink";
 
 // src/ui/App.tsx
-import { useEffect as useEffect2, useState as useState4 } from "react";
-import { Box as Box10, Text as Text10, useApp, useInput as useInput3, useWindowSize as useWindowSize2 } from "ink";
+import { Box as Box13, Text as Text13, useApp, useInput as useInput6, useWindowSize as useWindowSize5 } from "ink";
 
 // src/core/store.ts
 import { create } from "zustand";
+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");
+}
+function runAlgoliaCli(args) {
+  return new Promise((resolve4, reject) => {
+    const child = spawn(process.execPath, [algoliaCliEntry(), ...args]);
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => stdout += chunk);
+    child.stderr.on("data", (chunk) => stderr += chunk);
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve4(stdout);
+      } else {
+        const detail = stderr.trim() || stdout.trim();
+        reject(
+          new Error(
+            `Algolia CLI \`${args.join(" ")}\` failed (exit ${code})${detail ? `: ${detail}` : ""}`
+          )
+        );
+      }
+    });
+  });
+}
+async function getUser() {
+  let raw;
+  try {
+    raw = await runAlgoliaCli(["auth", "get", "--with-access-token"]);
+  } catch {
+    return null;
+  }
+  try {
+    return toUserInfo(JSON.parse(raw));
+  } catch {
+    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}).`));
+    });
+  });
+}
+
+// src/lib/auth.ts
+function getAuthToken() {
+  return useWizard.getState().user?.token || null;
+}
+var inFlightRefresh = null;
+function refreshAuthToken() {
+  inFlightRefresh ??= (async () => {
+    try {
+      const raw = await runAlgoliaCli(["auth", "get", "--with-access-token"]);
+      const user2 = toUserInfo(JSON.parse(raw));
+      useWizard.getState().setUser(user2);
+      return user2.token;
+    } catch {
+      return null;
+    } finally {
+      inFlightRefresh = null;
+    }
+  })();
+  return inFlightRefresh;
+}
+
+// src/lib/logger.ts
+import pino from "pino";
+import { join as join2, dirname } from "node:path";
+import { devNull } from "node:os";
+import { mkdirSync, openSync, closeSync } from "node:fs";
+
+// src/core/constants.ts
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+function rootDir() {
+  return process.env.WIZARD_HOME ?? join(homedir(), ".algolia");
+}
+function projectSlug(cwd = process.cwd()) {
+  return resolve(cwd).replace(/[/\\:]+/g, "-").replace(/^-+/, "") || "root";
+}
+function stateDir(cwd = process.cwd()) {
+  return join(rootDir(), projectSlug(cwd));
+}
+
+// src/lib/logger.ts
+var STDERR_FD = 2;
+function resolveDest() {
+  const target = process.env.VITEST ? devNull : process.env.WIZARD_LOG ?? join2(stateDir(), "wizard.log");
+  try {
+    mkdirSync(dirname(target), { recursive: true });
+    closeSync(openSync(target, "a"));
+    return target;
+  } catch {
+    return STDERR_FD;
+  }
+}
+function logDestination() {
+  return pino.destination({ dest: resolveDest(), sync: false });
+}
+var logger = pino(
+  { level: process.env.LOG_LEVEL ?? "info" },
+  logDestination()
+);
+
+// src/lib/proxyFetch.ts
+var PROXY_BASE_URL = process.env.PROXY_BASE_URL ?? "https://proxy-624203421261.us-east4.run.app";
+var PROXY_AUTH_REJECTED_HEADER = "x-wizard-proxy-auth";
+var proxyFetch = async (input, init) => {
+  const req = new Request(input, init);
+  const retry = req.clone();
+  const res = await fetch(req);
+  if (res.status !== 401) return res;
+  if (res.headers.get(PROXY_AUTH_REJECTED_HEADER) !== "rejected") return res;
+  const fresh = await refreshAuthToken();
+  if (!fresh) return res;
+  const headers = new Headers(retry.headers);
+  if (headers.has("authorization")) {
+    headers.set("authorization", `Bearer ${fresh}`);
+  } else {
+    headers.set("x-api-key", fresh);
+  }
+  return fetch(new Request(retry, { headers }));
+};
+
+// src/lib/interaction.ts
+async function markInteraction() {
+  const token = getAuthToken();
+  if (!token) return;
+  try {
+    const res = await proxyFetch(`${PROXY_BASE_URL}/interaction`, {
+      method: "POST",
+      headers: { authorization: `Bearer ${token}` }
+    });
+    if (!res.ok) throw new Error(`proxy interaction ${res.status}`);
+  } catch (err) {
+    logger.warn({ err }, "failed to mark wizard interaction");
+  }
+}
+
+// src/core/store.ts
 function toUserInfo({ user_id, ...rest }) {
   return { userId: user_id, ...rest };
 }
+function describeInputValue(value) {
+  if (typeof value === "boolean") return value ? "Yes" : "No";
+  return Array.isArray(value) ? value.join(", ") : value;
+}
+var NOTICE_INTERVAL_MS = 2e3;
 var useWizard = create((set, get) => ({
   phase: "idle",
+  homeScreen: "home",
   user: null,
   workflow: null,
   steps: [],
   currentStepIndex: 0,
   output: "",
+  notices: [],
+  _noticeQueue: [],
+  _noticeTimer: 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.
-  confirmStart: () => set((s) => s.phase === "idle" ? { phase: "preflight" } : {}),
+  // Reset `homeScreen` so preflight shows Welcome, not the Learn more sub-view.
+  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 spacebar handler is what
   // drives the transition via `confirmStart`).
@@ -48,10 +218,64 @@ var useWizard = create((set, get) => ({
     error: null
   }),
   syncSteps: (steps, currentStepIndex) => set({ steps, currentStepIndex }),
-  setActiveStep: (index) => set({ phase: "running", currentStepIndex: index, output: "" }),
+  setActiveStep: (index) => {
+    get()._clearNoticeQueue();
+    set({ phase: "running", currentStepIndex: index, output: "", notices: [] });
+  },
   setUser: (user2) => set({ user: user2 }),
   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.
+  pushNotice: (notice) => {
+    const { notices, _noticeQueue, _noticeTimer } = get();
+    if (_noticeTimer === null) {
+      set({
+        notices: [...notices, notice],
+        _noticeTimer: setTimeout(() => get()._drainNoticeQueue(), NOTICE_INTERVAL_MS)
+      });
+    } else {
+      set({ _noticeQueue: [..._noticeQueue, notice] });
+    }
+  },
+  _drainNoticeQueue: () => {
+    const [next, ...rest] = get()._noticeQueue;
+    if (next) {
+      set((s) => ({
+        notices: [...s.notices, next],
+        _noticeQueue: rest,
+        _noticeTimer: setTimeout(() => get()._drainNoticeQueue(), NOTICE_INTERVAL_MS)
+      }));
+    } else {
+      set({ _noticeTimer: null });
+    }
+  },
+  _clearNoticeQueue: () => {
+    const timer = get()._noticeTimer;
+    if (timer) clearTimeout(timer);
+    set({ _noticeQueue: [], _noticeTimer: null });
+  },
+  clearNotices: () => {
+    get()._clearNoticeQueue();
+    set({ notices: [] });
+  },
+  logStart: (kind, name, input) => {
+    const id = nanoid();
+    set((s) => ({
+      logs: [
+        ...s.logs,
+        { id, kind, name, input, status: "running", startedAt: Date.now() }
+      ]
+    }));
+    return id;
+  },
+  logEnd: (id, status) => set((s) => ({
+    logs: s.logs.map(
+      (t) => t.id === id ? { ...t, status, durationMs: Date.now() - t.startedAt } : t
+    )
+  })),
   requestUserInput: (req) => new Promise((resolve4) => {
     set({
       phase: "awaitingInput",
@@ -59,43 +283,39 @@ var useWizard = create((set, get) => ({
       _resolve: resolve4
     });
   }),
-  submitInput: (value) => {
+  // 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);
     set({ inputReq: null, _resolve: null, phase: "running" });
+    const id = get().logStart("prompt", `User input: ${describeInputValue(value)}`);
+    get().logEnd(id, "success");
   },
   setDone: () => set({ phase: "done" }),
   setError: (message) => set({ phase: "error", error: message }),
-  reset: () => set({
-    phase: "idle",
-    workflow: null,
-    steps: [],
-    currentStepIndex: 0,
-    output: "",
-    error: null,
-    inputReq: null,
-    _resolve: null
-  })
+  reset: () => {
+    get()._clearNoticeQueue();
+    set({
+      phase: "idle",
+      homeScreen: "home",
+      workflow: null,
+      steps: [],
+      currentStepIndex: 0,
+      output: "",
+      notices: [],
+      logs: [],
+      error: null,
+      inputReq: null,
+      _resolve: null
+    });
+  }
 }));
 
-// src/lib/clipboard.ts
-function copyToClipboard(text, stream = process.stdout) {
-  const encoded = Buffer.from(text, "utf8").toString("base64");
-  stream.write(`\x1B]52;c;${encoded}\x07`);
-}
-
-// src/lib/shell.ts
-function shellQuote(value) {
-  return "'" + value.replace(/'/g, "'\\''") + "'";
-}
-
-// src/ui/PromptInput.tsx
-import { Box as Box3, Text as Text3 } from "ink";
-import TextInput from "ink-text-input";
-import { useState as useState3 } from "react";
-
-// src/ui/SelectPrompt.tsx
-import { Box as Box2, Text as Text2, useInput } from "ink";
-import { useState as useState2 } from "react";
+// src/ui/Notices.tsx
+import { Box as Box2, Text as Text2, useWindowSize as useWindowSize2 } from "ink";
+import { useEffect as useEffect2, useState as useState2 } from "react";
 
 // src/ui/Table.tsx
 import { Box, Text, measureElement, useWindowSize } from "ink";
@@ -159,6 +379,7 @@ var MARKER = {
 };
 var BRAND = "#003DFF";
 var SECONDARY = "#5468FF";
+var DANGER = "#F86E7E";
 var COLORS = {
   brand: BRAND,
   primary: "#E6EDF3",
@@ -168,23 +389,145 @@ var COLORS = {
   dim: "#484F58",
   highlight: { bg: "#12331C", fg: "#4ADE80" },
   badge: "#E3B341",
-  warning: "#F86E7E",
+  danger: DANGER,
   success: "#4ADE80",
   bg: {
     main: "#0B0E14",
     sidebar: "#14171E"
   },
+  border: "#30363D",
   accent: "#76A0FF",
   status: {
     pending: "gray",
     running: "#76A0FF",
     done: "#4ADE80",
-    error: "#F86E7E"
+    error: DANGER
   }
 };
 
-// src/ui/SelectPrompt.tsx
+// src/ui/Notices.tsx
 import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var AGENT_MARKER = "\u2726";
+var RESERVED_ROWS = 14;
+var PANEL_TEXT_WIDTH = 45;
+function messageLineCount(text) {
+  return Math.max(1, Math.ceil(text.length / PANEL_TEXT_WIDTH));
+}
+function noticeLineCount(notice) {
+  const messageLines = (notice.messages ?? []).reduce((sum, m) => {
+    const text = typeof m === "string" ? m : m.text;
+    return sum + messageLineCount(text);
+  }, 0);
+  const tableLines = notice.table ? notice.table.rows.length + 4 : 0;
+  return messageLines + tableLines;
+}
+function fitVisibleNotices(notices, windowRows) {
+  const budget = Math.max(windowRows - RESERVED_ROWS, 3);
+  let used = 0;
+  let count = 0;
+  for (let i = notices.length - 1; i >= 0; i--) {
+    const height = noticeLineCount(notices[i]) + (count > 0 ? 1 : 0);
+    if (count > 0 && used + height > budget) break;
+    used += height;
+    count++;
+  }
+  return notices.slice(notices.length - count);
+}
+var PULSE_STEPS = 12;
+var PULSE_STEP_MS = 150;
+var PULSE_COLORS = Array.from(
+  { length: PULSE_STEPS },
+  (_, i) => mixHex(COLORS.accent, COLORS.strong, i / (PULSE_STEPS - 1))
+);
+function mixHex(from, to, t) {
+  const a = parseHex(from);
+  const b = parseHex(to);
+  const channel = (k) => Math.round(a[k] + (b[k] - a[k]) * t).toString(16).padStart(2, "0");
+  return `#${channel("r")}${channel("g")}${channel("b")}`;
+}
+function parseHex(hex) {
+  const n = hex.replace("#", "");
+  return {
+    r: parseInt(n.slice(0, 2), 16),
+    g: parseInt(n.slice(2, 4), 16),
+    b: parseInt(n.slice(4, 6), 16)
+  };
+}
+function Notices() {
+  const notices = useWizard((s) => s.notices);
+  const { rows: windowRows } = useWindowSize2();
+  const visible = fitVisibleNotices(notices, windowRows);
+  const [pulseStep, setPulseStep] = useState2(0);
+  useEffect2(() => {
+    let direction = 1;
+    const id = setInterval(() => {
+      setPulseStep((step) => {
+        const next = step + direction;
+        if (next >= PULSE_COLORS.length - 1) direction = -1;
+        else if (next <= 0) direction = 1;
+        return Math.min(Math.max(next, 0), PULSE_COLORS.length - 1);
+      });
+    }, PULSE_STEP_MS);
+    return () => clearInterval(id);
+  }, []);
+  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) => {
+    const isLatest = i === visible.length - 1;
+    return /* @__PURE__ */ jsxs(Box2, { 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,
+          {
+            color: isLatest && !line.color ? pulseColor : line.color ?? COLORS.dim,
+            bold: line.bold,
+            children: [
+              prefix,
+              line.text
+            ]
+          },
+          `notice-${i}-${j}`
+        );
+      }),
+      notice.table && /* @__PURE__ */ jsx2(Table, { columns: notice.table.columns, rows: notice.table.rows })
+    ] }, `notice-${i}`);
+  }) });
+}
+
+// src/ui/PromptInput.tsx
+import { Box as Box5, Text as Text5, useInput as useInput2 } from "ink";
+import TextInput from "ink-text-input";
+import { useState as useState4 } 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";
+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 })
+    ] }),
+    /* @__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: `]` })
+    ] })
+  ] });
+}
+
+// src/ui/SelectPrompt.tsx
+import { Box as Box4, Text as Text4, useInput } from "ink";
+import { useState as useState3 } from "react";
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
 var CANCEL = "cancel";
 function SelectPrompt({
   options,
@@ -199,10 +542,10 @@ function SelectPrompt({
   secondary,
   defaultSelectedIndex = 0
 }) {
-  const [index, setIndex] = useState2(
+  const [index, setIndex] = useState3(
     () => defaultSelectedIndex > 0 && defaultSelectedIndex < options.length ? defaultSelectedIndex : 0
   );
-  const [checked, setChecked] = useState2(() => /* @__PURE__ */ new Set());
+  const [checked, setChecked] = useState3(() => /* @__PURE__ */ new Set());
   const hasCancel = Boolean(multi || cancelable);
   const rows = hasCancel ? [...options, "Cancel"] : options;
   const cancelIndex = hasCancel ? options.length : -1;
@@ -239,46 +582,46 @@ function SelectPrompt({
       }
     }
   });
-  return /* @__PURE__ */ jsxs(Box2, { flexDirection: "column", gap: 1, children: [
-    error && /* @__PURE__ */ jsx2(Text2, { color: COLORS.warning, children: error }),
-    messages?.map((m, i) => /* @__PURE__ */ jsx2(Text2, { color: COLORS.muted, children: m }, `msg-${i}`)),
-    table && /* @__PURE__ */ jsx2(Table, { columns: table.columns, rows: table.rows }),
-    /* @__PURE__ */ jsxs(Box2, { flexDirection: "column", children: [
-      question && /* @__PURE__ */ jsx2(Text2, { color: COLORS.muted, children: question }),
-      helpText && /* @__PURE__ */ jsx2(Text2, { color: COLORS.dim, children: helpText })
+  return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", gap: 1, 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 })
     ] }),
-    /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", children: rows.map((option, i) => {
+    /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", children: rows.map((option, i) => {
       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__ */ jsxs(Text2, { color: labelColor, children: [
+      const label = /* @__PURE__ */ jsxs3(Text4, { color: labelColor, children: [
         highlighted ? "\u276F   " : "    ",
         bullet,
         option
       ] });
-      return /* @__PURE__ */ jsxs(
-        Box2,
+      return /* @__PURE__ */ jsxs3(
+        Box4,
         {
           width: rowWidth,
           paddingX: 1,
           paddingY: 1,
           backgroundColor: highlighted ? COLORS.highlight.bg : void 0,
           children: [
-            sec?.kind === "text" ? /* @__PURE__ */ jsx2(Box2, { width: labelColWidth, flexShrink: 0, children: label }) : label,
-            sec?.kind === "text" && /* @__PURE__ */ jsx2(Text2, { color: highlighted ? COLORS.primary : COLORS.muted, children: sec.value }),
-            /* @__PURE__ */ jsx2(Box2, { flexGrow: 1 }),
-            sec?.kind === "badge" && /* @__PURE__ */ jsx2(Text2, { color: COLORS.badge, children: sec.value })
+            sec?.kind === "text" ? /* @__PURE__ */ jsx4(Box4, { width: labelColWidth, flexShrink: 0, children: label }) : label,
+            sec?.kind === "text" && /* @__PURE__ */ jsx4(Text4, { color: highlighted ? COLORS.primary : COLORS.muted, children: sec.value }),
+            /* @__PURE__ */ jsx4(Box4, { flexGrow: 1 }),
+            sec?.kind === "badge" && /* @__PURE__ */ jsx4(Text4, { color: COLORS.badge, children: sec.value })
           ]
         },
         `row-${i}`
       );
     }) }),
-    /* @__PURE__ */ jsx2(Box2, { children: hints.map(({ key, label }, i) => /* @__PURE__ */ jsxs(Text2, { children: [
+    /* @__PURE__ */ jsx4(Box4, { children: hints.map(({ key, label }, i) => /* @__PURE__ */ jsxs3(Text4, { children: [
       i > 0 ? "   " : "",
-      /* @__PURE__ */ jsx2(Text2, { color: COLORS.primary, children: key }),
-      /* @__PURE__ */ jsxs(Text2, { color: COLORS.dim, children: [
+      /* @__PURE__ */ jsx4(Text4, { color: COLORS.primary, children: key }),
+      /* @__PURE__ */ jsxs3(Text4, { color: COLORS.dim, children: [
         " ",
         label
       ] })
@@ -287,17 +630,35 @@ function SelectPrompt({
 }
 
 // src/ui/PromptInput.tsx
-import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
 var ACCEPT_REJECT_OPTIONS = ["Accept", "Reject"];
+function SpaceToContinuePrompt({
+  question,
+  messages,
+  onDecide
+}) {
+  useInput2((input, key) => {
+    if (input === " ") 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: [
+      /* @__PURE__ */ jsx5(NextAction, { action: "continue", keyHint: "space" }),
+      /* @__PURE__ */ jsx5(NextAction, { action: "decline", keyHint: "esc", hierarchy: "secondary" })
+    ] })
+  ] });
+}
 function PromptInput() {
   const { phase, inputReq, submitInput } = useWizard();
-  const [draft, setDraft] = useState3("");
+  const [draft, setDraft] = useState4("");
   if (phase === "done" || phase === "error") {
-    return /* @__PURE__ */ jsx3(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx3(Text3, { color: "gray", dimColor: true, children: "Press Enter or Esc to exit" }) });
+    return /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx5(Text5, { color: "gray", dimColor: true, children: "Press Enter or Esc to exit" }) });
   }
   if (phase !== "awaitingInput" || !inputReq) return null;
   if (inputReq.promptType === "multipleChoice") {
-    return /* @__PURE__ */ jsx3(Box3, { children: /* @__PURE__ */ jsx3(
+    return /* @__PURE__ */ jsx5(Box5, { children: /* @__PURE__ */ jsx5(
       SelectPrompt,
       {
         question: inputReq.prompt,
@@ -314,7 +675,7 @@ function PromptInput() {
     ) });
   }
   if (inputReq.promptType === "multiSelect") {
-    return /* @__PURE__ */ jsx3(Box3, { children: /* @__PURE__ */ jsx3(
+    return /* @__PURE__ */ jsx5(Box5, { children: /* @__PURE__ */ jsx5(
       SelectPrompt,
       {
         multi: true,
@@ -329,7 +690,7 @@ function PromptInput() {
     ) });
   }
   if (inputReq.promptType === "notice") {
-    return /* @__PURE__ */ jsx3(Box3, { children: /* @__PURE__ */ jsx3(
+    return /* @__PURE__ */ jsx5(Box5, { children: /* @__PURE__ */ jsx5(
       SelectPrompt,
       {
         question: inputReq.prompt,
@@ -339,9 +700,19 @@ function PromptInput() {
       }
     ) });
   }
+  if (inputReq.promptType === "spaceToContinue") {
+    return /* @__PURE__ */ jsx5(
+      SpaceToContinuePrompt,
+      {
+        question: inputReq.prompt,
+        messages: inputReq.messages,
+        onDecide: submitInput
+      }
+    );
+  }
   if (inputReq.promptType === "acceptReject") {
     const labels = inputReq.options?.length ? inputReq.options : ACCEPT_REJECT_OPTIONS;
-    return /* @__PURE__ */ jsx3(Box3, { children: /* @__PURE__ */ jsx3(
+    return /* @__PURE__ */ jsx5(Box5, { children: /* @__PURE__ */ jsx5(
       SelectPrompt,
       {
         question: inputReq.prompt,
@@ -352,15 +723,15 @@ function PromptInput() {
       }
     ) });
   }
-  return /* @__PURE__ */ jsxs2(Box3, { flexDirection: "column", children: [
-    inputReq.error && /* @__PURE__ */ jsx3(Text3, { color: COLORS.warning, children: inputReq.error }),
-    inputReq.messages?.map((m, i) => /* @__PURE__ */ jsx3(Text3, { color: COLORS.muted, children: m }, `msg-${i}`)),
-    /* @__PURE__ */ jsxs2(Box3, { children: [
-      /* @__PURE__ */ jsxs2(Text3, { color: COLORS.brand, children: [
+  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: [
         inputReq.prompt,
         " "
       ] }),
-      /* @__PURE__ */ jsx3(
+      /* @__PURE__ */ jsx5(
         TextInput,
         {
           value: draft,
@@ -376,32 +747,9 @@ function PromptInput() {
 }
 
 // src/ui/Welcome.tsx
-import { dirname, join } from "node:path";
+import { dirname as dirname2, join as join3 } from "node:path";
 import { fileURLToPath } from "node:url";
-import { Box as Box5, Spacer, Text as Text5, useInput as useInput2 } from "ink";
-
-// src/ui/NextAction.tsx
-import { Box as Box4, Text as Text4 } from "ink";
-import { Fragment, jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
-function NextAction({
-  action,
-  keyHint,
-  hierarchy = "primary"
-}) {
-  return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "row", gap: 1, children: [
-    hierarchy === "primary" && /* @__PURE__ */ jsx4(Text4, { color: COLORS.success, bold: true, children: `> ${action}` }),
-    hierarchy === "secondary" && /* @__PURE__ */ jsxs3(Fragment, { children: [
-      /* @__PURE__ */ jsx4(Text4, { color: COLORS.success, bold: true, children: `>` }),
-      /* @__PURE__ */ jsx4(Text4, { color: COLORS.primary, bold: true, children: action })
-    ] }),
-    /* @__PURE__ */ jsxs3(Box4, { children: [
-      /* @__PURE__ */ jsx4(Text4, { color: COLORS.muted, children: "press " }),
-      /* @__PURE__ */ jsx4(Text4, { color: COLORS.muted, children: `[` }),
-      /* @__PURE__ */ jsx4(Text4, { color: COLORS.primary, children: keyHint }),
-      /* @__PURE__ */ jsx4(Text4, { color: COLORS.muted, children: `]` })
-    ] })
-  ] });
-}
+import { Box as Box6, Spacer, Text as Text6, useInput as useInput3 } from "ink";
 
 // src/ui/copy/welcome.ts
 var sidebarItems = [
@@ -429,31 +777,33 @@ var sidebarItems = [
 
 // src/ui/Welcome.tsx
 import Image, { InkPictureProvider } from "ink-picture";
-import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
-var IMAGE_PATH = join(dirname(fileURLToPath(import.meta.url)), "algolia.png");
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+var IMAGE_PATH = join3(dirname2(fileURLToPath(import.meta.url)), "algolia.png");
 function SidebarItem({
   title,
   description
 }) {
-  return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsxs4(Box5, { gap: 1, children: [
-      /* @__PURE__ */ jsx5(Text5, { color: COLORS.success, children: "\u2192" }),
-      /* @__PURE__ */ jsx5(Text5, { color: COLORS.strong, bold: true, children: title })
+  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 })
     ] }),
-    /* @__PURE__ */ jsxs4(Box5, { flexDirection: "row", gap: 2, children: [
-      /* @__PURE__ */ jsx5(Spacer, {}),
-      /* @__PURE__ */ jsx5(Text5, { color: COLORS.muted, children: description })
+    /* @__PURE__ */ jsxs5(Box6, { flexDirection: "row", gap: 2, children: [
+      /* @__PURE__ */ jsx6(Spacer, {}),
+      /* @__PURE__ */ jsx6(Text6, { color: COLORS.muted, children: description })
     ] })
   ] });
 }
 function Welcome() {
   const confirmStart = useWizard((s) => s.confirmStart);
-  useInput2((input) => {
+  const openLearnMore = useWizard((s) => s.openLearnMore);
+  useInput3((input) => {
     if (input === " ") confirmStart();
+    else if (input === "i") openLearnMore();
   });
-  return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "row", justifyContent: "space-between", width: "100%", children: [
-    /* @__PURE__ */ jsx5(Box5, { padding: 8, flexDirection: "column", justifyContent: "center", children: /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", gap: 4, children: [
-      /* @__PURE__ */ jsx5(InkPictureProvider, { children: /* @__PURE__ */ jsx5(
+  return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "row", justifyContent: "space-between", width: "100%", children: [
+    /* @__PURE__ */ jsx6(Box6, { padding: 8, flexDirection: "column", justifyContent: "center", children: /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", gap: 4, children: [
+      /* @__PURE__ */ jsx6(InkPictureProvider, { children: /* @__PURE__ */ jsx6(
         Image,
         {
           src: IMAGE_PATH,
@@ -464,14 +814,14 @@ function Welcome() {
           protocol: "halfBlock"
         }
       ) }),
-      /* @__PURE__ */ jsx5(Text5, { color: COLORS.muted, children: "\u2726 From zero \u2192 working search in ~10 minutes" }),
-      /* @__PURE__ */ jsxs4(Box5, { gap: 1, flexDirection: "column", children: [
-        /* @__PURE__ */ jsx5(NextAction, { action: "start wizard", keyHint: "space" }),
-        /* @__PURE__ */ jsx5(NextAction, { action: "learn more", keyHint: "i", hierarchy: "secondary" })
+      /* @__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(NextAction, { action: "start wizard", keyHint: "space" }),
+        /* @__PURE__ */ jsx6(NextAction, { action: "learn more", keyHint: "i", hierarchy: "secondary" })
       ] })
     ] }) }),
-    /* @__PURE__ */ jsxs4(
-      Box5,
+    /* @__PURE__ */ jsxs5(
+      Box6,
       {
         backgroundColor: COLORS.bg.sidebar,
         width: 40,
@@ -480,41 +830,168 @@ function Welcome() {
         flexDirection: "column",
         justifyContent: "center",
         children: [
-          /* @__PURE__ */ jsx5(Text5, { color: COLORS.muted, children: "WHAT THIS WIZARD WILL DO" }),
-          sidebarItems.map((i, idx) => /* @__PURE__ */ jsx5(SidebarItem, { title: i.title, description: i.description }, idx))
+          /* @__PURE__ */ jsx6(Text6, { color: COLORS.muted, children: "WHAT THIS WIZARD WILL DO" }),
+          sidebarItems.map((i, idx) => /* @__PURE__ */ jsx6(SidebarItem, { title: i.title, description: i.description }, idx))
         ]
       }
     )
   ] });
 }
 
+// src/ui/LearnMore.tsx
+import { Fragment as Fragment2 } from "react";
+import { Box as Box7, Text as Text7, useInput as useInput4, useWindowSize as useWindowSize3 } 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.";
+var accessItems = [
+  {
+    tag: "READ",
+    title: "Project files",
+    description: "reads package.json, configs & source to detect your stack. Read-only; nothing is uploaded."
+  },
+  {
+    tag: "WRITE",
+    title: "Code changes",
+    description: "creates & edits files (search UI, config). Shown as a diff first \u2014 nothing lands without your approval."
+  },
+  {
+    tag: "NET",
+    title: "Algolia API",
+    description: "sends index settings & the records you pick to your Algolia app over HTTPS."
+  },
+  {
+    tag: "KEY",
+    title: "Credentials",
+    description: "saves your Admin API key to .env and adds it to .gitignore."
+  }
+];
+var neverItems = [
+  "Send your source code to a model or third party",
+  "Commit or push to git",
+  "Touch files outside your project directory"
+];
+var policyLinks = [
+  { label: "Terms", url: "https://www.algolia.com/policies/terms" },
+  { label: "Privacy Policy", url: "https://www.algolia.com/policies/privacy" }
+];
+
+// src/ui/LearnMore.tsx
+import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
+var TAG_COLORS = {
+  READ: COLORS.success,
+  WRITE: COLORS.badge,
+  NET: COLORS.accent,
+  KEY: COLORS.muted
+};
+var TAG_COLUMN_WIDTH = 10;
+var PADDING_X = 6;
+var NEVER_BOX_PAD_X = 2;
+function NeverLine({
+  width,
+  segments = []
+}) {
+  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" }),
+    " ".repeat(NEVER_BOX_PAD_X),
+    segments.map((s, i) => /* @__PURE__ */ jsx7(Text7, { color: s.color, bold: s.bold, children: s.text }, i)),
+    " ".repeat(rightPad),
+    /* @__PURE__ */ jsx7(Text7, { color: COLORS.danger, children: "\u2502" })
+  ] });
+}
+function LearnMore() {
+  const confirmStart = useWizard((s) => s.confirmStart);
+  const backToHome = useWizard((s) => s.backToHome);
+  const { columns } = useWindowSize3();
+  const dividerWidth = Math.max(0, columns - PADDING_X * 2);
+  useInput4((input, key) => {
+    if (key.escape) backToHome();
+    else if (input === " ") confirmStart();
+  });
+  return /* @__PURE__ */ jsxs6(
+    Box7,
+    {
+      flexDirection: "column",
+      paddingX: PADDING_X,
+      paddingY: 2,
+      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}` })
+            ] }) })
+          ] })
+        ] }, 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__ */ jsx7(NeverLine, { width: dividerWidth }),
+          /* @__PURE__ */ jsx7(
+            NeverLine,
+            {
+              width: dividerWidth,
+              segments: [{ text: "I NEVER", color: COLORS.danger, bold: true }]
+            }
+          ),
+          neverItems.map((item) => /* @__PURE__ */ jsxs6(Fragment2, { children: [
+            /* @__PURE__ */ jsx7(NeverLine, { width: dividerWidth }),
+            /* @__PURE__ */ jsx7(
+              NeverLine,
+              {
+                width: dividerWidth,
+                segments: [
+                  { text: "\u2715", color: COLORS.danger },
+                  { text: " " },
+                  { text: item, color: COLORS.primary }
+                ]
+              }
+            )
+          ] }, item)),
+          /* @__PURE__ */ jsx7(NeverLine, { width: dividerWidth }),
+          /* @__PURE__ */ jsx7(Text7, { 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 })
+        ] }, 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__ */ jsxs6(Box7, { flexDirection: "row", gap: 1, children: [
+            /* @__PURE__ */ jsx7(Text7, { color: COLORS.muted, children: "[" }),
+            /* @__PURE__ */ jsx7(Text7, { color: COLORS.primary, children: "space" }),
+            /* @__PURE__ */ jsx7(Text7, { color: COLORS.muted, children: "]" }),
+            /* @__PURE__ */ jsx7(Text7, { color: COLORS.success, bold: true, children: "start wizard" })
+          ] })
+        ] })
+      ]
+    }
+  );
+}
+
 // src/ui/Sidebar.tsx
-import { Box as Box8, Text as Text8 } from "ink";
+import { Box as Box10, Text as Text10 } from "ink";
 
 // src/ui/Steps.tsx
-import { Box as Box6, Text as Text6 } from "ink";
+import { Box as Box8, Text as Text8 } from "ink";
 import Spinner from "ink-spinner";
 
 // src/core/persistence.ts
 import { mkdir, readFile, writeFile, rm } from "node:fs/promises";
-import { join as join3 } from "node:path";
-
-// src/core/constants.ts
-import { homedir } from "node:os";
-import { join as join2, resolve } from "node:path";
-function rootDir() {
-  return process.env.WIZARD_HOME ?? join2(homedir(), ".algolia");
-}
-function projectSlug(cwd = process.cwd()) {
-  return resolve(cwd).replace(/[/\\:]+/g, "-").replace(/^-+/, "") || "root";
-}
-function stateDir(cwd = process.cwd()) {
-  return join2(rootDir(), projectSlug(cwd));
-}
-
-// src/core/persistence.ts
+import { join as join4 } from "node:path";
 var isStepVisible = (s) => s.visible !== false;
-var stateFile = (workflowId) => join3(stateDir(), `state-${workflowId}.json`);
+var stateFile = (workflowId) => join4(stateDir(), `state-${workflowId}.json`);
 async function loadWorkflowState(workflowId) {
   try {
     const raw = await readFile(stateFile(workflowId), "utf8");
@@ -536,154 +1013,55 @@ async function clearWorkflowState(workflowId) {
 }
 
 // src/ui/Steps.tsx
-import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
-function introspectDetail(output) {
-  if (!output || typeof output !== "object") return null;
-  const o = output;
-  if (!o.recordShape || typeof o.recordShape !== "object" || !Array.isArray(o.facets)) {
-    return null;
-  }
-  const fields = Object.entries(o.recordShape).map(
-    ([name, type]) => ({ name, type: String(type) })
-  );
-  return { fields, facets: o.facets.map(String) };
-}
-function reviewDetail(output) {
-  if (!output || typeof output !== "object") return null;
-  const o = output;
-  if (!Array.isArray(o.stepSummaries) || typeof o.reviewPrompt !== "string" || !Array.isArray(o.nextSteps)) {
-    return null;
-  }
-  const stepSummaries = o.stepSummaries.filter((entry) => {
-    if (!entry || typeof entry !== "object") return false;
-    const s = entry;
-    return typeof s.stepId === "string" && typeof s.stepTitle === "string" && typeof s.summary === "string";
-  }).map((s) => ({
-    stepId: s.stepId,
-    stepTitle: s.stepTitle,
-    summary: s.summary
-  }));
-  return {
-    stepSummaries,
-    reviewPrompt: o.reviewPrompt,
-    nextSteps: o.nextSteps.map(String)
-  };
-}
-function plural(count, noun) {
-  return `${count} ${noun}${count === 1 ? "" : "s"}`;
-}
-function IntrospectSummary({ detail }) {
-  return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsxs5(Text6, { color: "gray", children: [
-      " ",
-      "Inferred ",
-      plural(detail.fields.length, "field"),
-      ",",
-      " ",
-      plural(detail.facets.length, "facet")
-    ] }),
-    detail.fields.map((f) => /* @__PURE__ */ jsxs5(Text6, { color: "gray", children: [
-      "   ",
-      f.name,
-      ": ",
-      f.type
-    ] }, f.name)),
-    /* @__PURE__ */ jsxs5(Text6, { color: "gray", children: [
-      "   ",
-      "Facets:",
-      " ",
-      detail.facets.length ? detail.facets.join(", ") : "none"
-    ] })
-  ] });
-}
-function ReviewSummary({ detail }) {
-  return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", children: [
-    detail.stepSummaries.map((s) => /* @__PURE__ */ jsxs5(Text6, { color: "gray", children: [
-      " ",
-      s.stepTitle,
-      ": ",
-      s.summary
-    ] }, s.stepId)),
-    /* @__PURE__ */ jsxs5(Text6, { color: COLORS.brand, children: [
-      " ",
-      detail.reviewPrompt
-    ] }),
-    detail.nextSteps.map((step, i) => {
-      const isIngestCommand = step.includes(".algolia-wizard/ingest.sh");
-      const isWorktreeCommand = step.includes("/worktrees/");
-      const color = isIngestCommand ? COLORS.brand : isWorktreeCommand ? COLORS.secondary : "gray";
-      return /* @__PURE__ */ jsxs5(
-        Text6,
-        {
-          color,
-          bold: isIngestCommand || isWorktreeCommand,
-          children: [
-            " ",
-            "\u2192 ",
-            step
-          ]
-        },
-        `next-${i}`
-      );
-    })
-  ] });
-}
+import { jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
 function Steps() {
   const { steps } = useWizard();
   const visibleSteps = steps.filter(isStepVisible);
-  return /* @__PURE__ */ jsx6(Box6, { flexDirection: "column", gap: 1, children: visibleSteps.map((s) => {
-    const introspect = s.status === "done" ? introspectDetail(s.output) : null;
-    const review = s.status === "done" ? reviewDetail(s.output) : null;
-    return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsxs5(Text6, { color: COLORS.status[s.status], children: [
-        s.status === "running" ? /* @__PURE__ */ jsx6(Spinner, { type: "dots" }) : MARKER[s.status],
-        " ",
-        s.title
-      ] }),
-      introspect && /* @__PURE__ */ jsx6(IntrospectSummary, { detail: introspect }),
-      review && /* @__PURE__ */ jsx6(ReviewSummary, { detail: review })
-    ] }, s.id);
-  }) });
+  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: [
+    s.status === "running" ? /* @__PURE__ */ jsx8(Spinner, { type: "dots" }) : MARKER[s.status],
+    " ",
+    s.title
+  ] }) }, s.id)) });
 }
 function CurrentStep() {
   const { steps } = useWizard();
   const currentStep = steps.filter(isStepVisible).find((s) => s.status === "running");
   if (!currentStep) return null;
-  return /* @__PURE__ */ jsxs5(Text6, { color: COLORS.status.running, children: [
-    /* @__PURE__ */ jsx6(Spinner, { type: "dots" }),
+  return /* @__PURE__ */ jsxs7(Text8, { color: COLORS.status.running, children: [
+    /* @__PURE__ */ jsx8(Spinner, { type: "dots" }),
     " ",
     ` ${currentStep.title}`
   ] });
 }
 
 // src/ui/Progress.tsx
-import { Box as Box7, Text as Text7 } from "ink";
-import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
+import { Box as Box9, Text as Text9 } from "ink";
+import { jsx as jsx9, jsxs as jsxs8 } 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__ */ jsxs6(Box7, { flexDirection: "row", gap: 1, children: [
-    /* @__PURE__ */ jsx7(Text7, { color: COLORS.muted, children: "STEP" }),
-    /* @__PURE__ */ jsx7(Text7, { bold: true, children: activeStepNumber }),
-    /* @__PURE__ */ jsx7(Text7, { bold: true, children: "/" }),
-    /* @__PURE__ */ jsx7(Text7, { bold: true, children: visibleSteps.length })
+  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 })
   ] });
 }
 
 // src/ui/copy/sidebar-commands.ts
 var sidebarCommands = [
   { keyHint: "tab", description: "toggle logs" },
-  { keyHint: "esc", description: "close" }
+  { keyHint: "esc", description: "exit wizard" }
 ];
 
 // src/ui/Sidebar.tsx
-import { jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
+import { jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
 function Sidebar() {
-  return /* @__PURE__ */ jsxs7(
-    Box8,
+  return /* @__PURE__ */ jsxs9(
+    Box10,
     {
       backgroundColor: "#14171E",
       width: 30,
@@ -692,16 +1070,16 @@ function Sidebar() {
       flexDirection: "column",
       justifyContent: "space-between",
       children: [
-        /* @__PURE__ */ jsxs7(Box8, { flexDirection: "column", gap: 1, children: [
-          /* @__PURE__ */ jsx8(Text8, { color: COLORS.muted, children: "PROGRESS" }),
-          /* @__PURE__ */ jsx8(Steps, {})
+        /* @__PURE__ */ jsxs9(Box10, { flexDirection: "column", gap: 1, children: [
+          /* @__PURE__ */ jsx10(Text10, { color: COLORS.muted, children: "PROGRESS" }),
+          /* @__PURE__ */ jsx10(Steps, {})
         ] }),
-        /* @__PURE__ */ jsxs7(Box8, { flexDirection: "column", gap: 1, children: [
-          /* @__PURE__ */ jsx8(Progress, {}),
-          /* @__PURE__ */ jsx8(Box8, { flexDirection: "column", children: sidebarCommands.map((c) => {
-            return /* @__PURE__ */ jsxs7(Box8, { flexDirection: "row", gap: 1, children: [
-              /* @__PURE__ */ jsx8(Text8, { color: COLORS.primary, children: `[${c.keyHint}]` }),
-              /* @__PURE__ */ jsx8(Text8, { color: COLORS.muted, children: c.description })
+        /* @__PURE__ */ jsxs9(Box10, { 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 })
             ] });
           }) })
         ] })
@@ -711,12 +1089,12 @@ function Sidebar() {
 }
 
 // src/ui/Ribbon.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 jsx11, jsxs as jsxs10 } from "react/jsx-runtime";
 function Ribbon() {
   const firstCommand = sidebarCommands[0];
-  return /* @__PURE__ */ jsxs8(
-    Box9,
+  return /* @__PURE__ */ jsxs10(
+    Box11,
     {
       backgroundColor: "#14171E",
       flexDirection: "row",
@@ -724,11 +1102,11 @@ function Ribbon() {
       paddingX: 2,
       paddingY: 1,
       children: [
-        /* @__PURE__ */ jsx9(Progress, {}),
-        /* @__PURE__ */ jsx9(CurrentStep, {}),
-        /* @__PURE__ */ jsxs8(Box9, { flexDirection: "row", gap: 1, children: [
-          /* @__PURE__ */ jsx9(Text9, { color: COLORS.primary, children: `[${firstCommand.keyHint}]` }),
-          /* @__PURE__ */ jsx9(Text9, { color: COLORS.muted, children: firstCommand.description })
+        /* @__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 })
         ] })
       ]
     }
@@ -736,75 +1114,205 @@ function Ribbon() {
 }
 
 // src/ui/App.tsx
-import { jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
+import { useState as useState6 } from "react";
+
+// src/ui/Logs.tsx
+import { useLayoutEffect, useRef as useRef2, useState as useState5 } from "react";
+import { Box as Box12, Text as Text12, measureElement as measureElement2, useInput as useInput5, useWindowSize as useWindowSize4 } from "ink";
+import { jsx as jsx12, jsxs as jsxs11 } from "react/jsx-runtime";
+var KIND_COLOR = {
+  tool: COLORS.primary,
+  prompt: COLORS.badge
+};
+var STATUS_COLOR = {
+  running: COLORS.status.running,
+  error: COLORS.danger
+};
+function logNameColor(entry) {
+  return STATUS_COLOR[entry.status] ?? KIND_COLOR[entry.kind];
+}
+var ROW_GAP = 1;
+function truncate2(str, maxWidth) {
+  if (maxWidth <= 0) return "";
+  return str.length > maxWidth ? `${str.slice(0, maxWidth - 1)}\u2026` : str;
+}
+function rawInputText(input) {
+  if (input === void 0) return "";
+  const str = typeof input === "string" ? input : JSON.stringify(input);
+  if (!str || str === "{}") return "";
+  return str.replace(/\s+/g, " ").trim();
+}
+function formatTimestamp(ms) {
+  const d = new Date(ms);
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+}
+function Logs() {
+  const logs = useWizard((s) => s.logs);
+  const { rows, columns } = useWindowSize4();
+  const viewportRef = useRef2(null);
+  const [viewportHeight, setViewportHeight] = useState5(0);
+  const [viewportWidth, setViewportWidth] = useState5(0);
+  const [scrollOffset, setScrollOffset] = useState5(0);
+  const prevMaxOffsetRef = useRef2(0);
+  useLayoutEffect(() => {
+    if (!viewportRef.current) return;
+    const { width, height } = measureElement2(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);
+  useLayoutEffect(() => {
+    const wasAtBottom = scrollOffset >= prevMaxOffsetRef.current;
+    prevMaxOffsetRef.current = maxOffset;
+    setScrollOffset((o) => wasAtBottom ? maxOffset : Math.min(o, maxOffset));
+  }, [maxOffset]);
+  useInput5((_input, key) => {
+    if (!key.upArrow && !key.downArrow) return;
+    setScrollOffset(
+      (o) => key.upArrow ? Math.max(o - 1, 0) : Math.min(o + 1, maxOffset)
+    );
+  });
+  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" })
+  ] });
+}
+
+// src/lib/events.ts
+import "zod";
+function track(event, payload) {
+  const token = getAuthToken();
+  if (!token) return;
+  const userId = useWizard.getState().user?.userId;
+  if (!userId) return;
+  void proxyFetch(`${PROXY_BASE_URL}/events`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({ userId, event, properties: payload })
+  }).catch((err) => {
+    logger.warn({ err, event }, "failed to send analytics event");
+  });
+}
+
+// src/ui/App.tsx
+import { jsx as jsx13, jsxs as jsxs12 } from "react/jsx-runtime";
 function App() {
-  const { phase, error } = useWizard();
-  const implementOutput = useWizard((s) => {
-    return s.steps.find((st) => st.id === "ingestion")?.output;
-  });
-  const ingestCommand = implementOutput?.ingestCommand;
-  const openWorktreeCommand = implementOutput?.worktreePath ? `cd ${shellQuote(implementOutput.worktreePath)}` : void 0;
+  const { phase, error, homeScreen, currentStepIndex, steps, inputReq } = useWizard();
   const { exit } = useApp();
-  const { columns, rows } = useWindowSize2();
-  const [copied, setCopied] = useState4(null);
+  const { columns, rows } = useWindowSize5();
+  const [showLogs, setShowLogs] = useState6(false);
   const finished = phase === "done" || phase === "error";
-  useEffect2(() => {
-    if (!copied) return;
-    const timer = setTimeout(() => setCopied(null), 5e3);
-    return () => clearTimeout(timer);
-  }, [copied]);
-  useInput3(
-    (input, key) => {
-      if (key.return || key.escape) {
+  const currentStep = steps[currentStepIndex];
+  useInput6(
+    (_input, key) => {
+      if (key.return) {
         exit();
-        return;
-      }
-      if (ingestCommand && (input === "c" || input === "C")) {
-        copyToClipboard(ingestCommand);
-        setCopied("ingest");
-      }
-      if (openWorktreeCommand && (input === "d" || input === "D")) {
-        copyToClipboard(openWorktreeCommand);
-        setCopied("worktree");
       }
     },
     { isActive: finished }
   );
+  useInput6((_input, key) => {
+    if (phase === "idle" || phase === "preflight") return;
+    if (key.tab) {
+      setShowLogs(!showLogs);
+      track("AI Wizard Interaction", {
+        context: "global",
+        key: "tab",
+        currentStep: currentStep?.id
+      });
+    }
+  });
+  const escOwnedElsewhere = phase === "idle" || phase === "awaitingInput" && inputReq?.promptType === "spaceToContinue";
+  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 flexDirection = columns > 90 ? "row" : "column";
   const showSidebar = flexDirection === "row";
-  return /* @__PURE__ */ jsxs9(
-    Box10,
+  return /* @__PURE__ */ jsxs12(
+    Box13,
     {
       backgroundColor: COLORS.bg.main,
       flexDirection: "row",
       width: columns,
       minHeight: rows,
       children: [
-        mainWindowVisible && /* @__PURE__ */ jsxs9(
-          Box10,
+        mainWindowVisible && /* @__PURE__ */ jsxs12(
+          Box13,
           {
             flexDirection,
             width: "100%",
             justifyContent: "space-between",
             children: [
-              /* @__PURE__ */ jsxs9(Box10, { flexDirection: "column", paddingX: 4, paddingY: 2, children: [
-                /* @__PURE__ */ jsx10(PromptInput, {}),
-                phase === "error" && error && /* @__PURE__ */ jsx10(Box10, { marginTop: 1, children: /* @__PURE__ */ jsxs9(Text10, { color: COLORS.status.error, children: [
+              showLogs ? /* @__PURE__ */ jsx13(Logs, {}) : /* @__PURE__ */ jsxs12(Box13, { flexDirection: "column", paddingX: 4, paddingY: 2, width: 70, children: [
+                /* @__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: [
                   "\u2716 ",
                   error
-                ] }) }),
-                finished && (ingestCommand || openWorktreeCommand) && /* @__PURE__ */ jsxs9(Box10, { flexDirection: "column", marginTop: 1, children: [
-                  ingestCommand && /* @__PURE__ */ jsx10(Text10, { color: COLORS.brand, children: copied === "ingest" ? "\u2713 Ingestion command copied to clipboard" : 'Press "c" to copy the ingestion command' }),
-                  openWorktreeCommand && /* @__PURE__ */ jsx10(Text10, { color: COLORS.secondary, children: copied === "worktree" ? "\u2713 Worktree command copied to clipboard" : 'Press "d" to copy the command to open the worktree' })
-                ] })
+                ] }) })
               ] }),
-              /* @__PURE__ */ jsx10(Text10, { color: "white", backgroundColor: "#14171E" }),
-              showSidebar ? /* @__PURE__ */ jsx10(Sidebar, {}) : /* @__PURE__ */ jsx10(Ribbon, {})
+              showSidebar ? /* @__PURE__ */ jsx13(Sidebar, {}) : /* @__PURE__ */ jsx13(Ribbon, {})
             ]
           }
         ),
-        (phase === "idle" || phase === "preflight") && /* @__PURE__ */ jsx10(Welcome, {})
+        (phase === "idle" || phase === "preflight") && (homeScreen === "learnMore" ? /* @__PURE__ */ jsx13(LearnMore, {}) : /* @__PURE__ */ jsx13(Welcome, {}))
       ]
     }
   );
@@ -815,8 +1323,8 @@ import "zod";
 
 // src/core/config.ts
 import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join4 } from "node:path";
-var configFile = () => join4(stateDir(), "config.json");
+import { join as join5 } from "node:path";
+var configFile = () => join5(stateDir(), "config.json");
 var DEFAULT_CONFIG = {
   version: 1,
   aiConsent: false,
@@ -840,128 +1348,6 @@ async function recordWorkflowRun(workflowId, completedAt) {
   await saveConfig(config);
 }
 
-// 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");
-}
-function runAlgoliaCli(args) {
-  return new Promise((resolve4, reject) => {
-    const child = spawn(process.execPath, [algoliaCliEntry(), ...args]);
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (chunk) => stdout += chunk);
-    child.stderr.on("data", (chunk) => stderr += chunk);
-    child.on("error", reject);
-    child.on("close", (code) => {
-      if (code === 0) {
-        resolve4(stdout);
-      } else {
-        const detail = stderr.trim() || stdout.trim();
-        reject(
-          new Error(
-            `Algolia CLI \`${args.join(" ")}\` failed (exit ${code})${detail ? `: ${detail}` : ""}`
-          )
-        );
-      }
-    });
-  });
-}
-async function getUser() {
-  let raw;
-  try {
-    raw = await runAlgoliaCli(["auth", "get", "--with-access-token"]);
-  } catch {
-    return null;
-  }
-  try {
-    return toUserInfo(JSON.parse(raw));
-  } catch {
-    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}).`));
-    });
-  });
-}
-
-// src/lib/auth.ts
-function getAuthToken() {
-  return useWizard.getState().user?.token || null;
-}
-var inFlightRefresh = null;
-function refreshAuthToken() {
-  inFlightRefresh ??= (async () => {
-    try {
-      const raw = await runAlgoliaCli(["auth", "get", "--with-access-token"]);
-      const user2 = toUserInfo(JSON.parse(raw));
-      useWizard.getState().setUser(user2);
-      return user2.token;
-    } catch {
-      return null;
-    } finally {
-      inFlightRefresh = null;
-    }
-  })();
-  return inFlightRefresh;
-}
-
-// src/lib/logger.ts
-import pino from "pino";
-import { join as join5, dirname as dirname2 } from "node:path";
-import { devNull } from "node:os";
-import { mkdirSync, openSync, closeSync } from "node:fs";
-var STDERR_FD = 2;
-function resolveDest() {
-  const target = process.env.VITEST ? devNull : process.env.WIZARD_LOG ?? join5(stateDir(), "wizard.log");
-  try {
-    mkdirSync(dirname2(target), { recursive: true });
-    closeSync(openSync(target, "a"));
-    return target;
-  } catch {
-    return STDERR_FD;
-  }
-}
-function logDestination() {
-  return pino.destination({ dest: resolveDest(), sync: false });
-}
-var logger = pino(
-  { level: process.env.LOG_LEVEL ?? "info" },
-  logDestination()
-);
-
-// src/lib/proxyFetch.ts
-var PROXY_BASE_URL = process.env.PROXY_BASE_URL ?? "https://proxy-624203421261.us-east4.run.app";
-var PROXY_AUTH_REJECTED_HEADER = "x-wizard-proxy-auth";
-var proxyFetch = async (input, init) => {
-  const req = new Request(input, init);
-  const retry = req.clone();
-  const res = await fetch(req);
-  if (res.status !== 401) return res;
-  if (res.headers.get(PROXY_AUTH_REJECTED_HEADER) !== "rejected") return res;
-  const fresh = await refreshAuthToken();
-  if (!fresh) return res;
-  const headers = new Headers(retry.headers);
-  if (headers.has("authorization")) {
-    headers.set("authorization", `Bearer ${fresh}`);
-  } else {
-    headers.set("x-api-key", fresh);
-  }
-  return fetch(new Request(retry, { headers }));
-};
-
 // src/lib/telemetry.ts
 function isTelemetryEnabled() {
   return Boolean(getAuthToken()) && !process.env.VITEST && process.env.WIZARD_TELEMETRY !== "false";
@@ -1124,25 +1510,6 @@ function trackWorkflowError(ctx) {
   );
 }
 
-// src/lib/events.ts
-import "zod";
-function track(event, payload) {
-  const token = getAuthToken();
-  if (!token) return;
-  const userId = useWizard.getState().user?.userId;
-  if (!userId) return;
-  void proxyFetch(`${PROXY_BASE_URL}/events`, {
-    method: "POST",
-    headers: {
-      "content-type": "application/json",
-      authorization: `Bearer ${token}`
-    },
-    body: JSON.stringify({ userId, event, properties: payload })
-  }).catch((err) => {
-    logger.warn({ err, event }, "failed to send analytics event");
-  });
-}
-
 // src/core/orchestrator.ts
 function defineStep(step) {
   return { visible: true, ...step };
@@ -1186,12 +1553,14 @@ async function ensureConsent() {
   if (config.aiConsent) return;
   const store2 = useWizard.getState();
   const answer = await store2.requestUserInput({
-    prompt: 'Wizard will make AI-authored changes to this repository. Type "yes" to consent:',
-    promptType: "textInput",
+    prompt: "Wizard will make AI-authored changes to this repository.",
+    promptType: "spaceToContinue",
     options: []
   });
-  if (typeof answer !== "string" || answer.trim().toLowerCase() !== "yes") {
-    throw new Error("AI consent declined \u2014 cannot proceed.");
+  if (answer !== true) {
+    throw new Error(
+      "AI consent declined \u2014 cannot proceed. If you change your mind, just run the Wizard again!"
+    );
   }
   config.aiConsent = true;
   await saveConfig(config);
@@ -1212,6 +1581,10 @@ async function makeContext(state) {
     completedSteps,
     getStepOutput: (stepId) => outputs[stepId],
     requestUserInput: (prompt) => useWizard.getState().requestUserInput(prompt),
+    notify: (notice) => useWizard.getState().pushNotice(notice),
+    clearNotices: () => useWizard.getState().clearNotices(),
+    logStart: (name, input) => useWizard.getState().logStart("tool", name, input),
+    logEnd: (id, status) => useWizard.getState().logEnd(id, status),
     updateAlgoliaState: (key, value) => {
       state.algoliaState[key] = value;
     },
@@ -1243,6 +1616,7 @@ async function runStep(state, index, step, appId) {
   store2.setActiveStep(index);
   store2.syncSteps([...state.steps], index);
   await saveWorkflowState(state);
+  await markInteraction();
   const ctx = await makeContext(state);
   const raw = await step.run(ctx);
   const output = step.outputSchema.parse(raw);
@@ -1263,7 +1637,6 @@ async function runStep(state, index, step, appId) {
 async function runWorkflow(workflow2, appId) {
   const store2 = useWizard.getState();
   try {
-    await ensureConsent();
     const persisted = await loadWorkflowState(workflow2.id);
     const state = (persisted && reconcileWorkflowState(persisted, workflow2)) ?? initWorkflowState(workflow2, nowIso());
     ensureExecutedStepCount(state);
@@ -1275,6 +1648,7 @@ async function runWorkflow(workflow2, appId) {
       },
       [...state.steps]
     );
+    await ensureConsent();
     trackWorkflowStart({ workflowId: workflow2.id, appId });
     for (let i = state.currentStepIndex; i < workflow2.steps.length; i++) {
       await runStep(state, i, workflow2.steps[i], appId);
@@ -1384,7 +1758,7 @@ async function loadActiveProfile() {
 }
 
 // src/workflows/default.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 
 // src/actions/listIndices.ts
 import { z as z3 } from "zod";
@@ -1863,8 +2237,11 @@ function verifyImplementationTool() {
 // src/lib/tools/generateRecord.ts
 import { tool as tool9, generateText, Output, NoObjectGeneratedError } from "ai";
 import { createAnthropic } from "@ai-sdk/anthropic";
-import { nanoid } from "nanoid";
+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";
+var DATA_DIR = ".algolia-wizard/data";
 var RECORD_MODEL = "claude-haiku-4-5";
 var MAX_RECORDS = 100;
 var BATCH_SIZE = 10;
@@ -1872,9 +2249,9 @@ var MAX_BATCH_ATTEMPTS = 3;
 var anthropic = createAnthropic({
   apiKey: process.env.PROVIDER_API_KEY ?? ""
 });
-function generateRecordTool() {
+function generateRecordTool(ctx) {
   return tool9({
-    description: "Generate realistic sample records for an entity. Provide the entity name and its attributes; this tool asks a model to invent varied, realistic values and returns fully-formed records, each with a unique objectID. Do not invent the record values or objectIDs yourself \u2014 call this tool.",
+    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."),
@@ -1906,7 +2283,7 @@ function generateRecordTool() {
                   // would otherwise drift to the same high-probability values and
                   // collide across batches. This per-batch seed pushes each call
                   // into a different region of the output space.
-                  `Variety seed: ${nanoid()}. Use it to diversify values.`
+                  `Variety seed: ${nanoid2()}. Use it to diversify values.`
                 ].filter(Boolean).join("\n")
               });
               return output.records;
@@ -1928,10 +2305,23 @@ function generateRecordTool() {
         const batches = await Promise.all(batchSizes.map(generateBatch));
         const records = batches.flat().map((record) => ({
           ...record,
-          objectID: nanoid()
+          objectID: nanoid2()
         }));
-        logger.info(records);
-        return { records };
+        const slug = entityName.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+        const relPath = `${DATA_DIR}/${slug}.json`;
+        const resolved = resolveInRoot(ctx, relPath);
+        if (resolved.ok === false) return resolved.error;
+        if (await hasSymlinkParent(ctx, resolved.target)) {
+          return `Refused: ${resolved.target} is outside the repo root (${ctx.root}).`;
+        }
+        await mkdir5(dirname6(resolved.target), { recursive: true });
+        await writeFile5(resolved.target, JSON.stringify(records, null, 2), "utf8");
+        logger.info({ entityName, count: records.length, relPath }, "generateRecord wrote records to disk");
+        return {
+          filePath: relPath,
+          count: records.length,
+          message: `Wrote ${records.length} records to ${relPath}. Read and parse this file in the script at runtime (e.g. JSON.parse(readFileSync(...)) in Node/Bun, json.load(open(...)) in Python) \u2014 do not inline the records as literals.`
+        };
       } catch (err) {
         return `Error generating records: ${err.message}`;
       }
@@ -1939,6 +2329,25 @@ function generateRecordTool() {
   });
 }
 
+// src/lib/tools/notifyUser.ts
+import { tool as tool10 } from "ai";
+import z13 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(
+        "Short, plain-language description of what you are doing now."
+      )
+    }),
+    execute: async ({ message }) => {
+      logger.info({ message }, "called notifyUser tool");
+      useWizard.getState().pushNotice({ messages: [message] });
+      return "ok";
+    }
+  });
+}
+
 // src/lib/tools/context.ts
 var DEFAULT_TOOL_LIMITS = {
   list: 10,
@@ -1956,20 +2365,45 @@ function createToolContext(limits = DEFAULT_TOOL_LIMITS, cwd = process.cwd()) {
 }
 
 // src/lib/tools/index.ts
+function withLogging(name, def) {
+  const execute = def.execute;
+  if (!execute) return def;
+  return {
+    ...def,
+    execute: async (input, options) => {
+      const id = useWizard.getState().logStart("tool", name, input);
+      try {
+        const output = await execute(input, options);
+        useWizard.getState().logEnd(id, "success");
+        return output;
+      } catch (err) {
+        useWizard.getState().logEnd(id, "error");
+        throw err;
+      }
+    }
+  };
+}
 function createTools(ctx, { output, tools }) {
   const all = {
-    listFiles: listFilesTool(ctx),
-    changeDirectory: changeDirectoryTool(ctx),
-    reportStatus: reportStatusTool(output),
-    readFile: readFileTool(ctx),
-    writeFile: writeFileTool(ctx),
-    writeCredentials: writeCredentialsTool(ctx),
-    searchFiles: searchFilesTool(ctx),
-    verifyImplementation: verifyImplementationTool(),
-    generateRecord: generateRecordTool()
+    listFiles: withLogging("listFiles", listFilesTool(ctx)),
+    changeDirectory: withLogging("changeDirectory", changeDirectoryTool(ctx)),
+    reportStatus: withLogging("reportStatus", reportStatusTool(output)),
+    readFile: withLogging("readFile", readFileTool(ctx)),
+    writeFile: withLogging("writeFile", writeFileTool(ctx)),
+    writeCredentials: withLogging(
+      "writeCredentials",
+      writeCredentialsTool(ctx)
+    ),
+    searchFiles: withLogging("searchFiles", searchFilesTool(ctx)),
+    verifyImplementation: withLogging(
+      "verifyImplementation",
+      verifyImplementationTool()
+    ),
+    generateRecord: withLogging("generateRecord", generateRecordTool(ctx)),
+    notifyUser: withLogging("notifyUser", notifyUserTool())
   };
   if (!tools) return all;
-  const selection = /* @__PURE__ */ new Set([...tools, "reportStatus"]);
+  const selection = /* @__PURE__ */ new Set([...tools, "reportStatus", "notifyUser"]);
   return Object.fromEntries(
     Object.entries(all).filter(([name]) => selection.has(name))
   );
@@ -2002,16 +2436,19 @@ async function runAgent(req) {
   const toolContext = createToolContext();
   const readTools = ["readFile", "searchFiles", "listFiles"];
   const hasReadTools = !req.tools || req.tools.some((t) => readTools.includes(t));
-  const instructions = hasReadTools ? [
+  const instructions = [
     ...req.instructions ?? [],
-    "When you need to read or search multiple files, issue those tool calls together in one step rather than one at a time."
-  ] : req.instructions;
+    ...hasReadTools ? [
+      "When you need to read or search multiple files, issue those tool calls together in one step rather than one at a time."
+    ] : [],
+    "Call notifyUser whenever you start a new phase of work or your focus shifts (e.g. moving from reading code to writing files) \u2014 a short, plain-language, high-level update. Do not call it for every tool use."
+  ];
   const agent = new ToolLoopAgent({
     model: anthropic2(MODEL_BY_SIZE[req.modelSize ?? "medium"]),
     // Cache tools + system on the last system block. Tools render before
     // system, so one breakpoint here caches both, reused on every loop turn
     // after the first.
-    instructions: instructions?.map((i, idx, arr) => {
+    instructions: instructions.map((i, idx, arr) => {
       return {
         role: "system",
         content: i,
@@ -2079,10 +2516,10 @@ async function runAgent(req) {
 }
 
 // src/actions/detectLanguage.ts
-import z15 from "zod";
-var detectLanguageSchema = z15.object({
-  languages: z15.array(z15.object({ name: z15.string(), version: z15.string() })),
-  frameworks: z15.array(z15.object({ name: z15.string(), version: z15.string() }))
+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() }))
 });
 var detectLanguage = () => runAgent({
   instructions: [
@@ -2100,31 +2537,31 @@ var detectLanguage = () => runAgent({
 });
 
 // src/actions/analyzeCodebase.ts
-import z16 from "zod";
+import z17 from "zod";
 var READONLY_TOOLS = [
   "listFiles",
   "changeDirectory",
   "readFile",
   "searchFiles"
 ];
-var ingestionAnalysisSchema = z16.object({
-  ingestionAnalysis: z16.array(
-    z16.object({
-      name: z16.string(),
-      paths: z16.array(z16.string()),
+var ingestionAnalysisSchema = z17.object({
+  ingestionAnalysis: z17.array(
+    z17.object({
+      name: z17.string(),
+      paths: z17.array(z17.string()),
       // indexable fields the agent found for this entity
-      attributes: z16.array(z16.string())
+      attributes: z17.array(z17.string())
     })
   )
 });
-var searchImplementationAnalysisSchema = z16.object({
-  searchImplementationAnalysis: z16.string()
+var searchImplementationAnalysisSchema = z17.object({
+  searchImplementationAnalysis: z17.string()
 });
-var verificationSchema = z16.object({
-  verification: z16.array(z16.string())
+var verificationSchema = z17.object({
+  verification: z17.array(z17.string())
 });
 var confirmedEntitiesFieldSchema = ingestionAnalysisSchema.shape.ingestionAnalysis.optional();
-var analyzeCodebaseSchema = z16.object({
+var analyzeCodebaseSchema = z17.object({
   ingestionAnalysis: ingestionAnalysisSchema.shape.ingestionAnalysis.optional(),
   searchImplementationAnalysis: searchImplementationAnalysisSchema.shape.searchImplementationAnalysis.optional(),
   verification: verificationSchema.shape.verification.optional(),
@@ -2186,7 +2623,7 @@ async function runAnalysis(mode, extraInstructions = []) {
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.2.0",
+  version: "0.3.0-rc.43.6",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {
@@ -2200,9 +2637,9 @@ var package_default = {
     "docs"
   ],
   scripts: {
-    "build:proxy": `esbuild src/proxy/index.ts --bundle --platform=node --format=esm --target=node24 --banner:js='import { createRequire as __cr } from "module"; const require = __cr(import.meta.url);' --outfile=dist/proxy.mjs`,
-    build: "esbuild src/main.tsx --bundle --platform=node --format=esm --target=node18 --packages=external --jsx=automatic --banner:js='#!/usr/bin/env node' --outfile=dist/main.js && cp src/ui/algolia.png dist/algolia.png",
-    "dev:proxy": "NODE_OPTIONS=--use-system-ca tsx watch src/proxy/index.ts",
+    "build:proxy": "node scripts/build.mjs proxy",
+    build: "node scripts/build.mjs",
+    "dev:proxy": "touch .env && NODE_OPTIONS=--use-system-ca tsx watch --env-file=.env src/proxy/index.ts",
     dev: "touch .env && tsx --env-file=.env ./src/main.tsx",
     "env:load": "pnpm exec -- varlock load",
     prepare: "husky",
@@ -2307,8 +2744,8 @@ async function askList(ctx, prompt, { required = false } = {}) {
 }
 
 // src/actions/confirmLanguage.ts
-import z18 from "zod";
-var confirmLanguageSchema = z18.object({
+import z19 from "zod";
+var confirmLanguageSchema = z19.object({
   languages: detectLanguageSchema.shape.languages
 });
 async function confirmLanguage(ctx) {
@@ -2329,8 +2766,8 @@ async function confirmLanguage(ctx) {
 }
 
 // src/actions/confirmFramework.ts
-import z19 from "zod";
-var confirmFrameworkSchema = z19.object({
+import z20 from "zod";
+var confirmFrameworkSchema = z20.object({
   frameworks: detectLanguageSchema.shape.frameworks
 });
 var CURATED_FRAMEWORKS = [
@@ -2458,8 +2895,8 @@ async function promptUser(ctx, params) {
 }
 
 // src/actions/confirmEntities.ts
-import z20 from "zod";
-var confirmEntitiesSchema = z20.object({
+import z21 from "zod";
+var confirmEntitiesSchema = z21.object({
   // Final detection — the focused re-run may supersede project-scan's.
   ingestionAnalysis: ingestionAnalysisSchema.shape.ingestionAnalysis.optional(),
   confirmedEntities: confirmedEntitiesFieldSchema
@@ -2529,17 +2966,15 @@ async function confirmEntities(ctx) {
 }
 
 // src/actions/review.ts
-import { z as z21 } from "zod";
-var reviewSchema = z21.object({
-  stepSummaries: z21.array(
-    z21.object({
-      stepId: z21.string(),
-      stepTitle: z21.string(),
-      summary: z21.string()
-    })
-  ),
-  reviewPrompt: z21.string(),
-  nextSteps: z21.array(z21.string())
+import { z as z22 } from "zod";
+var reviewSchema = z22.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())
 });
 function formatCompletedSteps(steps) {
   if (!steps.length) return "(no prior steps completed)";
@@ -2549,32 +2984,55 @@ Output:
 ${JSON.stringify(s.output, null, 2)}`
   ).join("\n\n");
 }
-var reviewStep = (ctx, options) => runAgent({
-  instructions: [
-    "Summarize what was accomplished in the workflow, leaving out verbose details.",
-    "Base your summary only on the step outputs provided \u2014 do not read the repository.",
-    "Write one entry in stepSummaries per step \u2014 use the exact stepId and stepTitle provided.",
-    'Set reviewPrompt to a short message that asks the user to review the changes \u2014 it must include wording like "Please review the generated code".',
-    "Set nextSteps to concrete actions the user should take to use what this workflow set up \u2014 do not suggest open-ended or generic tasks (e.g. deploying, writing tests) unless they are directly required.",
-    options.nextStepsGuidance,
-    `Completed steps:
+function formatReviewSummary(result) {
+  const nextStepLines = result.nextSteps.map((step) => {
+    const isIngestCommand = step.includes(".algolia-wizard/ingest.sh");
+    const isWorktreeCommand = step.includes("/worktrees/");
+    return {
+      text: `\u2192 ${step}`,
+      color: isIngestCommand ? COLORS.brand : isWorktreeCommand ? COLORS.secondary : void 0,
+      bold: isIngestCommand || isWorktreeCommand
+    };
+  });
+  return [
+    // Plain lines, same as nextSteps' un-highlighted entries — the summary is
+    // an overview, not a call to action, so it gets no arrow/color/bold.
+    ...result.summaryPoints,
+    { text: result.reviewPrompt, color: COLORS.brand },
+    ...nextStepLines
+  ];
+}
+var reviewStep = async (ctx, options) => {
+  const result = await runAgent({
+    instructions: [
+      "Summarize what was accomplished in the workflow, leaving out verbose details.",
+      "Base your summary only on the step outputs provided \u2014 do not read the repository.",
+      "Group summaryPoints into a few broad, high-level takeaways (e.g. what was ingested, what search UI was built) rather than one entry per step \u2014 do not mirror the step outputs 1:1 or restate every detail.",
+      "Each summaryPoint should be a short, standalone statement.",
+      'Set reviewPrompt to a short message that asks the user to review the changes \u2014 it must include wording like "Please review the generated code".',
+      "Set nextSteps to concrete actions the user should take to use what this workflow set up \u2014 do not suggest open-ended or generic tasks (e.g. deploying, writing tests) unless they are directly required.",
+      options.nextStepsGuidance,
+      `Completed steps:
 ${formatCompletedSteps(ctx.completedSteps)}`,
-    "When done, call reportStatus"
-  ],
-  tools: [],
-  outputSchema: reviewSchema,
-  modelSize: "small"
-});
+      "When done, call reportStatus"
+    ],
+    tools: [],
+    outputSchema: reviewSchema,
+    modelSize: "small"
+  });
+  ctx.notify({ messages: formatReviewSummary(result) });
+  return result;
+};
 
 // src/actions/implement.ts
-import z23 from "zod";
+import z24 from "zod";
 
 // src/lib/worktree.ts
 import { execFile, spawn as spawn3 } from "node:child_process";
-import { copyFile, mkdir as mkdir5, readdir as readdir3, stat as stat2 } from "node:fs/promises";
+import { copyFile, mkdir as mkdir6, readdir as readdir3, readFile as readFile8, stat as stat2, writeFile as writeFile6 } from "node:fs/promises";
 import {
   basename as basename2,
-  dirname as dirname6,
+  dirname as dirname7,
   isAbsolute as isAbsolute2,
   join as join10,
   relative as relative2,
@@ -2638,7 +3096,7 @@ async function createWorktree(repoRoot) {
   const path = join10(stateDir(repoRoot), "worktrees", dirSlug);
   await git(["-C", repoRoot, "worktree", "prune"]);
   await pruneOldWorktrees(repoRoot);
-  await mkdir5(dirname6(path), { recursive: true });
+  await mkdir6(dirname7(path), { recursive: true });
   await git(["-C", repoRoot, "worktree", "add", "-b", branch, path, "HEAD"]);
   return { path, branch };
 }
@@ -2758,7 +3216,7 @@ async function copyUploadIntoWorktree(repoRoot, worktreePath, ingestDir, sourceP
   const relPath = join10(ingestDir, basename2(source));
   const dest = join10(worktreePath, relPath);
   try {
-    await mkdir5(dirname6(dest), { recursive: true });
+    await mkdir6(dirname7(dest), { recursive: true });
     await copyFile(source, dest);
   } catch (err) {
     return {
@@ -2768,6 +3226,25 @@ async function copyUploadIntoWorktree(repoRoot, worktreePath, ingestDir, sourceP
   }
   return { ok: true, relPath };
 }
+function hasEnvVar(content, name) {
+  return new RegExp(`^(\\s*(?:export\\s+)?${name})\\s*=`, "m").test(content);
+}
+async function writeSearchEnvValues(worktreePath, vars) {
+  const target = join10(worktreePath, ".env");
+  let existing = "";
+  try {
+    existing = await readFile8(target, "utf8");
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  const missing = vars.filter((v) => !hasEnvVar(existing, v.name));
+  if (missing.length === 0) return [];
+  const prefix = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+  const lines = missing.map(({ name, value }) => `${name}=${value}
+`).join("");
+  await writeFile6(target, existing + prefix + lines, "utf8");
+  return missing.map((v) => v.name);
+}
 async function listChangedFiles(worktreePath) {
   const raw = await git(["-C", worktreePath, "status", "--porcelain", "-z"]);
   const entries = raw.split("\0");
@@ -2825,20 +3302,20 @@ async function confirmDirtyWorkingTree(ctx, repoRoot) {
 }
 
 // src/lib/algoliaApiKey.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 var SAFE_ACLS = /* @__PURE__ */ new Set(["search", "browse", "listIndexes"]);
-var apiKeySchema = z22.object({
-  value: z22.string().min(1),
-  acl: z22.array(z22.string()).default([]),
-  indexes: z22.array(z22.string()).default([])
+var apiKeySchema = z23.object({
+  value: z23.string().min(1),
+  acl: z23.array(z23.string()).default([]),
+  indexes: z23.array(z23.string()).default([])
 });
-var apiKeyListSchema = z22.object({
-  items: z22.array(apiKeySchema).optional(),
-  keys: z22.array(apiKeySchema).optional()
+var apiKeyListSchema = z23.object({
+  items: z23.array(apiKeySchema).optional(),
+  keys: z23.array(apiKeySchema).optional()
 }).transform((o) => o.items ?? o.keys ?? []);
-var createdKeySchema = z22.object({
-  key: z22.string().min(1).optional(),
-  value: z22.string().min(1).optional()
+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));
@@ -2874,15 +3351,15 @@ async function resolveSearchOnlyKey(index) {
 
 // src/lib/algoliaDocs.ts
 import { readFileSync, readdirSync, existsSync as existsSync2 } from "node:fs";
-import { dirname as dirname7, join as join11 } from "node:path";
+import { dirname as dirname8, join as join11 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var DOCS_SUBPATH = join11("docs", "algolia-sdk");
 function findDocsDir() {
-  let dir = dirname7(fileURLToPath2(import.meta.url));
+  let dir = dirname8(fileURLToPath2(import.meta.url));
   for (; ; ) {
     const candidate = join11(dir, DOCS_SUBPATH);
     if (existsSync2(candidate)) return candidate;
-    const parent = dirname7(dir);
+    const parent = dirname8(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
@@ -2932,51 +3409,56 @@ function getFrameworkSpecificDoc(frameworks) {
   return loadAlgoliaDoc("js");
 }
 
+// src/lib/shell.ts
+function shellQuote(value) {
+  return "'" + value.replace(/'/g, "'\\''") + "'";
+}
+
 // src/actions/implement.ts
-var implementSchema = z23.object({
-  filesChanged: z23.array(z23.string()),
-  summary: z23.string(),
+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: z23.string().optional(),
-  ingestCommand: z23.string().optional(),
+  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: z23.boolean().optional(),
+  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: z23.number().optional(),
+  ingestRecordCount: z24.number().optional(),
   // Wall-clock duration of the run-now ingestion execution, in ms.
-  ingestDurationMs: z23.number().optional(),
-  ingestionSource: z23.enum(["local", "fileUpload", "generated"]),
+  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: z23.array(
-    z23.object({
-      name: z23.string(),
-      value: z23.string()
+  searchEnvVars: z24.array(
+    z24.object({
+      name: z24.string(),
+      value: z24.string()
     })
   ).optional()
 });
-var implementationOutputSchema = z23.object({
-  summary: z23.string(),
+var implementationOutputSchema = z24.object({
+  summary: z24.string(),
   // Ingestion only: how to run the generated script, as a structured pair the
   // wizard turns into an argv (`<runtime> <entrypoint>`) — never a free-form
   // command string. `runtime` is constrained to an allowlisted interpreter and
   // `entrypoint` is validated to a worktree-relative path before execution, so
   // the agent cannot inject extra commands or swap the interpreter.
-  runtime: z23.enum(INGEST_RUNTIMES).optional(),
-  entrypoint: z23.string().optional()
+  runtime: z24.enum(INGEST_RUNTIMES).optional(),
+  entrypoint: z24.string().optional()
 });
-var verificationOutputSchema = z23.object({
-  summary: z23.string(),
-  sufficient: z23.boolean(),
-  additionalInstructions: z23.string().optional()
+var verificationOutputSchema = z24.object({
+  summary: z24.string(),
+  sufficient: z24.boolean(),
+  additionalInstructions: z24.string().optional()
 });
 var MAX_IMPLEMENT_VERIFICATION_ATTEMPTS = 3;
 var DEFAULT_IMPLEMENT_USE_CASES = ["ingestion", "search"];
@@ -3058,9 +3540,9 @@ 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) to get the records; it invents the values and unique objectIDs. Do not write records or objectIDs yourself.",
-      "Bake the returned records inline into the script, clearly commented as generated sample data.",
-      "Add a prominent TODO where the developer swaps the generated records for their real record source."
+      "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 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];
@@ -3090,12 +3572,16 @@ function searchInstructions(input) {
     doc,
     `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.`,
     "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.",
-    `Values: App ID ${input.appId ? `"${input.appId}"` : "(placeholder for the developer to fill in)"}, search-only key ${input.searchKey ? `"${input.searchKey}"` : "(placeholder for the developer to fill in)"}.`,
-    `Suggested public env var names: ${input.searchEnvVars.map(({ name }) => name).join(", ")}.`,
-    `The prefix on those names was derived from framework detection and may not match the project. If the project's build tool exposes client-side env vars under a different convention (e.g. NEXT_PUBLIC_ for Next.js, NUXT_PUBLIC_ for Nuxt, VITE_ for Vite, PUBLIC_ for Astro), rename the prefix to match, keeping the ALGOLIA_APP_ID and ALGOLIA_SEARCH_API_KEY suffixes. Use the final names consistently in the code, ".env.example", and your summary.`,
+    // 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
+    // reading a var the wizard never wrote.
+    `Use exactly these public env var names in the code: ${input.searchEnvVars.map(({ name }) => name).join(", ")}.`,
     '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.',
-    'Add these env var placeholders to ".env.example", preserving existing entries; create the file if it does not exist.',
-    "In your summary, tell the developer to fill in the concrete env values after reviewing the code."
+    "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) {
@@ -3127,9 +3613,14 @@ var IMPLEMENT_CONFIG = {
   }
 };
 var useCaseToolMap = {
-  ingestion: [...FS_READ_TOOLS, "writeFile", "writeCredentials"],
-  search: [...FS_READ_TOOLS, "writeFile"],
-  verification: [...FS_READ_TOOLS, "verifyImplementation"]
+  ingestion: [...FS_READ_TOOLS, "writeFile", "writeCredentials", "notifyUser"],
+  search: [...FS_READ_TOOLS, "writeFile", "notifyUser"],
+  verification: [
+    ...FS_READ_TOOLS,
+    "writeFile",
+    "verifyImplementation",
+    "notifyUser"
+  ]
 };
 function toolsForUseCase(useCase, ingestionSource) {
   const tools = useCaseToolMap[useCase];
@@ -3152,6 +3643,9 @@ function formatSummary(useCase, summary) {
   const label = useCase === "ingestion" ? "Ingestion" : useCase === "search" ? "Search" : "Verification";
   return `${label}: ${summary}`;
 }
+function buildIngestCommand(worktree, runtime, entrypoint) {
+  return `cd ${shellQuote(worktree)} && ${runtime} ${shellQuote(entrypoint)}`;
+}
 function parseIngestRecordCount(output) {
   const match = output.match(/ALGOLIA_WIZARD_RECORD_COUNT=(\d+)/);
   if (!match) return void 0;
@@ -3295,6 +3789,7 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
     let ingestRecordCount;
     let ingestDurationMs;
     let installFailed = false;
+    let ingestOutcomeMessage;
     async function runImplementationUseCase(currentUseCase, extraInstructions = []) {
       if (agentRuns > 0) ctx.recordStepExecution();
       agentRuns += 1;
@@ -3307,7 +3802,14 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
         tools: toolsForUseCase(currentUseCase, input.ingestionSource),
         outputSchema: implementationOutputSchema
       });
+      ctx.notify({
+        messages: [`Installing dependencies for ${currentUseCase}\u2026`]
+      });
+      const installLogId = ctx.logStart("installWorktreeDeps", {
+        useCase: currentUseCase
+      });
       const install = await installWorktreeDeps(worktree);
+      ctx.logEnd(installLogId, install.ok ? "success" : "error");
       if (!install.ok) {
         installFailed = true;
         logger.warn(
@@ -3332,6 +3834,7 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
       ingestRuntime = runtime;
       ingestEntrypoint = entrypoint;
       if (ingestRuntime && ingestEntrypoint && !installFailed) {
+        ctx.clearNotices();
         const runNow = await ctx.requestUserInput({
           prompt: `Run the ingestion script now? This writes records to the "${targetIndex}" index.`,
           promptType: "acceptReject",
@@ -3340,6 +3843,11 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
         }) === true;
         if (runNow) {
           const profile2 = await loadActiveProfile();
+          ctx.notify({ messages: [`Writing records to "${targetIndex}"\u2026`] });
+          const scriptLogId = ctx.logStart("runIngestScript", {
+            runtime: ingestRuntime,
+            entrypoint: ingestEntrypoint
+          });
           const startedAt = Date.now();
           const run = await runIngestScript(
             worktree,
@@ -3350,6 +3858,7 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
               [API_KEY_VAR]: profile2.apiKey
             }
           );
+          ctx.logEnd(scriptLogId, run.ok ? "success" : "error");
           ingestScriptRan = run.ran && run.ok;
           if (ingestScriptRan) {
             ingestDurationMs = Date.now() - startedAt;
@@ -3405,19 +3914,38 @@ ${run.output}` : status;
             });
           }
           summaries.push(summaryLine);
-          await ctx.requestUserInput({
-            prompt: "Continue",
-            promptType: "notice",
-            options: [],
-            messages: [outcomeMessage]
-          });
+          ingestOutcomeMessage = outcomeMessage;
         }
       }
+      const commandMessages = [`Open the worktree: cd ${shellQuote(worktree)}`];
+      if (ingestRuntime && ingestEntrypoint) {
+        commandMessages.push(
+          `Ingestion command: ${buildIngestCommand(worktree, ingestRuntime, ingestEntrypoint)}`
+        );
+      }
+      await ctx.requestUserInput({
+        // No question being asked here, just an acknowledgement — the
+        // continue/decline hints below already say "continue".
+        prompt: "",
+        promptType: "spaceToContinue",
+        options: [],
+        messages: ingestOutcomeMessage ? [ingestOutcomeMessage, ...commandMessages] : commandMessages
+      });
     }
     if (useCases.includes("search")) {
       let extraInstructions = [];
       const preSearchFiles = new Set(await listChangedFiles(worktree));
       for (let attempt = 1; attempt <= MAX_IMPLEMENT_VERIFICATION_ATTEMPTS; attempt++) {
+        if (attempt > 1) {
+          logger.info(
+            {
+              attempt,
+              maxAttempts: MAX_IMPLEMENT_VERIFICATION_ATTEMPTS,
+              extraInstructions
+            },
+            "implement: retrying search implementation after failed verification"
+          );
+        }
         const { summary } = await runImplementationUseCase(
           "search",
           extraInstructions
@@ -3446,6 +3974,26 @@ ${run.output}` : status;
         }
         extraInstructions = verificationRetryInstructions(verification);
       }
+      const resolvedSearchEnvVars = input.searchEnvVars.filter(
+        (v) => !v.value.startsWith("<")
+      );
+      if (resolvedSearchEnvVars.length > 0) {
+        const written = await writeSearchEnvValues(
+          worktree,
+          resolvedSearchEnvVars
+        );
+        if (written.length > 0) {
+          summaries.push(`Wrote ${written.join(", ")} to .env.`);
+        }
+      }
+      const unresolvedSearchEnvVars = input.searchEnvVars.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.`
+        );
+      }
     } else {
       ctx.setUserInput("implementation", "success");
     }
@@ -3466,7 +4014,11 @@ ${run.output}` : status;
       summary: summaries.join("\n\n"),
       worktreePath: worktree,
       ...useCases.includes("ingestion") && ingestRuntime && ingestEntrypoint ? {
-        ingestCommand: `cd ${shellQuote(worktree)} && ${ingestRuntime} ${shellQuote(ingestEntrypoint)}`,
+        ingestCommand: buildIngestCommand(
+          worktree,
+          ingestRuntime,
+          ingestEntrypoint
+        ),
         ingestScriptRan,
         ...ingestRecordCount != null ? { ingestRecordCount } : {},
         ...ingestDurationMs != null ? { ingestDurationMs } : {}
@@ -3488,7 +4040,14 @@ var defaultWorkflow = {
       id: "project-scan",
       title: "project scan",
       outputSchema: projectScanSchema,
-      run: (ctx) => projectScan(ctx)
+      run: (ctx) => {
+        ctx.notify({
+          messages: [
+            "Scanning your project for languages, frameworks, and Algolia integration points\u2026"
+          ]
+        });
+        return projectScan(ctx);
+      }
     }),
     defineStep({
       id: "confirm-language",
@@ -3507,8 +4066,8 @@ var defaultWorkflow = {
     defineStep({
       id: "select-index",
       title: "Set up index",
-      outputSchema: z24.object({
-        selection: z24.string()
+      outputSchema: z25.object({
+        selection: z25.string()
       }),
       run: (ctx) => selectIndexStep(ctx)
     }),
@@ -3516,7 +4075,14 @@ var defaultWorkflow = {
       id: "ingestion",
       title: "ingest records",
       outputSchema: implementSchema,
-      run: (ctx) => implement(ctx, ["ingestion"])
+      run: (ctx) => {
+        ctx.notify({
+          messages: [
+            "Setting up an Algolia ingestion pipeline in your project\u2026"
+          ]
+        });
+        return implement(ctx, ["ingestion"]);
+      }
     }),
     defineStep({
       id: "confirm-framework",
@@ -3530,6 +4096,9 @@ var defaultWorkflow = {
       title: "create search ui",
       outputSchema: implementSchema,
       run: (ctx) => {
+        ctx.notify({
+          messages: ["Building your Algolia search experience\u2026"]
+        });
         const ingestion = ctx.getStepOutput(
           "ingestion"
         );
@@ -3541,11 +4110,17 @@ var defaultWorkflow = {
       title: "done",
       outputSchema: reviewSchema,
       run: (ctx) => {
+        ctx.notify({
+          messages: ["Summarizing what we did\u2026"]
+        });
         const ingestion = ctx.getStepOutput(
           "ingestion"
         );
         return reviewStep(ctx, {
-          nextStepsGuidance: ingestion?.ingestScriptRan ? "The wizard already ran the ingestion script and records are in the index. Do NOT tell the user to run it again; instead point them at the target index to confirm the records, and note they can re-run the `ingestCommand` from the implement step output if they change the data." : "Tell the user to run the ingestion script. Use prior step outputs to make the instructions specific, and include the exact `ingestCommand` from the implement step output."
+          // The ingestion step already showed the user the exact `ingestCommand`
+          // and worktree path as a notice, so nextSteps must not restate it —
+          // an LLM-paraphrased command risks being wrong.
+          nextStepsGuidance: ingestion?.ingestScriptRan ? "The wizard already ran the ingestion script and records are in the index. Do NOT tell the user to run it again; instead point them at the target index to confirm the records. Do not restate the ingestion command \u2014 the wizard already showed it to them." : "Tell the user to run the ingestion script; do not restate the exact command \u2014 the wizard already showed it to them above."
         });
       }
     })
@@ -3561,7 +4136,7 @@ function getWorkflow(id) {
 }
 
 // src/main.tsx
-import { jsx as jsx11 } from "react/jsx-runtime";
+import { jsx as jsx14 } from "react/jsx-runtime";
 var requestedId = process.argv[2] ?? defaultWorkflow.id;
 var workflow = getWorkflow(requestedId);
 if (!workflow) {
@@ -3570,7 +4145,7 @@ if (!workflow) {
   process.exit(1);
 }
 var store = useWizard.getState();
-var instance = render(/* @__PURE__ */ jsx11(App, {}));
+var instance = render(/* @__PURE__ */ jsx14(App, {}), { incrementalRendering: true });
 var user = await getUser();
 if (!user) {
   await instance.waitUntilRenderFlush();
@@ -3581,7 +4156,7 @@ if (!user) {
     console.error(err instanceof Error ? err.message : String(err));
     process.exit(1);
   }
-  instance = render(/* @__PURE__ */ jsx11(App, {}));
+  instance = render(/* @__PURE__ */ jsx14(App, {}), { incrementalRendering: true });
   user = await getUser();
   if (!user) {
     store.setError(