@algolia/wizard 0.36.0 → 0.38.0-rc.131.265

package/dist/main.js

@@ -258,10 +258,14 @@ var useWizard = create((set, get) => ({
   error: null,
   inputReq: null,
   _resolve: null,
+  settingUpAppId: null,
+  setSettingUpApp: (appId) => set({ settingUpAppId: appId }),
   // `endAuth` lands on 'preflight', not 'idle': sign-in happens after the
   // welcome screen, so going back would gate the run a second time.
   beginAuth: () => set({ phase: "authenticating", cliOutput: [] }),
-  endAuth: () => set((s) => s.phase === "authenticating" ? { phase: "preflight" } : {}),
+  endAuth: () => set(
+    (s) => s.phase === "authenticating" ? { phase: "preflight", cliOutput: [] } : {}
+  ),
   confirmStart: () => set(
     (s) => s.phase === "idle" ? { phase: "preflight", homeScreen: "home" } : {}
   ),
@@ -405,7 +409,8 @@ var useWizard = create((set, get) => ({
       logs: [],
       error: null,
       inputReq: null,
-      _resolve: null
+      _resolve: null,
+      settingUpAppId: null
     });
   }
 }));
@@ -653,25 +658,27 @@ function SelectRow({
   labelWidth,
   highlightBackground = true,
   usePadding = false,
+  disabled = false,
   children
 }) {
-  const labelColor = highlighted ? highlightBackground ? COLORS.highlight.fg : COLORS.success : COLORS.primary;
+  const active = highlighted && !disabled;
+  const labelColor = disabled ? COLORS.dim : active ? highlightBackground ? COLORS.highlight.fg : COLORS.success : COLORS.primary;
   return /* @__PURE__ */ jsxs3(
     Box4,
     {
       width,
       paddingX: usePadding ? 1 : 0,
       paddingY: usePadding ? 1 : 0,
-      backgroundColor: highlighted && highlightBackground ? COLORS.highlight.bg : void 0,
+      backgroundColor: active && highlightBackground ? COLORS.highlight.bg : void 0,
       children: [
         /* @__PURE__ */ jsx3(Box4, { width: labelWidth, children: /* @__PURE__ */ jsxs3(
           Text4,
           {
             color: labelColor,
-            bold: highlighted && !highlightBackground,
+            bold: active && !highlightBackground,
             wrap: "truncate",
             children: [
-              highlighted ? "\u276F   " : "    ",
+              active ? "\u276F   " : "    ",
               label
             ]
           }
@@ -870,6 +877,14 @@ var ARROW_WIDTH = 4;
 var COLUMN_GAP = 2;
 var BAR_PADDING = 2;
 var ROW_HEIGHT = 3;
+function nextSelectableIndex(start, dir, rowCount, isDisabled) {
+  let i = start;
+  for (let step = 0; step < rowCount; step++) {
+    i = (i + dir + rowCount) % rowCount;
+    if (!isDisabled(i)) return i;
+  }
+  return start;
+}
 function SelectPrompt({
   options,
   onSelect,
@@ -881,15 +896,18 @@ function SelectPrompt({
   multi,
   cancelable,
   secondary,
+  disabled,
   defaultSelectedIndex = 0
 }) {
-  const [index, setIndex] = useState5(
-    () => defaultSelectedIndex > 0 && defaultSelectedIndex < options.length ? defaultSelectedIndex : 0
-  );
-  const [checked, setChecked] = useState5(() => /* @__PURE__ */ new Set());
   const hasCancel = Boolean(multi || cancelable);
   const rows = hasCancel ? [...options, "Cancel"] : options;
   const cancelIndex = hasCancel ? options.length : -1;
+  const isDisabled = (i) => i !== cancelIndex && Boolean(disabled?.[i]);
+  const [index, setIndex] = useState5(() => {
+    const start = defaultSelectedIndex > 0 && defaultSelectedIndex < options.length ? defaultSelectedIndex : 0;
+    return isDisabled(start) ? nextSelectableIndex(start, 1, rows.length, isDisabled) : start;
+  });
+  const [checked, setChecked] = useState5(() => /* @__PURE__ */ new Set());
   const hints = [];
   if (rows.length > 1) hints.push({ key: "[\u2191] [\u2193]", label: "move" });
   if (multi) hints.push({ key: "[space]", label: "select" });
@@ -929,9 +947,15 @@ function SelectPrompt({
   useInput2((input, key) => {
     if (rows.length === 0) return;
     if (key.upArrow || input === "k") {
-      setIndex((i) => (i - 1 + rows.length) % rows.length);
+      setIndex((i) => {
+        const next = (i - 1 + rows.length) % rows.length;
+        return isDisabled(next) ? i : next;
+      });
     } else if (key.downArrow || input === "j") {
-      setIndex((i) => (i + 1) % rows.length);
+      setIndex((i) => {
+        const next = (i + 1) % rows.length;
+        return isDisabled(next) ? i : next;
+      });
     } else if (multi && input === " " && index !== cancelIndex) {
       setChecked((prev) => {
         const next = new Set(prev);
@@ -942,6 +966,7 @@ function SelectPrompt({
     } else if (key.return) {
       if (index === cancelIndex) {
         onSelect(CANCEL);
+      } else if (isDisabled(index)) {
       } else if (!multi) {
         onSelect(options[index]);
       } else if (checked.size > 0) {
@@ -966,10 +991,12 @@ function SelectPrompt({
       const bullet = multi && !isCancel ? checked.has(i) ? "\u25CF " : "\u25CB " : "";
       const sec = isCancel ? void 0 : secondary?.[i];
       const isText = sec?.kind === "text";
+      const rowDisabled = isDisabled(i);
       return /* @__PURE__ */ jsxs7(
         SelectRow,
         {
           highlighted,
+          disabled: rowDisabled,
           width: isText ? "100%" : barWidth,
           labelWidth: isText ? labelWidth : barLabelWidth,
           label: `${bullet}${option}`,
@@ -979,7 +1006,7 @@ function SelectPrompt({
               Text8,
               {
                 wrap: "truncate",
-                color: highlighted ? COLORS.primary : COLORS.muted,
+                color: rowDisabled ? COLORS.dim : highlighted ? COLORS.primary : COLORS.muted,
                 children: sec.value
               }
             ) }),
@@ -1041,6 +1068,7 @@ function PromptInput() {
         table: inputReq.table,
         options: inputReq.options,
         secondary: inputReq.secondary,
+        disabled: inputReq.disabled,
         defaultSelectedIndex: inputReq.defaultSelectedIndex,
         cancelable: inputReq.cancelable,
         error: inputReq.error,
@@ -1112,7 +1140,7 @@ function PromptInput() {
         inputReq.prompt,
         " "
       ] }),
-      /* @__PURE__ */ jsx7(
+      /* @__PURE__ */ jsx7(Text9, { color: COLORS.primary, children: /* @__PURE__ */ jsx7(
         TextInput,
         {
           value: draft,
@@ -1122,13 +1150,13 @@ function PromptInput() {
             setDraft("");
           }
         }
-      )
+      ) })
     ] })
   ] });
 }
 
 // src/workflows/default.ts
-import { z as z30 } from "zod";
+import { z as z29 } from "zod";
 
 // src/core/orchestrator.ts
 import "zod";
@@ -1404,6 +1432,10 @@ function reconcileWorkflowState(state, workflow) {
   }
   return state;
 }
+async function isResumableWorkflow(workflow) {
+  const persisted = await loadWorkflowState(workflow.id);
+  return persisted != null && reconcileWorkflowState(persisted, workflow) != null;
+}
 function initWorkflowState(workflow, now) {
   return {
     workflowId: workflow.id,
@@ -1600,267 +1632,31 @@ async function listIndices() {
   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 Output3 } from "ai";
-import { createAnthropic as createAnthropic3 } from "@ai-sdk/anthropic";
-import "zod";
-
-// src/lib/tools/index.ts
-import "zod";
-
-// src/lib/tools/listFiles.ts
-import { tool } from "ai";
-import z5 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 dirname2, join as join5, 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, dirname2(target)).split(sep).filter(Boolean);
-  for (const part of parts) {
-    current = join5(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: z5.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 resolved2 = resolveInRoot(ctx, ".");
-      if (!resolved2.ok) return resolved2.error;
-      const entries = await readdir(resolved2.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 z6 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: z6.object({
-      path: z6.string().describe("Directory to change into")
-    }),
-    execute: async ({ path }) => {
-      logger.info({ path }, "called changeDirectory tool");
-      const resolved2 = resolveInRoot(ctx, path);
-      if (!resolved2.ok) return resolved2.error;
-      try {
-        const info = await stat(resolved2.target);
-        if (!info.isDirectory()) {
-          return `Error changing directory to ${path}: not a directory`;
-        }
-        ctx.cwd = resolved2.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 z7 from "zod";
-function reportStatusTool(output) {
-  return tool3({
-    description: "Report the status of your execution. Return a reason in case of failure.",
-    inputSchema: z7.object({
-      status: z7.enum(["success", "fail"]),
-      reason: z7.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 z8 from "zod";
-import { readFile as readFile3 } 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: z8.object({
-      filePath: z8.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 resolved2 = resolveInRoot(ctx, filePath);
-      if (!resolved2.ok) return resolved2.error;
-      try {
-        const content = await readFile3(resolved2.target, "utf8");
-        return isEnvFile(resolved2.target) ? redactEnvValues(content) : content;
-      } catch (err) {
-        return `Error reading ${filePath}: ${err.message}`;
-      }
-    }
-  });
-}
-
-// src/lib/tools/writeFile.ts
-import { tool as tool5 } from "ai";
-import z9 from "zod";
-import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname3 } 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: z9.object({
-      filePath: z9.string().describe("Path to the file to write"),
-      content: z9.string().describe("Content to write to the file")
-    }),
-    execute: async ({ filePath, content }) => {
-      logger.info({ filePath }, "called writeFile tool");
-      const resolved2 = resolveInRoot(ctx, filePath);
-      if (resolved2.ok === false) return resolved2.error;
-      if (isSecretEnvFile(resolved2.target)) {
-        return `Refused: ${filePath} holds secrets. Use the writeCredentials tool to set Algolia environment variables, passing this file path.`;
-      }
-      try {
-        if (await hasSymlinkParent(ctx, resolved2.target)) {
-          return `Refused: ${resolved2.target} is outside the repo root (${ctx.root}).`;
-        }
-        await mkdir3(dirname3(resolved2.target), { recursive: true });
-        await writeFile3(resolved2.target, content, "utf8");
-        useWizard.getState().recordWrittenFile(resolved2.target);
-        return `Wrote to ${filePath}`;
-      } catch (err) {
-        return `Error writing ${filePath}: ${err.message}`;
-      }
-    }
-  });
-}
-
-// src/lib/tools/writeAlgoliaCredentials.ts
-import { tool as tool6 } from "ai";
-import z13 from "zod";
-import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile5 } from "node:fs/promises";
-import { dirname as dirname4, relative as relative3 } from "node:path";
-
 // src/lib/algoliaApp.ts
-import { z as z10 } from "zod";
-var applicationSchema = z10.object({
-  id: z10.string().min(1),
-  name: z10.string().default(""),
-  plan: z10.string().optional()
+import { z as z5 } from "zod";
+var applicationSchema = z5.object({
+  id: z5.string().min(1),
+  name: z5.string().default(""),
+  plan: z5.string().optional()
 });
-var listSchema = z10.array(
-  z10.object({
-    id: z10.string().min(1),
-    name: z10.string().default(""),
-    plan_label: z10.string().optional()
-  }).transform(({ id, name, plan_label }) => ({ id, name, plan: plan_label }))
+var listSchema = z5.array(
+  z5.object({
+    id: z5.string().min(1),
+    name: z5.string().default(""),
+    plan_label: z5.string().optional(),
+    status: z5.string().optional(),
+    acl: z5.array(z5.string()).optional()
+  }).transform(({ id, name, plan_label, status, acl }) => ({
+    id,
+    name,
+    plan: plan_label,
+    status,
+    acl
+  }))
 );
+function canSelectApplication(app) {
+  return app.status === "active" && (app.acl ?? []).includes("keys");
+}
 async function currentApplication() {
   let raw;
   try {
@@ -1909,20 +1705,160 @@ function parseJson(text) {
   }
 }
 
+// src/lib/envAppId.ts
+import { readFile as readFile3 } from "node:fs/promises";
+import { join as join5 } from "node:path";
+var ENV_FILES = [".env", ".env.local"];
+var APP_ID_LINE = /^[ \t]*(?:export[ \t]+)?([A-Z0-9_]*ALGOLIA_APP(?:LICATION)?_ID)[ \t]*=[ \t]*(.*)$/gm;
+async function findEnvApplicationId(root = process.cwd()) {
+  for (const file of ENV_FILES) {
+    let content;
+    try {
+      content = await readFile3(join5(root, file), "utf8");
+    } catch (err) {
+      if (err.code !== "ENOENT") {
+        logger.warn(
+          { file, err },
+          "could not read env file for an application id"
+        );
+      }
+      continue;
+    }
+    for (const [, name, raw] of content.matchAll(APP_ID_LINE)) {
+      const id = readValue(raw);
+      if (id) {
+        logger.info({ file, name, app: id }, "found an application id in env");
+        return { id, name, file };
+      }
+    }
+  }
+  return null;
+}
+function readValue(raw) {
+  const trimmed = raw.trim();
+  const quoted = trimmed.match(/^(['"])(.*)\1/);
+  const value = quoted ? quoted[2].trim() : trimmed.replace(/\s+#.*$/, "").trim();
+  return value.length > 0 && !value.startsWith("<") ? value : null;
+}
+
+// src/lib/algoliaAppPicker.ts
+function blockReasonFor(app) {
+  return app.status !== "active" ? "Inactive" : "Missing permissions";
+}
+function secondaryFor(app) {
+  if (!canSelectApplication(app)) {
+    return { kind: "text", value: blockReasonFor(app) };
+  }
+  return app.plan ? { kind: "badge", value: app.plan } : void 0;
+}
+function labelFor(app) {
+  return app.name.trim() ? `${app.name} \u2014 ${app.id}` : app.id;
+}
+async function selectAndReport(app) {
+  const store = useWizard.getState();
+  store.setSettingUpApp(app.id);
+  try {
+    return await selectApplication(app.id);
+  } finally {
+    store.setSettingUpApp(null);
+  }
+}
+async function promptForApplication(leadIn = []) {
+  const store = useWizard.getState();
+  const unordered = await listApplications();
+  if (unordered.length === 0) {
+    throw new Error(
+      "This Algolia account has no applications. Create one in the Algolia dashboard, or with `npx @algolia/cli@latest application create`, then restart the wizard."
+    );
+  }
+  const apps = [
+    ...unordered.filter(canSelectApplication),
+    ...unordered.filter((app) => !canSelectApplication(app))
+  ];
+  const messages = [...leadIn];
+  for (; ; ) {
+    const choice = await store.requestUserInput({
+      prompt: "Which Algolia application should the wizard work in?",
+      promptType: "multipleChoice",
+      options: apps.map(labelFor),
+      secondary: apps.map(secondaryFor),
+      disabled: apps.map((app) => !canSelectApplication(app)),
+      messages
+    });
+    const chosen = apps.find((app) => labelFor(app) === choice);
+    if (!chosen || !canSelectApplication(chosen)) {
+      throw new Error("Application picker received an unexpected selection");
+    }
+    try {
+      return await selectAndReport(chosen);
+    } catch (err) {
+      logger.warn(
+        { app: chosen.id, err: err.message },
+        "application select failed; re-prompting"
+      );
+      messages.push(
+        `Could not select \u201C${labelFor(chosen)}\u201D. It may have been removed \u2014 pick another.`
+      );
+    }
+  }
+}
+async function confirmEnvApplication(env, current) {
+  const useEnv = `Use ${env.id} (from ${env.file})`;
+  const choice = await useWizard.getState().requestUserInput({
+    prompt: "Select an application",
+    promptType: "multipleChoice",
+    options: [
+      useEnv,
+      current ? `Use ${labelFor(current)} (already selected)` : "Pick a different application"
+    ],
+    messages: [
+      `${env.file} already sets ${env.name}=${env.id}.`,
+      "Which Algolia application would you like to use?"
+    ]
+  });
+  if (choice === useEnv) return selectEnvApplication(env);
+  return current ? selectAndReport(current) : null;
+}
+async function selectEnvApplication(env) {
+  try {
+    return await selectAndReport({ id: env.id, name: "" });
+  } catch (err) {
+    logger.warn(
+      { app: env.id, err: err.message },
+      "could not select the application named in env; falling back to the picker"
+    );
+    return promptForApplication([
+      `Could not select ${env.id} from ${env.file} \u2014 it may have been removed, or this account may not have access to it.`
+    ]);
+  }
+}
+async function ensureApplication(isResuming) {
+  const current = await currentApplication();
+  if (isResuming) {
+    return current ?? await promptForApplication();
+  }
+  const env = await findEnvApplicationId();
+  if (env && env.id !== current?.id) {
+    const chosen = await confirmEnvApplication(env, current);
+    if (chosen) return chosen;
+  }
+  return promptForApplication();
+}
+
 // src/lib/algoliaApiKey.ts
-import { z as z12 } from "zod";
+import { z as z7 } from "zod";
 
 // src/lib/keychain.ts
 import { deletePassword, getPassword, setPassword } from "cross-keychain";
-import { z as z11 } from "zod";
+import { z as z6 } from "zod";
 var SERVICE = "algolia-wizard";
-var ACCOUNT = "api-keys";
-var storedKeysSchema = z11.record(z11.string(), z11.string());
+var account = (userId) => `api-keys:${userId}`;
+var storedKeysSchema = z6.record(z6.string(), z6.string());
 function entryId(kind, index, appId) {
   return `${kind}:${appId}:${index}`;
 }
-async function loadKeys() {
-  const raw = await getPassword(SERVICE, ACCOUNT);
+async function loadKeys(userId) {
+  const raw = await getPassword(SERVICE, account(userId));
   if (!raw) return {};
   let payload;
   try {
@@ -1944,47 +1880,47 @@ function serialized(op) {
   });
   return next;
 }
-async function readStoredKey(kind, index, appId) {
+async function readStoredKey(kind, userId, index, appId) {
   try {
-    return (await loadKeys())[entryId(kind, index, appId)] ?? null;
+    return (await loadKeys(userId))[entryId(kind, index, appId)] ?? null;
   } catch (err) {
     logger.warn(
-      { err: err.message, kind, index, appId },
+      { err: err.message, kind, index, appId, userId },
       "could not read the API key from the keychain"
     );
     return null;
   }
 }
-function storeKey(kind, index, appId, value) {
+function storeKey(kind, userId, index, appId, value) {
   return serialized(async () => {
     const id = entryId(kind, index, appId);
     try {
-      const keys = await loadKeys();
+      const keys = await loadKeys(userId);
       await setPassword(
         SERVICE,
-        ACCOUNT,
+        account(userId),
         JSON.stringify({ ...keys, [id]: value })
       );
-      if ((await loadKeys())[id] !== value) {
+      if ((await loadKeys(userId))[id] !== value) {
         throw new Error("the keychain did not store the value");
       }
     } catch (err) {
       logger.warn(
-        { err: err.message, kind, index, appId },
+        { err: err.message, kind, index, appId, userId },
         "could not store the API key in the keychain; the next run will create another"
       );
     }
   });
 }
-function deleteStoredKeys() {
+function deleteStoredKeys(userId) {
   return serialized(async () => {
     try {
-      await deletePassword(SERVICE, ACCOUNT);
+      await deletePassword(SERVICE, account(userId));
     } catch (err) {
       const message = err.message;
       if (/not found/i.test(message)) return;
       logger.warn(
-        { err: message },
+        { err: message, userId },
         "could not delete the API keys from the keychain"
       );
     }
@@ -1992,6 +1928,16 @@ function deleteStoredKeys() {
 }
 
 // src/lib/algoliaApiKey.ts
+function requireUserId() {
+  const userId = useWizard.getState().user?.userId;
+  if (!userId) {
+    throw new Error("No Algolia user is signed in; cannot scope the API key.");
+  }
+  return userId;
+}
+async function currentUserId() {
+  return useWizard.getState().user?.userId ?? (await getUser())?.userId ?? null;
+}
 var WRITE_ACLS = [
   "addObject",
   "deleteObject",
@@ -1999,9 +1945,9 @@ var WRITE_ACLS = [
   "editSettings",
   "listIndexes"
 ];
-var createdKeySchema = z12.object({
-  key: z12.string().min(1).optional(),
-  value: z12.string().min(1).optional()
+var createdKeySchema = z7.object({
+  key: z7.string().min(1).optional(),
+  value: z7.string().min(1).optional()
 }).transform((o) => o.key ?? o.value);
 async function createKey(index, acls, description) {
   logger.info({ index, acls }, "creating an API key");
@@ -2038,7 +1984,8 @@ async function keyExists(key) {
 var resolved = /* @__PURE__ */ new Map();
 async function forgetResolvedKeys() {
   resolved.clear();
-  await deleteStoredKeys();
+  const userId = await currentUserId();
+  if (userId) await deleteStoredKeys(userId);
 }
 function resolveKey(kind, index, appId, acls, description) {
   const cacheKey = `${kind}:${appId}:${index}`;
@@ -2054,7 +2001,8 @@ function resolveKey(kind, index, appId, acls, description) {
   return pending;
 }
 async function provisionKey(kind, index, appId, acls, description) {
-  const stored = await readStoredKey(kind, index, appId);
+  const userId = requireUserId();
+  const stored = await readStoredKey(kind, userId, index, appId);
   if (stored) {
     if (await keyExists(stored)) {
       logger.info({ kind, index, appId }, "reusing the stored API key");
@@ -2066,7 +2014,7 @@ async function provisionKey(kind, index, appId, acls, description) {
     );
   }
   const key = await createKey(index, acls, description);
-  await storeKey(kind, index, appId, key);
+  await storeKey(kind, userId, index, appId, key);
   return { key, source: "created" };
 }
 function resolveWriteKey(index, appId) {
@@ -2078,21 +2026,299 @@ function resolveWriteKey(index, appId) {
     `Algolia Wizard write key for ${index} index`
   );
 }
-async function resolveSearchOnlyKey(index, appId, envKey) {
-  if (envKey) return { key: envKey, source: "env" };
-  return resolveKey(
-    "search",
-    index,
-    appId,
-    ["search"],
-    `Algolia Wizard search-only key for ${index} index`
-  );
+async function resolveSearchOnlyKey(index, appId) {
+  return resolveKey(
+    "search",
+    index,
+    appId,
+    ["search"],
+    `Algolia Wizard search-only key for ${index} index`
+  );
+}
+
+// src/actions/selectIndex.ts
+var CREATE_NEW_INDEX = "Create a new index\u2026";
+async function canIssueKeys(index, appId) {
+  try {
+    await resolveWriteKey(index, appId);
+    await resolveSearchOnlyKey(index, appId);
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+var selectIndexStep = async (ctx) => {
+  let appId = (await requireApplication()).id;
+  for (; ; ) {
+    const indices = await listIndices();
+    const names = indices.map((i) => i.name);
+    const hasIndices = names.length > 0;
+    let error;
+    let chosen;
+    while (chosen === void 0) {
+      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 candidate;
+      if (!hasIndices) {
+        candidate = 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");
+        }
+        candidate = name.trim();
+      } else {
+        candidate = selection;
+      }
+      if (!candidate) {
+        error = "Index name cannot be empty.";
+        continue;
+      }
+      chosen = candidate;
+    }
+    const issued = await canIssueKeys(chosen, appId);
+    if (issued.ok) {
+      ctx.setUserInput("index", chosen);
+      return { selection: chosen };
+    }
+    logger.warn(
+      { appId, index: chosen, err: issued.error },
+      "selectIndex: could not mint API keys in the selected application; asking for another"
+    );
+    const reselected = await promptForApplication([
+      `Could not create an Algolia API key in application ${appId} (${issued.error}).`,
+      "Pick a different application to work in."
+    ]);
+    appId = reselected.id;
+  }
+};
+
+// src/lib/agent.ts
+import { ToolLoopAgent, hasToolCall, Output as Output3 } from "ai";
+import { createAnthropic as createAnthropic3 } from "@ai-sdk/anthropic";
+import "zod";
+
+// src/lib/tools/index.ts
+import "zod";
+
+// src/lib/tools/listFiles.ts
+import { tool } from "ai";
+import z8 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 dirname2, join as join6, 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, dirname2(target)).split(sep).filter(Boolean);
+  for (const part of parts) {
+    current = join6(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 a directory (default: the current working directory). Pass path to list a subdirectory directly \u2014 e.g. "packages/api" \u2014 without first changeDirectory-ing into it.',
+    inputSchema: z8.object({
+      path: z8.string().optional().describe("Directory to list, relative to cwd (default: cwd)")
+    }),
+    execute: async ({ path = "." }) => {
+      logger.info({ path }, "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 resolved2 = resolveInRoot(ctx, path);
+      if (!resolved2.ok) return resolved2.error;
+      try {
+        const entries = await readdir(resolved2.target, { withFileTypes: true });
+        return entries.map((e) => e.isDirectory() ? `${e.name}/` : e.name).join("\n");
+      } catch (err) {
+        return `Error listing ${path}: ${err.message}`;
+      }
+    }
+  });
+}
+
+// src/lib/tools/changeDirectory.ts
+import { tool as tool2 } from "ai";
+import z9 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: z9.object({
+      path: z9.string().describe("Directory to change into")
+    }),
+    execute: async ({ path }) => {
+      logger.info({ path }, "called changeDirectory tool");
+      const resolved2 = resolveInRoot(ctx, path);
+      if (!resolved2.ok) return resolved2.error;
+      try {
+        const info = await stat(resolved2.target);
+        if (!info.isDirectory()) {
+          return `Error changing directory to ${path}: not a directory`;
+        }
+        ctx.cwd = resolved2.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 z10 from "zod";
+function reportStatusTool(output) {
+  return tool3({
+    description: "Report the status of your execution. Return a reason in case of failure.",
+    inputSchema: z10.object({
+      status: z10.enum(["success", "fail"]),
+      reason: z10.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 z11 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: z11.object({
+      filePath: z11.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 resolved2 = resolveInRoot(ctx, filePath);
+      if (!resolved2.ok) return resolved2.error;
+      try {
+        const content = await readFile4(resolved2.target, "utf8");
+        return isEnvFile(resolved2.target) ? redactEnvValues(content) : content;
+      } catch (err) {
+        return `Error reading ${filePath}: ${err.message}`;
+      }
+    }
+  });
+}
+
+// src/lib/tools/writeFile.ts
+import { tool as tool5 } from "ai";
+import z12 from "zod";
+import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname3 } from "node:path";
+function writeFileTool(ctx) {
+  return tool5({
+    description: "Write content to a file at the given path, overwriting it. Writes to secret env files (.env, .env.local, etc.) are refused by this tool \u2014 call it anyway and the tool will tell you how to proceed.",
+    inputSchema: z12.object({
+      filePath: z12.string().describe("Path to the file to write"),
+      content: z12.string().describe("Content to write to the file")
+    }),
+    execute: async ({ filePath, content }) => {
+      logger.info({ filePath }, "called writeFile tool");
+      const resolved2 = resolveInRoot(ctx, filePath);
+      if (resolved2.ok === false) return resolved2.error;
+      if (isSecretEnvFile(resolved2.target)) {
+        return `Refused: ${filePath} holds secrets and cannot be written directly. If a writeCredentials tool is available, use it to set Algolia credentials. If not, tell the user to set the value manually \u2014 do not reproduce the secret value in your response.`;
+      }
+      try {
+        if (await hasSymlinkParent(ctx, resolved2.target)) {
+          return `Refused: ${resolved2.target} is outside the repo root (${ctx.root}).`;
+        }
+        await mkdir3(dirname3(resolved2.target), { recursive: true });
+        await writeFile3(resolved2.target, content, "utf8");
+        useWizard.getState().recordWrittenFile(resolved2.target);
+        return `Wrote to ${filePath}`;
+      } catch (err) {
+        return `Error writing ${filePath}: ${err.message}`;
+      }
+    }
+  });
 }
 
+// src/lib/tools/writeAlgoliaCredentials.ts
+import { tool as tool6 } from "ai";
+import z13 from "zod";
+import { mkdir as mkdir4, readFile as readFile6, writeFile as writeFile5 } from "node:fs/promises";
+import { dirname as dirname4, relative as relative3 } from "node:path";
+
 // src/lib/gitignore.ts
 import { execFile } from "node:child_process";
-import { lstat as lstat2, readFile as readFile4, writeFile as writeFile4 } from "node:fs/promises";
-import { join as join6, relative as relative2 } from "node:path";
+import { lstat as lstat2, readFile as readFile5, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join7, relative as relative2 } from "node:path";
 var GIT_ENV_OVERRIDES = [
   "GIT_DIR",
   "GIT_WORK_TREE",
@@ -2118,6 +2344,12 @@ function isIgnoredByRule(root, relPath) {
 function isTracked(root, relPath) {
   return gitSucceeds(root, ["ls-files", "--error-unmatch", "--", relPath]);
 }
+async function gitIgnoreStatus(root, target) {
+  const { ignoredByRule, tracked } = await inspect(root, target);
+  if (ignoredByRule === void 0) return "unknown";
+  if (tracked) return "tracked";
+  return ignoredByRule ? "covered" : "needsRule";
+}
 async function inspect(root, target) {
   const relPath = relative2(root, target);
   if (!relPath || relPath.startsWith("..")) {
@@ -2138,7 +2370,7 @@ async function ensureGitIgnored(root, target) {
   if (ignoredByRule === void 0) return "unknown";
   if (ignoredByRule) return tracked ? "tracked" : "covered";
   const pattern = relative2(root, target);
-  const gitIgnore = join6(root, ".gitignore");
+  const gitIgnore = join7(root, ".gitignore");
   try {
     const link = await lstat2(gitIgnore).catch(() => null);
     if (link?.isSymbolicLink()) {
@@ -2148,7 +2380,7 @@ async function ensureGitIgnored(root, target) {
       );
       return "unknown";
     }
-    const existing = link ? await readFile4(gitIgnore, "utf8") : "";
+    const existing = link ? await readFile5(gitIgnore, "utf8") : "";
     const prefix = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
     await writeFile4(gitIgnore, `${existing}${prefix}${pattern}
 `, "utf8");
@@ -2163,31 +2395,9 @@ async function ensureGitIgnored(root, target) {
 }
 
 // src/lib/tools/writeAlgoliaCredentials.ts
-var APP_ID_VAR = "ALGOLIA_APPLICATION_ID";
-var API_KEY_VAR = "ALGOLIA_WRITE_API_KEY";
+var APP_ID_VAR = "ALGOLIA_APP_ID";
+var API_KEY_VAR = "ALGOLIA_WRITE_KEY";
 var INDEX_NAME_VAR = "ALGOLIA_INDEX_NAME";
-var PUBLIC_APP_ID_SUFFIX = "ALGOLIA_APP_ID";
-var PUBLIC_SEARCH_KEY_SUFFIX = "ALGOLIA_SEARCH_KEY";
-var PUBLIC_INDEX_NAME_SUFFIX = "ALGOLIA_INDEX_NAME";
-function publicAppIdVar(prefix) {
-  return `${prefix}${PUBLIC_APP_ID_SUFFIX}`;
-}
-function publicSearchKeyVar(prefix) {
-  return `${prefix}${PUBLIC_SEARCH_KEY_SUFFIX}`;
-}
-function publicIndexNameVar(prefix) {
-  return `${prefix}${PUBLIC_INDEX_NAME_SUFFIX}`;
-}
-function publicSearchEnvVars(prefix, index, appId, searchKey) {
-  return [
-    { name: publicAppIdVar(prefix), value: appId ?? "<your-algolia-app-id>" },
-    {
-      name: publicSearchKeyVar(prefix),
-      value: searchKey ?? "<your-algolia-search-only-api-key>"
-    },
-    { name: publicIndexNameVar(prefix), value: index }
-  ];
-}
 function appendEnv(content, entries) {
   const prefix = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
   const lines = entries.map(([name, value]) => `${name}=${value}
@@ -2195,11 +2405,13 @@ function appendEnv(content, entries) {
   return content + prefix + lines;
 }
 function hasEnv(content, name) {
-  return new RegExp(`^(\\s*(?:export\\s+)?${name})\\s*=`, "m").test(content);
+  return new RegExp(`^([ \\t]*(?:export[ \\t]+)?${name})[ \\t]*=`, "m").test(
+    content
+  );
 }
 function readEnv(content, name) {
   const found = content.match(
-    new RegExp(`^\\s*(?:export\\s+)?${name}\\s*=\\s*(.*)$`, "m")
+    new RegExp(`^[ \\t]*(?:export[ \\t]+)?${name}[ \\t]*=[ \\t]*(.*)$`, "m")
   );
   if (!found) return null;
   const raw = found[1].trim();
@@ -2210,16 +2422,16 @@ function readEnv(content, name) {
 function upsertEnv(content, name, value) {
   if (!hasEnv(content, name)) return appendEnv(content, [[name, value]]);
   return content.replace(
-    new RegExp(`^\\s*(?:export\\s+)?${name}\\s*=.*$`, "gm"),
+    new RegExp(`^[ \\t]*(?:export[ \\t]+)?${name}[ \\t]*=.*$`, "gm"),
     () => `${name}=${value}`
   );
 }
 function writeCredentialsTool(ctx) {
   return tool6({
-    description: `Write the active Algolia credentials (${APP_ID_VAR} and ${API_KEY_VAR}) and the target index name (${INDEX_NAME_VAR}) into the given env file. The credentials come from the selected Algolia application, with a write key scoped to the target index; you only pass the path to the env file. ${INDEX_NAME_VAR} is always set to this run's target index, replacing any value already there. An ${APP_ID_VAR} or ${API_KEY_VAR} the file already gives a value is left untouched; a missing or blank one is filled in when it can be paired with the selected application. The env file is added to .gitignore automatically; do not edit .gitignore yourself.`,
+    description: `Write the active Algolia credentials (${APP_ID_VAR} and ${API_KEY_VAR}) and the target index name (${INDEX_NAME_VAR}) into the given env file. The credentials come from the selected Algolia application, with a write key scoped to the target index; you only pass the path to the env file. ${INDEX_NAME_VAR} is always set to this run's target index, replacing any value already there. An ${APP_ID_VAR} or ${API_KEY_VAR} the file already gives a value is left untouched; a missing or blank one is filled in when it can be paired with the selected application. The env file is added to .gitignore automatically; do not edit .gitignore yourself. If the script or app that reads these credentials lives in a subdirectory (e.g. a package in a monorepo), an env file at the repo root is the wrong default \u2014 a script only loads env vars from its own directory (or one it's explicitly configured to read), so check every directory from the script's own up to the repo root, not just those two: its own directory, each ancestor in between (a shared workspace-level directory above the immediate package is common), and the root. Use whichever of those already holds real credentials; only fall back to the repo root when none of them do. Never invent a brand-new file in one of those directories when a real one already exists in another \u2014 that leaves the real one stale and the new one wrong. Listing just the script's own directory and the very top-level root is not enough to find a workspace-level file in between; check the intermediate ones too. If instructions describe a location that doesn't match the project you actually find (e.g. a path outside the repo, or a convention the project doesn't follow), don't stop and ask before doing anything \u2014 call this tool on the real, in-repo file the script actually reads (that's always the safe default), then note the mismatch afterward. Ending your turn with only a question and no call to this tool leaves the project unconfigured.`,
     inputSchema: z13.object({
       filePath: z13.string().describe(
-        'Path to the env file to write credentials into (e.g. ".env")'
+        'Path to the env file to write credentials into, relative to the repo root (e.g. ".env", or "packages/api/.env" when the consuming script lives in that package)'
       )
     }),
     execute: async ({ filePath }) => {
@@ -2237,7 +2449,7 @@ function writeCredentialsTool(ctx) {
           return `Refused: ${resolved2.target} is outside the repo root (${ctx.root}).`;
         }
         try {
-          existing = await readFile5(resolved2.target, "utf8");
+          existing = await readFile6(resolved2.target, "utf8");
         } catch (err) {
           if (err.code !== "ENOENT") throw err;
         }
@@ -2327,8 +2539,8 @@ async function gitIgnoreOutcome(ctx, target) {
 // src/lib/tools/searchFiles.ts
 import { tool as tool7 } from "ai";
 import z14 from "zod";
-import { readdir as readdir2, readFile as readFile6 } from "node:fs/promises";
-import { join as join7 } from "node:path";
+import { readdir as readdir2, readFile as readFile7 } from "node:fs/promises";
+import { join as join8 } from "node:path";
 var MAX_QUERY_LENGTH = 1e3;
 var SKIP_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
@@ -2343,7 +2555,7 @@ async function walkFiles(dir) {
   const out = [];
   for (const e of await readdir2(dir, { withFileTypes: true })) {
     if (e.name.startsWith(".") || SKIP_DIRS.has(e.name)) continue;
-    const full = join7(dir, e.name);
+    const full = join8(dir, e.name);
     if (e.isDirectory()) out.push(...await walkFiles(full));
     else if (e.isFile()) out.push(full);
   }
@@ -2376,7 +2588,7 @@ function searchFilesTool(ctx) {
       for (const file of await walkFiles(resolved2.target)) {
         let content;
         try {
-          content = await readFile6(file, "utf8");
+          content = await readFile7(file, "utf8");
         } catch {
           continue;
         }
@@ -3180,6 +3392,7 @@ var detectLanguage = () => runAgent({
     "Return the exact version",
     "Exclude things like CSS frameworks, build tools, or testing frameworks",
     `Determine publicEnvVarPrefix: check the project's own env var usage first (e.g. names already referenced in code, .env/.env.example); if none exists, fall back to the detected framework's known convention for exposing env vars to client-side code; use "" when the project has no such convention (e.g. a backend-only project).`,
+    "A brand-new project has no existing env var usage to find \u2014 one or two targeted checks (e.g. .env/.env.example, or a grep for the bundler's public-prefix convention) are enough to confirm that. Do not keep searching once those turn up nothing; fall back to the framework convention immediately.",
     'Use as few tools as possible, but do not guess. If you cant find the answer, say "unknown"',
     "When done, call reportStatus"
   ],
@@ -3275,7 +3488,7 @@ async function runAnalysis(mode, extraInstructions = []) {
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.36.0",
+  version: "0.38.0-rc.131.265",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {
@@ -3299,6 +3512,7 @@ var package_default = {
     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:tools:improve": "tsx ./tool-evals/improveFromPlan.ts",
     test: "vitest",
     typecheck: "tsc --noEmit -p tsconfig.json"
   },
@@ -3680,14 +3894,14 @@ ${formatCompletedSteps(ctx.completedSteps)}`,
 };
 
 // src/actions/implement.ts
-import z29 from "zod";
+import z28 from "zod";
 import { mkdir as mkdir7 } from "node:fs/promises";
-import { join as join10, relative as relative6 } from "node:path";
+import { join as join11, relative as relative6 } from "node:path";
 
 // src/lib/git.ts
 import { execFile as execFile2 } from "node:child_process";
-import { copyFile, mkdir as mkdir6, readFile as readFile7, stat as stat3, writeFile as writeFile7 } from "node:fs/promises";
-import { basename as basename2, dirname as dirname6, isAbsolute as isAbsolute2, join as join8, resolve as resolve3 } from "node:path";
+import { copyFile, mkdir as mkdir6, stat as stat3 } from "node:fs/promises";
+import { basename as basename2, dirname as dirname6, isAbsolute as isAbsolute2, join as join9, resolve as resolve3 } from "node:path";
 var MAX_BUFFER = 32 * 1024 * 1024;
 function git(args) {
   return new Promise((resolve4, reject) => {
@@ -3724,8 +3938,8 @@ async function copyUploadIntoProject(repoRoot, ingestDir, sourcePath) {
   } catch {
     return { ok: false, reason: `"${sourcePath}" does not exist` };
   }
-  const relPath = join8(ingestDir, basename2(source));
-  const dest = join8(repoRoot, relPath);
+  const relPath = join9(ingestDir, basename2(source));
+  const dest = join9(repoRoot, relPath);
   if (resolve3(source) === resolve3(dest)) {
     return { ok: true, relPath };
   }
@@ -3740,42 +3954,6 @@ async function copyUploadIntoProject(repoRoot, ingestDir, sourcePath) {
   }
   return { ok: true, relPath };
 }
-function hasEnvVar(content, name) {
-  return new RegExp(`^(\\s*(?:export\\s+)?${name})\\s*=`, "m").test(content);
-}
-async function readEnvVar(repoRoot, name) {
-  let content;
-  try {
-    content = await readFile7(join8(repoRoot, ".env"), "utf8");
-  } catch (err) {
-    if (err.code !== "ENOENT") throw err;
-    return void 0;
-  }
-  const match = new RegExp(
-    `^[ \\t]*(?:export[ \\t]+)?${name}[ \\t]*=[ \\t]*(.*)$`,
-    "m"
-  ).exec(content);
-  if (!match) return void 0;
-  const value = match[1].trim().replace(/^(['"])(.*)\1$/, "$2").trim();
-  if (!value || value.startsWith("<")) return void 0;
-  return value;
-}
-async function writeSearchEnvValues(repoRoot, vars) {
-  const target = join8(repoRoot, ".env");
-  let existing = "";
-  try {
-    existing = await readFile7(target, "utf8");
-  } catch (err) {
-    if (err.code !== "ENOENT") throw err;
-  }
-  const missing = vars.filter((v) => !hasEnvVar(existing, v.name));
-  if (missing.length === 0) return [];
-  const prefix = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
-  const lines = missing.map(({ name, value }) => `${name}=${value}
-`).join("");
-  await writeFile7(target, existing + prefix + lines, "utf8");
-  return missing.map((v) => v.name);
-}
 function normalizeFindingPaths(findings) {
   return {
     ...findings,
@@ -3800,13 +3978,13 @@ function toRootRelative(p) {
 
 // src/lib/algoliaDocs.ts
 import { readFileSync, readdirSync, existsSync } from "node:fs";
-import { dirname as dirname7, join as join9 } from "node:path";
+import { dirname as dirname7, join as join10 } from "node:path";
 import { fileURLToPath } from "node:url";
-var DOCS_SUBPATH = join9("docs", "algolia-sdk");
+var DOCS_SUBPATH = join10("docs", "algolia-sdk");
 function findDocsDir() {
   let dir = dirname7(fileURLToPath(import.meta.url));
   for (; ; ) {
-    const candidate = join9(dir, DOCS_SUBPATH);
+    const candidate = join10(dir, DOCS_SUBPATH);
     if (existsSync(candidate)) return candidate;
     const parent = dirname7(dir);
     if (parent === dir) return void 0;
@@ -3829,7 +4007,7 @@ function loadAlgoliaDoc(language) {
     );
     return "";
   }
-  return readFileSync(join9(docsDir, files[0]), "utf8").trim();
+  return readFileSync(join10(docsDir, files[0]), "utf8").trim();
 }
 function getNamedDoc(name, language) {
   const docsDir = findDocsDir();
@@ -3837,7 +4015,7 @@ function getNamedDoc(name, language) {
     logger.warn("docs/algolia-sdk not found");
     return "";
   }
-  const file = join9(docsDir, `${name}-${language}.md`);
+  const file = join10(docsDir, `${name}-${language}.md`);
   if (!existsSync(file)) {
     logger.warn({ name, language }, "named SDK reference not found");
     return "";
@@ -3856,46 +4034,36 @@ function getFrameworkSpecificDoc(frameworks) {
   return loadAlgoliaDoc("js");
 }
 
-// src/actions/resolveEnvVarPrefix.ts
-import z28 from "zod";
-var resolveEnvVarPrefixSchema = z28.object({
-  publicEnvVarPrefix: detectLanguageSchema.shape.publicEnvVarPrefix
-});
-var resolveEnvVarPrefix = (frameworkName) => runAgent({
-  instructions: [
-    `The developer corrected the project's framework to "${frameworkName}".`,
-    `Determine publicEnvVarPrefix for this framework: check the project's own env var usage first (e.g. names already referenced in code, .env/.env.example); if none exists, fall back to this framework's known convention for exposing env vars to client-side code; use "" when the framework has no such convention (e.g. a backend-only framework).`,
-    '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: resolveEnvVarPrefixSchema,
-  modelSize: "small"
-});
-
 // src/actions/implement.ts
-var implementSchema = z29.object({
-  summary: z29.string(),
-  ingestCommand: z29.string().optional(),
-  ingestScriptRan: z29.boolean().optional(),
-  ingestRecordCount: z29.number().optional(),
-  ingestDurationMs: z29.number().optional(),
-  ingestionSource: z29.enum(["local", "fileUpload", "generated"]),
-  searchEnvVars: z29.array(
-    z29.object({
-      name: z29.string(),
-      value: z29.string()
-    })
-  ).optional()
+var implementSchema = z28.object({
+  summary: z28.string(),
+  ingestCommand: z28.string().optional(),
+  ingestScriptRan: z28.boolean().optional(),
+  ingestRecordCount: z28.number().optional(),
+  ingestDurationMs: z28.number().optional(),
+  ingestionSource: z28.enum(["local", "fileUpload", "generated"]),
+  searchConfig: z28.object({
+    filePath: z28.string().optional(),
+    vars: z28.array(
+      z28.object({
+        name: z28.string(),
+        value: z28.string()
+      })
+    )
+  }).optional()
 });
-var implementationOutputSchema = z29.object({
-  summary: z29.string(),
-  ingestCommand: z29.string().optional()
+var implementationOutputSchema = z28.object({
+  summary: z28.string(),
+  ingestCommand: z28.string().optional(),
+  // Only for the search use case: the path of whatever module the agent
+  // defined the Algolia config constants in, so the wizard can check it
+  // won't end up gitignored (it's public, meant to be committed).
+  searchConfigFile: z28.string().optional()
 });
-var verificationOutputSchema = z29.object({
-  summary: z29.string(),
-  sufficient: z29.boolean(),
-  additionalInstructions: z29.string().optional()
+var verificationOutputSchema = z28.object({
+  summary: z28.string(),
+  sufficient: z28.boolean(),
+  additionalInstructions: z28.string().optional()
 });
 var MAX_IMPLEMENT_VERIFICATION_ATTEMPTS = 3;
 var DEFAULT_IMPLEMENT_USE_CASES = ["ingestion", "search"];
@@ -3909,6 +4077,10 @@ function isJsProject(language) {
     (name) => JS_LANGUAGES.some((js) => name.includes(js))
   );
 }
+var SEARCH_CONFIG_APP_ID = "ALGOLIA_APP_ID";
+var SEARCH_CONFIG_SEARCH_KEY = "ALGOLIA_SEARCH_API_KEY";
+var SEARCH_CONFIG_INDEX_NAME = "ALGOLIA_INDEX_NAME";
+var SEARCH_KEY_PLACEHOLDER = "<your-algolia-search-only-api-key>";
 var UI_FRAMEWORKS = [
   { match: ["vue", "nuxt"], target: "Vue", doc: "vue" },
   { match: ["react", "next"], target: "React", doc: "react" },
@@ -3979,6 +4151,7 @@ function ingestionInstructions(input) {
       "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.",
       ...algoliaClientDoc(input),
       "Install the Algolia client with the project's own package manager via runShell, declaring it in whatever manifest the project uses (e.g. package.json, requirements.txt, Gemfile, go.mod, composer.json) so the dependency is not just installed ad hoc.",
+      `If the script loads its env vars from a file (e.g. via dotenv or an equivalent for its language) rather than the process environment directly, decide that up front and call writeCredentials on that file before you finish the script \u2014 do not wait to discover the need for it by having a writeFile call refused.`,
       "When the script is finished, call reviewScript with its path and wait: running it writes records to a live index, so the developer reads it first. Do not run it before that call returns.",
       'Then run the script yourself via runShell, and report the command you ran as "ingestCommand" so the developer can re-run it. Its explanation must say that running it writes records to Algolia.',
       "The summary should be extremely concise.",
@@ -4000,17 +4173,14 @@ function searchInstructions(input) {
     `Create the search experience as its own component in a new file, following the project's existing component conventions (location, naming, styling approach). Do not write it inline into an existing file.`,
     `Import and render that new component from ${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 search input and results list against the target index.`,
     "If a search box already exists, replace its usage with an import and render of your new component; remove the old implementation.",
-    `Read the index name from the ${publicIndexNameVar(input.publicEnvVarPrefix)} env var, which the wizard sets to "${input.targetIndex}". Never hardcode an index name or derive one from the project, file, or component name.`,
-    "Read the App ID, the search-only API key, and the index name from env vars; never hardcode them. A search-only key is safe to expose client-side.",
-    // The key is provisioned only after verification passes, and the wizard
-    // reads .env to decide whether a key already exists — an agent-invented
-    // value there would be reused as if it were real.
-    `Add Algolia App ID "${input.appId}"; leave the search-only key as a placeholder. Do not create or edit .env \u2014 the wizard writes the resolved key there itself.`,
-    // The wizard writes these exact names into .env right after this step.
-    `Use exactly these env var names in the code: ${input.searchEnvVars.map(({ name }) => name).join(", ")}.`,
+    "When rendering results with an existing shared component (e.g. a card), import and reuse that component rather than inlining its markup \u2014 inlining silently drops the styles and behavior its own file provides.",
+    `Define ${SEARCH_CONFIG_APP_ID}, ${SEARCH_CONFIG_SEARCH_KEY}, and ${SEARCH_CONFIG_INDEX_NAME} as exported constants in a module that fits this project's existing conventions for shared client-side config \u2014 reuse an existing one if it already holds config like this, or add a small new one otherwise. These are PUBLIC values, safe to commit and expose client-side: never read them from an environment variable or a .env* file, and never hardcode them anywhere except in that one module (import them wherever the search client needs them).`,
+    `Set ${SEARCH_CONFIG_APP_ID} to "${input.appId}" and ${SEARCH_CONFIG_INDEX_NAME} to "${input.targetIndex}".`,
+    input.searchKey ? `Set ${SEARCH_CONFIG_SEARCH_KEY} to "${input.searchKey}".` : `A real search-only key could not be provisioned${input.searchKeyError ? ` (${input.searchKeyError})` : ""} \u2014 set ${SEARCH_CONFIG_SEARCH_KEY} to the placeholder "${SEARCH_KEY_PLACEHOLDER}" and add a prominent TODO for the developer to fill in a real one.`,
+    'Report the repo-relative path of that module as "searchConfigFile" in your final status.',
     "Install any Algolia packages you import with the project's own package manager via runShell, and declare them in the project's dependency manifest.",
     "Match the styles of the application as closely as possible.",
-    "The summary should be extremely concise; do not mention env var setup or manual testing steps \u2014 the wizard writes the resolved credentials to .env and reports that separately."
+    "The summary should be extremely concise; do not mention manual testing steps."
   ];
 }
 function verificationInstructions(input) {
@@ -4141,21 +4311,6 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
     languages: ctx.getStepOutput("confirm-language")?.languages ?? scan.languages,
     frameworks: ctx.getStepOutput("confirm-framework")?.frameworks ?? scan.frameworks
   };
-  const normalizeFrameworkName = (name) => name.toLowerCase().replace(/[^a-z0-9]/g, "");
-  const confirmedPrimaryFramework = language.frameworks[0]?.name;
-  const frameworkWasCorrected = confirmedPrimaryFramework !== void 0 && !scan.frameworks.some(
-    (fw) => normalizeFrameworkName(fw.name) === normalizeFrameworkName(confirmedPrimaryFramework)
-  );
-  const publicEnvVarPrefixPromise = frameworkWasCorrected ? resolveEnvVarPrefix(confirmedPrimaryFramework).then(
-    (r) => r.publicEnvVarPrefix,
-    (err) => {
-      logger.warn(
-        { err, framework: confirmedPrimaryFramework },
-        "implement: could not re-resolve publicEnvVarPrefix after a framework correction; using the stale scan value"
-      );
-      return scan.publicEnvVarPrefix;
-    }
-  ) : Promise.resolve(scan.publicEnvVarPrefix);
   const selected = ctx.getStepOutput(
     "select-index"
   );
@@ -4207,7 +4362,7 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
   useWizard.getState().setTargetIndex(targetIndex ?? null);
   await assertGitRepoWithHead(repoRoot);
   if (useCases.includes("ingestion")) {
-    await mkdir7(join10(repoRoot, INGEST_DIR), { recursive: true });
+    await mkdir7(join11(repoRoot, INGEST_DIR), { recursive: true });
   }
   const normalized = normalizeFindingPaths(findings);
   const confirmed2 = normalized.confirmedEntities;
@@ -4220,6 +4375,10 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
   if (useCases.includes("ingestion")) {
     ingestAppId = appId ?? (await requireApplication()).id;
   }
+  let ingestWriteKey;
+  if (useCases.includes("ingestion") && ingestAppId) {
+    ingestWriteKey = (await resolveWriteKey(targetIndex, ingestAppId)).key;
+  }
   let uploadFilePath;
   let uploadWarning;
   if (ingestionSource === "fileUpload") {
@@ -4239,49 +4398,42 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
       );
     }
   }
-  const publicEnvVarPrefix = await publicEnvVarPrefixPromise;
+  const summaries = [];
+  if (uploadWarning) summaries.push(uploadWarning);
+  let searchKey;
+  let searchKeyError;
+  if (useCases.includes("search") && appId) {
+    try {
+      const resolved2 = await resolveSearchOnlyKey(targetIndex, appId);
+      searchKey = resolved2.key;
+      summaries.push(
+        resolved2.source === "created" ? `Created a new search-only Algolia API key for the "${targetIndex}" index in app ${appId} \u2014 safe to expose in frontend code.` : `Reused the existing search-only Algolia API key for the "${targetIndex}" index in app ${appId}.`
+      );
+    } catch (err) {
+      searchKeyError = err.message;
+      summaries.push(
+        `Could not provision a search-only Algolia API key (${searchKeyError}) \u2014 the search agent will scaffold a placeholder with a TODO for you to fill in.`
+      );
+      logger.warn(
+        { err: searchKeyError },
+        "implement: could not provision a search-only API key; the agent will scaffold a placeholder"
+      );
+    }
+  }
   const input = {
     findings: normalized,
     confirmed: confirmed2,
     searchLocation,
     targetIndex,
     language,
-    publicEnvVarPrefix,
     appId,
-    searchEnvVars: publicSearchEnvVars(publicEnvVarPrefix, targetIndex, appId),
+    searchKey,
+    searchKeyError,
     ingestDir: INGEST_DIR,
     ingestionSource,
     uploadFilePath,
     searchUiTarget: searchUiTarget(language)
   };
-  const summaries = [];
-  if (uploadWarning) summaries.push(uploadWarning);
-  let envSearchKey;
-  let envAppIdMismatch = false;
-  if (useCases.includes("search") && appId) {
-    const envAppId = await readEnvVar(
-      repoRoot,
-      publicAppIdVar(publicEnvVarPrefix)
-    );
-    if (envAppId === appId) {
-      envSearchKey = await readEnvVar(
-        repoRoot,
-        publicSearchKeyVar(publicEnvVarPrefix)
-      );
-    } else if (envAppId) {
-      envAppIdMismatch = true;
-      const appIdVarName = publicAppIdVar(publicEnvVarPrefix);
-      const searchKeyVarName = publicSearchKeyVar(publicEnvVarPrefix);
-      summaries.push(
-        `\u26A0\uFE0F .env already sets ${appIdVarName}=${envAppId}, but the active Algolia application is ${appId}. The wizard left those values alone \u2014 update ${appIdVarName} and ${searchKeyVarName} by hand, or searches will fail.`
-      );
-      logger.warn(
-        { envAppId, appId },
-        "implement: .env holds credentials for a different Algolia application; not reusing its search key"
-      );
-    }
-  }
-  let finalSearchEnvVars = input.searchEnvVars;
   let agentRuns = 0;
   let ingestCommand;
   let ingestScriptRan = false;
@@ -4289,9 +4441,9 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
   let ingestDurationMs;
   let ingestOutcomeMessage;
   const ingestKeyAppId = ingestAppId;
-  const ingestionTools = ingestKeyAppId ? makeToolContext(repoRoot, async () => ({
+  const ingestionTools = ingestKeyAppId && ingestWriteKey ? makeToolContext(repoRoot, async () => ({
     [APP_ID_VAR]: ingestKeyAppId,
-    [API_KEY_VAR]: (await resolveWriteKey(targetIndex, ingestKeyAppId)).key,
+    [API_KEY_VAR]: ingestWriteKey,
     [INDEX_NAME_VAR]: targetIndex
   })) : void 0;
   const searchTools = makeToolContext(repoRoot);
@@ -4391,6 +4543,7 @@ ${detail}` : ""}`
       ]
     });
   }
+  let searchConfigFile;
   if (useCases.includes("search")) {
     let extraInstructions = [];
     useWizard.getState().clearWrittenFiles();
@@ -4405,11 +4558,14 @@ ${detail}` : ""}`
           "implement: retrying search implementation after failed verification"
         );
       }
-      const { summary } = await runImplementationUseCase(
+      const searchResult = await runImplementationUseCase(
         "search",
         extraInstructions
       );
-      summaries.push(formatSummary("search", summary));
+      summaries.push(formatSummary("search", searchResult.summary));
+      if (searchResult.searchConfigFile) {
+        searchConfigFile = searchResult.searchConfigFile;
+      }
       const verification = await runVerificationUseCase();
       summaries.push(formatSummary("verification", verification.summary));
       if (verification.sufficient) {
@@ -4433,76 +4589,17 @@ ${detail}` : ""}`
       }
       extraInstructions = verificationRetryInstructions(verification);
     }
-    let searchKey;
-    let searchKeyError;
-    if (appId) {
-      try {
-        const resolved2 = await resolveSearchOnlyKey(
-          targetIndex,
-          appId,
-          envSearchKey
-        );
-        searchKey = resolved2.key;
-        summaries.push(
-          resolved2.source === "created" ? `Created a new search-only Algolia API key for the "${targetIndex}" index in app ${appId} \u2014 safe to expose in frontend code.` : `Reused the existing search-only Algolia API key for the "${targetIndex}" index in app ${appId}.`
-        );
-      } catch (err) {
-        searchKeyError = err.message;
-        logger.warn(
-          { err: searchKeyError },
-          "implement: could not provision a search-only API key; the .env value stays a placeholder"
-        );
-      }
-    }
-    finalSearchEnvVars = publicSearchEnvVars(
-      publicEnvVarPrefix,
-      targetIndex,
-      appId,
-      searchKey
-    );
-    const resolvedSearchEnvVars = finalSearchEnvVars.filter(
-      (v) => !v.value.startsWith("<")
-    );
-    if (resolvedSearchEnvVars.length > 0) {
-      const written = await writeSearchEnvValues(
+    if (searchConfigFile) {
+      const ignoreStatus = await gitIgnoreStatus(
         repoRoot,
-        resolvedSearchEnvVars
+        join11(repoRoot, searchConfigFile)
       );
-      if (written.length > 0) {
-        summaries.push(`Wrote ${written.join(", ")} to .env.`);
-      }
-      const ignored = await ensureGitIgnored(repoRoot, join10(repoRoot, ".env"));
-      if (ignored === "added") {
-        summaries.push("Added .env to .gitignore.");
-      } else if (ignored === "tracked") {
-        summaries.push(
-          '\u26A0\uFE0F .env is tracked by git, so a .gitignore rule cannot un-stage it. Run "git rm --cached .env" before committing, or the credentials go into history.'
-        );
-      }
-      const stale = [];
-      for (const v of resolvedSearchEnvVars) {
-        if (written.includes(v.name)) continue;
-        const current = await readEnvVar(repoRoot, v.name);
-        if (current && current !== v.value) stale.push(v);
-      }
-      if (stale.length > 0 && !envAppIdMismatch) {
+      if (ignoreStatus === "covered") {
         summaries.push(
-          `\u26A0\uFE0F .env already assigns a different value to ${stale.map((v) => `${v.name} (should be ${v.value})`).join(", ")} \u2014 the wizard left it alone. Fix it by hand, or searches will fail.`
-        );
-        logger.warn(
-          { vars: stale.map((v) => v.name) },
-          "implement: .env holds different values for the resolved search credentials; not overwriting them"
+          `\u26A0\uFE0F ${searchConfigFile} is gitignored, so this public, safe-to-share search config won't reach teammates or CI. Remove whatever .gitignore rule covers it.`
         );
       }
     }
-    const unresolvedSearchEnvVars = finalSearchEnvVars.filter(
-      (v) => v.value.startsWith("<")
-    );
-    if (unresolvedSearchEnvVars.length > 0) {
-      summaries.push(
-        `Could not resolve a value for ${unresolvedSearchEnvVars.map((v) => v.name).join(", ")} \u2014 fill it in manually in .env.` + (searchKeyError ? ` Reason: ${searchKeyError}` : "")
-      );
-    }
   } else {
     ctx.setUserInput("implementation", "success");
   }
@@ -4515,7 +4612,19 @@ ${detail}` : ""}`
       ...ingestRecordCount != null ? { ingestRecordCount } : {},
       ...ingestDurationMs != null ? { ingestDurationMs } : {}
     } : {},
-    ...useCases.includes("search") ? { searchEnvVars: finalSearchEnvVars } : {}
+    ...useCases.includes("search") ? {
+      searchConfig: {
+        filePath: searchConfigFile,
+        vars: [
+          { name: SEARCH_CONFIG_APP_ID, value: appId ?? "" },
+          {
+            name: SEARCH_CONFIG_SEARCH_KEY,
+            value: searchKey ?? SEARCH_KEY_PLACEHOLDER
+          },
+          { name: SEARCH_CONFIG_INDEX_NAME, value: targetIndex }
+        ]
+      }
+    } : {}
   };
 }
 
@@ -4561,8 +4670,8 @@ var defaultWorkflow = {
     defineStep({
       id: "select-index",
       title: "Set up index",
-      outputSchema: z30.object({
-        selection: z30.string()
+      outputSchema: z29.object({
+        selection: z29.string()
       }),
       run: (ctx) => selectIndexStep(ctx)
     }),
@@ -4629,7 +4738,7 @@ function getWorkflow(id) {
 }
 
 // src/ui/Welcome.tsx
-import { dirname as dirname8, join as join11 } from "node:path";
+import { dirname as dirname8, join as join12 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { useState as useState7 } from "react";
 import { Box as Box10, Spacer, Text as Text10, useInput as useInput3, useWindowSize as useWindowSize5 } from "ink";
@@ -4661,7 +4770,7 @@ var sidebarItems = [
 // src/ui/Welcome.tsx
 import Image, { TerminalInfoContext, defaultTerminalInfo } from "ink-picture";
 import { jsx as jsx8, jsxs as jsxs9 } from "react/jsx-runtime";
-var IMAGE_PATH = join11(dirname8(fileURLToPath2(import.meta.url)), "algolia.png");
+var IMAGE_PATH = join12(dirname8(fileURLToPath2(import.meta.url)), "algolia.png");
 var TERMINAL_INFO = {
   ...defaultTerminalInfo,
   supportsUnicode: true,
@@ -5489,7 +5598,8 @@ function App() {
     steps,
     inputReq,
     user,
-    workflow
+    workflow,
+    settingUpAppId
   } = useWizard();
   const { exit } = useApp();
   const { columns, rows } = useWindowSize7();
@@ -5504,7 +5614,7 @@ function App() {
   const isCommandApprovalPrompt = isAwaitingUserInput && inputReq?.promptType === "commandApproval";
   const promptPending = isAwaitingUserInput && !isCommandApprovalPrompt;
   const holdForTip = stepHasTips && promptPending && tipState === "revealing";
-  const showTips = stepHasTips && (phase === "running" || isCommandApprovalPrompt || holdForTip);
+  const showTips = stepHasTips && (phase === "running" && currentStep?.status === "running" || isCommandApprovalPrompt || holdForTip);
   const showNoticesInMain = !stepHasTips;
   const showNotices = !isAwaitingUserInput || holdForTip;
   useInput6(
@@ -5589,6 +5699,12 @@ function App() {
                           ] }),
                           /* @__PURE__ */ jsx17(Text19, { color: COLORS.muted, children: "A browser window will open \u2014 complete sign-in there." })
                         ] }),
+                        settingUpAppId && /* @__PURE__ */ jsx17(Box19, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ jsxs17(Text19, { color: COLORS.strong, bold: true, children: [
+                          /* @__PURE__ */ jsx17(Spinner2, { type: "dots" }),
+                          " Setting up wizard using app",
+                          " ",
+                          settingUpAppId
+                        ] }) }),
                         /* @__PURE__ */ jsx17(CliOutput, {}),
                         showTips && currentStep && /* @__PURE__ */ jsx17(
                           Tips,
@@ -5621,140 +5737,6 @@ function App() {
   );
 }
 
-// src/lib/envAppId.ts
-import { readFile as readFile8 } from "node:fs/promises";
-import { join as join12 } from "node:path";
-var ENV_FILES = [".env", ".env.local"];
-var APP_ID_LINE = /^[ \t]*(?:export[ \t]+)?([A-Z0-9_]*ALGOLIA_APP(?:LICATION)?_ID)[ \t]*=[ \t]*(.*)$/gm;
-async function findEnvApplicationId(root = process.cwd()) {
-  for (const file of ENV_FILES) {
-    let content;
-    try {
-      content = await readFile8(join12(root, file), "utf8");
-    } catch (err) {
-      if (err.code !== "ENOENT") {
-        logger.warn(
-          { file, err },
-          "could not read env file for an application id"
-        );
-      }
-      continue;
-    }
-    for (const [, name, raw] of content.matchAll(APP_ID_LINE)) {
-      const id = readValue(raw);
-      if (id) {
-        logger.info({ file, name, app: id }, "found an application id in env");
-        return { id, name, file };
-      }
-    }
-  }
-  return null;
-}
-function readValue(raw) {
-  const trimmed = raw.trim();
-  const quoted = trimmed.match(/^(['"])(.*)\1/);
-  const value = quoted ? quoted[2].trim() : trimmed.replace(/\s+#.*$/, "").trim();
-  return value.length > 0 && !value.startsWith("<") ? value : null;
-}
-
-// src/lib/algoliaAppPicker.ts
-function secondaryFor(app) {
-  return app.plan ? { kind: "badge", value: app.plan } : void 0;
-}
-function labelFor(app) {
-  return app.name.trim() ? `${app.name} \u2014 ${app.id}` : app.id;
-}
-function selectAndReport(app) {
-  useWizard.getState().pushCliOutput(
-    "stdout",
-    `Selecting ${labelFor(app)} \u2014 provisioning its API key\u2026`
-  );
-  return selectApplication(app.id);
-}
-async function promptForApplication(leadIn = []) {
-  const store = useWizard.getState();
-  const apps = await listApplications();
-  if (apps.length === 0) {
-    throw new Error(
-      "This Algolia account has no applications. Create one in the Algolia dashboard, or with `npx @algolia/cli@latest application create`, then restart the wizard."
-    );
-  }
-  if (apps.length === 1) {
-    const only = apps[0];
-    logger.info(
-      { app: only.id },
-      "single application on the account; selecting it"
-    );
-    for (const line of leadIn) store.pushCliOutput("stdout", line);
-    return selectAndReport(only);
-  }
-  const messages = [
-    ...leadIn,
-    "Which Algolia application should the wizard work in?"
-  ];
-  for (; ; ) {
-    const choice = await store.requestUserInput({
-      prompt: "Select an application",
-      promptType: "multipleChoice",
-      options: apps.map(labelFor),
-      secondary: apps.map(secondaryFor),
-      messages
-    });
-    const chosen = apps.find((app) => labelFor(app) === choice);
-    if (!chosen) {
-      throw new Error("Application picker received an unexpected selection");
-    }
-    try {
-      return await selectAndReport(chosen);
-    } catch (err) {
-      logger.warn(
-        { app: chosen.id, err: err.message },
-        "application select failed; re-prompting"
-      );
-      messages.push(
-        `Could not select \u201C${labelFor(chosen)}\u201D. It may have been removed \u2014 pick another.`
-      );
-    }
-  }
-}
-async function confirmEnvApplication(env, current) {
-  const useEnv = `Use ${env.id} (from ${env.file})`;
-  const choice = await useWizard.getState().requestUserInput({
-    prompt: "Select an application",
-    promptType: "multipleChoice",
-    options: [
-      useEnv,
-      current ? `Use ${labelFor(current)} (already selected)` : "Pick a different application"
-    ],
-    messages: [
-      `${env.file} already sets ${env.name}=${env.id}.`,
-      "Which Algolia application should the wizard work in?"
-    ]
-  });
-  return choice === useEnv;
-}
-async function selectEnvApplication(env) {
-  try {
-    return await selectAndReport({ id: env.id, name: "" });
-  } catch (err) {
-    logger.warn(
-      { app: env.id, err: err.message },
-      "could not select the application named in env; falling back to the picker"
-    );
-    return promptForApplication([
-      `Could not select ${env.id} from ${env.file} \u2014 it may have been removed, or this account may not have access to it.`
-    ]);
-  }
-}
-async function ensureApplication() {
-  const current = await currentApplication();
-  const env = await findEnvApplicationId();
-  if (env && env.id !== current?.id && await confirmEnvApplication(env, current)) {
-    return selectEnvApplication(env);
-  }
-  return current ?? await promptForApplication();
-}
-
 // src/lib/seed.ts
 var projectScan2 = {
   languages: [{ name: "TypeScript", version: "5.7.2" }],
@@ -5799,10 +5781,14 @@ var confirmFramework2 = {
 var search = {
   summary: "Added an InstantSearch-powered search box and results list, mounted in the shared header component.",
   ingestionSource: "generated",
-  searchEnvVars: [
-    { name: "NEXT_PUBLIC_ALGOLIA_APP_ID", value: "SEEDAPPID" },
-    { name: "NEXT_PUBLIC_ALGOLIA_SEARCH_KEY", value: "seedsearchkey" }
-  ]
+  searchConfig: {
+    filePath: "src/algolia.config.ts",
+    vars: [
+      { name: "ALGOLIA_APP_ID", value: "SEEDAPPID" },
+      { name: "ALGOLIA_SEARCH_API_KEY", value: "seedsearchkey" },
+      { name: "ALGOLIA_INDEX_NAME", value: "wizard_seed_products" }
+    ]
+  }
 };
 var review = {
   summaryPoints: [
@@ -6113,7 +6099,8 @@ async function run(workflow) {
   store.setUser(user);
   let app;
   try {
-    app = await ensureApplication();
+    const resuming = await isResumableWorkflow(workflow);
+    app = await ensureApplication(resuming);
   } catch (err) {
     store.setError(err instanceof Error ? err.message : String(err));
     await instance.waitUntilExit();