@algolia/wizard 0.1.0

package/dist/main.js

@@ -0,0 +1,3597 @@
+#!/usr/bin/env node
+
+// src/main.tsx
+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";
+
+// src/core/store.ts
+import { create } from "zustand";
+function toUserInfo({ user_id, ...rest }) {
+  return { userId: user_id, ...rest };
+}
+var useWizard = create((set, get) => ({
+  phase: "idle",
+  user: null,
+  workflow: null,
+  steps: [],
+  currentStepIndex: 0,
+  output: "",
+  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" } : {}),
+  // 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`).
+  waitForStart: () => new Promise((resolve4) => {
+    if (get().phase !== "idle") {
+      resolve4();
+      return;
+    }
+    const unsubscribe = useWizard.subscribe((s) => {
+      if (s.phase !== "idle") {
+        unsubscribe();
+        resolve4();
+      }
+    });
+  }),
+  startWorkflow: (workflow2, steps) => set({
+    phase: "running",
+    workflow: workflow2,
+    steps,
+    currentStepIndex: 0,
+    error: null
+  }),
+  syncSteps: (steps, currentStepIndex) => set({ steps, currentStepIndex }),
+  setActiveStep: (index) => set({ phase: "running", currentStepIndex: index, output: "" }),
+  setUser: (user2) => set({ user: user2 }),
+  appendToken: (text) => set((s) => ({ output: s.output + text })),
+  clearOutput: () => set({ output: "" }),
+  requestUserInput: (req) => new Promise((resolve4) => {
+    set({
+      phase: "awaitingInput",
+      inputReq: req,
+      _resolve: resolve4
+    });
+  }),
+  submitInput: (value) => {
+    get()._resolve?.(value);
+    set({ inputReq: null, _resolve: null, phase: "running" });
+  },
+  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
+  })
+}));
+
+// 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/Table.tsx
+import { Box, Text, measureElement, useWindowSize } from "ink";
+import { useEffect, useRef, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+function Table({ columns, rows }) {
+  const { columns: termCols } = useWindowSize();
+  const ref = useRef(null);
+  const [width, setWidth] = useState(0);
+  useEffect(() => {
+    if (ref.current) setWidth(measureElement(ref.current).width);
+  }, [termCols, columns, rows]);
+  if (rows.length === 0) return null;
+  const lines = formatTable(columns, rows, width || void 0);
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", ref, children: lines.map((line, i) => /* @__PURE__ */ jsx(Text, { wrap: "truncate", children: line }, `tbl-${i}`)) });
+}
+function formatTable(columns, rows, width) {
+  const natural = columns.map(
+    (c, i) => Math.max(c.length, ...rows.map((r) => (r[i] ?? "").length))
+  );
+  const overhead = 3 * columns.length + 1;
+  const widths = width !== void 0 ? resize(natural, Math.max(width - overhead, columns.length)) : natural;
+  const border = (left, mid, right) => left + widths.map((w) => "\u2500".repeat(w + 2)).join(mid) + right;
+  const rowLine = (cells) => "\u2502" + widths.map((w, i) => ` ${truncate(cells[i] ?? "", w).padEnd(w)} `).join("\u2502") + "\u2502";
+  return [
+    border("\u250C", "\u252C", "\u2510"),
+    rowLine(columns),
+    border("\u251C", "\u253C", "\u2524"),
+    ...rows.map(rowLine),
+    border("\u2514", "\u2534", "\u2518")
+  ];
+}
+function resize(widths, budget) {
+  const out = [...widths];
+  const widest = () => {
+    let w = 0;
+    for (let i = 1; i < out.length; i++) if (out[i] > out[w]) w = i;
+    return w;
+  };
+  let total = out.reduce((a, b) => a + b, 0);
+  while (total > budget) {
+    const i = widest();
+    if (out[i] <= 1) break;
+    out[i]--;
+    total--;
+  }
+  while (total < budget) {
+    out[widest()]++;
+    total++;
+  }
+  return out;
+}
+var truncate = (s, width) => s.length <= width ? s : width <= 1 ? s.slice(0, width) : `${s.slice(0, width - 1)}\u2026`;
+
+// src/ui/theme.ts
+var MARKER = {
+  pending: "\u25CB",
+  running: "\u25D0",
+  done: "\u2713",
+  error: "\u2716"
+};
+var BRAND = "#003DFF";
+var SECONDARY = "#5468FF";
+var COLORS = {
+  brand: BRAND,
+  primary: "#E6EDF3",
+  secondary: SECONDARY,
+  strong: "#FFFFFF",
+  muted: "#8B949E",
+  dim: "#484F58",
+  highlight: { bg: "#12331C", fg: "#4ADE80" },
+  badge: "#E3B341",
+  warning: "#F86E7E",
+  success: "#4ADE80",
+  bg: {
+    main: "#0B0E14",
+    sidebar: "#14171E"
+  },
+  accent: "#76A0FF",
+  status: {
+    pending: "gray",
+    running: "#76A0FF",
+    done: "#4ADE80",
+    error: "#F86E7E"
+  }
+};
+
+// src/ui/SelectPrompt.tsx
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var CANCEL = "cancel";
+function SelectPrompt({
+  options,
+  onSelect,
+  question,
+  helpText,
+  messages,
+  table,
+  error,
+  multi,
+  cancelable,
+  secondary,
+  defaultSelectedIndex = 0
+}) {
+  const [index, setIndex] = useState2(
+    () => defaultSelectedIndex > 0 && defaultSelectedIndex < options.length ? defaultSelectedIndex : 0
+  );
+  const [checked, setChecked] = useState2(() => /* @__PURE__ */ new Set());
+  const hasCancel = Boolean(multi || cancelable);
+  const rows = hasCancel ? [...options, "Cancel"] : options;
+  const cancelIndex = hasCancel ? options.length : -1;
+  const hints = [];
+  if (rows.length > 1) hints.push({ key: "[\u2191] [\u2193]", label: "move" });
+  if (multi) hints.push({ key: "[space]", label: "select" });
+  hints.push({ key: "[enter]", label: "confirm" });
+  const labelColWidth = 6 + Math.max(0, ...rows.map((opt) => opt.length));
+  const secondaryWidth = Math.max(
+    0,
+    ...rows.map((_, i) => secondary?.[i]?.value.length ?? 0)
+  );
+  const rowWidth = labelColWidth + (secondaryWidth ? secondaryWidth + 2 : 0) + 6;
+  useInput((input, key) => {
+    if (rows.length === 0) return;
+    if (key.upArrow || input === "k") {
+      setIndex((i) => (i - 1 + rows.length) % rows.length);
+    } else if (key.downArrow || input === "j") {
+      setIndex((i) => (i + 1) % rows.length);
+    } else if (multi && input === " " && index !== cancelIndex) {
+      setChecked((prev) => {
+        const next = new Set(prev);
+        if (next.has(index)) next.delete(index);
+        else next.add(index);
+        return next;
+      });
+    } else if (key.return) {
+      if (index === cancelIndex) {
+        onSelect(CANCEL);
+      } else if (!multi) {
+        onSelect(options[index]);
+      } else if (checked.size > 0) {
+        onSelect(options.filter((_, i) => checked.has(i)));
+      }
+    }
+  });
+  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 })
+    ] }),
+    /* @__PURE__ */ jsx2(Box2, { 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: [
+        highlighted ? "\u276F   " : "    ",
+        bullet,
+        option
+      ] });
+      return /* @__PURE__ */ jsxs(
+        Box2,
+        {
+          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 })
+          ]
+        },
+        `row-${i}`
+      );
+    }) }),
+    /* @__PURE__ */ jsx2(Box2, { children: hints.map(({ key, label }, i) => /* @__PURE__ */ jsxs(Text2, { children: [
+      i > 0 ? "   " : "",
+      /* @__PURE__ */ jsx2(Text2, { color: COLORS.primary, children: key }),
+      /* @__PURE__ */ jsxs(Text2, { color: COLORS.dim, children: [
+        " ",
+        label
+      ] })
+    ] }, label)) })
+  ] });
+}
+
+// src/ui/PromptInput.tsx
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var ACCEPT_REJECT_OPTIONS = ["Accept", "Reject"];
+function PromptInput() {
+  const { phase, inputReq, submitInput } = useWizard();
+  const [draft, setDraft] = useState3("");
+  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" }) });
+  }
+  if (phase !== "awaitingInput" || !inputReq) return null;
+  if (inputReq.promptType === "multipleChoice") {
+    return /* @__PURE__ */ jsx3(Box3, { children: /* @__PURE__ */ jsx3(
+      SelectPrompt,
+      {
+        question: inputReq.prompt,
+        helpText: inputReq.helpText,
+        messages: inputReq.messages,
+        table: inputReq.table,
+        options: inputReq.options,
+        secondary: inputReq.secondary,
+        defaultSelectedIndex: inputReq.defaultSelectedIndex,
+        cancelable: inputReq.cancelable,
+        error: inputReq.error,
+        onSelect: submitInput
+      }
+    ) });
+  }
+  if (inputReq.promptType === "multiSelect") {
+    return /* @__PURE__ */ jsx3(Box3, { children: /* @__PURE__ */ jsx3(
+      SelectPrompt,
+      {
+        multi: true,
+        question: inputReq.prompt,
+        helpText: inputReq.helpText,
+        messages: inputReq.messages,
+        table: inputReq.table,
+        options: inputReq.options,
+        error: inputReq.error,
+        onSelect: submitInput
+      }
+    ) });
+  }
+  if (inputReq.promptType === "notice") {
+    return /* @__PURE__ */ jsx3(Box3, { children: /* @__PURE__ */ jsx3(
+      SelectPrompt,
+      {
+        question: inputReq.prompt,
+        messages: inputReq.messages,
+        options: ["Continue"],
+        onSelect: submitInput
+      }
+    ) });
+  }
+  if (inputReq.promptType === "acceptReject") {
+    const labels = inputReq.options?.length ? inputReq.options : ACCEPT_REJECT_OPTIONS;
+    return /* @__PURE__ */ jsx3(Box3, { children: /* @__PURE__ */ jsx3(
+      SelectPrompt,
+      {
+        question: inputReq.prompt,
+        messages: inputReq.messages,
+        options: labels,
+        secondary: inputReq.secondary,
+        onSelect: (value) => submitInput(value === labels[0])
+      }
+    ) });
+  }
+  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: [
+        inputReq.prompt,
+        " "
+      ] }),
+      /* @__PURE__ */ jsx3(
+        TextInput,
+        {
+          value: draft,
+          onChange: setDraft,
+          onSubmit: (v) => {
+            submitInput(v);
+            setDraft("");
+          }
+        }
+      )
+    ] })
+  ] });
+}
+
+// src/ui/Welcome.tsx
+import { dirname, join } 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: `]` })
+    ] })
+  ] });
+}
+
+// src/ui/copy/welcome.ts
+var sidebarItems = [
+  {
+    title: "scan your project",
+    description: "detect models, schemas, and data worth indexing"
+  },
+  {
+    title: "select and index",
+    description: "push 100 records to Algolia in seconds"
+  },
+  {
+    title: "detect your framework",
+    description: "React, Vue, Angular, Vanilla JS"
+  },
+  {
+    title: "scaffold a search UI",
+    description: "a styled InstantSearch component, wired into your app"
+  },
+  {
+    title: "ship it",
+    description: "build check passes, search is live with your real data"
+  }
+];
+
+// 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");
+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 })
+    ] }),
+    /* @__PURE__ */ jsxs4(Box5, { flexDirection: "row", gap: 2, children: [
+      /* @__PURE__ */ jsx5(Spacer, {}),
+      /* @__PURE__ */ jsx5(Text5, { color: COLORS.muted, children: description })
+    ] })
+  ] });
+}
+function Welcome() {
+  const confirmStart = useWizard((s) => s.confirmStart);
+  useInput2((input) => {
+    if (input === " ") confirmStart();
+  });
+  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(
+        Image,
+        {
+          src: IMAGE_PATH,
+          objectFit: "contain",
+          alt: "Algolia",
+          width: 30,
+          height: 15,
+          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__ */ jsxs4(
+      Box5,
+      {
+        backgroundColor: COLORS.bg.sidebar,
+        width: 40,
+        padding: 4,
+        gap: 2,
+        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))
+        ]
+      }
+    )
+  ] });
+}
+
+// src/ui/Sidebar.tsx
+import { Box as Box8, Text as Text8 } from "ink";
+
+// src/ui/Steps.tsx
+import { Box as Box6, Text as Text6 } 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
+var isStepVisible = (s) => s.visible !== false;
+var stateFile = (workflowId) => join3(stateDir(), `state-${workflowId}.json`);
+async function loadWorkflowState(workflowId) {
+  try {
+    const raw = await readFile(stateFile(workflowId), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function saveWorkflowState(state) {
+  await mkdir(stateDir(), { recursive: true });
+  await writeFile(
+    stateFile(state.workflowId),
+    JSON.stringify(state, null, 2),
+    "utf8"
+  );
+}
+async function clearWorkflowState(workflowId) {
+  await rm(stateFile(workflowId), { force: true });
+}
+
+// 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}`
+      );
+    })
+  ] });
+}
+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);
+  }) });
+}
+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" }),
+    " ",
+    ` ${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";
+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 })
+  ] });
+}
+
+// src/ui/copy/sidebar-commands.ts
+var sidebarCommands = [
+  { keyHint: "tab", description: "toggle logs" },
+  { keyHint: "esc", description: "close" }
+];
+
+// src/ui/Sidebar.tsx
+import { jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
+function Sidebar() {
+  return /* @__PURE__ */ jsxs7(
+    Box8,
+    {
+      backgroundColor: "#14171E",
+      width: 30,
+      paddingX: 4,
+      paddingY: 2,
+      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__ */ 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 })
+            ] });
+          }) })
+        ] })
+      ]
+    }
+  );
+}
+
+// src/ui/Ribbon.tsx
+import { Box as Box9, Text as Text9 } from "ink";
+import { jsx as jsx9, jsxs as jsxs8 } from "react/jsx-runtime";
+function Ribbon() {
+  const firstCommand = sidebarCommands[0];
+  return /* @__PURE__ */ jsxs8(
+    Box9,
+    {
+      backgroundColor: "#14171E",
+      flexDirection: "row",
+      justifyContent: "space-between",
+      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 })
+        ] })
+      ]
+    }
+  );
+}
+
+// src/ui/App.tsx
+import { jsx as jsx10, jsxs as jsxs9 } 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 { exit } = useApp();
+  const { columns, rows } = useWindowSize2();
+  const [copied, setCopied] = useState4(null);
+  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) {
+        exit();
+        return;
+      }
+      if (ingestCommand && (input === "c" || input === "C")) {
+        copyToClipboard(ingestCommand);
+        setCopied("ingest");
+      }
+      if (openWorktreeCommand && (input === "d" || input === "D")) {
+        copyToClipboard(openWorktreeCommand);
+        setCopied("worktree");
+      }
+    },
+    { isActive: finished }
+  );
+  const mainWindowVisible = phase === "running" || phase === "awaitingInput" || phase === "error" || phase === "done";
+  const flexDirection = columns > 90 ? "row" : "column";
+  const showSidebar = flexDirection === "row";
+  return /* @__PURE__ */ jsxs9(
+    Box10,
+    {
+      backgroundColor: COLORS.bg.main,
+      flexDirection: "row",
+      width: columns,
+      minHeight: rows,
+      children: [
+        mainWindowVisible && /* @__PURE__ */ jsxs9(
+          Box10,
+          {
+            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: [
+                  "\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, {})
+            ]
+          }
+        ),
+        (phase === "idle" || phase === "preflight") && /* @__PURE__ */ jsx10(Welcome, {})
+      ]
+    }
+  );
+}
+
+// src/core/orchestrator.ts
+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");
+var DEFAULT_CONFIG = {
+  version: 1,
+  aiConsent: false,
+  workflowsRun: []
+};
+async function loadConfig() {
+  try {
+    const raw = await readFile2(configFile(), "utf8");
+    return { ...DEFAULT_CONFIG, ...JSON.parse(raw) };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+async function saveConfig(config) {
+  await mkdir2(stateDir(), { recursive: true });
+  await writeFile2(configFile(), JSON.stringify(config, null, 2), "utf8");
+}
+async function recordWorkflowRun(workflowId, completedAt) {
+  const config = await loadConfig();
+  config.workflowsRun.push({ 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";
+}
+function fireAndForget(promise) {
+  void promise.catch(() => {
+  });
+}
+function sendTelemetry(payload) {
+  if (!isTelemetryEnabled()) return;
+  const token = getAuthToken();
+  if (!token) return;
+  const body = {
+    env: process.env.DD_ENV ?? "development",
+    ...payload
+  };
+  fireAndForget(
+    proxyFetch(`${PROXY_BASE_URL}/telemetry`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        authorization: `Bearer ${token}`
+      },
+      body: JSON.stringify(body)
+    }).then((res) => {
+      if (!res.ok) {
+        throw new Error(`Proxy telemetry ${res.status}`);
+      }
+    })
+  );
+}
+function sendLog(status, message, attributes = {}, tags = []) {
+  sendTelemetry({
+    logs: [{ status, message, attributes, tags }]
+  });
+}
+function sendMetric(name, value, type, tags = []) {
+  sendTelemetry({
+    metrics: [{ name, value, type, tags }]
+  });
+}
+function metricTags(workflowId, actionId) {
+  return actionId ? [`workflow:${workflowId}`, `action:${actionId}`] : [`workflow:${workflowId}`];
+}
+function logTags(workflowId, actionId, appId) {
+  return [
+    ...metricTags(workflowId, actionId),
+    ...appId ? [`app_id:${appId}`] : []
+  ];
+}
+function emitTelemetryLog(level, message, attributes, tags) {
+  if (level === "info") {
+    logger.info(attributes, message);
+  } else {
+    logger.error(attributes, message);
+  }
+  sendLog(level, message, attributes, tags);
+}
+function trackWorkflowStart(ctx) {
+  const attributes = {
+    event: "wizard.workflow.start",
+    workflow_id: ctx.workflowId,
+    app_id: ctx.appId
+  };
+  emitTelemetryLog(
+    "info",
+    "wizard workflow started",
+    attributes,
+    logTags(ctx.workflowId, void 0, ctx.appId)
+  );
+  sendMetric("wizard.workflow.invocation", 1, 1, metricTags(ctx.workflowId));
+}
+function trackActionStart(ctx) {
+  const attributes = {
+    event: "wizard.action.start",
+    workflow_id: ctx.workflowId,
+    action_id: ctx.actionId,
+    action_title: ctx.actionTitle,
+    app_id: ctx.appId
+  };
+  emitTelemetryLog(
+    "info",
+    "wizard action started",
+    attributes,
+    logTags(ctx.workflowId, ctx.actionId, ctx.appId)
+  );
+}
+function trackActionEnd(ctx) {
+  const attributes = {
+    event: "wizard.action.end",
+    workflow_id: ctx.workflowId,
+    action_id: ctx.actionId,
+    action_title: ctx.actionTitle,
+    duration_ms: ctx.durationMs,
+    app_id: ctx.appId
+  };
+  emitTelemetryLog(
+    "info",
+    "wizard action completed",
+    attributes,
+    logTags(ctx.workflowId, ctx.actionId, ctx.appId)
+  );
+  sendMetric(
+    "wizard.action.invocation",
+    1,
+    1,
+    metricTags(ctx.workflowId, ctx.actionId)
+  );
+}
+function trackActionError(ctx) {
+  const attributes = {
+    event: "wizard.action.error",
+    workflow_id: ctx.workflowId,
+    action_id: ctx.actionId,
+    action_title: ctx.actionTitle,
+    error: ctx.error,
+    app_id: ctx.appId
+  };
+  emitTelemetryLog(
+    "error",
+    "wizard action failed",
+    attributes,
+    logTags(ctx.workflowId, ctx.actionId, ctx.appId)
+  );
+  sendMetric(
+    "wizard.action.error",
+    1,
+    1,
+    metricTags(ctx.workflowId, ctx.actionId)
+  );
+}
+function trackWizardComplete(event) {
+  const attributes = {
+    event: "wizard.workflow.complete",
+    workflow_id: event.workflowId,
+    app_id: event.appId,
+    total_duration: event.total_duration,
+    total_steps: event.total_steps
+  };
+  emitTelemetryLog(
+    "info",
+    "wizard workflow completed",
+    attributes,
+    logTags(event.workflowId, void 0, event.appId)
+  );
+}
+function trackWorkflowError(ctx) {
+  const attributes = {
+    event: "wizard.workflow.error",
+    workflow_id: ctx.workflowId,
+    action_id: ctx.actionId,
+    error: ctx.error,
+    app_id: ctx.appId
+  };
+  emitTelemetryLog(
+    "error",
+    "wizard workflow failed",
+    attributes,
+    logTags(ctx.workflowId, ctx.actionId, ctx.appId)
+  );
+}
+
+// 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 };
+}
+var nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
+function ensureExecutedStepCount(state) {
+  if (state.executedStepCount == null) {
+    state.executedStepCount = state.steps.filter(
+      (s) => s.status === "done" && isStepVisible(s)
+    ).length;
+  }
+}
+function reconcileWorkflowState(state, workflow2) {
+  const persistedIds = state.steps.map((s) => s.id).join("\n");
+  const definedIds = workflow2.steps.map((s) => s.id).join("\n");
+  if (persistedIds !== definedIds) return null;
+  for (let i = 0; i < state.steps.length; i++) {
+    state.steps[i].title = workflow2.steps[i].title;
+    state.steps[i].visible = workflow2.steps[i].visible;
+  }
+  return state;
+}
+function initWorkflowState(workflow2, now) {
+  return {
+    workflowId: workflow2.id,
+    startedAt: now,
+    updatedAt: now,
+    currentStepIndex: 0,
+    steps: workflow2.steps.map((s) => ({
+      id: s.id,
+      title: s.title,
+      visible: s.visible,
+      status: "pending"
+    })),
+    algoliaState: {},
+    userInputs: {}
+  };
+}
+async function ensureConsent() {
+  const config = await loadConfig();
+  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",
+    options: []
+  });
+  if (typeof answer !== "string" || answer.trim().toLowerCase() !== "yes") {
+    throw new Error("AI consent declined \u2014 cannot proceed.");
+  }
+  config.aiConsent = true;
+  await saveConfig(config);
+}
+async function makeContext(state) {
+  const outputs = {};
+  const completedSteps = [];
+  for (const s of state.steps) {
+    if (s.status === "done") {
+      outputs[s.id] = s.output;
+      if (s.visible) {
+        completedSteps.push({ id: s.id, title: s.title, output: s.output });
+      }
+    }
+  }
+  return {
+    outputs,
+    completedSteps,
+    getStepOutput: (stepId) => outputs[stepId],
+    requestUserInput: (prompt) => useWizard.getState().requestUserInput(prompt),
+    updateAlgoliaState: (key, value) => {
+      state.algoliaState[key] = value;
+    },
+    setUserInput: (key, value) => {
+      state.userInputs[key] = value;
+    },
+    recordStepExecution: (count = 1) => {
+      state.executedStepCount = (state.executedStepCount ?? 0) + count;
+    },
+    config: await loadConfig()
+  };
+}
+async function runStep(state, index, step, appId) {
+  const store2 = useWizard.getState();
+  const record = state.steps[index];
+  const startedAt = Date.now();
+  trackActionStart({
+    workflowId: state.workflowId,
+    appId,
+    actionId: step.id,
+    actionTitle: step.title
+  });
+  record.status = "running";
+  state.currentStepIndex = index;
+  if (step.visible) {
+    state.executedStepCount = (state.executedStepCount ?? 0) + 1;
+  }
+  state.updatedAt = nowIso();
+  store2.setActiveStep(index);
+  store2.syncSteps([...state.steps], index);
+  await saveWorkflowState(state);
+  const ctx = await makeContext(state);
+  const raw = await step.run(ctx);
+  const output = step.outputSchema.parse(raw);
+  await step.onStepComplete?.(output, ctx);
+  record.status = "done";
+  record.output = output;
+  state.updatedAt = nowIso();
+  store2.syncSteps([...state.steps], index);
+  await saveWorkflowState(state);
+  trackActionEnd({
+    workflowId: state.workflowId,
+    appId,
+    actionId: step.id,
+    actionTitle: step.title,
+    durationMs: Date.now() - startedAt
+  });
+}
+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);
+    store2.startWorkflow(
+      {
+        id: workflow2.id,
+        title: workflow2.title,
+        description: workflow2.description
+      },
+      [...state.steps]
+    );
+    trackWorkflowStart({ workflowId: workflow2.id, appId });
+    for (let i = state.currentStepIndex; i < workflow2.steps.length; i++) {
+      await runStep(state, i, workflow2.steps[i], appId);
+    }
+    const totalDurationMs = Date.now() - Date.parse(state.startedAt);
+    const stepCount = state.executedStepCount ?? state.steps.filter((s) => s.status === "done" && isStepVisible(s)).length;
+    trackWizardComplete({
+      workflowId: workflow2.id,
+      appId,
+      total_duration: Math.round(totalDurationMs / 1e3),
+      total_steps: stepCount
+    });
+    track("AI Wizard Complete", {
+      total_duration_ms: totalDurationMs,
+      step_count: stepCount
+    });
+    await recordWorkflowRun(workflow2.id, nowIso());
+    await clearWorkflowState(workflow2.id);
+    store2.setDone();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const state = await loadWorkflowState(workflow2.id);
+    let step = "unknown";
+    let failedActionId;
+    let failedActionTitle;
+    if (state) {
+      const record = state.steps[state.currentStepIndex];
+      if (record) {
+        step = record.title;
+        if (record.status === "running") {
+          record.status = "error";
+          record.error = message;
+          await saveWorkflowState(state);
+          store2.syncSteps([...state.steps], state.currentStepIndex);
+        }
+        failedActionId = record.id;
+        failedActionTitle = record.title;
+      }
+    }
+    if (failedActionId && failedActionTitle) {
+      trackActionError({
+        workflowId: workflow2.id,
+        appId,
+        actionId: failedActionId,
+        actionTitle: failedActionTitle,
+        error: message
+      });
+    }
+    trackWorkflowError({
+      workflowId: workflow2.id,
+      appId,
+      error: message,
+      actionId: failedActionId
+    });
+    track("Error", {
+      step,
+      error: message,
+      product_area: "AI Wizard"
+    });
+    store2.setError(message);
+  }
+}
+
+// src/lib/algoliaProfile.ts
+import { readFile as readFile3 } from "node:fs/promises";
+import { createRequire as createRequire2 } from "node:module";
+import { homedir as homedir2 } from "node:os";
+import { join as join6 } from "node:path";
+import { parse as parseToml } from "toml";
+var require3 = createRequire2(import.meta.url);
+function configPath() {
+  const base = process.env.XDG_CONFIG_HOME || join6(homedir2(), ".config");
+  return join6(base, "algolia", "config.toml");
+}
+function profilesFromConfig(tomlText) {
+  let parsed;
+  try {
+    parsed = parseToml(tomlText);
+  } catch {
+    return [];
+  }
+  const profiles = Object.entries(parsed).filter(
+    ([, t]) => typeof t.application_id === "string" && typeof t.api_key === "string"
+  ).map(([name, t]) => ({
+    name,
+    appId: t.application_id,
+    apiKey: t.api_key,
+    isDefault: t.default === true
+  }));
+  profiles.sort((a, b) => Number(b.isDefault) - Number(a.isDefault));
+  return profiles.map(({ name, appId, apiKey }) => ({ name, appId, apiKey }));
+}
+async function loadActiveProfile() {
+  let profiles;
+  try {
+    profiles = profilesFromConfig(await readFile3(configPath(), "utf8"));
+  } catch {
+    profiles = [];
+  }
+  const profile2 = profiles[0];
+  if (!profile2) {
+    throw new Error(
+      "No Algolia profile is configured. Run `npx @algolia/cli auth login` to authenticate."
+    );
+  }
+  return profile2;
+}
+
+// src/workflows/default.ts
+import { z as z24 } from "zod";
+
+// src/actions/listIndices.ts
+import { z as z3 } from "zod";
+var indicesListSchema = z3.object({
+  items: z3.array(
+    z3.object({
+      name: z3.string(),
+      entries: z3.number().default(0)
+    })
+  )
+});
+async function listIndices() {
+  const stdout = await runAlgoliaCli(["indices", "list", "-o", "json"]);
+  const { items } = indicesListSchema.parse(JSON.parse(stdout));
+  return items.map((i) => ({ name: i.name, entries: i.entries })).sort((a, b) => a.name.localeCompare(b.name));
+}
+
+// src/actions/selectIndex.ts
+var CREATE_NEW_INDEX = "Create a new index\u2026";
+var selectIndexStep = async (ctx) => {
+  const indices = await listIndices();
+  const names = indices.map((i) => i.name);
+  const hasIndices = names.length > 0;
+  let error;
+  for (; ; ) {
+    const selection = hasIndices ? await ctx.requestUserInput({
+      prompt: "Which index do you want to ingest into?",
+      promptType: "multipleChoice",
+      options: [...names, CREATE_NEW_INDEX],
+      messages: ["We found these indices:"],
+      error
+    }) : await ctx.requestUserInput({
+      prompt: "Name the index to create and ingest into:",
+      promptType: "textInput",
+      options: [],
+      messages: [
+        "This app has no existing indices \u2014 enter a name to create one."
+      ],
+      error
+    });
+    if (typeof selection !== "string") {
+      throw new Error("selectIndex received an unexpected non-text result");
+    }
+    let chosen;
+    if (!hasIndices) {
+      chosen = selection.trim();
+    } else if (selection === CREATE_NEW_INDEX) {
+      const name = await ctx.requestUserInput({
+        prompt: "Name the new index:",
+        promptType: "textInput",
+        options: []
+      });
+      if (typeof name !== "string") {
+        throw new Error("selectIndex received an unexpected non-text result");
+      }
+      chosen = name.trim();
+    } else {
+      chosen = selection;
+    }
+    if (!chosen) {
+      error = "Index name cannot be empty.";
+      continue;
+    }
+    ctx.setUserInput("index", chosen);
+    return { selection: chosen };
+  }
+};
+
+// src/lib/agent.ts
+import { ToolLoopAgent, hasToolCall, Output as Output2 } from "ai";
+import { createAnthropic as createAnthropic2 } from "@ai-sdk/anthropic";
+import "zod";
+
+// src/lib/tools/index.ts
+import "zod";
+
+// src/lib/tools/listFiles.ts
+import { tool } from "ai";
+import z4 from "zod";
+import { readdir } from "node:fs/promises";
+
+// src/lib/tools/path.ts
+import { lstat } from "node:fs/promises";
+import { resolve as resolve2, relative, isAbsolute, dirname as dirname3, join as join7, sep } from "node:path";
+function resolveInRoot(ctx, path) {
+  const target = resolve2(ctx.cwd, path);
+  const rel = relative(ctx.root, target);
+  if (rel.startsWith("..") || isAbsolute(rel)) {
+    return {
+      ok: false,
+      error: `Refused: ${target} is outside the repo root (${ctx.root}).`
+    };
+  }
+  return { ok: true, target };
+}
+async function hasSymlinkParent(ctx, target) {
+  let current = ctx.root;
+  const parts = relative(ctx.root, dirname3(target)).split(sep).filter(Boolean);
+  for (const part of parts) {
+    current = join7(current, part);
+    try {
+      if ((await lstat(current)).isSymbolicLink()) return true;
+    } catch (err) {
+      if (err.code === "ENOENT") return false;
+      throw err;
+    }
+  }
+  return false;
+}
+
+// src/lib/tools/listFiles.ts
+function listFilesTool(ctx) {
+  return tool({
+    description: "List files in the current working directory",
+    inputSchema: z4.object(),
+    execute: async () => {
+      logger.info("called listFiles tool");
+      if (++ctx.counts.list > ctx.limits.list) {
+        return `Refused: list limit (${ctx.limits.list}) reached. Stop listing and proceed with the information you already have.`;
+      }
+      const resolved = resolveInRoot(ctx, ".");
+      if (!resolved.ok) return resolved.error;
+      const entries = await readdir(resolved.target, { withFileTypes: true });
+      return entries.map((e) => e.isDirectory() ? `${e.name}/` : e.name).join("\n");
+    }
+  });
+}
+
+// src/lib/tools/changeDirectory.ts
+import { tool as tool2 } from "ai";
+import z5 from "zod";
+import { stat } from "node:fs/promises";
+function changeDirectoryTool(ctx) {
+  return tool2({
+    description: "Change the current working directory. Subsequent file operations resolve relative to it. Returns the new working directory.",
+    inputSchema: z5.object({
+      path: z5.string().describe("Directory to change into")
+    }),
+    execute: async ({ path }) => {
+      logger.info({ path }, "called changeDirectory tool");
+      const resolved = resolveInRoot(ctx, path);
+      if (!resolved.ok) return resolved.error;
+      try {
+        const info = await stat(resolved.target);
+        if (!info.isDirectory()) {
+          return `Error changing directory to ${path}: not a directory`;
+        }
+        ctx.cwd = resolved.target;
+        return `Changed working directory to ${ctx.cwd}`;
+      } catch (err) {
+        return `Error changing directory to ${path}: ${err.message}`;
+      }
+    }
+  });
+}
+
+// src/lib/tools/reportStatus.ts
+import { tool as tool3 } from "ai";
+import z6 from "zod";
+function reportStatusTool(output) {
+  return tool3({
+    description: "Report the status of your execution. Return a reason in case of failure.",
+    inputSchema: z6.object({
+      status: z6.enum(["success", "fail"]),
+      reason: z6.string().optional(),
+      output
+    }),
+    execute: async ({ status, reason, output: output2 }) => {
+      logger.info({ status, reason }, "called reportStatus tool");
+      return { status, reason, output: output2 };
+    }
+  });
+}
+
+// src/lib/tools/readFile.ts
+import { tool as tool4 } from "ai";
+import z7 from "zod";
+import { readFile as readFile4 } from "node:fs/promises";
+
+// src/lib/tools/env.ts
+import { basename } from "node:path";
+function isEnvFile(filePath) {
+  const name = basename(filePath);
+  return name === ".env" || name.startsWith(".env.");
+}
+function isSecretEnvFile(filePath) {
+  if (!isEnvFile(filePath)) return false;
+  const name = basename(filePath);
+  return !/\.(example|sample|template)$/.test(name);
+}
+
+// src/lib/tools/readFile.ts
+function redactEnvValues(content) {
+  return content.split("\n").map((line) => {
+    const match = line.match(/^(\s*(?:export\s+)?[\w.-]+\s*=)(.*)$/);
+    if (!match) return line;
+    const value = match[2].trim();
+    if (value === "") return line;
+    return `${match[1]}[REDACTED]`;
+  }).join("\n");
+}
+function readFileTool(ctx) {
+  return tool4({
+    description: "Read the contents of a file at the given path",
+    inputSchema: z7.object({
+      filePath: z7.string().describe("Path to the file to read")
+    }),
+    execute: async ({ filePath }) => {
+      if (++ctx.counts.read > ctx.limits.read) {
+        return `Refused: read limit (${ctx.limits.read}) reached. Stop reading and proceed with the information you already have.`;
+      }
+      logger.info({ filePath }, "called readFile tool");
+      const resolved = resolveInRoot(ctx, filePath);
+      if (!resolved.ok) return resolved.error;
+      try {
+        const content = await readFile4(resolved.target, "utf8");
+        return isEnvFile(resolved.target) ? redactEnvValues(content) : content;
+      } catch (err) {
+        return `Error reading ${filePath}: ${err.message}`;
+      }
+    }
+  });
+}
+
+// src/lib/tools/writeFile.ts
+import { tool as tool5 } from "ai";
+import z8 from "zod";
+import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname4 } from "node:path";
+function writeFileTool(ctx) {
+  return tool5({
+    description: "Write content to a file at the given path, overwriting it. To set Algolia credentials in an env file, use writeCredentials instead of this tool.",
+    inputSchema: z8.object({
+      filePath: z8.string().describe("Path to the file to write"),
+      content: z8.string().describe("Content to write to the file")
+    }),
+    execute: async ({ filePath, content }) => {
+      logger.info({ filePath }, "called writeFile tool");
+      const resolved = resolveInRoot(ctx, filePath);
+      if (resolved.ok === false) return resolved.error;
+      if (isSecretEnvFile(resolved.target)) {
+        return `Refused: ${filePath} holds secrets. Use the writeCredentials tool to set Algolia environment variables, passing this file path.`;
+      }
+      try {
+        if (await hasSymlinkParent(ctx, resolved.target)) {
+          return `Refused: ${resolved.target} is outside the repo root (${ctx.root}).`;
+        }
+        await mkdir3(dirname4(resolved.target), { recursive: true });
+        await writeFile3(resolved.target, content, "utf8");
+        return `Wrote to ${filePath}`;
+      } catch (err) {
+        return `Error writing ${filePath}: ${err.message}`;
+      }
+    }
+  });
+}
+
+// src/lib/tools/writeAlgoliaCredentials.ts
+import { tool as tool6 } from "ai";
+import z9 from "zod";
+import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile4 } from "node:fs/promises";
+import { dirname as dirname5 } from "node:path";
+var APP_ID_VAR = "ALGOLIA_APPLICATION_ID";
+var API_KEY_VAR = "ALGOLIA_WRITE_API_KEY";
+function appendEnv(content, entries) {
+  const prefix = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
+  const lines = entries.map(([name, value]) => `${name}=${value}
+`).join("");
+  return content + prefix + lines;
+}
+function hasEnv(content, name) {
+  return new RegExp(`^(\\s*(?:export\\s+)?${name})\\s*=`, "m").test(content);
+}
+function writeCredentialsTool(ctx) {
+  return tool6({
+    description: `Write the active Algolia credentials (${APP_ID_VAR} and ${API_KEY_VAR}) into the given env file. The credentials are read from the local Algolia CLI profile; you only pass the path to the env file (e.g. ".env"). If the file already defines ${APP_ID_VAR} or ${API_KEY_VAR}, the write is skipped and existing values are left untouched.`,
+    inputSchema: z9.object({
+      filePath: z9.string().describe(
+        'Path to the env file to write credentials into (e.g. ".env")'
+      )
+    }),
+    execute: async ({ filePath }) => {
+      logger.info({ filePath }, "called writeCredentials tool");
+      const resolved = resolveInRoot(ctx, filePath);
+      if (resolved.ok === false) return resolved.error;
+      let profile2;
+      try {
+        profile2 = await loadActiveProfile();
+      } catch {
+        return "Error: no Algolia profile is configured, so credentials cannot be written. Ask the user to authenticate with the Algolia CLI first.";
+      }
+      try {
+        if (await hasSymlinkParent(ctx, resolved.target)) {
+          return `Refused: ${resolved.target} is outside the repo root (${ctx.root}).`;
+        }
+        let existing = "";
+        try {
+          existing = await readFile5(resolved.target, "utf8");
+        } catch (err) {
+          if (err.code !== "ENOENT") throw err;
+        }
+        const present = [APP_ID_VAR, API_KEY_VAR].filter(
+          (name) => hasEnv(existing, name)
+        );
+        if (present.length > 0) {
+          return `Skipped: ${filePath} already defines ${present.join(" and ")}. Leaving existing credentials untouched.`;
+        }
+        const envWithCredentials = appendEnv(existing, [
+          [APP_ID_VAR, profile2.appId],
+          [API_KEY_VAR, profile2.apiKey]
+        ]);
+        await mkdir4(dirname5(resolved.target), { recursive: true });
+        await writeFile4(resolved.target, envWithCredentials, "utf8");
+        return `Wrote Algolia credentials to ${filePath}`;
+      } catch (err) {
+        return `Error writing credentials to ${filePath}: ${err.message}`;
+      }
+    }
+  });
+}
+
+// src/lib/tools/searchFiles.ts
+import { tool as tool7 } from "ai";
+import z10 from "zod";
+import { readdir as readdir2, readFile as readFile6 } from "node:fs/promises";
+import { join as join8 } from "node:path";
+var MAX_QUERY_LENGTH = 1e3;
+async function walkFiles(dir) {
+  const skip = /* @__PURE__ */ new Set(["node_modules", ".git", "dist"]);
+  const out = [];
+  for (const e of await readdir2(dir, { withFileTypes: true })) {
+    if (e.name.startsWith(".") || skip.has(e.name)) continue;
+    const full = join8(dir, e.name);
+    if (e.isDirectory()) out.push(...await walkFiles(full));
+    else if (e.isFile()) out.push(full);
+  }
+  return out;
+}
+function searchFilesTool(ctx) {
+  return tool7({
+    description: "Search file contents for a JavaScript regular expression (RegExp syntax, not grep/PCRE). Returns matching lines as file:line:text.",
+    inputSchema: z10.object({
+      query: z10.string().describe("JavaScript RegExp pattern to search for"),
+      path: z10.string().optional().describe("Directory to search in (default: cwd)")
+    }),
+    execute: async ({ query, path = "." }) => {
+      logger.info({ query, path }, "called searchFiles tool");
+      if (++ctx.counts.search > ctx.limits.search) {
+        return `Refused: search limit (${ctx.limits.search}) reached. Stop searching and proceed with the information you already have.`;
+      }
+      if (query.length > MAX_QUERY_LENGTH) {
+        return `Refused: query exceeds ${MAX_QUERY_LENGTH} characters. Use a shorter pattern.`;
+      }
+      const resolved = resolveInRoot(ctx, path);
+      if (!resolved.ok) return resolved.error;
+      let re;
+      try {
+        re = new RegExp(query);
+      } catch (err) {
+        return `Invalid regex: ${err.message}`;
+      }
+      const matches = [];
+      for (const file of await walkFiles(resolved.target)) {
+        let content;
+        try {
+          content = await readFile6(file, "utf8");
+        } catch {
+          continue;
+        }
+        const lines = content.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+          if (re.test(lines[i])) {
+            matches.push(`${file}:${i + 1}:${lines[i]}`);
+            if (matches.length >= ctx.limits.match) {
+              matches.push(`... (truncated at ${ctx.limits.match} matches)`);
+              return matches.join("\n");
+            }
+          }
+        }
+      }
+      return matches.length ? matches.join("\n") : "No matches";
+    }
+  });
+}
+
+// src/lib/tools/verifyImplementation.ts
+import { tool as tool8 } from "ai";
+import z11 from "zod";
+
+// src/lib/tools/utils/runCommand.ts
+import { spawn as spawn2 } from "node:child_process";
+function runCommand(command, args, cwd) {
+  return new Promise((resolve4) => {
+    let output = "";
+    const child = spawn2(command, args, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    child.stdout?.on("data", (d) => output += d);
+    child.stderr?.on("data", (d) => output += d);
+    child.on(
+      "error",
+      (err) => resolve4({ code: 1, output: `Failed to run ${command}: ${err.message}` })
+    );
+    child.on("close", (code) => resolve4({ code: code ?? 1, output }));
+  });
+}
+
+// src/lib/tools/utils/packageManager.ts
+import { readFile as readFile7 } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join as join9 } from "node:path";
+var LOCKFILES = [
+  ["pnpm-lock.yaml", "pnpm"],
+  ["yarn.lock", "yarn"],
+  ["bun.lockb", "bun"],
+  ["bun.lock", "bun"],
+  ["package-lock.json", "npm"]
+];
+async function readPackageJson(cwd = process.cwd()) {
+  return JSON.parse(await readFile7(join9(cwd, "package.json"), "utf8"));
+}
+function packageManagerFrom(pkg) {
+  return pkg.packageManager?.split("@")[0] ?? "npm";
+}
+function packageManagerFromLockfile(cwd) {
+  return LOCKFILES.find(([file]) => existsSync(join9(cwd, file)))?.[1];
+}
+async function detectPackageManager(cwd) {
+  try {
+    const pkg = await readPackageJson(cwd);
+    if (pkg.packageManager) return packageManagerFrom(pkg);
+  } catch {
+  }
+  return packageManagerFromLockfile(cwd) ?? "npm";
+}
+
+// src/lib/tools/repoVerification.ts
+var VERIFICATION_SCRIPT_CANDIDATES = ["lint", "typecheck", "check"];
+async function runRepoVerificationCheck() {
+  let pkg;
+  try {
+    pkg = await readPackageJson();
+  } catch (err) {
+    const limitation = `Could not read package.json to detect verification conventions: ${err.message}`;
+    return { ok: false, checks: [], limitation };
+  }
+  const scripts = pkg.scripts ?? {};
+  const present = VERIFICATION_SCRIPT_CANDIDATES.filter((s) => s in scripts);
+  if (present.length === 0) {
+    const limitation = `No verification script found in package.json (looked for: ${VERIFICATION_SCRIPT_CANDIDATES.join(", ")}).`;
+    return { ok: false, checks: [], limitation };
+  }
+  const pm = await detectPackageManager(process.cwd());
+  const checks = [];
+  for (const script of present) {
+    const command = `${pm} run ${script}`;
+    const { code, output } = await runCommand(pm, ["run", script]);
+    checks.push({ command, exitCode: code, ok: code === 0, output: output.trim() });
+  }
+  return { ok: checks.every((c) => c.ok), checks };
+}
+
+// src/lib/tools/verifyImplementation.ts
+function verifyImplementationTool() {
+  return tool8({
+    description: "Run the repo's mechanical verification check for generated implementation changes. Detects lint/typecheck/check from package.json and returns structured pass/fail evidence for the verifier to interpret.",
+    inputSchema: z11.object(),
+    execute: async () => {
+      logger.info("called verifyImplementation tool");
+      return runRepoVerificationCheck();
+    }
+  });
+}
+
+// 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 z12 from "zod";
+var RECORD_MODEL = "claude-haiku-4-5";
+var MAX_RECORDS = 100;
+var BATCH_SIZE = 10;
+var MAX_BATCH_ATTEMPTS = 3;
+var anthropic = createAnthropic({
+  apiKey: process.env.PROVIDER_API_KEY ?? ""
+});
+function generateRecordTool() {
+  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.",
+    inputSchema: z12.object({
+      entityName: z12.string().describe("Name of the entity to generate records for."),
+      attributes: z12.array(z12.string()).describe("Attribute names each record must contain."),
+      count: z12.number().int().min(1).max(MAX_RECORDS).default(10).describe(`How many records to generate (max ${MAX_RECORDS}).`),
+      hint: z12.string().optional().describe("Optional context to steer realistic values.")
+    }),
+    execute: async ({ entityName, attributes, count, hint }) => {
+      logger.info({ entityName, count }, "called generateRecord tool");
+      try {
+        const value = z12.union([z12.string(), z12.number(), z12.boolean(), z12.null()]);
+        const recordSchema = z12.object(
+          Object.fromEntries(attributes.map((attr) => [attr, value]))
+        );
+        const generateBatch = async (batchCount) => {
+          let lastError;
+          for (let attempt = 1; attempt <= MAX_BATCH_ATTEMPTS; attempt++) {
+            try {
+              const { output } = await generateText({
+                model: anthropic(RECORD_MODEL),
+                output: Output.object({
+                  schema: z12.object({
+                    records: z12.array(recordSchema).length(batchCount)
+                  })
+                }),
+                prompt: [
+                  `Generate ${batchCount} realistic, varied sample records for the "${entityName}" entity.`,
+                  hint ? `Context: ${hint}` : "",
+                  // Batches run concurrently with identical prompts, so each call
+                  // 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.`
+                ].filter(Boolean).join("\n")
+              });
+              return output.records;
+            } catch (err) {
+              if (!NoObjectGeneratedError.isInstance(err)) throw err;
+              lastError = err;
+              logger.warn(
+                { entityName, batchCount, attempt, err },
+                "generateRecord batch failed schema validation, retrying"
+              );
+            }
+          }
+          throw lastError;
+        };
+        const batchSizes = [];
+        for (let remaining = count; remaining > 0; remaining -= BATCH_SIZE) {
+          batchSizes.push(Math.min(BATCH_SIZE, remaining));
+        }
+        const batches = await Promise.all(batchSizes.map(generateBatch));
+        const records = batches.flat().map((record) => ({
+          ...record,
+          objectID: nanoid()
+        }));
+        logger.info(records);
+        return { records };
+      } catch (err) {
+        return `Error generating records: ${err.message}`;
+      }
+    }
+  });
+}
+
+// src/lib/tools/context.ts
+var DEFAULT_TOOL_LIMITS = {
+  list: 10,
+  search: 10,
+  read: 20,
+  match: 100
+};
+function createToolContext(limits = DEFAULT_TOOL_LIMITS, cwd = process.cwd()) {
+  return {
+    root: cwd,
+    cwd,
+    limits,
+    counts: { list: 0, search: 0, read: 0 }
+  };
+}
+
+// src/lib/tools/index.ts
+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()
+  };
+  if (!tools) return all;
+  const selection = /* @__PURE__ */ new Set([...tools, "reportStatus"]);
+  return Object.fromEntries(
+    Object.entries(all).filter(([name]) => selection.has(name))
+  );
+}
+var FS_READ_TOOLS = [
+  "listFiles",
+  "changeDirectory",
+  "readFile",
+  "searchFiles"
+];
+
+// src/lib/agent.ts
+var MODEL_BY_SIZE = {
+  small: "claude-haiku-4-5",
+  medium: "claude-sonnet-4-6",
+  large: "claude-opus-4-8"
+};
+async function runAgent(req) {
+  const start = Date.now();
+  logger.info({ startedAt: new Date(start).toISOString() }, "runAgent started");
+  const token = getAuthToken();
+  if (!token) {
+    throw new Error("Not authenticated: no user token available");
+  }
+  const anthropic2 = createAnthropic2({
+    apiKey: token,
+    baseURL: PROXY_BASE_URL,
+    fetch: proxyFetch
+  });
+  const toolContext = createToolContext();
+  const readTools = ["readFile", "searchFiles", "listFiles"];
+  const hasReadTools = !req.tools || req.tools.some((t) => readTools.includes(t));
+  const instructions = hasReadTools ? [
+    ...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;
+  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) => {
+      return {
+        role: "system",
+        content: i,
+        ...idx === arr.length - 1 && {
+          providerOptions: {
+            anthropic: { cacheControl: { type: "ephemeral" } }
+          }
+        }
+      };
+    }),
+    output: Output2.object({ schema: req.outputSchema }),
+    tools: createTools(toolContext, {
+      output: req.outputSchema,
+      tools: req.tools
+    }),
+    toolChoice: "required",
+    stopWhen: [hasToolCall("reportStatus")]
+  });
+  const stream = await agent.stream({
+    prompt: "Follow system instructions"
+  });
+  let chunks = [];
+  const chunkLimit = 5;
+  for await (const chunk of stream.textStream) {
+    if (chunks.length < chunkLimit) {
+      chunks.push(chunk);
+      continue;
+    }
+    chunks.push(chunk);
+    logger.debug(chunks.join(""));
+    chunks = [];
+  }
+  if (chunks.length) {
+    logger.debug(chunks.join(""));
+  }
+  const end = Date.now();
+  const usage = await stream.totalUsage;
+  logger.info(
+    {
+      finishedAt: new Date(end).toISOString(),
+      durationMs: end - start,
+      // cachedInputTokens > 0 confirms prompt caching engaged. If it stays 0
+      // across turns, the tools+system prefix is under the model's min
+      // cacheable size (2048 tokens for sonnet-4-6) and caching is a no-op.
+      usage
+    },
+    "runAgent finished"
+  );
+  logger.info(
+    { counts: toolContext.counts, limits: toolContext.limits },
+    "tool usage"
+  );
+  const toolResults = await stream.toolResults;
+  const report = [...toolResults].reverse().find((r) => r.toolName === "reportStatus");
+  if (!report) {
+    throw new Error("Agent finished without calling reportStatus");
+  }
+  const result = report.output;
+  if (result.status !== "success") {
+    throw new Error(
+      `Agent reported failure: ${result.reason ?? "no reason given"}`
+    );
+  }
+  return result.output;
+}
+
+// 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() }))
+});
+var detectLanguage = () => runAgent({
+  instructions: [
+    "Analyze the codebase and determine the programming languages and frameworks used",
+    "If a superset language is found, exclude the subset language. TS-over-JS.",
+    "If a meta-framework is used, exclude the framework. Next-over-React.",
+    "Return the exact version",
+    "Exclude things like CSS frameworks, build tools, or testing frameworks",
+    'Use as few tools as possible, but do not guess. If you cant find the answer, say "unknown"',
+    "When done, call reportStatus"
+  ],
+  tools: ["listFiles", "changeDirectory", "readFile", "searchFiles"],
+  outputSchema: detectLanguageSchema,
+  modelSize: "small"
+});
+
+// src/actions/analyzeCodebase.ts
+import z16 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()),
+      // indexable fields the agent found for this entity
+      attributes: z16.array(z16.string())
+    })
+  )
+});
+var searchImplementationAnalysisSchema = z16.object({
+  searchImplementationAnalysis: z16.string()
+});
+var verificationSchema = z16.object({
+  verification: z16.array(z16.string())
+});
+var confirmedEntitiesFieldSchema = ingestionAnalysisSchema.shape.ingestionAnalysis.optional();
+var analyzeCodebaseSchema = z16.object({
+  ingestionAnalysis: ingestionAnalysisSchema.shape.ingestionAnalysis.optional(),
+  searchImplementationAnalysis: searchImplementationAnalysisSchema.shape.searchImplementationAnalysis.optional(),
+  verification: verificationSchema.shape.verification.optional(),
+  confirmedEntities: confirmedEntitiesFieldSchema
+});
+var toEntitySummary = (entities) => entities.map((e) => ({ name: e.name, attributes: e.attributes }));
+var MODE_CONFIG = {
+  ingestion: {
+    instructions: [
+      "Analyze the codebase to find the data entities (models) that should be ingested into Algolia.",
+      "For each entity, return its name, the file path(s) where it is defined, and its indexable attribute keys (the fields a user would search or filter on).",
+      "Inspect the source of each entity to extract real field names for attributes \u2014 do not guess or leave attributes empty.",
+      "Prefer domain models (e.g. Document, Product, User) over framework or infrastructure types.",
+      "Use as few tools as possible, but do not guess. If you cannot find any entities, return an empty array.",
+      "Ignore directories that may be related to testing, like `/fixtures`, `/tests`, etc",
+      "When done, call reportStatus"
+    ],
+    outputSchema: ingestionAnalysisSchema
+  },
+  searchImplementation: {
+    instructions: [
+      "Analyze the codebase to determine the single best location to add search UI functionality.",
+      "Prefer a shared, always-rendered layout location (e.g. a header or navigation component) so search is reachable across the app.",
+      "Return one file path as searchImplementationAnalysis (e.g. /layouts/header.tsx).",
+      'Use as few tools as possible, but do not guess. If you cannot find a clear location, say "unknown".',
+      "Ignore directories that may be related to testing, like `/fixtures`, `/tests`, etc",
+      "When done, call reportStatus"
+    ],
+    outputSchema: searchImplementationAnalysisSchema
+  },
+  verification: {
+    instructions: [
+      "Analyze the codebase to determine which code-quality tools are available to validate changes.",
+      "Look at package.json scripts, config files (e.g. .eslintrc, tsconfig, prettier), and dev dependencies.",
+      'Return the tool names as an array, e.g. ["eslint", "prettier", "tsc"].',
+      "Use as few tools as possible, but do not guess. If you cannot find any, return an empty array.",
+      "Ignore directories that may be related to testing, like `/fixtures`, `/tests`, etc",
+      "When done, call reportStatus"
+    ],
+    outputSchema: verificationSchema
+  }
+};
+function runMode(mode, extraInstructions = []) {
+  const { instructions, outputSchema } = MODE_CONFIG[mode];
+  return runAgent({
+    instructions: [...instructions, ...extraInstructions],
+    tools: READONLY_TOOLS,
+    outputSchema
+  });
+}
+async function runAnalysis(mode, extraInstructions = []) {
+  const modes = mode ? [mode] : ["ingestion", "searchImplementation", "verification"];
+  const results = await Promise.all(
+    modes.map((m) => runMode(m, extraInstructions))
+  );
+  return Object.assign({}, ...results);
+}
+
+// package.json
+var package_default = {
+  name: "@algolia/wizard",
+  version: "0.1.0",
+  description: "Magically implement Algolia functionality in your codebase",
+  type: "module",
+  engines: {
+    node: ">=24"
+  },
+  bin: {
+    wizard: "dist/main.js"
+  },
+  files: [
+    "dist",
+    "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",
+    dev: "touch .env && tsx --env-file=.env ./src/main.tsx",
+    "env:load": "pnpm exec -- varlock load",
+    prepare: "husky",
+    prepublishOnly: "pnpm build",
+    reset: "tsx ./scripts/reset-state.ts",
+    "test:fixtures": "touch .env && tsx --env-file=.env ./fixtures/run-fixtures.ts",
+    "test:tools": "tsx ./tool-evals/toolEval.ts",
+    test: "vitest",
+    typecheck: "tsc --noEmit -p tsconfig.json"
+  },
+  keywords: [],
+  author: "",
+  license: "ISC",
+  packageManager: "pnpm@11.9.0+sha512.bd682d5d03fe525ef7c9fd6780c6884d1e756ac4c9c9fe00c538782824310dcf90e3ddc4f53835f06dfaebd5085e41855e0bcbb3b60de2ac5bbab89e5036f03b",
+  devDependencies: {
+    "@clack/prompts": "^1.6.0",
+    "@types/ioredis-mock": "^8.2.7",
+    "@types/node": "^25.9.1",
+    "@types/react": "^19.2.16",
+    esbuild: "^0.28.0",
+    husky: "^9.1.7",
+    "ink-testing-library": "^4.0.0",
+    "ioredis-mock": "^8.13.1",
+    "lint-staged": "^17.0.8",
+    tsx: "^4.22.3",
+    typescript: "^6.0.3",
+    vitest: "^4.1.8"
+  },
+  dependencies: {
+    "@ai-sdk/anthropic": "^3.0.81",
+    "@ai-sdk/openai-compatible": "^2.0.47",
+    "@algolia/cli": "^5.11.0",
+    "@hono/node-server": "^2.0.10",
+    "@mishieck/ink-titled-box": "^0.4.2",
+    "@segment/analytics-node": "^3.1.0",
+    ai: "^6.0.190",
+    dotenv: "^17.4.2",
+    hono: "^4.12.27",
+    ink: "^7.0.5",
+    "ink-picture": "^2.1.0",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
+    ioredis: "^5.11.1",
+    nanoid: "^5.1.15",
+    pino: "^10.3.1",
+    react: "^19.2.7",
+    toml: "^4.1.1",
+    varlock: "^1.5.1",
+    zod: "^4.4.3",
+    zustand: "^5.0.14"
+  }
+};
+
+// src/actions/projectScan.ts
+import "zod";
+var projectScanSchema = detectLanguageSchema.extend({
+  ingestionAnalysis: analyzeCodebaseSchema.shape.ingestionAnalysis,
+  searchImplementationAnalysis: analyzeCodebaseSchema.shape.searchImplementationAnalysis,
+  verification: analyzeCodebaseSchema.shape.verification
+});
+async function projectScan(ctx) {
+  const [detected, analyses] = await Promise.all([
+    detectLanguage(),
+    runAnalysis()
+  ]);
+  track("AI Wizard Started", {
+    wizard_version: package_default.version,
+    os: process.platform
+  });
+  track("AI Wizard Scan Completed", {
+    entities: toEntitySummary(analyses.ingestionAnalysis ?? [])
+  });
+  for (const [key, value] of Object.entries(analyses)) {
+    ctx.setUserInput(key, value);
+  }
+  return { ...detected, ...analyses };
+}
+
+// src/actions/confirmStack.ts
+var MAX_FIELD_LEN = 80;
+var MAX_ENTRIES = 20;
+var clean = (s) => s.replace(/[\x00-\x1f\x7f]/g, " ").replace(/\s+/g, " ").trim().slice(0, MAX_FIELD_LEN);
+function parseEntries(raw) {
+  return raw.split(",").map(clean).filter(Boolean).slice(0, MAX_ENTRIES).map((name) => ({ name, version: "unknown" }));
+}
+var summarize = (entries) => entries.length ? entries.map((e) => e.name).join(", ") : "none";
+async function askList(ctx, prompt, { required = false } = {}) {
+  for (; ; ) {
+    const answer = await ctx.requestUserInput({
+      prompt,
+      promptType: "textInput",
+      options: [],
+      helpText: 'Comma-separated, e.g. "TypeScript, Node".'
+    });
+    if (typeof answer !== "string") {
+      throw new Error("askList received an unexpected non-text result");
+    }
+    const entries = parseEntries(answer);
+    if (entries.length || !required) return entries;
+    prompt = "Please enter at least one entry:";
+  }
+}
+
+// src/actions/confirmLanguage.ts
+import z18 from "zod";
+var confirmLanguageSchema = z18.object({
+  languages: detectLanguageSchema.shape.languages
+});
+async function confirmLanguage(ctx) {
+  const detected = ctx.getStepOutput("project-scan");
+  const answer = await ctx.requestUserInput({
+    prompt: "Did we detect your language(s) correctly?",
+    promptType: "acceptReject",
+    options: ["Yes", "No"],
+    messages: [`Languages: ${summarize(detected.languages)}`]
+  });
+  const languages = answer === true ? detected.languages : await askList(ctx, "List the languages your project uses:", {
+    required: true
+  });
+  track("AI Wizard Language Confirmed", {
+    languages
+  });
+  return { languages };
+}
+
+// src/actions/confirmFramework.ts
+import z19 from "zod";
+var confirmFrameworkSchema = z19.object({
+  frameworks: detectLanguageSchema.shape.frameworks
+});
+var CURATED_FRAMEWORKS = [
+  "Next.js",
+  "React",
+  "Vue",
+  "Angular",
+  "Svelte",
+  "Vanilla JS"
+];
+var OTHER_OPTION = "Other";
+var normalize = (s) => s.toLowerCase().replace(/[^a-z0-9]/g, "");
+var FRAMEWORK_ALIASES = {
+  next: "nextjs",
+  nextjs: "nextjs",
+  react: "react",
+  reactjs: "react",
+  vue: "vue",
+  vuejs: "vue",
+  angular: "angular",
+  angularjs: "angular",
+  svelte: "svelte",
+  sveltekit: "svelte",
+  vanillajs: "vanillajs",
+  vanilla: "vanillajs",
+  javascript: "vanillajs",
+  js: "vanillajs"
+};
+var isSameFramework = (a, b) => {
+  const x = FRAMEWORK_ALIASES[normalize(a)] ?? normalize(a);
+  const y = FRAMEWORK_ALIASES[normalize(b)] ?? normalize(b);
+  return x !== "" && x === y;
+};
+function confirmed(name, version) {
+  const frameworks = [{ name, version: version ?? "unknown" }];
+  track("AI Wizard Frontend Framework Confirmed", { frameworks });
+  return { frameworks };
+}
+async function askOtherFramework(ctx) {
+  let prompt = "enter your framework";
+  for (; ; ) {
+    const answer = await ctx.requestUserInput({
+      prompt,
+      promptType: "textInput",
+      options: []
+    });
+    if (typeof answer !== "string") {
+      throw new Error("confirmFramework received an unexpected non-text result");
+    }
+    const name = parseEntries(answer)[0]?.name;
+    if (name) return name;
+    prompt = "please enter a framework name:";
+  }
+}
+async function confirmFramework(ctx) {
+  const detected = ctx.getStepOutput("project-scan");
+  const detectedFrameworks = detected.frameworks ?? [];
+  const options = [...CURATED_FRAMEWORKS];
+  for (const fw of detectedFrameworks) {
+    if (!options.some((o) => isSameFramework(o, fw.name))) options.push(fw.name);
+  }
+  options.push(OTHER_OPTION);
+  const detectedFor = (option) => detectedFrameworks.find((fw) => isSameFramework(option, fw.name));
+  const primary = detectedFrameworks[0];
+  if (primary) {
+    const accepted = await ctx.requestUserInput({
+      prompt: `Use ${primary.name}?`,
+      promptType: "acceptReject",
+      options: [`Confirm ${primary.name}`, "Use a different framework"],
+      secondary: [{ kind: "badge", value: "[DETECTED]" }, void 0]
+    });
+    if (accepted === true) return confirmed(primary.name, primary.version);
+  }
+  const secondary = options.map(
+    (o) => detectedFor(o) ? { kind: "badge", value: "[DETECTED]" } : void 0
+  );
+  const defaultSelectedIndex = Math.max(
+    options.findIndex((o) => detectedFor(o)),
+    0
+  );
+  const selection = await ctx.requestUserInput({
+    prompt: "select a framework",
+    promptType: "multipleChoice",
+    options,
+    secondary,
+    defaultSelectedIndex
+  });
+  if (typeof selection !== "string") {
+    throw new Error("confirmFramework received an unexpected non-text result");
+  }
+  if (selection === OTHER_OPTION) {
+    return confirmed(await askOtherFramework(ctx));
+  }
+  return confirmed(selection, detectedFor(selection)?.version);
+}
+
+// src/actions/promptUser.ts
+async function promptUser(ctx, params) {
+  const {
+    workflowStateKey,
+    promptType,
+    promptContent,
+    table,
+    secondary,
+    cancelable,
+    onSubmit
+  } = params;
+  const question = promptContent.find((c) => c.type === "question")?.value ?? "";
+  const helpText = promptContent.find((c) => c.type === "helpText")?.value ?? "";
+  const messages = promptContent.filter((c) => c.type === "message").map((c) => c.value);
+  const options = promptContent.filter((c) => c.type === "option").map((c) => c.value);
+  const selection = await ctx.requestUserInput({
+    prompt: question,
+    promptType,
+    options,
+    messages,
+    table,
+    secondary,
+    cancelable,
+    helpText
+  });
+  ctx.setUserInput(workflowStateKey, selection);
+  onSubmit();
+  return selection;
+}
+
+// src/actions/confirmEntities.ts
+import z20 from "zod";
+var confirmEntitiesSchema = z20.object({
+  // Final detection — the focused re-run may supersede project-scan's.
+  ingestionAnalysis: ingestionAnalysisSchema.shape.ingestionAnalysis.optional(),
+  confirmedEntities: confirmedEntitiesFieldSchema
+});
+async function confirmEntities(ctx) {
+  const scan = ctx.getStepOutput("project-scan");
+  let entities = scan.ingestionAnalysis;
+  if (!entities?.length) {
+    const declared = await promptUser(ctx, {
+      workflowStateKey: "confirmedEntities",
+      promptType: "textInput",
+      promptContent: [
+        {
+          type: "message",
+          value: "We couldn't detect any entities to ingest in this codebase."
+        },
+        {
+          type: "question",
+          value: "Name an entity to search for (leave blank to cancel):"
+        }
+      ],
+      onSubmit: () => {
+      }
+    });
+    if (typeof declared !== "string" || declared.trim() === "") {
+      throw new Error("User declined to specify an entity \u2014 analysis halted.");
+    }
+    const declaredName = declared.trim();
+    ctx.setUserInput("confirmedEntities", [declaredName]);
+    const rerun = await runAnalysis("ingestion", [
+      `The user has confirmed the codebase contains an entity named "${declaredName}". Focus your search on locating this entity, the file path(s) where it is defined, and its indexable attribute keys.`
+    ]);
+    entities = rerun.ingestionAnalysis;
+    ctx.setUserInput("ingestionAnalysis", entities);
+    if (!entities?.length) {
+      throw new Error(
+        `Could not locate the "${declaredName}" entity in this codebase \u2014 analysis halted.`
+      );
+    }
+  }
+  const selection = await promptUser(ctx, {
+    workflowStateKey: "confirmedEntities",
+    promptType: "multipleChoice",
+    // A Cancel row lets the user halt here (the single-select equivalent of the
+    // old multi-select Cancel); its 'cancel' sentinel matches no entity below.
+    cancelable: true,
+    secondary: entities.map((e) => ({
+      kind: "text",
+      value: e.attributes.join(", ") || "\u2014"
+    })),
+    promptContent: [
+      { type: "question", value: "Pick the entity to index" },
+      ...entities.map((e) => ({ type: "option", value: e.name }))
+    ],
+    onSubmit: () => {
+    }
+  });
+  const confirmed2 = typeof selection === "string" ? entities.filter((e) => e.name === selection) : [];
+  if (confirmed2.length === 0) {
+    throw new Error("User cancelled entity selection \u2014 analysis halted.");
+  }
+  ctx.setUserInput("confirmedEntities", confirmed2);
+  track("AI Wizard Entities Confirmed", {
+    entities: toEntitySummary(confirmed2)
+  });
+  return { ingestionAnalysis: entities, confirmedEntities: confirmed2 };
+}
+
+// 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())
+});
+function formatCompletedSteps(steps) {
+  if (!steps.length) return "(no prior steps completed)";
+  return steps.map(
+    (s) => `### ${s.title} (${s.id})
+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:
+${formatCompletedSteps(ctx.completedSteps)}`,
+    "When done, call reportStatus"
+  ],
+  tools: [],
+  outputSchema: reviewSchema,
+  modelSize: "small"
+});
+
+// src/actions/implement.ts
+import z23 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 {
+  basename as basename2,
+  dirname as dirname6,
+  isAbsolute as isAbsolute2,
+  join as join10,
+  relative as relative2,
+  resolve as resolve3
+} from "node:path";
+var MAX_BUFFER = 32 * 1024 * 1024;
+var MAX_WIZARD_WORKTREES = 3;
+var WIZARD_BRANCH_PREFIX = "wizard/implement-";
+function git(args) {
+  return new Promise((resolve4, reject) => {
+    execFile("git", args, { maxBuffer: MAX_BUFFER }, (err, stdout, stderr) => {
+      if (err)
+        return reject(
+          new Error(
+            `git ${args.join(" ")} failed: ${stderr.toString().trim() || err.message}`
+          )
+        );
+      resolve4(stdout.toString());
+    });
+  });
+}
+async function assertGitRepoWithHead(repoRoot) {
+  try {
+    await git(["-C", repoRoot, "rev-parse", "HEAD"]);
+  } catch {
+    throw new Error(
+      "implement requires a git repository with at least one commit. Initialize git and commit before running the wizard."
+    );
+  }
+}
+async function isWorkingTreeDirty(repoRoot) {
+  const out = await git(["-C", repoRoot, "status", "--porcelain"]);
+  return out.trim().length > 0;
+}
+async function pruneOldWorktrees(repoRoot) {
+  const dir = join10(stateDir(repoRoot), "worktrees");
+  const stale = (await readdir3(dir).catch(() => [])).filter((name) => /^wizard-implement-\d+$/.test(name)).sort().reverse().slice(MAX_WIZARD_WORKTREES - 1);
+  for (const slug of stale) {
+    const branch = slug.replace("wizard-implement-", WIZARD_BRANCH_PREFIX);
+    try {
+      await git([
+        "-C",
+        repoRoot,
+        "worktree",
+        "remove",
+        "--force",
+        join10(dir, slug)
+      ]);
+      await git(["-C", repoRoot, "branch", "-D", branch]);
+    } catch (err) {
+      logger.warn(
+        { branch, err: err.message },
+        "createWorktree: failed to prune a stale wizard worktree; continuing"
+      );
+    }
+  }
+}
+async function createWorktree(repoRoot) {
+  const branch = `${WIZARD_BRANCH_PREFIX}${Date.now()}`;
+  const dirSlug = branch.replace(/\//g, "-");
+  const path = join10(stateDir(repoRoot), "worktrees", dirSlug);
+  await git(["-C", repoRoot, "worktree", "prune"]);
+  await pruneOldWorktrees(repoRoot);
+  await mkdir5(dirname6(path), { recursive: true });
+  await git(["-C", repoRoot, "worktree", "add", "-b", branch, path, "HEAD"]);
+  return { path, branch };
+}
+async function installWorktreeDeps(worktreePath) {
+  try {
+    await readPackageJson(worktreePath);
+  } catch {
+    return { ok: true, output: "no package.json; skipped install" };
+  }
+  const pm = await detectPackageManager(worktreePath);
+  return new Promise((resolve4) => {
+    let output = "";
+    const child = spawn3(pm, ["install"], {
+      cwd: worktreePath,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    child.stdout?.on("data", (d) => output += d);
+    child.stderr?.on("data", (d) => output += d);
+    child.on(
+      "error",
+      (err) => resolve4({
+        ok: false,
+        output: `Failed to run ${pm} install: ${err.message}`
+      })
+    );
+    child.on(
+      "close",
+      (code) => resolve4({ ok: code === 0, output: output.trim() })
+    );
+  });
+}
+var INGEST_RUNTIMES = ["node", "python", "python3", "bun"];
+function validateIngestEntrypoint(worktreePath, entrypoint) {
+  if (!entrypoint || entrypoint.startsWith("-")) {
+    return {
+      ok: false,
+      reason: `entrypoint "${entrypoint}" is not a plain file path`
+    };
+  }
+  const target = resolve3(worktreePath, entrypoint);
+  const rel = relative2(worktreePath, target);
+  if (rel.startsWith("..") || isAbsolute2(rel)) {
+    return {
+      ok: false,
+      reason: `entrypoint "${entrypoint}" resolves outside the worktree`
+    };
+  }
+  return { ok: true, target };
+}
+async function runIngestScript(worktreePath, runtime, entrypoint, env = {}) {
+  if (!INGEST_RUNTIMES.includes(runtime)) {
+    return {
+      ran: false,
+      ok: false,
+      output: "",
+      reason: `runtime "${runtime}" is not an allowed interpreter (${INGEST_RUNTIMES.join(", ")})`
+    };
+  }
+  const validated = validateIngestEntrypoint(worktreePath, entrypoint);
+  if (!validated.ok) {
+    return { ran: false, ok: false, output: "", reason: validated.reason };
+  }
+  try {
+    if (!(await stat2(validated.target)).isFile()) {
+      return {
+        ran: false,
+        ok: false,
+        output: "",
+        reason: `entrypoint "${entrypoint}" is not a file`
+      };
+    }
+  } catch {
+    return {
+      ran: false,
+      ok: false,
+      output: "",
+      reason: `entrypoint "${entrypoint}" does not exist`
+    };
+  }
+  return new Promise((resolveRun) => {
+    let output = "";
+    const child = spawn3(runtime, [entrypoint], {
+      cwd: worktreePath,
+      shell: false,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env, ...env }
+    });
+    child.stdout?.on("data", (d) => output += d);
+    child.stderr?.on("data", (d) => output += d);
+    child.on(
+      "error",
+      (err) => resolveRun({
+        ran: true,
+        ok: false,
+        output: `Failed to run ${runtime} ${entrypoint}: ${err.message}`
+      })
+    );
+    child.on(
+      "close",
+      (code) => resolveRun({ ran: true, ok: code === 0, output: output.trim() })
+    );
+  });
+}
+async function copyUploadIntoWorktree(repoRoot, worktreePath, ingestDir, sourcePath) {
+  const trimmed = sourcePath.trim();
+  if (!trimmed) {
+    return { ok: false, reason: "no file path was provided" };
+  }
+  const source = isAbsolute2(trimmed) ? trimmed : resolve3(repoRoot, trimmed);
+  try {
+    if (!(await stat2(source)).isFile()) {
+      return { ok: false, reason: `"${sourcePath}" is not a file` };
+    }
+  } catch {
+    return { ok: false, reason: `"${sourcePath}" does not exist` };
+  }
+  const relPath = join10(ingestDir, basename2(source));
+  const dest = join10(worktreePath, relPath);
+  try {
+    await mkdir5(dirname6(dest), { recursive: true });
+    await copyFile(source, dest);
+  } catch (err) {
+    return {
+      ok: false,
+      reason: `failed to copy "${sourcePath}": ${err.message}`
+    };
+  }
+  return { ok: true, relPath };
+}
+async function listChangedFiles(worktreePath) {
+  const raw = await git(["-C", worktreePath, "status", "--porcelain", "-z"]);
+  const entries = raw.split("\0");
+  const files = [];
+  for (let i = 0; i < entries.length; i += 1) {
+    const entry = entries[i];
+    if (!entry) continue;
+    files.push(entry.slice(3));
+    if (["R", "C"].includes(entry[0]) || ["R", "C"].includes(entry[1])) i += 1;
+  }
+  return files;
+}
+function normalizeFindingPaths(findings) {
+  return {
+    ...findings,
+    ingestionAnalysis: findings.ingestionAnalysis?.map((e) => ({
+      ...e,
+      paths: e.paths.map(toWorktreeRelative)
+    })),
+    searchImplementationAnalysis: findings.searchImplementationAnalysis ? normalizeSearchLocation(findings.searchImplementationAnalysis) : void 0,
+    confirmedEntities: findings.confirmedEntities?.map((e) => ({
+      ...e,
+      paths: e.paths.map(toWorktreeRelative)
+    }))
+  };
+}
+function normalizeSearchLocation(path) {
+  const normalized = path ? toWorktreeRelative(path).trim() : "";
+  return normalized && normalized.toLowerCase() !== "unknown" ? normalized : void 0;
+}
+function toWorktreeRelative(p) {
+  return p.replace(/^\/+/, "");
+}
+async function confirmDirtyWorkingTree(ctx, repoRoot) {
+  const MAX_LISTED_DIRTY_FILES = 10;
+  const dirty = await listChangedFiles(repoRoot);
+  const shown = dirty.slice(0, MAX_LISTED_DIRTY_FILES);
+  const overflow = dirty.length - shown.length;
+  const answer = await ctx.requestUserInput({
+    prompt: "Proceed using HEAD only? Uncommitted changes will NOT be included in the generated implementation.",
+    promptType: "acceptReject",
+    options: [],
+    messages: [
+      `${dirty.length} uncommitted change(s) detected. The wizard builds an isolated worktree from HEAD, so these are ignored:`,
+      ...shown.map((file) => `  \u2022 ${file}`),
+      ...overflow > 0 ? [`  \u2022 \u2026and ${overflow} more`] : [],
+      "Commit or stash them first to include them in the implementation."
+    ]
+  });
+  if (answer !== true) {
+    throw new Error(
+      "implement aborted: commit or stash your changes so they are built into the worktree, then re-run the wizard."
+    );
+  }
+}
+
+// src/lib/algoliaApiKey.ts
+import { z as z22 } 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 apiKeyListSchema = z22.object({
+  items: z22.array(apiKeySchema).optional(),
+  keys: z22.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()
+});
+function canReuse(key, index) {
+  return key.acl.includes("search") && key.acl.every((acl) => SAFE_ACLS.has(acl)) && (key.indexes.length === 0 || key.indexes.includes("*") || key.indexes.includes(index));
+}
+async function createSearchKey(index) {
+  const stdout = await runAlgoliaCli([
+    "apikeys",
+    "create",
+    "--indices",
+    index,
+    "--acl",
+    "search,browse",
+    "--description",
+    `wizard search-only key for ${index}`,
+    "-o",
+    "json"
+  ]);
+  const { key, value } = createdKeySchema.parse(JSON.parse(stdout));
+  const created = key ?? value;
+  if (!created) throw new Error("apikeys create returned no key value");
+  return created;
+}
+async function resolveSearchOnlyKey(index) {
+  const stdout = await runAlgoliaCli(["apikeys", "list", "-o", "json"]);
+  const existing = apiKeyListSchema.parse(JSON.parse(stdout)).find((key) => canReuse(key, index))?.value;
+  if (existing) {
+    logger.info({ index }, "reusing existing search-only API key");
+    return existing;
+  }
+  logger.info({ index }, "no reusable search-only key found; creating one");
+  return createSearchKey(index);
+}
+
+// src/lib/algoliaDocs.ts
+import { readFileSync, readdirSync, existsSync as existsSync2 } from "node:fs";
+import { dirname as dirname7, 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));
+  for (; ; ) {
+    const candidate = join11(dir, DOCS_SUBPATH);
+    if (existsSync2(candidate)) return candidate;
+    const parent = dirname7(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function loadAlgoliaDoc(language) {
+  const docsDir = findDocsDir();
+  if (!docsDir) {
+    logger.warn(
+      "algoliaDocs: docs/algolia-sdk not found; skipping SDK reference"
+    );
+    return "";
+  }
+  const files = readdirSync(docsDir).filter((f) => f.includes(language));
+  if (files.length === 0) {
+    logger.warn(
+      { language },
+      "algoliaDocs: no SDK reference found for language; skipping"
+    );
+    return "";
+  }
+  return readFileSync(join11(docsDir, files[0]), "utf8").trim();
+}
+function getNamedDoc(name, language) {
+  const docsDir = findDocsDir();
+  if (!docsDir) {
+    logger.warn("docs/algolia-sdk not found");
+    return "";
+  }
+  const file = join11(docsDir, `${name}-${language}.md`);
+  if (!existsSync2(file)) {
+    logger.warn({ name, language }, "named SDK reference not found");
+    return "";
+  }
+  return readFileSync(file, "utf8").trim();
+}
+function getFrameworkSpecificDoc(frameworks) {
+  const fw = frameworks.map((f) => f.toLowerCase());
+  if (fw.includes("vue") || fw.includes("nuxt")) {
+    return loadAlgoliaDoc("vue");
+  }
+  if (fw.includes("react") || fw.includes("next.js")) {
+    return loadAlgoliaDoc("react");
+  }
+  if (fw.includes("angular")) {
+    return loadAlgoliaDoc("angular");
+  }
+  return loadAlgoliaDoc("js");
+}
+
+// src/actions/implement.ts
+var implementSchema = z23.object({
+  filesChanged: z23.array(z23.string()),
+  summary: z23.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(),
+  // 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(),
+  // 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(),
+  // Wall-clock duration of the run-now ingestion execution, in ms.
+  ingestDurationMs: z23.number().optional(),
+  ingestionSource: z23.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()
+    })
+  ).optional()
+});
+var implementationOutputSchema = z23.object({
+  summary: z23.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()
+});
+var verificationOutputSchema = z23.object({
+  summary: z23.string(),
+  sufficient: z23.boolean(),
+  additionalInstructions: z23.string().optional()
+});
+var MAX_IMPLEMENT_VERIFICATION_ATTEMPTS = 3;
+var DEFAULT_IMPLEMENT_USE_CASES = ["ingestion", "search"];
+var INGEST_DIR = ".algolia-wizard";
+function detectUiFramework(language) {
+  const names = language.frameworks.map((f) => f.name.toLowerCase());
+  if (names.some((n) => n.includes("vue") || n.includes("nuxt"))) return "Vue";
+  if (names.some((n) => n.includes("react") || n.includes("next")))
+    return "React";
+  if (names.some((n) => n.includes("angular"))) return "Angular";
+  return "JavaScript";
+}
+function frameworksForDoc(framework) {
+  switch (framework) {
+    case "React":
+      return ["react"];
+    case "Vue":
+      return ["vue"];
+    case "Angular":
+      return ["angular"];
+    case "JavaScript":
+      return [];
+  }
+}
+function publicEnvPrefix(language) {
+  const frameworkNames = language.frameworks.map(
+    (framework) => framework.name.toLowerCase()
+  );
+  if (frameworkNames.some((name) => name.includes("next"))) {
+    return "NEXT_PUBLIC_";
+  }
+  if (frameworkNames.some((name) => name.includes("nuxt"))) {
+    return "NUXT_PUBLIC_";
+  }
+  if (frameworkNames.some((name) => name.includes("astro"))) {
+    return "PUBLIC_";
+  }
+  if (frameworkNames.some((name) => name.includes("vite"))) {
+    return "VITE_";
+  }
+  return "PUBLIC_";
+}
+function searchEnvVars(language, appId, searchKey) {
+  const prefix = publicEnvPrefix(language);
+  return [
+    {
+      name: `${prefix}ALGOLIA_APP_ID`,
+      value: appId ?? "<your-algolia-app-id>"
+    },
+    {
+      name: `${prefix}ALGOLIA_SEARCH_API_KEY`,
+      value: searchKey ?? "<your-algolia-search-only-api-key>"
+    }
+  ];
+}
+function baseInstructions(input) {
+  return [
+    `Target Algolia index: ${input.targetIndex}`,
+    `Project languages and frameworks: ${JSON.stringify(input.language)}`,
+    "Make minimal, idiomatic changes; do not touch unrelated code."
+  ];
+}
+function sourceSpecificInstructions(input) {
+  const byLine = {
+    local: [
+      "Records live locally in this project (files, local DB, or local API).",
+      "Read each record from its real local source at the confirmed entity paths.",
+      "Never fabricate, hardcode, or use placeholder records.",
+      "Add env vars for any local source access (DB URL, API base, file paths) that is not a fixed repo path."
+    ],
+    fileUpload: [
+      // The wizard already copied the developer's file into the worktree at this
+      // exact path, so the agent must read it directly — never search for or
+      // substitute another file.
+      `Records come from the developer's file, already copied into the worktree at "${input.uploadFilePath}". Read and parse that exact file.`,
+      "Parse by extension: JSON = array of objects; CSV/TSV = header row maps to keys.",
+      "Map parsed columns/fields to the confirmed entity attributes.",
+      "Never fabricate, hardcode, or substitute a different file."
+    ],
+    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."
+    ]
+  };
+  return byLine[input.ingestionSource];
+}
+function ingestionInstructions(input) {
+  return [
+    ...input.confirmed && input.confirmed.length ? [
+      `Create an ingestion script under "${input.ingestDir}/" at the repo root.`,
+      `Ingest only these confirmed entities (name, source paths, attributes): ${JSON.stringify(input.confirmed)}.`,
+      `Ingesting writes to Algolia, so the script needs a write API key and App ID \u2014 read them from the ${API_KEY_VAR} and ${APP_ID_VAR} environment variables rather than hardcoding them. The wizard sets these when it runs the script.`,
+      "Use the appropriate Algolia package in the ingestion script. Do not use the raw HTTP API.",
+      "After a successful ingest, the script must print exactly one line to stdout in the form `ALGOLIA_WIZARD_RECORD_COUNT=<n>`, where <n> is the total number of records pushed to Algolia. Print it last, on its own line, with no surrounding text.",
+      getNamedDoc("save-records", "js"),
+      'Add algoliasearch to package.json "dependencies" with a valid version range; the wizard installs the worktree deps after you finish.',
+      "The summary should be extremely concise.",
+      `Return how to run the script as two fields, not a command string: "runtime" (one of ${INGEST_RUNTIMES.join(", ")}) and "entrypoint" (the script path relative to the worktree root, e.g. "${input.ingestDir}/ingest.mjs"). The wizard runs \`<runtime> <entrypoint>\` directly, so the entrypoint must be a plain path with no flags or arguments. Write a script one of those interpreters can run as-is.`,
+      ...sourceSpecificInstructions(input)
+    ] : []
+  ];
+}
+function searchInstructions(input) {
+  const doc = getFrameworkSpecificDoc(frameworksForDoc(input.uiFramework));
+  return [
+    "Implement an in-app Algolia search experience.",
+    `Build the search UI for ${input.uiFramework}.`,
+    "Follow the Algolia JS SDK reference below for client setup and InstantSearch wiring; prefer it over prior knowledge:",
+    doc,
+    `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.`,
+    '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."
+  ];
+}
+function verificationInstructions(input) {
+  return [
+    "Verify the Algolia implementation changes in the current worktree.",
+    `Verification tools found in the codebase: ${JSON.stringify(input.findings.verification ?? [])}.`,
+    "Call verifyImplementation at least once; it runs every repo-defined lint/typecheck/check script and returns per-check results plus an aggregate ok.",
+    "For issues caused by the implementation, make minimal fixes with writeFile and re-run verifyImplementation.",
+    "Do not make speculative fixes when verifyImplementation cannot run, no checks exist, or failures are unrelated to these changes \u2014 note the limitation in your summary.",
+    "Do not add new Algolia functionality here; only validate and make minimal correctness fixes.",
+    `Do not modify "${input.ingestDir}/" unless verifyImplementation reports an actionable issue in its files.`,
+    "Always call reportStatus with status=success once verification has run, even when sufficient=false.",
+    "Set sufficient=true only when the implementation is complete and checks pass (or fail for a clearly unrelated reason).",
+    "Set sufficient=false when the implementation is incomplete or has implementation-caused failures; include concrete additionalInstructions for the next pass."
+  ];
+}
+var IMPLEMENT_CONFIG = {
+  ingestion: {
+    title: "Algolia ingestion",
+    buildInstructions: ingestionInstructions
+  },
+  search: {
+    title: "Algolia search",
+    buildInstructions: searchInstructions
+  },
+  verification: {
+    title: "Algolia verification",
+    buildInstructions: verificationInstructions
+  }
+};
+var useCaseToolMap = {
+  ingestion: [...FS_READ_TOOLS, "writeFile", "writeCredentials"],
+  search: [...FS_READ_TOOLS, "writeFile"],
+  verification: [...FS_READ_TOOLS, "verifyImplementation"]
+};
+function toolsForUseCase(useCase, ingestionSource) {
+  const tools = useCaseToolMap[useCase];
+  if (useCase === "ingestion" && ingestionSource === "generated") {
+    return [...tools, "generateRecord"];
+  }
+  return tools;
+}
+function buildAgentInstructions(useCase, input, extraInstructions = []) {
+  const config = IMPLEMENT_CONFIG[useCase];
+  return [
+    `You are implementing ${config.title}.`,
+    ...baseInstructions(input),
+    ...config.buildInstructions(input),
+    ...extraInstructions,
+    "When done, call reportStatus"
+  ];
+}
+function formatSummary(useCase, summary) {
+  const label = useCase === "ingestion" ? "Ingestion" : useCase === "search" ? "Search" : "Verification";
+  return `${label}: ${summary}`;
+}
+function parseIngestRecordCount(output) {
+  const match = output.match(/ALGOLIA_WIZARD_RECORD_COUNT=(\d+)/);
+  if (!match) return void 0;
+  const count = Number(match[1]);
+  return Number.isFinite(count) ? count : void 0;
+}
+function verificationRetryInstructions(verification) {
+  return [
+    `Implementation insufficient. Address these findings before reporting completion: ${verification.additionalInstructions ?? verification.summary}`
+  ];
+}
+async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWorktreePath) {
+  const repoRoot = process.cwd();
+  const scan = ctx.getStepOutput("project-scan");
+  const entities = ctx.getStepOutput(
+    "confirm-entities"
+  );
+  const findings = {
+    ingestionAnalysis: entities?.ingestionAnalysis ?? scan.ingestionAnalysis,
+    searchImplementationAnalysis: scan.searchImplementationAnalysis,
+    verification: scan.verification,
+    confirmedEntities: entities?.confirmedEntities
+  };
+  const language = {
+    languages: ctx.getStepOutput("confirm-language")?.languages ?? scan.languages,
+    frameworks: ctx.getStepOutput("confirm-framework")?.frameworks ?? scan.frameworks
+  };
+  const selected = ctx.getStepOutput(
+    "select-index"
+  );
+  if (!selected?.selection) {
+    throw new Error(`No index was selected`);
+  }
+  let ingestionSource = "generated";
+  const ingestionSourceQuestions = [
+    {
+      question: "Do you have local access to the data you want to ingest in Algolia?",
+      source: "local"
+    },
+    {
+      question: "Do you have a JSON, CSV or TSV you would like to upload?",
+      source: "fileUpload"
+    },
+    {
+      question: "Do you want me to generate sample records based on your entity schema?",
+      source: "generated"
+    }
+  ];
+  let uploadSourcePath;
+  if (useCases.includes("ingestion")) {
+    for (const sq of ingestionSourceQuestions) {
+      const result = Boolean(
+        await ctx.requestUserInput({
+          prompt: sq.question,
+          promptType: "acceptReject",
+          options: ["Yes", "No"],
+          messages: []
+        })
+      );
+      if (result) {
+        ingestionSource = sq.source;
+        break;
+      }
+    }
+    if (ingestionSource === "fileUpload") {
+      const answer = await ctx.requestUserInput({
+        prompt: "Enter the path to your JSON, CSV, or TSV file (relative to the project root, or absolute):",
+        promptType: "textInput",
+        options: [],
+        messages: []
+      });
+      uploadSourcePath = typeof answer === "string" ? answer : "";
+    }
+  }
+  const targetIndex = selected?.selection;
+  await assertGitRepoWithHead(repoRoot);
+  if (await isWorkingTreeDirty(repoRoot)) {
+    await confirmDirtyWorkingTree(ctx, repoRoot);
+  }
+  const normalized = normalizeFindingPaths(findings);
+  const confirmed2 = normalized.confirmedEntities;
+  const searchLocation = normalized.searchImplementationAnalysis;
+  let appId;
+  let searchKey;
+  if (useCases.includes("search")) {
+    appId = (await loadActiveProfile()).appId;
+    try {
+      searchKey = await resolveSearchOnlyKey(targetIndex);
+    } catch (err) {
+      logger.warn(
+        { err: err.message },
+        "implement: could not resolve a search-only API key; the agent will scaffold a placeholder"
+      );
+    }
+  }
+  const worktree = existingWorktreePath ?? (await createWorktree(repoRoot)).path;
+  try {
+    process.chdir(worktree);
+    let uploadFilePath;
+    let uploadWarning;
+    if (ingestionSource === "fileUpload") {
+      const copied = await copyUploadIntoWorktree(
+        repoRoot,
+        worktree,
+        INGEST_DIR,
+        uploadSourcePath ?? ""
+      );
+      if (copied.ok) {
+        uploadFilePath = copied.relPath;
+      } else {
+        ingestionSource = "generated";
+        uploadWarning = `\u26A0\uFE0F Could not use the uploaded file (${copied.reason}); generating sample records instead.`;
+        logger.warn(
+          { reason: copied.reason },
+          "implement: file upload unavailable; falling back to generated sample records"
+        );
+      }
+    }
+    const input = {
+      findings: normalized,
+      confirmed: confirmed2,
+      searchLocation,
+      targetIndex,
+      language,
+      appId,
+      searchKey,
+      searchEnvVars: searchEnvVars(language, appId, searchKey),
+      ingestDir: INGEST_DIR,
+      ingestionSource,
+      uploadFilePath,
+      // language.frameworks already prefers the confirm-framework step output,
+      // so the user's confirmed stack (not just raw detection) picks the flavor.
+      uiFramework: detectUiFramework(language)
+    };
+    const summaries = [];
+    if (uploadWarning) summaries.push(uploadWarning);
+    let agentRuns = 0;
+    let ingestRuntime;
+    let ingestEntrypoint;
+    let ingestScriptRan = false;
+    let ingestRecordCount;
+    let ingestDurationMs;
+    let installFailed = false;
+    async function runImplementationUseCase(currentUseCase, extraInstructions = []) {
+      if (agentRuns > 0) ctx.recordStepExecution();
+      agentRuns += 1;
+      const result = await runAgent({
+        instructions: buildAgentInstructions(
+          currentUseCase,
+          input,
+          extraInstructions
+        ),
+        tools: toolsForUseCase(currentUseCase, input.ingestionSource),
+        outputSchema: implementationOutputSchema
+      });
+      const install = await installWorktreeDeps(worktree);
+      if (!install.ok) {
+        installFailed = true;
+        logger.warn(
+          { useCase: currentUseCase, output: install.output },
+          "implement: dependency install in worktree failed; generated commands may not run until deps are installed"
+        );
+      }
+      return result;
+    }
+    async function runVerificationUseCase() {
+      if (agentRuns > 0) ctx.recordStepExecution();
+      agentRuns += 1;
+      return runAgent({
+        instructions: buildAgentInstructions("verification", input),
+        tools: toolsForUseCase("verification"),
+        outputSchema: verificationOutputSchema
+      });
+    }
+    if (useCases.includes("ingestion")) {
+      const { summary, runtime, entrypoint } = await runImplementationUseCase("ingestion");
+      summaries.push(formatSummary("ingestion", summary));
+      ingestRuntime = runtime;
+      ingestEntrypoint = entrypoint;
+      if (ingestRuntime && ingestEntrypoint && !installFailed) {
+        const runNow = await ctx.requestUserInput({
+          prompt: `Run the ingestion script now? This writes records to the "${targetIndex}" index.`,
+          promptType: "acceptReject",
+          options: ["Yes", "No"],
+          messages: []
+        }) === true;
+        if (runNow) {
+          const profile2 = await loadActiveProfile();
+          const startedAt = Date.now();
+          const run = await runIngestScript(
+            worktree,
+            ingestRuntime,
+            ingestEntrypoint,
+            {
+              [APP_ID_VAR]: profile2.appId,
+              [API_KEY_VAR]: profile2.apiKey
+            }
+          );
+          ingestScriptRan = run.ran && run.ok;
+          if (ingestScriptRan) {
+            ingestDurationMs = Date.now() - startedAt;
+            ingestRecordCount = parseIngestRecordCount(run.output);
+            if (ingestRecordCount != null) {
+              track("AI Wizard Ingest Successful", {
+                entity_name: confirmed2?.map((e) => e.name).join(", ") || "unknown",
+                record_count: ingestRecordCount,
+                duration_ms: ingestDurationMs
+              });
+            }
+          }
+          let summaryLine;
+          let outcomeMessage;
+          if (!run.ran) {
+            summaryLine = `\u26A0\uFE0F Skipped running the ingestion script: ${run.reason}`;
+            outcomeMessage = `\u26A0\uFE0F The ingestion script did not run: ${run.reason}`;
+            logger.warn(
+              {
+                runtime: ingestRuntime,
+                entrypoint: ingestEntrypoint,
+                reason: run.reason
+              },
+              "implement: refused to auto-run ingestion script"
+            );
+            track("Error", {
+              step: "Push Data",
+              error: `ingestion script skipped: ${run.reason}`,
+              product_area: "AI Wizard"
+            });
+          } else if (run.ok) {
+            const status = "Ingestion run: succeeded.";
+            summaryLine = run.output ? `${status}
+${run.output}` : status;
+            outcomeMessage = `\u2705 Ingestion succeeded${ingestRecordCount != null ? ` \u2014 ${ingestRecordCount} record(s) indexed.` : "."}`;
+          } else {
+            const status = "\u26A0\uFE0F Ingestion run failed:";
+            summaryLine = run.output ? `${status}
+${run.output}` : status;
+            outcomeMessage = `\u274C Ingestion failed.${run.output ? ` ${run.output}` : ""}`;
+            logger.warn(
+              {
+                runtime: ingestRuntime,
+                entrypoint: ingestEntrypoint,
+                output: run.output
+              },
+              "implement: ingestion script run failed"
+            );
+            track("Error", {
+              step: "Push Data",
+              error: run.output || "ingestion script exited non-zero",
+              product_area: "AI Wizard"
+            });
+          }
+          summaries.push(summaryLine);
+          await ctx.requestUserInput({
+            prompt: "Continue",
+            promptType: "notice",
+            options: [],
+            messages: [outcomeMessage]
+          });
+        }
+      }
+    }
+    if (useCases.includes("search")) {
+      let extraInstructions = [];
+      const preSearchFiles = new Set(await listChangedFiles(worktree));
+      for (let attempt = 1; attempt <= MAX_IMPLEMENT_VERIFICATION_ATTEMPTS; attempt++) {
+        const { summary } = await runImplementationUseCase(
+          "search",
+          extraInstructions
+        );
+        summaries.push(formatSummary("search", summary));
+        const verification = await runVerificationUseCase();
+        summaries.push(formatSummary("verification", verification.summary));
+        if (verification.sufficient) {
+          ctx.setUserInput("implementation", "success");
+          const searchFilesChanged = (await listChangedFiles(worktree)).filter(
+            (file) => !preSearchFiles.has(file)
+          );
+          track("AI Wizard Frontend Component Generated", {
+            filePaths: searchFilesChanged
+          });
+          track("AI Wizard Wired to UI", {
+            location_heuristic: searchLocation ?? "unknown"
+          });
+          break;
+        }
+        if (attempt === MAX_IMPLEMENT_VERIFICATION_ATTEMPTS) {
+          ctx.setUserInput("implementation", "fail");
+          throw new Error(
+            `Implementation verification failed after ${MAX_IMPLEMENT_VERIFICATION_ATTEMPTS} attempts: ${verification.additionalInstructions ?? verification.summary}`
+          );
+        }
+        extraInstructions = verificationRetryInstructions(verification);
+      }
+    } else {
+      ctx.setUserInput("implementation", "success");
+    }
+    const filesChanged = await listChangedFiles(worktree);
+    if (filesChanged.length === 0) {
+      logger.warn(
+        "implement: agent reported success but no files changed in the worktree"
+      );
+    }
+    if (installFailed) {
+      summaries.push(
+        '\u26A0\uFE0F Dependency install in the worktree failed. Run your package manager install in the worktree before the command below, or it will fail with "Cannot find module".'
+      );
+    }
+    return {
+      ingestionSource,
+      filesChanged,
+      summary: summaries.join("\n\n"),
+      worktreePath: worktree,
+      ...useCases.includes("ingestion") && ingestRuntime && ingestEntrypoint ? {
+        ingestCommand: `cd ${shellQuote(worktree)} && ${ingestRuntime} ${shellQuote(ingestEntrypoint)}`,
+        ingestScriptRan,
+        ...ingestRecordCount != null ? { ingestRecordCount } : {},
+        ...ingestDurationMs != null ? { ingestDurationMs } : {}
+      } : {},
+      ...useCases.includes("search") ? { searchEnvVars: input.searchEnvVars } : {}
+    };
+  } finally {
+    process.chdir(repoRoot);
+  }
+}
+
+// src/workflows/default.ts
+var defaultWorkflow = {
+  id: "default",
+  title: "Default Workflow",
+  description: "This workflow explores your repo and implements Algolia on your behalf",
+  steps: [
+    defineStep({
+      id: "project-scan",
+      title: "project scan",
+      outputSchema: projectScanSchema,
+      run: (ctx) => projectScan(ctx)
+    }),
+    defineStep({
+      id: "confirm-language",
+      title: "confirm language",
+      outputSchema: confirmLanguageSchema,
+      visible: false,
+      run: (ctx) => confirmLanguage(ctx)
+    }),
+    defineStep({
+      id: "confirm-entities",
+      title: "confirm entities",
+      outputSchema: confirmEntitiesSchema,
+      visible: false,
+      run: (ctx) => confirmEntities(ctx)
+    }),
+    defineStep({
+      id: "select-index",
+      title: "Set up index",
+      outputSchema: z24.object({
+        selection: z24.string()
+      }),
+      run: (ctx) => selectIndexStep(ctx)
+    }),
+    defineStep({
+      id: "ingestion",
+      title: "ingest records",
+      outputSchema: implementSchema,
+      run: (ctx) => implement(ctx, ["ingestion"])
+    }),
+    defineStep({
+      id: "confirm-framework",
+      title: "Confirm framework",
+      outputSchema: confirmFrameworkSchema,
+      visible: false,
+      run: (ctx) => confirmFramework(ctx)
+    }),
+    defineStep({
+      id: "search",
+      title: "create search ui",
+      outputSchema: implementSchema,
+      run: (ctx) => {
+        const ingestion = ctx.getStepOutput(
+          "ingestion"
+        );
+        return implement(ctx, ["search"], ingestion?.worktreePath);
+      }
+    }),
+    defineStep({
+      id: "review",
+      title: "done",
+      outputSchema: reviewSchema,
+      run: (ctx) => {
+        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."
+        });
+      }
+    })
+  ]
+};
+
+// src/workflows/index.ts
+var workflows = {
+  [defaultWorkflow.id]: defaultWorkflow
+};
+function getWorkflow(id) {
+  return workflows[id];
+}
+
+// src/main.tsx
+import { jsx as jsx11 } from "react/jsx-runtime";
+var requestedId = process.argv[2] ?? defaultWorkflow.id;
+var workflow = getWorkflow(requestedId);
+if (!workflow) {
+  const available = Object.keys(workflows).join(", ");
+  console.error(`Unknown workflow "${requestedId}". Available: ${available}`);
+  process.exit(1);
+}
+var store = useWizard.getState();
+var instance = render(/* @__PURE__ */ jsx11(App, {}));
+var user = await getUser();
+if (!user) {
+  await instance.waitUntilRenderFlush();
+  instance.cleanup();
+  try {
+    await runAuthLogin();
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+  instance = render(/* @__PURE__ */ jsx11(App, {}));
+  user = await getUser();
+  if (!user) {
+    store.setError(
+      "Authentication completed but no Algolia user was returned. Try running `npx @algolia/cli auth login` directly."
+    );
+    await instance.waitUntilExit();
+    process.exit(1);
+  }
+}
+store.setUser(user);
+var profile = await loadActiveProfile();
+await store.waitForStart();
+runWorkflow(workflow, profile?.appId);