@algolia/wizard 0.83.0 → 0.84.0-rc.202.645

package/dist/main.js

@@ -884,20 +884,28 @@ function useScrollWindow({
     revealIndex
   };
 }
-function ScrollView({ scroll, children }) {
-  return /* @__PURE__ */ jsxs5(Box6, { ref: scroll.viewportRef, flexDirection: "column", flexGrow: 1, children: [
-    scroll.hiddenAbove > 0 && /* @__PURE__ */ jsxs5(Text6, { color: COLORS.dim, children: [
-      "\u2191 ",
-      scroll.hiddenAbove,
-      " more"
-    ] }),
-    children,
-    scroll.hiddenBelow > 0 && /* @__PURE__ */ jsxs5(Text6, { color: COLORS.dim, children: [
-      "\u2193 ",
-      scroll.hiddenBelow,
-      " more"
-    ] })
-  ] });
+function ScrollView({ scroll, grow = true, children }) {
+  return /* @__PURE__ */ jsxs5(
+    Box6,
+    {
+      ref: scroll.viewportRef,
+      flexDirection: "column",
+      flexGrow: grow ? 1 : 0,
+      children: [
+        scroll.hiddenAbove > 0 && /* @__PURE__ */ jsxs5(Text6, { color: COLORS.dim, children: [
+          "\u2191 ",
+          scroll.hiddenAbove,
+          " more"
+        ] }),
+        children,
+        scroll.hiddenBelow > 0 && /* @__PURE__ */ jsxs5(Text6, { color: COLORS.dim, children: [
+          "\u2193 ",
+          scroll.hiddenBelow,
+          " more"
+        ] })
+      ]
+    }
+  );
 }
 
 // src/ui/Review.tsx
@@ -1082,6 +1090,7 @@ function CommandApproval({
     if (scroll.measured) setWidth(scroll.width);
   }, [scroll.measured, scroll.width]);
   const scrollable = scroll.maxOffset > 0;
+  const grow = width === 0 || scrollable;
   useInput3(
     (input) => {
       if (input === "k") scroll.scrollBy(-1);
@@ -1104,10 +1113,10 @@ function CommandApproval({
         borderBottom: false,
         borderRight: false,
         width: "100%",
-        flexGrow: 1,
+        flexGrow: grow ? 1 : 0,
         flexShrink: 1,
         minHeight: 3,
-        children: /* @__PURE__ */ jsx6(ScrollView, { scroll, children: visible.map((line, i) => /* @__PURE__ */ jsxs7(Text8, { wrap: "truncate", children: [
+        children: /* @__PURE__ */ jsx6(ScrollView, { scroll, grow, children: visible.map((line, i) => /* @__PURE__ */ jsxs7(Text8, { wrap: "truncate", children: [
           line.prefix ? /* @__PURE__ */ jsx6(Text8, { color: COLORS.muted, children: line.prefix }) : null,
           /* @__PURE__ */ jsx6(Text8, { color: line.color, children: line.text })
         ] }, `cmd-${scroll.offset + i}`)) })
@@ -1483,7 +1492,7 @@ function PromptInput() {
 }
 
 // src/workflows/default.ts
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 
 // src/core/orchestrator.ts
 import "zod";
@@ -2306,7 +2315,7 @@ async function ensureApplication(resumeAppId) {
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.83.0",
+  version: "0.84.0-rc.202.645",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {
@@ -2797,6 +2806,22 @@ async function listIndices() {
 
 // src/actions/selectIndex.ts
 var CREATE_NEW_INDEX = "Create a new index\u2026";
+var MAX_INDEX_NAME_LENGTH = 255;
+function indexNameError(name) {
+  if (!name) return "Index name cannot be empty.";
+  if (name.length > MAX_INDEX_NAME_LENGTH)
+    return `Index name cannot be longer than ${MAX_INDEX_NAME_LENGTH} characters.`;
+  if (name.startsWith(".")) return "Index name cannot start with '.'.";
+  if (/[/~,\\`&|;$*]/.test(name))
+    return "Index name cannot contain any of these characters: / ~ , \\ ` & | ; $ *";
+  if (/[\p{Cc}]/u.test(name))
+    return "Index name cannot contain control characters.";
+  if (/[\u{10000}-\u{10FFFF}]/u.test(name))
+    return "Index name cannot contain characters outside the Basic Multilingual Plane.";
+  if (/\.(txt|bin|idx)$/.test(name) && !name.endsWith(".indice.bin"))
+    return "Index name cannot end with .txt, .bin, or .idx.";
+  return void 0;
+}
 var selectIndexStep = async (ctx) => {
   await requireApplication(ctx.appId);
   const indices = await listIndices();
@@ -2824,6 +2849,7 @@ var selectIndexStep = async (ctx) => {
       throw new Error("selectIndex received an unexpected non-text result");
     }
     let candidate;
+    let isNewName = true;
     if (!hasIndices) {
       candidate = selection.trim();
     } else if (selection === CREATE_NEW_INDEX) {
@@ -2838,9 +2864,11 @@ var selectIndexStep = async (ctx) => {
       candidate = name.trim();
     } else {
       candidate = selection;
+      isNewName = false;
     }
-    if (!candidate) {
-      error = "Index name cannot be empty.";
+    const nameError = isNewName ? indexNameError(candidate) : void 0;
+    if (nameError) {
+      error = nameError;
       continue;
     }
     chosen = candidate;
@@ -2856,6 +2884,7 @@ import {
   Output as Output3,
   APICallError,
   NoOutputGeneratedError,
+  RetryError,
   stepCountIs
 } from "ai";
 import { createAnthropic as createAnthropic3 } from "@ai-sdk/anthropic";
@@ -2869,6 +2898,58 @@ import { tool } from "ai";
 import z6 from "zod";
 import { readdir } from "node:fs/promises";
 
+// src/lib/tools/context.ts
+var DEFAULT_TOOL_LIMITS = {
+  list: 10,
+  search: 20,
+  read: 20,
+  match: 100,
+  shell: 50
+};
+var EMPTY_TOOL_COUNTS = {
+  list: 0,
+  search: 0,
+  read: 0,
+  shell: 0
+};
+var DEFAULT_SHELL_TIMEOUT_MS = 10 * 60 * 1e3;
+async function refuseByDefault() {
+  return "reject";
+}
+async function emptyShellEnv() {
+  await Promise.resolve();
+  return {};
+}
+function createShellContext(overrides = {}) {
+  return {
+    env: emptyShellEnv,
+    secretEnv: emptyShellEnv,
+    timeoutMs: DEFAULT_SHELL_TIMEOUT_MS,
+    executions: [],
+    approve: refuseByDefault,
+    ...overrides
+  };
+}
+function createToolContext(limits = DEFAULT_TOOL_LIMITS, cwd = process.cwd(), shell2 = createShellContext()) {
+  return {
+    root: cwd,
+    cwd,
+    limits: { ...limits },
+    counts: { ...EMPTY_TOOL_COUNTS },
+    shell: shell2,
+    reviewed: []
+  };
+}
+function readLimitRefusal(kind, limit) {
+  return `Refused: ${kind} limit (${limit}) reached. This limit is not a failure, so do not report fail because of it. Finish the task now with the information you already have. If the task changes files, write or edit every file that the task still needs. Then report success, and name any gap in the summary.`;
+}
+function readLimitReached(ctx) {
+  return ctx.counts.read > ctx.limits.read || ctx.counts.search > ctx.limits.search || ctx.counts.list > ctx.limits.list;
+}
+function resetToolCounts(ctx) {
+  Object.assign(ctx.counts, EMPTY_TOOL_COUNTS);
+}
+
 // src/lib/tools/path.ts
 import { constants } from "node:fs";
 import { lstat, mkdir as mkdir3, open } from "node:fs/promises";
@@ -2950,7 +3031,7 @@ function listFilesTool(ctx) {
     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.`;
+        return readLimitRefusal("list", ctx.limits.list);
       }
       const resolved2 = resolveInRoot(ctx, path);
       if (!resolved2.ok) return resolved2.error;
@@ -3026,6 +3107,9 @@ function isSecretEnvFile(filePath) {
   const name = basename(filePath);
   return !/\.(example|sample|template)$/.test(name);
 }
+function secretEnvWriteRefusal(filePath) {
+  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.`;
+}
 
 // src/lib/tools/utils/truncateText.ts
 var HEAD_CHARS = 4e3;
@@ -3095,7 +3179,7 @@ function readFileTool(ctx) {
     }),
     execute: async ({ filePath, readLines }) => {
       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.`;
+        return readLimitRefusal("read", ctx.limits.read);
       }
       logger.info({ filePath, readLines }, "called readFile tool");
       const resolved2 = resolveInRoot(ctx, filePath);
@@ -3116,7 +3200,7 @@ import { tool as tool5 } from "ai";
 import z10 from "zod";
 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.",
+    description: "Write content to a file at the given path, overwriting it. Use it to create a file or to replace all of its content; to change part of an existing file, use editFile. 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: z10.object({
       filePath: z10.string().describe("Path to the file to write"),
       content: z10.string().describe("Content to write to the file")
@@ -3126,7 +3210,7 @@ function writeFileTool(ctx) {
       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.`;
+        return secretEnvWriteRefusal(filePath);
       }
       try {
         const writeError = await safeWriteFile(ctx, resolved2.target, content);
@@ -3140,22 +3224,107 @@ function writeFileTool(ctx) {
   });
 }
 
-// src/lib/tools/writeAlgoliaCredentials.ts
+// src/lib/tools/editFile.ts
 import { tool as tool6 } from "ai";
-import z13 from "zod";
-import { readFile as readFile6 } from "node:fs/promises";
+import z11 from "zod";
+import { readFile as readFile5 } from "node:fs/promises";
+var SNIPPET_CONTEXT_LINES = 3;
+var SNIPPET_MAX_LINES = 40;
+function countOccurrences(content, search2) {
+  let count = 0;
+  let index = content.indexOf(search2);
+  while (index !== -1) {
+    count += 1;
+    index = content.indexOf(search2, index + search2.length);
+  }
+  return count;
+}
+function replaceFirst(content, search2, replacement) {
+  const index = content.indexOf(search2);
+  return content.slice(0, index) + replacement + content.slice(index + search2.length);
+}
+function editedSnippet(updated, editIndex, newString) {
+  const lines = updated.split("\n");
+  const editStart = updated.slice(0, editIndex).split("\n").length - 1;
+  const editEnd = updated.slice(0, editIndex + newString.length).split("\n").length - (newString.endsWith("\n") ? 1 : 0);
+  const from = Math.max(0, editStart - SNIPPET_CONTEXT_LINES);
+  const to = Math.min(
+    lines.length,
+    editEnd + SNIPPET_CONTEXT_LINES,
+    from + SNIPPET_MAX_LINES
+  );
+  return `readLines [${from}, ${to}] now contains:
+${truncateText(lines.slice(from, to).join("\n"))}`;
+}
+function editFileTool(ctx) {
+  return tool6({
+    description: "Edit an existing file by replacing an exact string with a new string. Prefer this over writeFile for any change to an existing file: send only the changed part, not the whole file. oldString must match the file content exactly, including whitespace and indentation, and must be unique unless replaceAll is true. Include enough surrounding lines to make it unique. Read the file first so the match is exact. A single edit returns the edited lines with some context, so do not read the file again to check the edit.",
+    inputSchema: z11.object({
+      filePath: z11.string().describe("Path to the file to edit"),
+      oldString: z11.string().describe("Exact text to replace"),
+      newString: z11.string().describe("Text to put in place of oldString"),
+      replaceAll: z11.boolean().optional().describe("Replace every occurrence of oldString (default false)")
+    }),
+    execute: async ({ filePath, oldString, newString, replaceAll }) => {
+      logger.info({ filePath, replaceAll }, "called editFile tool");
+      const resolved2 = resolveInRoot(ctx, filePath);
+      if (resolved2.ok === false) return resolved2.error;
+      if (isSecretEnvFile(resolved2.target)) {
+        return secretEnvWriteRefusal(filePath);
+      }
+      if (oldString === "") {
+        return "Error: oldString is empty. To create a file, use writeFile.";
+      }
+      if (oldString === newString) {
+        return "Error: oldString and newString are identical. No change made.";
+      }
+      try {
+        const unsafe = await validateSafeWriteTarget(ctx, resolved2.target);
+        if (unsafe) return unsafe;
+        let content;
+        try {
+          content = await readFile5(resolved2.target, "utf8");
+        } catch (err) {
+          if (err.code === "ENOENT") {
+            return `Error: ${filePath} does not exist. To create it, use writeFile.`;
+          }
+          throw err;
+        }
+        const matches = countOccurrences(content, oldString);
+        if (matches === 0) {
+          return `Error: oldString not found in ${filePath}. Read the file again and copy the exact text, including whitespace.`;
+        }
+        if (matches > 1 && !replaceAll) {
+          return `Error: oldString matches ${matches} places in ${filePath}. Add surrounding lines to make it unique, or set replaceAll to true.`;
+        }
+        const updated = replaceAll ? content.split(oldString).join(newString) : replaceFirst(content, oldString, newString);
+        const writeError = await safeWriteFile(ctx, resolved2.target, updated);
+        if (writeError) return writeError;
+        useWizard.getState().recordWrittenFile(resolved2.target);
+        return matches > 1 ? `Edited ${filePath} (${matches} replacements)` : `Edited ${filePath}. ${editedSnippet(updated, content.indexOf(oldString), newString)}`;
+      } catch (err) {
+        return `Error editing ${filePath}: ${err.message}`;
+      }
+    }
+  });
+}
+
+// src/lib/tools/writeAlgoliaCredentials.ts
+import { tool as tool7 } from "ai";
+import z14 from "zod";
+import { readFile as readFile7 } from "node:fs/promises";
 import { relative as relative3 } from "node:path";
 
 // src/lib/algoliaApiKey.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 
 // src/lib/keychain.ts
 import { createHash } from "node:crypto";
 import { deletePassword, getPassword, setPassword } from "cross-keychain";
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var SERVICE = "algolia-wizard";
 var account = (userId) => `api-keys-${createHash("sha256").update(userId).digest("hex")}`;
-var storedKeysSchema = z11.record(z11.string(), z11.string());
+var storedKeysSchema = z12.record(z12.string(), z12.string());
 function entryId(kind, index, appId) {
   return `${kind}:${appId}:${index}`;
 }
@@ -3249,9 +3418,9 @@ var WRITE_ACLS = [
   "editSettings",
   "listIndexes"
 ];
-var createdKeySchema = z12.object({
-  key: z12.string().min(1).optional(),
-  value: z12.string().min(1).optional()
+var createdKeySchema = z13.object({
+  key: z13.string().min(1).optional(),
+  value: z13.string().min(1).optional()
 }).transform((o) => o.key ?? o.value);
 async function createKey(index, acls, description) {
   logger.info({ index, acls }, "creating an API key");
@@ -3347,7 +3516,7 @@ async function resolveSearchOnlyKey(index, appId) {
 
 // src/lib/gitignore.ts
 import { execFile } from "node:child_process";
-import { lstat as lstat2, readFile as readFile5, writeFile as writeFile3 } from "node:fs/promises";
+import { lstat as lstat2, readFile as readFile6, writeFile as writeFile3 } from "node:fs/promises";
 import { join as join7, relative as relative2 } from "node:path";
 var GIT_ENV_OVERRIDES = [
   "GIT_DIR",
@@ -3410,7 +3579,7 @@ async function ensureGitIgnored(root, target) {
       );
       return "unknown";
     }
-    const existing = link ? await readFile5(gitIgnore, "utf8") : "";
+    const existing = link ? await readFile6(gitIgnore, "utf8") : "";
     const prefix = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
     await writeFile3(gitIgnore, `${existing}${prefix}${pattern}
 `, "utf8");
@@ -3457,10 +3626,10 @@ function upsertEnv(content, name, value) {
   );
 }
 function writeCredentialsTool(ctx) {
-  return tool6({
+  return tool7({
     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(
+    inputSchema: z14.object({
+      filePath: z14.string().describe(
         '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)'
       )
     }),
@@ -3478,7 +3647,7 @@ function writeCredentialsTool(ctx) {
         const targetError = await validateSafeWriteTarget(ctx, resolved2.target);
         if (targetError) return targetError;
         try {
-          existing = await readFile6(resolved2.target, "utf8");
+          existing = await readFile7(resolved2.target, "utf8");
         } catch (err) {
           if (err.code !== "ENOENT") throw err;
         }
@@ -3567,9 +3736,9 @@ async function gitIgnoreOutcome(ctx, target) {
 
 // src/lib/tools/searchFiles.ts
 import { execFile as execFile2 } from "node:child_process";
-import { tool as tool7 } from "ai";
-import z14 from "zod";
-import { lstat as lstat3, readdir as readdir2, readFile as readFile7, realpath, stat as stat2 } from "node:fs/promises";
+import { tool as tool8 } from "ai";
+import z15 from "zod";
+import { lstat as lstat3, readdir as readdir2, readFile as readFile8, realpath, stat as stat2 } from "node:fs/promises";
 import { isAbsolute as isAbsolute2, join as join8, relative as relative4, sep as sep2 } from "node:path";
 import { performance } from "node:perf_hooks";
 import { Worker } from "node:worker_threads";
@@ -3940,16 +4109,16 @@ function formatSearchResult(matches, skippedFiles, deadlineReached, workerFailed
   return lines.length > 0 ? lines.join("\n") : "No matches";
 }
 function searchFilesTool(ctx) {
-  return tool7({
+  return tool8({
     description: "Search file contents for a JavaScript regular expression (RegExp syntax, not grep/PCRE). Returns matching lines as file:line:text.",
-    inputSchema: z14.object({
-      query: z14.string().describe("JavaScript RegExp pattern to search for"),
-      path: z14.string().optional().describe("Directory to search in (default: cwd)")
+    inputSchema: z15.object({
+      query: z15.string().describe("JavaScript RegExp pattern to search for"),
+      path: z15.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.`;
+        return readLimitRefusal("search", ctx.limits.search);
       }
       if (query.length > MAX_QUERY_LENGTH) {
         return `Refused: query exceeds ${MAX_QUERY_LENGTH} characters. Use a shorter pattern.`;
@@ -3992,7 +4161,7 @@ function searchFilesTool(ctx) {
             try {
               const filePath = await safeSearchPath(rootPath, file);
               if (filePath === null) continue;
-              content = await readFile7(filePath, "utf8");
+              content = await readFile8(filePath, "utf8");
             } catch {
               continue;
             }
@@ -4079,16 +4248,16 @@ function searchFilesTool(ctx) {
 }
 
 // src/lib/tools/runShell.ts
-import { tool as tool9, generateText, Output } from "ai";
+import { tool as tool10, generateText, Output } from "ai";
 import { createAnthropic } from "@ai-sdk/anthropic";
-import z16 from "zod";
+import z17 from "zod";
 import { relative as relative6 } from "node:path";
 
 // src/lib/tools/reviewScript.ts
-import { tool as tool8 } from "ai";
-import z15 from "zod";
+import { tool as tool9 } from "ai";
+import z16 from "zod";
 import { createHash as createHash2 } from "node:crypto";
-import { readFile as readFile8, stat as stat3 } from "node:fs/promises";
+import { readFile as readFile9, stat as stat3 } from "node:fs/promises";
 import { basename as basename2, relative as relative5, resolve as resolve3 } from "node:path";
 
 // src/lib/tools/utils/prompt.ts
@@ -4103,7 +4272,7 @@ function serializePrompt(work) {
 // src/lib/tools/reviewScript.ts
 var reviewedCommandApprovals = /* @__PURE__ */ new WeakMap();
 async function fileDigest(filePath) {
-  const content = await readFile8(filePath);
+  const content = await readFile9(filePath);
   return createHash2("sha256").update(content).digest("hex");
 }
 function grantReviewedCommandApproval(ctx, approval) {
@@ -4207,18 +4376,18 @@ async function reviewedCommandApprovalIsCurrent(approval) {
   return currentDigest === approval.digest;
 }
 function reviewScriptTool(ctx) {
-  return tool8({
+  return tool9({
     description: "Call this as soon as the ingestion script is finished and before you run it. It summarizes the records that will be written, then asks the user to review the script and approve the exact command that will run it, so a matching runShell call needs no second approval.",
-    inputSchema: z15.object({
-      filePath: z15.string().describe(
+    inputSchema: z16.object({
+      filePath: z16.string().describe(
         "Path to the script to review, relative to the project root."
       ),
-      command: z15.string().min(1).describe("The exact command that runShell will use to run the script."),
-      cwd: z15.string().describe(
+      command: z16.string().min(1).describe("The exact command that runShell will use to run the script."),
+      cwd: z16.string().describe(
         "The exact working directory that runShell will use, relative to the current tool working directory."
       ),
-      entityName: z15.string().trim().min(1).max(100).regex(/^[^\r\n]+$/).describe("The exact entity name selected by the user."),
-      usesGeneratedRecords: z15.boolean().describe(
+      entityName: z16.string().trim().min(1).max(100).regex(/^[^\r\n]+$/).describe("The exact entity name selected by the user."),
+      usesGeneratedRecords: z16.boolean().describe(
         "Whether the script reads generated sample records instead of the selected real data source."
       )
     }),
@@ -4309,54 +4478,6 @@ function redactSecrets(output, secrets) {
 
 // src/lib/tools/utils/runShell.ts
 import { spawn as spawn2 } from "node:child_process";
-
-// src/lib/tools/context.ts
-var DEFAULT_TOOL_LIMITS = {
-  list: 10,
-  search: 20,
-  read: 20,
-  match: 100,
-  shell: 50
-};
-var EMPTY_TOOL_COUNTS = {
-  list: 0,
-  search: 0,
-  read: 0,
-  shell: 0
-};
-var DEFAULT_SHELL_TIMEOUT_MS = 10 * 60 * 1e3;
-async function refuseByDefault() {
-  return "reject";
-}
-async function emptyShellEnv() {
-  await Promise.resolve();
-  return {};
-}
-function createShellContext(overrides = {}) {
-  return {
-    env: emptyShellEnv,
-    secretEnv: emptyShellEnv,
-    timeoutMs: DEFAULT_SHELL_TIMEOUT_MS,
-    executions: [],
-    approve: refuseByDefault,
-    ...overrides
-  };
-}
-function createToolContext(limits = DEFAULT_TOOL_LIMITS, cwd = process.cwd(), shell2 = createShellContext()) {
-  return {
-    root: cwd,
-    cwd,
-    limits: { ...limits },
-    counts: { ...EMPTY_TOOL_COUNTS },
-    shell: shell2,
-    reviewed: []
-  };
-}
-function resetToolCounts(ctx) {
-  Object.assign(ctx.counts, EMPTY_TOOL_COUNTS);
-}
-
-// src/lib/tools/utils/runShell.ts
 var SIGKILL_DELAY_MS = 5e3;
 function runShell(command, opts) {
   const timeoutMs = opts.timeoutMs ?? DEFAULT_SHELL_TIMEOUT_MS;
@@ -4618,9 +4739,9 @@ function fastPathSafety(command) {
   if (results.every((r) => r === true)) return true;
   return void 0;
 }
-var commandSafetySchema = z16.object({
-  safe: z16.boolean(),
-  reason: z16.string().describe("One short sentence explaining the verdict.")
+var commandSafetySchema = z17.object({
+  safe: z17.boolean(),
+  reason: z17.string().describe("One short sentence explaining the verdict.")
 });
 function defaultCreateModel() {
   const token = getAuthToken();
@@ -4661,17 +4782,17 @@ async function classifyCommandSafety(createModel, command, cwd, explanation, app
       prompt: [
         "A coding agent wants to run this shell command in a user's project without asking for approval first. The command may be in any programming language or ecosystem.",
         "Judge it SAFE only if it cannot modify, delete, move, rename, or install anything the project cares about, cannot push/publish/deploy/commit anything, and cannot make a network request that changes remote state.",
-        "Never judge a command SAFE if it runs, imports, requires, or otherwise references an ingestion script or any path under `.algolia-wizard/`. This rule includes shell wrappers, inline code, variable indirection, and dry-run or check descriptions. Such a command always requires explicit user approval.",
+        "Never judge a command SAFE if it runs, imports, requires, or otherwise executes an ingestion script or any code under `.algolia-wizard/`. This rule includes shell wrappers, inline code, variable indirection, and dry-run or check descriptions, and no earlier approval overrides it. Type-checking, parsing, or compiling such a file without running it (e.g. `tsc --noEmit <file>`, `node --check <file>`) does not execute it: judge that check unsafe the first time, and SAFE when the precedent rule at the end applies.",
         "Three broad categories are safe, and most commands you will see fall into one of them:",
         "(1) Reporting or listing existing state, with no side effect \u2014 e.g. `git status`, `npm ls`, `npm outdated`, `pip show`, `pip freeze`, `cargo tree`, `docker ps`, `docker images`, `kubectl get pods`, `terraform state list`. This includes a read-only GET-style query to a remote registry or API that only fetches public metadata and changes nothing remote (e.g. `npm view <package>`, `pip index versions <package>`, `curl` with no -X/--request other than GET and no -d/--data) \u2014 safe because nothing changes, not because it stays local.",
         '(2) A "preview" or "check" mode that reports what a change WOULD do, or reports a problem, without making the change. This is a general pattern, not a fixed list \u2014 ANY command that takes a dry-run/check/plan/validate/diff/list-only flag is safe when that flag is present, regardless of whether the same flag would normally appear on a "safe" kind of command: `terraform plan`, `terraform validate`, `terraform fmt -check`, `black --check`, `prettier --check`, `isort --check`, `gofmt -l` (list-only), `stylelint` with no `--fix`, and equally `git push --dry-run`, `npm publish --dry-run`, `kubectl apply --dry-run=client` \u2014 these last three are otherwise-unsafe operations (push, publish, cluster changes) that the dry-run flag turns into a report. The corresponding command WITHOUT that flag (e.g. `terraform apply`, `black .`, `gofmt -w`, `git push`) is a different, unsafe command \u2014 the flag is what makes the difference, for any tool, not just the ones named here. This cuts both ways, so do not assume a bare invocation is the safe one: `cargo fmt`, `black`, `prettier`, `isort`, `rustfmt`, and `terraform fmt` all REWRITE FILES by default and need an explicit check/diff/dry-run flag to become safe, while `gofmt`, `eslint`, `stylelint`, `rubocop`, and `ruff check` default to a safe check-only mode and need an explicit fix/write flag to become unsafe \u2014 the same-looking bare command is safe for one group and unsafe for the other, so judge each by what its own flags actually say, not by resemblance to a tool you already judged.',
         "(3) Running the project's own tests, type checker, linter, or build/compile step (e.g. `npm run build`, `yarn build`, `vite build`, `webpack`, `tsc`, `cargo build`, `go build`, `mvn compile`), as long as it is not passed an autofix/write/update flag (e.g. --fix, -u, --write, rubocop -a) \u2014 this holds even though the point of a build step is to write compiled output to a build/dist/target directory inside the project (e.g. a target/, build/, dist/, or __pycache__ directory): writing that output does not make the command unsafe. It stops being safe the moment the command chain goes past building \u2014 a step that also deploys, publishes, uploads, or pushes the build (e.g. `next build && vercel deploy`, `npm run build && npm publish`) is unsafe for that later segment even though the build segment itself is fine; judge each chained segment on its own, same as elsewhere in this list.",
         "Deleting or removing anything is unsafe, even something in a cache or build directory (e.g. `rm -rf __pycache__`, `cargo clean`, `git clean`), and even if the command otherwise fits one of the three categories above. Installing, uninstalling, or upgrading a dependency, changing a database schema, or writing to a path outside the project is also unsafe. A command chained with &&, ;, a pipe, or a line break (LF or CRLF) is only safe if every command segment is safe on its own. Treat each line as a separate command segment, even when the first line is safe.",
-        "One specific, narrow exception to all of the above: when the command literally invokes one of these runner programs BY NAME as the leading command \u2014 npx, bunx, pnpm dlx, yarn dlx, pipx run, uvx \u2014 it is unsafe regardless of what it then runs, even something that looks like a harmless test/lint/typecheck command (e.g. `npx tsc --noEmit`, `uvx ruff check .`), because that runner can fetch and execute a different, unreviewed version of a package from a registry each time. This exception is about that specific syntax, not a general doubt about whether a tool is installed: a plain `ruff check .`, `pytest`, or any other bare command name is NOT this exception merely because you cannot verify from the string alone that it is installed \u2014 judge those the same as any other already-installed project tool, per the categories above. If you are unsure, judge it unsafe.",
+        "One specific, narrow exception to all of the above: when the command literally invokes one of these runner programs BY NAME as the leading command \u2014 npx, bunx, pnpm dlx, yarn dlx, pipx run, uvx \u2014 it is unsafe regardless of what it then runs, even something that looks like a harmless test/lint/typecheck command (e.g. `npx tsc --noEmit`, `uvx ruff check .`), because that runner can fetch and execute a different, unreviewed version of a package from a registry each time. This exception is about that specific syntax, not a general doubt about whether a tool is installed: a plain `ruff check .`, `pytest`, or any other bare command name is NOT this exception merely because you cannot verify from the string alone that it is installed \u2014 judge those the same as any other already-installed project tool, per the categories above. If you are unsure, judge it unsafe. This runner rule yields to the precedent rule at the end: a later invocation of an approved runner and package (e.g. `npx tsc ...`) is SAFE only when it has the same action and side-effect profile as the approved one.",
         ...approvedHistory.length > 0 ? [
           "The user has already explicitly approved these exact commands earlier in this session (working directory in parentheses, then the command):",
           approvedHistory.map((h) => `- (${h.cwd}) ${h.command}`).join("\n"),
-          "If the new command performs the same action and side-effect profile as one of these \u2014 differing only in a trivial way, such as a different file path, package name, or argument value that does not change what kind of action it is \u2014 judge it SAFE on that precedent, even if it would not otherwise fit categories (1)-(3) above. Do not stretch this to a command that merely shares a binary name, or superficially resembles one on the list while doing something riskier or of a different kind (e.g. an approved `rm build/tmp.log` does not license a new `rm -rf src/`, and an approved `git push origin feature-x` does not license `git push --force`)."
+          "Precedent rule: if the new command performs the same action and side-effect profile as one of these \u2014 differing only in a trivial way, such as a different file path, flag, or argument value that does not change what kind of action it is \u2014 judge it SAFE on that precedent. A different package name is NOT trivial for a dependency install or a runner (npx, bunx, pnpm dlx, yarn dlx, pipx run, uvx): approving `npm install algoliasearch` does not approve `npm install <other-pkg>`, because installing runs lifecycle scripts. This overrides categories (1)-(3), the dependency install and upgrade rule, the runner rule, and the `.algolia-wizard/` check rule above. Precedent never makes SAFE a command that executes code under `.algolia-wizard/`. Do not stretch this to a command that merely shares a binary name, or superficially resembles one on the list while doing something riskier or of a different kind (e.g. an approved `rm build/tmp.log` does not license a new `rm -rf src/`, and an approved `git push origin feature-x` does not license `git push --force`)."
         ] : [],
         `Command: ${command}`,
         `Working directory: ${cwd}`,
@@ -4716,7 +4837,9 @@ async function resolveSecretShellEnv(ctx, command) {
   });
 }
 async function runAndRecord(ctx, command, environment) {
-  useWizard.getState().pushNotice({ messages: [`Running: ${command}`] });
+  useWizard.getState().pushNotice({
+    messages: [`Running: ${command.replace(/\s*\n\s*/g, " ").trim()}`]
+  });
   const run2 = await (ctx.shell.run ?? runShell)(command, {
     cwd: environment.cwd,
     env: environment.values,
@@ -4789,16 +4912,16 @@ async function runUnreviewedCommand(ctx, command, cwd) {
   return runAndRecord(ctx, command, { cwd, values: env, secrets });
 }
 function runShellTool(ctx, createModel = defaultCreateModel) {
-  return tool9({
+  return tool10({
     description: "Run a shell command in the project. Use this for anything the project needs done in its own ecosystem: installing dependencies, running a script you wrote, running the project's lint/typecheck/test commands. Do not use this to find or read files \u2014 use listFiles, searchFiles, and readFile instead of shell file-listing, reading, or search commands (ls/find/tree/cat/head/tail/grep/rg and similar). This tool refuses all of those outright: the dedicated tools enforce the project-root boundary and secret redaction that a raw shell read would bypass, and they won't count against this tool's command budget. The user approves any command that could change the project before it runs, so write a clear `explanation`. A command judged read-only (inspection, or running tests/typecheck/lint without an autofix flag, in any language) runs immediately without approval. If the user rejects a command, do not retry it \u2014 propose a different approach.",
-    inputSchema: z16.object({
-      command: z16.string().describe(
+    inputSchema: z17.object({
+      command: z17.string().describe(
         "The command to run, exactly as it would be typed in a shell. Pipes, && and redirects are allowed."
       ),
-      cwd: z16.string().optional().describe(
+      cwd: z17.string().optional().describe(
         "Directory to run in, relative to the project root. Defaults to the project root."
       ),
-      explanation: z16.string().describe(
+      explanation: z17.string().describe(
         "One short line telling the user what this command does and why, including any side effect (e.g. writes records to Algolia). This is what they approve against."
       )
     }),
@@ -4854,10 +4977,10 @@ function runShellTool(ctx, createModel = defaultCreateModel) {
 }
 
 // src/lib/tools/generateRecord.ts
-import { tool as tool10, generateText as generateText2, Output as Output2, NoObjectGeneratedError } from "ai";
+import { tool as tool11, generateText as generateText2, Output as Output2, NoObjectGeneratedError } from "ai";
 import { createAnthropic as createAnthropic2 } from "@ai-sdk/anthropic";
 import { nanoid as nanoid2 } from "nanoid";
-import z17 from "zod";
+import z18 from "zod";
 var DATA_DIR = ".algolia-wizard/data";
 var MAX_RECORDS = 100;
 var BATCH_SIZE = 10;
@@ -4874,20 +4997,20 @@ function defaultCreateModel2() {
   });
 }
 function generateRecordTool(ctx, createModel = defaultCreateModel2) {
-  return tool10({
+  return tool11({
     description: "Generate realistic sample records for an entity and write them to a JSON file. Provide the entity name and its attributes; this tool asks a model to invent varied, realistic values, each with a unique objectID, and returns the file path to read them from at runtime. Do not invent the record values or objectIDs yourself, and do not inline the returned records into the script \u2014 call this tool and read the file it writes.",
-    inputSchema: z17.object({
-      entityName: z17.string().describe("Name of the entity to generate records for."),
-      attributes: z17.array(z17.string()).describe("Attribute names each record must contain."),
-      count: z17.number().int().min(1).max(MAX_RECORDS).default(10).describe(`How many records to generate (max ${MAX_RECORDS}).`),
-      hint: z17.string().optional().describe("Optional context to steer realistic values.")
+    inputSchema: z18.object({
+      entityName: z18.string().describe("Name of the entity to generate records for."),
+      attributes: z18.array(z18.string()).describe("Attribute names each record must contain."),
+      count: z18.number().int().min(1).max(MAX_RECORDS).default(10).describe(`How many records to generate (max ${MAX_RECORDS}).`),
+      hint: z18.string().optional().describe("Optional context to steer realistic values.")
     }),
     execute: async ({ entityName, attributes, count, hint }) => {
       logger.info({ entityName, count }, "called generateRecord tool");
       try {
         const anthropic = createModel();
-        const value = z17.union([z17.string(), z17.number(), z17.boolean(), z17.null()]);
-        const recordSchema2 = z17.object(
+        const value = z18.union([z18.string(), z18.number(), z18.boolean(), z18.null()]);
+        const recordSchema2 = z18.object(
           Object.fromEntries(attributes.map((attr) => [attr, value]))
         );
         const generateBatch = async (batchCount) => {
@@ -4909,8 +5032,8 @@ function generateRecordTool(ctx, createModel = defaultCreateModel2) {
                   }
                 },
                 output: Output2.object({
-                  schema: z17.object({
-                    records: z17.array(recordSchema2).length(batchCount)
+                  schema: z18.object({
+                    records: z18.array(recordSchema2).length(batchCount)
                   })
                 }),
                 prompt: [
@@ -4981,13 +5104,13 @@ function generateRecordTool(ctx, createModel = defaultCreateModel2) {
 }
 
 // src/lib/tools/notifyUser.ts
-import { tool as tool11 } from "ai";
-import z18 from "zod";
+import { tool as tool12 } from "ai";
+import z19 from "zod";
 function notifyUserTool() {
-  return tool11({
+  return tool12({
     description: `Give the user a brief, high-level update on what you are currently doing or about to do next. This is for the big picture (e.g. "Reading through your data models", "Writing the search UI") \u2014 not granular detail like individual tool calls, which are already logged separately. Call it when you start a new phase of work or your focus shifts, just not on every step, enough to keep the user engaged. Don't say things like "starting", just describe what you are doing. Don't mention tool calls themselves, just general direction of the work. Only the latest update is shown on screen, in one line, so keep it under 140 characters.`,
-    inputSchema: z18.object({
-      message: z18.string().max(140).describe(
+    inputSchema: z19.object({
+      message: z19.string().max(140).describe(
         "Short, plain-language description of what you are doing now. Under 140 characters \u2014 only the latest update is shown, on one line."
       )
     }),
@@ -5025,6 +5148,7 @@ function createTools(ctx, { output, tools }) {
     reportStatus: withLogging("reportStatus", reportStatusTool(output)),
     readFile: withLogging("readFile", readFileTool(ctx)),
     writeFile: withLogging("writeFile", writeFileTool(ctx)),
+    editFile: withLogging("editFile", editFileTool(ctx)),
     writeCredentials: withLogging(
       "writeCredentials",
       writeCredentialsTool(ctx)
@@ -5052,9 +5176,19 @@ var FS_READ_TOOLS = [
 var MISSING_REPORT_STATUS_ERROR_MESSAGE = "Agent finished without calling reportStatus";
 var MISSING_REPORT_USER_MESSAGE = "This step ran into a problem finishing. Run the wizard again to retry it.";
 var REPORT_STATUS_RETRIES = 2;
+var STEP_LIMIT_INSTRUCTION = "When reportStatus is the only tool available, you reached the step limit. This limit is not a failure, so do not report fail because of it: report status=success with the work done so far, and name the remaining work in the summary.";
+var RECENT_STEPS_LOGGED = 3;
+var LOGGED_CHARS = 300;
 var ATTEMPT_NUMBER_OFFSET = 1;
 var INITIAL_ATTEMPT = 0;
 var PROVIDER_ERROR_USER_MESSAGE = "The AI service had trouble responding. Run the wizard again to retry this step.";
+var SESSION_TIMEOUT_USER_MESSAGE = "The wizard session timed out after a period of inactivity. Run the wizard again to retry this step.";
+var PROXY_AUTH_REJECTED_HEADER2 = "x-wizard-proxy-auth";
+var PROXY_REJECTION_BODY = "You shall not pass!";
+function isProxyInactivityRejection(err) {
+  const cause = RetryError.isInstance(err) ? err.lastError : err;
+  return APICallError.isInstance(cause) && cause.statusCode === 401 && cause.responseBody === PROXY_REJECTION_BODY && cause.responseHeaders?.[PROXY_AUTH_REJECTED_HEADER2] === void 0;
+}
 var MissingReportError = class extends Error {
   atStepLimit;
   constructor(atStepLimit) {
@@ -5062,6 +5196,13 @@ var MissingReportError = class extends Error {
     this.atStepLimit = atStepLimit;
   }
 };
+var AgentReportedFailureError = class extends Error {
+  reason;
+  constructor(reason) {
+    super(`Agent reported failure: ${reason ?? "no reason given"}`);
+    this.reason = reason;
+  }
+};
 function isMissingReportRetry(kind) {
   return kind === "missingReport" || kind === "missingReportAtStepLimit";
 }
@@ -5134,6 +5275,7 @@ async function runAgentAttempt(req, attempt, retryReason) {
       "When you need to read or search multiple files, issue those tool calls together in one step rather than one at a time."
     ] : [],
     "Call notifyUser whenever you start a new phase of work or your focus shifts (e.g. moving from reading code to writing files) \u2014 a short, plain-language, high-level update. Do not call it for every tool use.",
+    STEP_LIMIT_INSTRUCTION,
     // Last so a retry does not bust the cached tools+system prefix from
     // the first attempt. Inspect-and-continue, not start over: implement
     // shares the worktree and toolContext across attempts.
@@ -5181,7 +5323,11 @@ async function runAgentAttempt(req, attempt, retryReason) {
     stopWhen: [
       hasToolCall("reportStatus"),
       stepCountIs(profile.maxSteps)
-    ]
+    ],
+    prepareStep: ({ stepNumber }) => stepNumber >= profile.maxSteps - 1 ? { activeTools: ["reportStatus"] } : void 0,
+    // Not in the settings type, but forwarded to streamText, whose default prints over the UI.
+    ...{ onError: () => {
+    } }
   });
   const stream = await agent.stream({
     prompt: "Follow system instructions"
@@ -5208,6 +5354,9 @@ async function runAgentAttempt(req, attempt, retryReason) {
   }
   if (streamError !== void 0) {
     logger.error({ err: streamError }, "agent stream reported an error");
+    if (isProxyInactivityRejection(streamError)) {
+      throw new Error(SESSION_TIMEOUT_USER_MESSAGE, { cause: streamError });
+    }
     throw streamError;
   }
   const end = Date.now();
@@ -5257,19 +5406,33 @@ async function runAgentAttempt(req, attempt, retryReason) {
   }
   const result = report.output;
   if (result.status !== "success") {
-    throw new Error(
-      `Agent reported failure: ${result.reason ?? "no reason given"}`
+    const steps = await stream.steps;
+    logger.warn(
+      {
+        reason: result.reason,
+        stepCount: steps.length,
+        recentSteps: steps.slice(-RECENT_STEPS_LOGGED).map((s) => ({
+          text: s.text?.slice(0, LOGGED_CHARS),
+          toolCalls: s.toolCalls?.map((c) => c.toolName),
+          toolResults: s.toolResults?.map((r) => ({
+            tool: r.toolName,
+            output: JSON.stringify(r.output)?.slice(0, LOGGED_CHARS)
+          }))
+        }))
+      },
+      "agent reported failure"
     );
+    throw new AgentReportedFailureError(result.reason);
   }
   return result.output;
 }
 
 // src/actions/detectLanguage.ts
-import z21 from "zod";
-var detectLanguageSchema = z21.object({
-  languages: z21.array(z21.object({ name: z21.string(), version: z21.string() })),
-  frameworks: z21.array(z21.object({ name: z21.string(), version: z21.string() })),
-  publicEnvVarPrefix: z21.string().regex(/^([A-Z0-9]+_)*$/).describe(
+import z22 from "zod";
+var detectLanguageSchema = z22.object({
+  languages: z22.array(z22.object({ name: z22.string(), version: z22.string() })),
+  frameworks: z22.array(z22.object({ name: z22.string(), version: z22.string() })),
+  publicEnvVarPrefix: z22.string().regex(/^([A-Z0-9]+_)*$/).describe(
     `The prefix a bundler/framework requires for an env var to reach client-side code (e.g. "NEXT_PUBLIC_", "VITE_", "NUXT_PUBLIC_"), uppercase with a trailing underscore when non-empty. Prefer the project's own existing convention over a framework default. Empty string when the project has no client-side env var exposure (e.g. a backend-only project).`
   )
 });
@@ -5329,31 +5492,31 @@ var detectLanguage = async () => {
 };
 
 // src/actions/analyzeCodebase.ts
-import z22 from "zod";
+import z23 from "zod";
 var READONLY_TOOLS = [
   "listFiles",
   "changeDirectory",
   "readFile",
   "searchFiles"
 ];
-var ingestionAnalysisSchema = z22.object({
-  ingestionAnalysis: z22.array(
-    z22.object({
-      name: z22.string(),
-      paths: z22.array(z22.string()),
+var ingestionAnalysisSchema = z23.object({
+  ingestionAnalysis: z23.array(
+    z23.object({
+      name: z23.string(),
+      paths: z23.array(z23.string()),
       // indexable fields the agent found for this entity
-      attributes: z22.array(z22.string())
+      attributes: z23.array(z23.string())
     })
   )
 });
-var searchImplementationAnalysisSchema = z22.object({
-  searchImplementationAnalysis: z22.string()
+var searchImplementationAnalysisSchema = z23.object({
+  searchImplementationAnalysis: z23.string()
 });
-var verificationSchema = z22.object({
-  verification: z22.array(z22.string())
+var verificationSchema = z23.object({
+  verification: z23.array(z23.string())
 });
 var confirmedEntitiesFieldSchema = ingestionAnalysisSchema.shape.ingestionAnalysis.optional();
-var analyzeCodebaseSchema = z22.object({
+var analyzeCodebaseSchema = z23.object({
   ingestionAnalysis: ingestionAnalysisSchema.shape.ingestionAnalysis.optional(),
   searchImplementationAnalysis: searchImplementationAnalysisSchema.shape.searchImplementationAnalysis.optional(),
   verification: verificationSchema.shape.verification.optional(),
@@ -5475,8 +5638,8 @@ async function askList(ctx, prompt, { required = false } = {}) {
 }
 
 // src/actions/confirmLanguage.ts
-import z24 from "zod";
-var confirmLanguageSchema = z24.object({
+import z25 from "zod";
+var confirmLanguageSchema = z25.object({
   languages: detectLanguageSchema.shape.languages
 });
 async function confirmLanguage(ctx) {
@@ -5497,8 +5660,8 @@ async function confirmLanguage(ctx) {
 }
 
 // src/actions/confirmFramework.ts
-import z25 from "zod";
-var confirmFrameworkSchema = z25.object({
+import z26 from "zod";
+var confirmFrameworkSchema = z26.object({
   frameworks: detectLanguageSchema.shape.frameworks
 });
 var CURATED_FRAMEWORKS = [
@@ -5636,8 +5799,8 @@ async function promptUser(ctx, params) {
 }
 
 // src/actions/confirmEntities.ts
-import z26 from "zod";
-var confirmEntitiesSchema = z26.object({
+import z27 from "zod";
+var confirmEntitiesSchema = z27.object({
   // Final detection — the focused re-run may supersede project-scan's.
   ingestionAnalysis: ingestionAnalysisSchema.shape.ingestionAnalysis.optional(),
   confirmedEntities: confirmedEntitiesFieldSchema,
@@ -5788,15 +5951,15 @@ async function confirmEntities(ctx) {
 }
 
 // src/actions/review.ts
-import { z as z27 } from "zod";
-var reviewSchema = z27.object({
+import { z as z28 } from "zod";
+var reviewSchema = z28.object({
   // Broad, high-level takeaways grouped by theme (e.g. ingestion, search UI),
   // not one entry per workflow step — a step's raw output can be a long,
   // multi-paragraph blob (see implement.ts's summaries.join), and mirroring
   // that 1:1 is what made the old per-step summary an unreadable wall of text.
-  summaryPoints: z27.array(z27.string()),
-  reviewPrompt: z27.string(),
-  nextSteps: z27.array(z27.string())
+  summaryPoints: z28.array(z28.string()),
+  reviewPrompt: z28.string(),
+  nextSteps: z28.array(z28.string())
 });
 function formatCompletedSteps(steps) {
   if (!steps.length) return "(no prior steps completed)";
@@ -5831,9 +5994,17 @@ ${formatCompletedSteps(ctx.completedSteps)}`,
 };
 
 // src/actions/implement.ts
-import z28 from "zod";
-import { access, mkdir as mkdir5, readFile as readFile9 } from "node:fs/promises";
-import { dirname as dirname5, isAbsolute as isAbsolute4, join as join11, relative as relative7, resolve as resolve5, sep as sep3 } from "node:path";
+import z29 from "zod";
+import { access, mkdir as mkdir5, readdir as readdir3, readFile as readFile10 } from "node:fs/promises";
+import {
+  dirname as dirname5,
+  extname,
+  isAbsolute as isAbsolute4,
+  join as join11,
+  relative as relative7,
+  resolve as resolve5,
+  sep as sep3
+} from "node:path";
 
 // src/lib/git.ts
 import { execFile as execFile3 } from "node:child_process";
@@ -5913,6 +6084,12 @@ function toRootRelative(p) {
   return p.replace(/^\/+/, "");
 }
 
+// src/lib/dashboard.ts
+function browseUrl(appId, indexName) {
+  const base = appId ? `https://dashboard.algolia.com/apps/${appId}/explorer/browse` : "https://dashboard.algolia.com/explorer/browse";
+  return `${base}/${encodeURIComponent(indexName)}`;
+}
+
 // src/lib/algoliaDocs.ts
 import { readFileSync, readdirSync, existsSync } from "node:fs";
 import { dirname as dirname4, join as join10 } from "node:path";
@@ -5972,36 +6149,36 @@ function getFrameworkSpecificDoc(frameworks) {
 }
 
 // src/actions/implement.ts
-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()
+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"]),
+  searchConfig: z29.object({
+    filePath: z29.string().optional(),
+    vars: z29.array(
+      z29.object({
+        name: z29.string(),
+        value: z29.string()
       })
     )
   }).optional()
 });
-var implementationOutputSchema = z28.object({
-  summary: z28.string(),
-  ingestCommand: z28.string().optional(),
+var implementationOutputSchema = z29.object({
+  summary: z29.string(),
+  ingestCommand: z29.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()
+  searchConfigFile: z29.string().optional()
 });
-var validationOutputSchema = z28.object({
-  summary: z28.string(),
-  sufficient: z28.boolean(),
-  additionalInstructions: z28.string().optional(),
-  unrelatedFailure: z28.string().optional()
+var validationOutputSchema = z29.object({
+  summary: z29.string(),
+  sufficient: z29.boolean(),
+  additionalInstructions: z29.string().optional(),
+  unrelatedFailure: z29.string().optional()
 });
 var MAX_IMPLEMENT_VALIDATION_ATTEMPTS = 3;
 var FIRST_IMPLEMENTATION_ATTEMPT = 1;
@@ -6013,9 +6190,14 @@ var INGESTION_SOURCE = {
   fileUpload: "Import a data file (CSV, JSON, TSV)",
   generated: "Generate sample data"
 };
-var BUILD_CHECK_PROMPT = "Run type-check and lint now? This can take several minutes on a large repository.";
-var MISSING_DEPENDENCIES_PROMPT = "Dependencies are not installed. Install them and run type-check and lint now?";
+var BUILD_CHECK_PROMPT = "Run type-check now? This can take several minutes on a large repository.";
+var MISSING_DEPENDENCIES_PROMPT = "Dependencies are not installed. Install them and run type-check now?";
 var UNRELATED_FAILURE_PROMPT = "These checks are still failing and appear unrelated to the changes. Continue the investigation?";
+var INGEST_RETRY_PROMPT = "Fix the cause (for example, start the database the script reads from), then retry.";
+var INGEST_RETRY = {
+  retry: "Retry ingestion",
+  skip: "Continue without records"
+};
 var FILE_UPLOAD_PATH_PROMPT = "Enter the path to your JSON, CSV, or TSV file (relative to the project root, or absolute):";
 var JS_LANGUAGES = ["javascript", "typescript", "jsx", "tsx", "node"];
 function lower(entries) {
@@ -6053,10 +6235,12 @@ function baseInstructions(input) {
     `Project languages and frameworks: ${JSON.stringify(input.language)}`,
     "Make minimal, idiomatic changes; do not touch unrelated code.",
     `Commands run through a shell on ${process.platform}. Write commands that work there.`,
-    "Use the project's own tooling for every command \u2014 its package manager, task runner, and test/lint commands.",
+    "Use the project's own tooling for every command \u2014 its package manager and task runner.",
+    "Never run a linter or formatter, and do not fix lint or formatting issues. The developer did not ask for them.",
     "runShell needs the developer to approve each command, so give every call a clear `explanation` naming what it does and any side effect. If a command is rejected, do not retry it \u2014 take a different approach or report the limitation."
   ];
 }
+var FILE_EDIT_INSTRUCTION = "To change an existing file, call editFile with only the changed part. Use writeFile only to create a file; never rewrite an existing file with writeFile.";
 function sourceSpecificInstructions(input) {
   const byLine = {
     local: [
@@ -6089,15 +6273,23 @@ function algoliaClientDoc(input) {
     doc
   ];
 }
+var LARGE_RECORD_PLAN = /^(grow|elevate|premium)/i;
+function recordSizeInstruction(plan) {
+  const limit = plan && LARGE_RECORD_PLAN.test(plan.trim()) ? "Algolia rejects a record larger than 100 KB with a status 400 error, and the average record size in the index must stay under 10 KB. Keep every record well under 100 KB and the average under 10 KB" : "Algolia rejects a record larger than 10 KB with a status 400 error. Keep every record under 10 KB";
+  return `${limit}: split long text fields (for example an article body) into several records that share a parent identifier, or truncate them. Never push the whole text of a long document as one record. Check the size of the largest source item before you write the script.`;
+}
 function ingestionInstructions(input) {
   return [
     ...input.confirmed && input.confirmed.length ? [
       `Create an ingestion script under "${input.ingestDir}/" at the repo root. That directory already exists \u2014 writeFile creates any nested path itself, so never run a shell command just to create a directory.`,
+      FILE_EDIT_INSTRUCTION,
       `Ingest only the confirmed entity (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.`,
       `Read the index name from the ${INDEX_NAME_VAR} environment variable, which the wizard sets to "${input.targetIndex}". Never hardcode an index name or derive one from the project, file, or entity name \u2014 the write key only works for that exact index. Exit with an error if ${INDEX_NAME_VAR} is unset.`,
       "Write the script in the project's primary language, using Algolia's official client for that language. 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.",
+      recordSizeInstruction(input.appPlan),
+      "When you split one source item into several records, keep the fields that the search UI shows (title, description, URL parts) on every record. After you push the records, the script must set the index settings with attributeForDistinct set to the parent identifier and distinct set to true, so that a search returns each source item once.",
       ...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.`,
@@ -6108,6 +6300,7 @@ function ingestionInstructions(input) {
       ] : [],
       `When the script is finished, decide the exact command and cwd you will use to run it. Make sure that the script path in the command resolves from that cwd to the filePath. Then call reviewScript with that filePath, command, cwd, the exact selected entityName, and usesGeneratedRecords set to ${input.ingestionSource === "generated"}. Wait for the developer to review it because running it writes records to a live index. Do not run it before that call returns. If you change the command or cwd after a failed run, call reviewScript again before runShell.`,
       'Then, without changing directories, run the script yourself via runShell using the exact same command and cwd. 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.',
+      "When the script reads from a database or another service, find how the project connects to it locally (env files, README, socket or TCP settings). If that connection needs a local service, such as a database proxy (for example cloud-sql-proxy) or a tunnel, make the script check the connection before it reads, and exit with an error that names the service and the command from the project docs that starts it.",
       "If external data access fails, do not run authentication commands, change accounts or machine configuration, or start proxies, containers, or services.",
       "Do not troubleshoot unavailable external infrastructure. Preserve the script and command, report success, and let the developer prepare the data source.",
       "If the script cannot access an external data source because credentials or a service are unavailable, do not report status=fail. Report status=success with the completed script, ingestCommand, and a concise failure summary. The wizard handles this run failure and tells the developer how to retry.",
@@ -6127,7 +6320,7 @@ function searchInstructions(input) {
   const placementMessage = "Place content-specific search beside the heading or controls for the corresponding browse/listing task. Use shared navigation only for genuinely app-wide search and only when it fits the available space and responsive layout without crowding primary actions.";
   const replacementMessage = "If a search control with the same content scope and purpose already exists, replace its usage with the new component while preserving its intentional placement, and delete the implementation it supersedes. Do not remove or replace unrelated filters, navigation, or differently scoped search.";
   const accessibilityInstructions = [
-    "Target WCAG 2.2 AA. Use semantic search structure and give the input a persistent accessible name: prefer a visible associated label and use the project's visually-hidden utility where the layout has no room for one. A placeholder or a labeled search landmark does not name the input. When the input uses aria-labelledby, every referenced element must exist and contain meaningful, content-specific text. Preserve a widget's generated label when it provides one and make it content-specific through supported options; if the installed widget exposes no such option, use its documented connector or headless API to render a labeled input instead of patching generated DOM.",
+    "Target WCAG 2.2 AA. Use semantic search structure and give the input a persistent accessible name: prefer a visible associated label and use the project's visually-hidden utility where the layout has no room for one. A placeholder or a labeled search landmark does not name the input. When the input uses aria-labelledby, every referenced element must exist and contain meaningful, content-specific text. Preserve a widget's generated label when it provides one and make it content-specific through supported options. If the SDK reference says that no option changes the generated label, accept that label as a known widget limitation: do not rebuild the widget headless, do not patch generated DOM, and name the gap in the summary.",
     "Preserve widget-provided combobox, popup, and item roles, relationships, and keyboard behavior; for a headless widget, implement the documented semantics instead of inventing different ARIA. Tab must reach the input and controls, Arrow keys move through results, Enter selects, and Escape dismisses without trapping or losing focus.",
     "Meet 4.5:1 contrast for normal text, including input values, placeholders, and result text, and 3:1 for large text, meaningful icons, control boundaries, and focus indicators against adjacent colors. Keep focus visible and unobscured, and never communicate active, loading, empty, or error states by color alone.",
     "Keep loading, empty, and error status text perceivable to assistive technology. Do not assume a widget announces these states: use documented announcements when present, otherwise add a persistent polite live region driven by the current search status, results, and errors.",
@@ -6139,22 +6332,66 @@ function searchInstructions(input) {
     indexedContentMessage ?? "",
     `Build the search UI for ${input.searchUiTarget}.`,
     "Create search UI only. Do not create or modify ingestion scripts, rake/manage/CLI tasks, migrations, seeders, or other data-loading code, even if the data looks incomplete.",
+    FILE_EDIT_INSTRUCTION,
+    EXISTING_COMPONENT_INSTRUCTION,
     mountCandidateMessage,
     placementMessage,
     replacementMessage,
     "Inspect the chosen mount area at the app's existing breakpoints before writing CSS. Preserve its visual hierarchy, alignment, spacing, and primary actions rather than forcing the search control into an arbitrary gap.",
     ...packageManagedInstructions,
+    CSP_INSTRUCTION,
     ...accessibilityInstructions,
     "Style the search surfaces through the widget's class and CSS-variable overrides (or, when hand-built, the app's existing theme tokens): give the results panel and the element that actually draws the input's border and background \u2014 for a widget, the form or wrapper it renders around the bare input \u2014 non-transparent surfaces, keep that frame distinguishable from the background behind it in every supported theme, and never assume a light surface or reuse the surrounding page's colors unchanged inside the panel.",
     "The panel takes its width from the input by default, so a small input makes it unreadably narrow: give it `min-width: min(320px, calc(100vw - 2rem))` independent of the input, cap its maximum width to the viewport, and anchor it to the input edge it opens from so widening does not push it off-screen.",
     "Match the application styles closely, including light, dark, and high-contrast themes the project already supports.",
-    "Before reporting, mount the component and fix any type-check or lint errors your changes cause. If a tool limit is reached or an error remains unresolved, keep the implementation, report status=success, and name the remaining issue in the summary so validation can drive the next pass. Report status=fail only when no search implementation can be written, with the concrete blocker as the reason.",
+    "Before reporting, mount the component. Do not run a type check, build, or test command: the validation pass runs the type check, after the developer agrees to it. If a tool limit is reached or an error remains unresolved, keep the implementation, report status=success, and name the remaining issue in the summary so validation can drive the next pass. Report status=fail only when no search implementation can be written, with the concrete blocker as the reason.",
     "The summary should be extremely concise; do not mention manual testing steps."
   ];
 }
+var EXISTING_COMPONENT_INSTRUCTION = "A search component for this content can already exist, for example from an earlier run. Do not trust it: compare the record fields that it reads with the real records, and rewrite it when they differ. Do not report success while the UI reads a field that no record has.";
+var CSP_INSTRUCTION = 'Search for a Content-Security-Policy (next.config, middleware, proxy, server headers, or a meta tag). If the project sets one, it blocks Algolia until you allow it: add https://*.algolia.net, https://*.algolianet.com, and https://insights.algolia.io to connect-src, and load search-insights from npm as the SDK reference describes instead of from jsDelivr. Without this, every search fails with "Unreachable hosts" and the widget stays empty.';
+var INGEST_SCRIPT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".sh",
+  ".py",
+  ".js",
+  ".mjs",
+  ".cjs",
+  ".ts",
+  ".rb",
+  ".php",
+  ".go"
+]);
+async function findIngestionScript(repoRoot, ingestDir, ingestCommand) {
+  const fromCommand = ingestCommand?.split(/\s+/).map((token) => token.replace(/^["']|["']$/g, "")).find((token) => token.startsWith(`${ingestDir}/`));
+  if (fromCommand) {
+    try {
+      await access(join11(repoRoot, fromCommand));
+      return fromCommand;
+    } catch {
+    }
+  }
+  try {
+    const entries = await readdir3(join11(repoRoot, ingestDir), {
+      withFileTypes: true
+    });
+    const name = entries.filter(
+      (entry) => entry.isFile() && !entry.name.startsWith(".") && INGEST_SCRIPT_EXTENSIONS.has(extname(entry.name))
+    ).map((entry) => entry.name).sort()[0];
+    return name && `${ingestDir}/${name}`;
+  } catch {
+    return void 0;
+  }
+}
+function recordSourceInstruction(scriptPath) {
+  return `The records in the index come from the ingestion script "${scriptPath}" (repo root). Read that one file to learn each record's objectID, its fields, and how they map to the app's data and URLs. Do not search the backend, api, or scripts folders for them, and do not use shell reads (sed, grep, cat) to explore. Read the fields with their exact attribute names from the records: a dotted name such as "copy.en.title" is one flat attribute, so read it as item["copy.en.title"]. Use only the fields of the current locale. When the script splits one item into several records that share a parent identifier, the index returns each item once, so show one result per item.`;
+}
+function recordFieldCheckInstruction(scriptPath) {
+  return `Read the ingestion script "${scriptPath}" (repo root). Check that every record field that the search UI reads (title, description, link parts) exists in the records with that exact attribute name. A dotted name such as "copy.en.title" is one flat attribute. If the UI reads a field that no record has, set sufficient=false and name the wrong field and the right one in additionalInstructions. Do not use shell reads to explore.`;
+}
 function packageSearchInstructions(input) {
   const doc = getFrameworkSpecificDoc(frameworksForDoc(input.language));
   return [
+    "To check an installed package version, call readFile on node_modules/<package>/package.json. Do not otherwise explore node_modules, and do not run node -e or other scripts to discover a package API. If the reference below does not cover a detail, choose the documented option and name the gap in the summary.",
     ...doc ? [
       "Follow the Algolia SDK reference below for client setup, search UI wiring, and Insights instrumentation \u2014 Insights is required, not optional; prefer the reference over prior knowledge:",
       doc
@@ -6188,25 +6425,30 @@ function validationInstructions(input) {
     "Validate the Algolia search implementation by inspecting the project source.",
     `Indexed content context: ${JSON.stringify(input.findings.confirmedEntities?.[0] ?? null)}.`,
     `The confirmed placement candidate was "${input.searchLocation ?? "unknown"}", but verify the actual mount rather than assuming the candidate was used.`,
-    "Inspect the generated search component, its actual mount file, that file's parent layout and sibling controls, and the relevant content UI. Do not rely only on lint, type checks, or tests.",
+    "Inspect the generated search component, its actual mount file, that file's parent layout and sibling controls, and the relevant content UI. Do not rely only on type checks or tests.",
     "Confirm that the application renders exactly one search bar. Check for an old search bar and duplicate mounts.",
+    "If the project sets a Content-Security-Policy, confirm that connect-src allows https://*.algolia.net, https://*.algolianet.com, and https://insights.algolia.io, and that search-insights is loaded from npm. Otherwise set sufficient=false.",
     "Confirm content-specific search is placed with the corresponding content or task controls. Shared navigation is valid only for genuinely app-wide search that fits the visual hierarchy and responsive layout without crowding primary actions.",
     "Confirm the input has a persistent accessible name; widget-provided combobox, popup, and item relationships and keyboard behavior are preserved; and loading, empty, and error status text is perceivable to assistive technology.",
     "Inspect the CSS that actually applies to the generated DOM. Confirm the results panel and the element drawing the input frame have non-transparent surfaces, the input frame is distinguishable from its surrounding background in every supported theme, text meets 4.5:1 contrast, meaningful boundaries and focus indicators meet 3:1, and no state relies on color alone.",
     "Confirm the search experience reflows without horizontal page scrolling at 320 CSS pixels, keeps its panel on-screen, preserves visible focus, and respects reduced-motion preferences for any added animation.",
+    "If the project imports an InstantSearch theme and overrides its palette, confirm that the palette overrides (--ais-*-rgb) win over the theme: they must use a higher specificity than the theme, for example `:root:root`, and for a dark mode `:root:root.dark` or `:root:root[data-theme=dark]`, because the theme sets its own blue in `:root` and in `:root[data-theme=dark], .dark`. `:root:root` alone ties with `:root[data-theme=dark]`. If an override can lose to the theme, set sufficient=false, because the search icon and focus ring then show the theme blue instead of the app accent color.",
+    "When the project has a package.json, confirm that the theme CSS of the search widget (for InstantSearch, a theme from instantsearch.css) is imported once, from the component or the global stylesheet. If it is installed but not imported, set sufficient=false.",
     "Confirm that the search component is reachable from and fits the corresponding content task at every supported breakpoint; require app-wide reachability only when the search scope is genuinely app-wide.",
     "Do not run the test suite or any test command.",
     "Do not modify files. Report each implementation issue as a concrete instruction for the next implementation pass.",
-    `Available type-check and lint tools: ${JSON.stringify(input.findings.verification ?? [])}.`,
+    `Detected verification tools: ${JSON.stringify(input.findings.verification ?? [])}. Use only a type checker; ignore any linter or formatter in this list.`,
     ...!input.frontendHasPackageJson ? [
       "The frontend has no package.json: never create one or run npm, pnpm, yarn, or bun. Validate the CDN implementation by inspecting its HTML or template and classic scripts for the search container, Algolia \u2192 InstantSearch \u2192 config \u2192 search load order, browser globals, autocomplete widget configuration, search.start(), and exact pinned CDN URLs and integrity attributes for every Algolia script or stylesheet. Source inspection is required even when the project has no automated checks. window.instantsearch.widgets.autocomplete is a real widget in the pinned InstantSearch build; do not report its use as an error, and do not fetch a remote bundle or URL to verify it."
     ] : [],
     "Always call reportStatus with status=success after validation, even when sufficient=false.",
     "Set sufficient=false if the input's computed accessible name is empty or generic, including when aria-labelledby references a missing or empty element; a placeholder does not count as the label.",
+    'Exception: the InstantSearch Autocomplete widget (react-instantsearch or instantsearch.js) names its input "Submit" through its generated label (the input has aria-labelledby pointing at that label), and no widget option changes it. Accept that name when the widget is used unmodified, and do not ask for an aria-label, inputProps, or a label wrapper: do not set sufficient=false for it, and do not request a headless rebuild or DOM patch.',
     "Set sufficient=true when the search bar is unique and structurally complete and no placement or accessibility violation was found.",
     "Set sufficient=false when a required placement or accessibility property is observed to fail, the implementation is incomplete, or checks have implementation-caused failures; include concrete additionalInstructions for the next pass.",
-    "If any required placement or accessibility property cannot be established with the available tools\u2014including contrast, keyboard behavior, 320-pixel reflow, or live-region status\u2014set sufficient=false and request concrete verification or a fix in additionalInstructions; do not let an unverified requirement pass as a manual follow-up.",
-    "If a check fails only in untouched code, set unrelatedFailure to a concise failure description."
+    "You can only read source files. If a required property can be checked in the source, check it there. If it can be established only in a browser (rendered contrast, keyboard behavior, 320-pixel reflow, live-region status, computed accessible name), set sufficient=true when the source shows no violation. Never request devtools, a screenshot, or a contrast tool, and never repeat a finding that an earlier pass already fixed.",
+    "If a check fails only in untouched code, set unrelatedFailure to a concise failure description.",
+    "Keep the summary to one short sentence. Put the details in additionalInstructions."
   ];
 }
 var IMPLEMENT_CONFIG = {
@@ -6227,12 +6469,19 @@ var useCaseToolMap = {
   ingestion: [
     ...FS_READ_TOOLS,
     "writeFile",
+    "editFile",
     "writeCredentials",
     "runShell",
     "reviewScript",
     "notifyUser"
   ],
-  search: [...FS_READ_TOOLS, "writeFile", "runShell", "notifyUser"],
+  search: [
+    ...FS_READ_TOOLS,
+    "writeFile",
+    "editFile",
+    "runShell",
+    "notifyUser"
+  ],
   validation: [...FS_READ_TOOLS, "runShell", "notifyUser"]
 };
 function toolsForUseCase(useCase, ingestionSource) {
@@ -6306,7 +6555,7 @@ function jsTypeName(value) {
 }
 async function firstRecordIn(filePath) {
   try {
-    const parsed = JSON.parse(await readFile9(filePath, "utf8"));
+    const parsed = JSON.parse(await readFile10(filePath, "utf8"));
     const first = Array.isArray(parsed) ? parsed[0] : parsed;
     if (first && typeof first === "object" && !Array.isArray(first)) {
       return first;
@@ -6353,6 +6602,18 @@ function ingestFailure(attempt, executions) {
   }
   return { reason: `it failed (exit ${attempt.exitCode ?? "unknown"})`, detail };
 }
+function ingestFailureMessages(headline, detail, command, cwd) {
+  return [
+    headline,
+    // One message per line: Notices.tsx counts a message as one wrapped
+    // line, so an embedded newline overflows the panel's height accounting.
+    ...detail?.split("\n").filter((l) => l.trim()) ?? [],
+    ...command ? [
+      `Ingestion command: ${command}`,
+      ...cwd !== "." ? [`Working directory: ${cwd}`] : []
+    ] : []
+  ];
+}
 function makeToolContext(root, appId, env = async () => ({}), secretEnv = async () => ({})) {
   return {
     ...createToolContext(
@@ -6363,6 +6624,12 @@ function makeToolContext(root, appId, env = async () => ({}), secretEnv = async
     appId
   };
 }
+var ERROR_SUMMARY_MAX_CHARS = 200;
+function briefSummary(summary) {
+  const firstLine = summary.trim().split("\n")[0] ?? "";
+  if (!firstLine) return "no summary given";
+  return firstLine.length > ERROR_SUMMARY_MAX_CHARS ? `${firstLine.slice(0, ERROR_SUMMARY_MAX_CHARS - 1)}\u2026` : firstLine;
+}
 function validationRetryInstructions(validation) {
   return [
     `Implementation insufficient. Address these findings before reporting completion: ${validation.additionalInstructions ?? validation.summary}`
@@ -6420,7 +6687,7 @@ function installCheckInstructions(plan, attempt) {
   }
   return ["Dependencies were already installed. Do not install them again."];
 }
-function validationRunInstructions(plan, changedFiles, attempt) {
+function validationRunInstructions(plan, attempt) {
   if (!plan.run) {
     return [
       "The developer chose to skip build checks. Do not install dependencies or run shell checks."
@@ -6431,7 +6698,6 @@ function validationRunInstructions(plan, changedFiles, attempt) {
     ...installCheckInstructions(plan, attempt),
     "Do not use npx, dlx, or another package runner that can download an undeclared tool.",
     "Run the type check once with the project's existing command, when one is available.",
-    `Lint only these changed files: ${JSON.stringify(changedFiles)}. Do not run a full-project lint. If this list is empty, do not run lint.`,
     "Do not use an autofix option during validation."
   ];
 }
@@ -6526,11 +6792,16 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
   const searchLocation = findings.searchImplementationAnalysis;
   let appId;
   let ingestAppId;
+  let appPlan;
   if (useCases.includes("search")) {
-    appId = (await requireApplication(ctx.appId)).id;
+    const app = await requireApplication(ctx.appId);
+    appId = app.id;
+    appPlan = app.plan;
   }
   if (useCases.includes("ingestion")) {
-    ingestAppId = appId ?? (await requireApplication(ctx.appId)).id;
+    const app = appId ? void 0 : await requireApplication(ctx.appId);
+    ingestAppId = appId ?? app?.id;
+    appPlan ??= app?.plan;
   }
   let ingestWriteKey;
   if (useCases.includes("ingestion") && ingestAppId) {
@@ -6564,6 +6835,7 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
     targetIndex,
     language,
     appId,
+    appPlan,
     searchKey,
     searchKeyError,
     ingestDir: INGEST_DIR,
@@ -6577,6 +6849,7 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
   };
   let agentRuns = 0;
   let ingestCommand;
+  let ingestionScript;
   let ingestScriptRan = false;
   let ingestRecordCount;
   let ingestDurationMs;
@@ -6596,18 +6869,31 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
   async function runImplementationUseCase(currentUseCase, extraInstructions = [], isRetry = false) {
     if (agentRuns > 0) ctx.recordStepExecution();
     agentRuns += 1;
-    return runAgent({
-      operation: `${currentUseCase}-implementation`,
-      instructions: buildAgentInstructions(
-        currentUseCase,
-        input,
-        extraInstructions
-      ),
-      tools: toolsForUseCase(currentUseCase, input.ingestionSource),
-      outputSchema: implementationOutputSchema,
-      modelProfile: isRetry ? "implementationRetry" /* implementationRetry */ : "implementation" /* implementation */,
-      toolContext: currentUseCase === "ingestion" ? ingestionTools : makeToolContext(repoRoot)
-    });
+    const toolContext = currentUseCase === "ingestion" ? ingestionTools : makeToolContext(repoRoot);
+    try {
+      return await runAgent({
+        operation: `${currentUseCase}-implementation`,
+        instructions: buildAgentInstructions(currentUseCase, input, [
+          ...currentUseCase === "search" && ingestionScript ? [recordSourceInstruction(ingestionScript)] : [],
+          ...extraInstructions
+        ]),
+        tools: toolsForUseCase(currentUseCase, input.ingestionSource),
+        outputSchema: implementationOutputSchema,
+        modelProfile: isRetry ? "implementationRetry" /* implementationRetry */ : "implementation" /* implementation */,
+        toolContext
+      });
+    } catch (err) {
+      if (currentUseCase === "search" && err instanceof AgentReportedFailureError && readLimitReached(toolContext)) {
+        logger.warn(
+          { reason: err.reason, counts: toolContext.counts },
+          "implement: search agent reported fail at a read limit; continuing to validation"
+        );
+        return {
+          summary: "Stopped at a read limit before the implementation was complete."
+        };
+      }
+      throw err;
+    }
   }
   async function runValidationUseCase(extraInstructions) {
     if (agentRuns > 0) ctx.recordStepExecution();
@@ -6619,6 +6905,7 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
       operation: "search-validation",
       instructions: buildAgentInstructions("validation", input, [
         writtenFiles.length ? `Files written during search implementation: ${JSON.stringify(writtenFiles)}. Inspect these first, then trace the actual import and render site.` : "The search agent reported no written files. Inspect the current diff and set sufficient=false if no complete mounted search implementation exists.",
+        ...ingestionScript ? [recordFieldCheckInstruction(ingestionScript)] : [],
         ...extraInstructions
       ]),
       tools: toolsForUseCase("validation"),
@@ -6634,11 +6921,45 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
     ingestCommand = result.ingestCommand;
     const ingestionContext = ingestionTools;
     const executions = ingestionContext.shell.executions;
+    let outcome = ingestOutcome(executions, repoRoot, ingestCommand);
+    let failureAcknowledged = false;
+    while (!outcome.run && outcome.attempt?.approved) {
+      const attempt = outcome.attempt;
+      const { reason, detail } = ingestFailure(attempt, executions);
+      const choice = await ctx.requestUserInput({
+        prompt: INGEST_RETRY_PROMPT,
+        promptType: "multipleChoice",
+        options: [INGEST_RETRY.retry, INGEST_RETRY.skip],
+        messages: ingestFailureMessages(
+          `\u26A0\uFE0F Records were not indexed \u2014 ${reason}.`,
+          detail,
+          attempt.command,
+          relativeIngestCwd(attempt, repoRoot)
+        )
+      });
+      if (choice !== INGEST_RETRY.retry) {
+        failureAcknowledged = true;
+        break;
+      }
+      const rerun = await runReviewedCommand(
+        ingestionContext,
+        attempt.command,
+        attempt.cwd
+      );
+      if (rerun === void 0 || typeof rerun === "string") {
+        logger.warn(
+          { command: attempt.command, refusal: rerun },
+          "implement: could not retry the ingestion command"
+        );
+        break;
+      }
+      outcome = ingestOutcome(executions, repoRoot, ingestCommand);
+    }
     const {
       run: ingestRun,
       attempt: ingestAttempt,
       recordCount
-    } = ingestOutcome(executions, repoRoot, ingestCommand);
+    } = outcome;
     let ingestCwd = ".";
     if (ingestAttempt) {
       ingestCommand = ingestAttempt.command;
@@ -6714,31 +7035,31 @@ ${detail}` : ""}`
         messages: [
           ingestOutcomeMessage,
           "View your ingested records in the Algolia dashboard:",
-          "https://dashboard.algolia.com/explorer/browse",
+          browseUrl(ingestAppId, targetIndex),
           "When you're ready to continue, we'll move on to search implementation."
         ]
       });
-    } else {
-      const commandMessages = ingestCommand ? [
-        `Ingestion command: ${ingestCommand}`,
-        ...ingestCwd !== "." ? [`Working directory: ${ingestCwd}`] : []
-      ] : [];
+    } else if (!failureAcknowledged) {
       await ctx.requestUserInput({
         prompt: "",
         promptType: "enterToContinue",
         options: [],
-        // One message per line: Notices.tsx counts a message as one wrapped
-        // line, so an embedded newline overflows the panel's height accounting.
-        messages: [
+        messages: ingestFailureMessages(
           ingestOutcomeMessage,
-          ...ingestFailureDetail?.split("\n").filter((l) => l.trim()) ?? [],
-          ...commandMessages
-        ]
+          ingestFailureDetail,
+          ingestCommand,
+          ingestCwd
+        )
       });
     }
   }
   let searchConfigFile;
   if (useCases.includes("search")) {
+    ingestionScript = await findIngestionScript(
+      repoRoot,
+      INGEST_DIR,
+      ingestCommand
+    );
     let extraInstructions = [];
     let buildCheckPlan;
     const confirmedFrameworks = language.frameworks ?? [];
@@ -6786,11 +7107,8 @@ ${detail}` : ""}`
         searchConfigFile = searchResult.searchConfigFile;
       }
       buildCheckPlan ??= await resolveBuildCheckPlan(ctx, repoRoot, input);
-      const searchFilesChanged = [
-        ...new Set(useWizard.getState().writtenFiles)
-      ].map((file) => relative7(repoRoot, file));
       const validation = await runValidationUseCase(
-        validationRunInstructions(buildCheckPlan, searchFilesChanged, attempt)
+        validationRunInstructions(buildCheckPlan, attempt)
       );
       summaries.push(formatSummary("validation", validation.summary));
       const finalAttempt = attempt === MAX_IMPLEMENT_VALIDATION_ATTEMPTS;
@@ -6824,8 +7142,16 @@ ${detail}` : ""}`
       if (finalAttempt) {
         ctx.setUserInput("implementation", "fail");
         trackComponentGenerated(false, attempt);
+        logger.warn(
+          {
+            summary: validation.summary,
+            additionalInstructions: validation.additionalInstructions,
+            unrelatedFailure: validation.unrelatedFailure
+          },
+          "implement: search validation failed on the final attempt"
+        );
         throw new Error(
-          `Unable to validate the implementation after ${MAX_IMPLEMENT_VALIDATION_ATTEMPTS} attempts: ${validation.additionalInstructions ?? validation.unrelatedFailure ?? validation.summary}`
+          `Unable to validate the implementation after ${MAX_IMPLEMENT_VALIDATION_ATTEMPTS} attempts (details in wizard.log): ${briefSummary(validation.summary)}`
         );
       }
       extraInstructions = validation.sufficient ? [] : validationRetryInstructions(validation);
@@ -6911,8 +7237,8 @@ var defaultWorkflow = {
     defineStep({
       id: "select-index",
       title: "Set up index",
-      outputSchema: z29.object({
-        selection: z29.string()
+      outputSchema: z30.object({
+        selection: z30.string()
       }),
       run: (ctx) => selectIndexStep(ctx)
     }),
@@ -6973,7 +7299,7 @@ var defaultWorkflow = {
 import "zod";
 
 // src/actions/playbookSteps/selectPlaybook.ts
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 
 // src/lib/dashboardApi/client.ts
 import "zod";
@@ -7032,67 +7358,67 @@ async function dashboardError(res) {
 }
 
 // src/lib/dashboardApi/schemas.ts
-import { z as z31 } from "zod";
-var messageResponseSchema = z31.object({
-  message: z31.string()
+import { z as z32 } from "zod";
+var messageResponseSchema = z32.object({
+  message: z32.string()
 });
-var playbookSchema = z31.object({
-  slug: z31.string(),
-  category: z31.string().optional(),
-  title: z31.string(),
-  description: z31.string().optional()
+var playbookSchema = z32.object({
+  slug: z32.string(),
+  category: z32.string().optional(),
+  title: z32.string(),
+  description: z32.string().optional()
 });
-var playbooksListSchema = z31.array(playbookSchema);
-var playbookExecutionStepSchema = z31.enum([
+var playbooksListSchema = z32.array(playbookSchema);
+var playbookExecutionStepSchema = z32.enum([
   "assessment",
   "optimization",
   "implement"
 ]);
-var playbookExecutionStepStatusSchema = z31.enum([
+var playbookExecutionStepStatusSchema = z32.enum([
   "not_started",
   "in_progress",
   "done",
   "error"
 ]);
-var schemaComparisonEntrySchema = z31.object({
-  canonical_attr: z31.string(),
-  canonical_type: z31.array(z31.string()),
-  canonical_roles: z31.array(z31.string()),
-  canonical_required: z31.boolean(),
-  index_attr: z31.string().nullable(),
-  index_type: z31.array(z31.string()).nullable(),
-  index_required: z31.boolean().nullable(),
-  status: z31.string(),
-  mapping_confidence: z31.number()
+var schemaComparisonEntrySchema = z32.object({
+  canonical_attr: z32.string(),
+  canonical_type: z32.array(z32.string()),
+  canonical_roles: z32.array(z32.string()),
+  canonical_required: z32.boolean(),
+  index_attr: z32.string().nullable(),
+  index_type: z32.array(z32.string()).nullable(),
+  index_required: z32.boolean().nullable(),
+  status: z32.string(),
+  mapping_confidence: z32.number()
 });
-var settingsRecommendationSchema = z31.record(
-  z31.string(),
-  z31.object({
-    current: z31.any(),
-    recommended: z31.any()
+var settingsRecommendationSchema = z32.record(
+  z32.string(),
+  z32.object({
+    current: z32.any(),
+    recommended: z32.any()
   })
 );
-var assessmentResultSchema = z31.object({
-  ready: z31.boolean(),
-  schema_comparison: z31.array(schemaComparisonEntrySchema),
+var assessmentResultSchema = z32.object({
+  ready: z32.boolean(),
+  schema_comparison: z32.array(schemaComparisonEntrySchema),
   settings_recommendation: settingsRecommendationSchema
 });
-var playbookExecutionSchema = z31.object({
-  uuid: z31.string(),
-  playbook_slug: z31.string(),
-  application_id: z31.string(),
-  source_index_name: z31.string(),
+var playbookExecutionSchema = z32.object({
+  uuid: z32.string(),
+  playbook_slug: z32.string(),
+  application_id: z32.string(),
+  source_index_name: z32.string(),
   current_step: playbookExecutionStepSchema,
   step_status: playbookExecutionStepStatusSchema,
-  status_reason: z31.string().nullable(),
-  completed: z31.boolean(),
+  status_reason: z32.string().nullable(),
+  completed: z32.boolean(),
   assessment_result: assessmentResultSchema.nullable(),
-  settings_snapshot: z31.json().nullable(),
-  created_at: z31.iso.datetime()
+  settings_snapshot: z32.json().nullable(),
+  created_at: z32.iso.datetime()
 });
 var playbookExecutionCreateResponseSchema = playbookExecutionSchema.extend({
-  resumed: z31.boolean(),
-  sample_data: z31.boolean()
+  resumed: z32.boolean(),
+  sample_data: z32.boolean()
 });
 
 // src/lib/dashboardApi/api.ts
@@ -7142,8 +7468,8 @@ async function assessPlaybookExecution(uuid) {
 }
 
 // src/actions/playbookSteps/selectPlaybook.ts
-var selectPlaybookSchema = z32.object({
-  slug: z32.string()
+var selectPlaybookSchema = z33.object({
+  slug: z33.string()
 });
 function persistSlug(ctx, slug) {
   ctx.setUserInput("playbookSlug", slug);
@@ -7175,10 +7501,10 @@ async function selectPlaybookStep(ctx, requestedSlug) {
 }
 
 // src/actions/playbookSteps/selectIndex.ts
-import { z as z33 } from "zod";
-var selectIndexSchema = z33.object({
-  indexName: z33.string(),
-  sampleIndex: z33.boolean()
+import { z as z34 } from "zod";
+var selectIndexSchema = z34.object({
+  indexName: z34.string(),
+  sampleIndex: z34.boolean()
 });
 var CREATE_SAMPLE_INDEX = "Create a sample index";
 var GO_BACK_OPTION = "Go back to playbook selection";
@@ -8736,7 +9062,7 @@ function App() {
                             onComplete: () => setTipsComplete(true)
                           }
                         ),
-                        showNoticesInMain && showNotices && /* @__PURE__ */ jsx21(Notices, { showAll: true, border: false }),
+                        showNoticesInMain && showNotices && /* @__PURE__ */ jsx21(Notices, { border: false }),
                         /* @__PURE__ */ jsx21(Review, {}),
                         !showTips && /* @__PURE__ */ jsx21(PromptInput, {}),
                         phase === "error" && error && /* @__PURE__ */ jsx21(Box22, { marginTop: 1, children: /* @__PURE__ */ jsxs20(Text23, { color: COLORS.status.error, children: [
@@ -8967,7 +9293,7 @@ async function seedWorkflowState(workflow, value) {
 }
 
 // src/lib/resetState.ts
-import { readdir as readdir3, rm as rm2 } from "node:fs/promises";
+import { readdir as readdir4, rm as rm2 } from "node:fs/promises";
 import { join as join12 } from "node:path";
 var KEEP = ["wizard.log"];
 async function resetProjectState() {
@@ -8975,7 +9301,7 @@ async function resetProjectState() {
   await forgetResolvedKeys();
   let entries;
   try {
-    entries = await readdir3(dir);
+    entries = await readdir4(dir);
   } catch {
     return { dir, removed: [] };
   }
@@ -8991,7 +9317,7 @@ async function resetProjectState() {
 // package.json with { type: 'json' }
 var package_default2 = {
   name: "@algolia/wizard",
-  version: "0.83.0",
+  version: "0.84.0-rc.202.645",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {