@algolia/wizard 0.19.0-rc.111.189 → 0.20.0

package/README.md

@@ -12,8 +12,22 @@ npx @algolia/wizard
 
 # run a specific workflow by id
 npx @algolia/wizard <workflow-id>
+
+# see all options
+npx @algolia/wizard --help
 ```
 
+### Options
+
+| Flag             | Effect                                                                                                                                                         |
+| ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `--seed <step-id>` | Start the workflow at the step with this id (e.g. `--seed ingestion`), with the earlier steps pre-filled with test data. Pass with no value to print the step ids. |
+| `--no-telemetry` | Send no telemetry or analytics for this run.                                                                                                                    |
+| `--reset-on-run` | Wipe this project's wizard state (run state, AI-changes consent, worktrees) before starting, so the run behaves like a first-ever run. Credentials are untouched. |
+| `-h`, `--help`   | Print usage.                                                                                                                                                   |
+
+`--seed` pre-fills the earlier steps with fabricated data so a single step can be exercised without running the whole workflow — useful for testing a step, not for a real implementation. It replaces any in-progress run for that workflow and pre-grants the AI-changes consent. See [Starting mid-workflow](CONTRIBUTING.md#starting-mid-workflow---seed).
+
 On first run, Wizard checks whether you're signed in to the Algolia CLI. If you aren't, it runs `algolia auth login --non-interactive` — the browser opens for sign-in, and no prompts land in the wizard's terminal. It then asks which Algolia application to work in (skipping the question when the account has only one) and makes it current with `algolia application select`.
 
 You'll also be asked once to consent to AI-authored changes to the repository.

package/dist/main.js

@@ -251,7 +251,6 @@ var useWizard = create((set, get) => ({
   _noticeTimer: null,
   cliOutput: [],
   targetIndex: null,
-  writtenFiles: [],
   logs: [],
   error: null,
   inputReq: null,
@@ -345,8 +344,6 @@ var useWizard = create((set, get) => ({
   })),
   clearCliOutput: () => set({ cliOutput: [] }),
   setTargetIndex: (index) => set({ targetIndex: index }),
-  recordWrittenFile: (path) => set((s) => ({ writtenFiles: [...s.writtenFiles, path] })),
-  clearWrittenFiles: () => set({ writtenFiles: [] }),
   logStart: (kind, name, input) => {
     const id = nanoid();
     set((s) => ({
@@ -394,7 +391,6 @@ var useWizard = create((set, get) => ({
       notices: [],
       cliOutput: [],
       targetIndex: null,
-      writtenFiles: [],
       logs: [],
       error: null,
       inputReq: null,
@@ -1204,7 +1200,7 @@ var accessItems = [
   {
     tag: "WRITE",
     title: "Code changes",
-    description: "creates & edits files (search UI, config) directly in your branch. You are asked to confirm first if it has uncommitted changes."
+    description: "creates & edits files (search UI, config) in a throwaway git worktree \u2014 your checkout is never touched."
   },
   {
     tag: "EXEC",
@@ -1219,7 +1215,7 @@ var accessItems = [
   {
     tag: "KEY",
     title: "Credentials",
-    description: "writes your Algolia app id and a search-only key (safe to expose) to .env in your project."
+    description: "writes your Algolia app id and a search-only key (safe to expose) to .env in the worktree."
   }
 ];
 var neverItems = [
@@ -2250,7 +2246,7 @@ async function ensureApplication() {
 }
 
 // src/workflows/default.ts
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 
 // src/actions/listIndices.ts
 import { z as z5 } from "zod";
@@ -2500,7 +2496,6 @@ function writeFileTool(ctx) {
         }
         await mkdir3(dirname4(resolved2.target), { recursive: true });
         await writeFile3(resolved2.target, content, "utf8");
-        useWizard.getState().recordWrittenFile(resolved2.target);
         return `Wrote to ${filePath}`;
       } catch (err) {
         return `Error writing ${filePath}: ${err.message}`;
@@ -2772,6 +2767,28 @@ async function ensureGitIgnored(root, target) {
 var APP_ID_VAR = "ALGOLIA_APPLICATION_ID";
 var API_KEY_VAR = "ALGOLIA_WRITE_API_KEY";
 var INDEX_NAME_VAR = "ALGOLIA_INDEX_NAME";
+var PUBLIC_APP_ID_SUFFIX = "ALGOLIA_APP_ID";
+var PUBLIC_SEARCH_KEY_SUFFIX = "ALGOLIA_SEARCH_KEY";
+var PUBLIC_INDEX_NAME_SUFFIX = "ALGOLIA_INDEX_NAME";
+function publicAppIdVar(prefix) {
+  return `${prefix}${PUBLIC_APP_ID_SUFFIX}`;
+}
+function publicSearchKeyVar(prefix) {
+  return `${prefix}${PUBLIC_SEARCH_KEY_SUFFIX}`;
+}
+function publicIndexNameVar(prefix) {
+  return `${prefix}${PUBLIC_INDEX_NAME_SUFFIX}`;
+}
+function publicSearchEnvVars(prefix, index, appId, searchKey) {
+  return [
+    { name: publicAppIdVar(prefix), value: appId ?? "<your-algolia-app-id>" },
+    {
+      name: publicSearchKeyVar(prefix),
+      value: searchKey ?? "<your-algolia-search-only-api-key>"
+    },
+    { name: publicIndexNameVar(prefix), value: index }
+  ];
+}
 function appendEnv(content, entries) {
   const prefix = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
   const lines = entries.map(([name, value]) => `${name}=${value}
@@ -3251,7 +3268,7 @@ var anthropic = createAnthropic({
 });
 function generateRecordTool(ctx) {
   return tool10({
-    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.",
+    description: "Generate realistic sample records for an entity and write them to a JSON file in the worktree. Provide the entity name and its attributes; this tool asks a model to invent varied, realistic values, each with a unique objectID, and returns the file path to read them from at runtime. Do not invent the record values or objectIDs yourself, and do not inline the returned records into the script \u2014 call this tool and read the file it writes.",
     inputSchema: 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."),
@@ -3505,7 +3522,10 @@ async function runAgent(req) {
 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() }))
+  frameworks: z21.array(z21.object({ name: z21.string(), version: z21.string() })),
+  publicEnvVarPrefix: z21.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).`
+  )
 });
 var detectLanguage = () => runAgent({
   instructions: [
@@ -3514,6 +3534,7 @@ var detectLanguage = () => runAgent({
     "If a meta-framework is used, exclude the framework it builds on (e.g. Next.js over React, Rails over Rack).",
     "Return the exact version",
     "Exclude things like CSS frameworks, build tools, or testing frameworks",
+    `Determine publicEnvVarPrefix: check the project's own env var usage first (e.g. names already referenced in code, .env/.env.example); if none exists, fall back to the detected framework's known convention for exposing env vars to client-side code; use "" when the project has no such convention (e.g. a backend-only project).`,
     'Use as few tools as possible, but do not guess. If you cant find the answer, say "unknown"',
     "When done, call reportStatus"
   ],
@@ -3609,7 +3630,7 @@ async function runAnalysis(mode, extraInstructions = []) {
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.19.0-rc.111.189",
+  version: "0.20.0",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {
@@ -3976,10 +3997,11 @@ ${JSON.stringify(s.output, null, 2)}`
 function formatReviewSummary(result) {
   const nextStepLines = result.nextSteps.map((step) => {
     const isIngestCommand = step.includes(".algolia-wizard/ingest.sh");
+    const isWorktreeCommand = step.includes("/worktrees/");
     return {
       text: `\u2192 ${step}`,
-      color: isIngestCommand ? COLORS.brand : void 0,
-      bold: isIngestCommand
+      color: isIngestCommand ? COLORS.brand : isWorktreeCommand ? COLORS.secondary : void 0,
+      bold: isIngestCommand || isWorktreeCommand
     };
   });
   return [
@@ -4013,14 +4035,16 @@ ${formatCompletedSteps(ctx.completedSteps)}`,
 };
 
 // src/actions/implement.ts
-import z28 from "zod";
-import { join as join12, relative as relative6 } from "node:path";
+import z29 from "zod";
+import { join as join12 } from "node:path";
 
-// src/lib/git.ts
+// src/lib/worktree.ts
 import { execFile as execFile2 } from "node:child_process";
-import { copyFile, mkdir as mkdir6, readFile as readFile8, stat as stat3, writeFile as writeFile7 } from "node:fs/promises";
+import { copyFile, mkdir as mkdir6, readdir as readdir3, readFile as readFile8, stat as stat3, writeFile as writeFile7 } from "node:fs/promises";
 import { basename as basename2, dirname as dirname7, isAbsolute as isAbsolute2, join as join10, resolve as resolve3 } from "node:path";
 var MAX_BUFFER = 32 * 1024 * 1024;
+var MAX_WIZARD_WORKTREES = 3;
+var WIZARD_BRANCH_PREFIX = "wizard/implement-";
 function git(args) {
   return new Promise((resolve4, reject) => {
     execFile2("git", args, { maxBuffer: MAX_BUFFER }, (err, stdout, stderr) => {
@@ -4043,7 +4067,44 @@ async function assertGitRepoWithHead(repoRoot) {
     );
   }
 }
-async function copyUploadIntoProject(repoRoot, ingestDir, sourcePath) {
+async function isWorkingTreeDirty(repoRoot) {
+  const out = await git(["-C", repoRoot, "status", "--porcelain"]);
+  return out.trim().length > 0;
+}
+async function pruneOldWorktrees(repoRoot) {
+  const dir = join10(stateDir(repoRoot), "worktrees");
+  const stale = (await readdir3(dir).catch(() => [])).filter((name) => /^wizard-implement-\d+$/.test(name)).sort().reverse().slice(MAX_WIZARD_WORKTREES - 1);
+  for (const slug of stale) {
+    const branch = slug.replace("wizard-implement-", WIZARD_BRANCH_PREFIX);
+    try {
+      await git([
+        "-C",
+        repoRoot,
+        "worktree",
+        "remove",
+        "--force",
+        join10(dir, slug)
+      ]);
+      await git(["-C", repoRoot, "branch", "-D", branch]);
+    } catch (err) {
+      logger.warn(
+        { branch, err: err.message },
+        "createWorktree: failed to prune a stale wizard worktree; continuing"
+      );
+    }
+  }
+}
+async function createWorktree(repoRoot) {
+  const branch = `${WIZARD_BRANCH_PREFIX}${Date.now()}`;
+  const dirSlug = branch.replace(/\//g, "-");
+  const path = join10(stateDir(repoRoot), "worktrees", dirSlug);
+  await git(["-C", repoRoot, "worktree", "prune"]);
+  await pruneOldWorktrees(repoRoot);
+  await mkdir6(dirname7(path), { recursive: true });
+  await git(["-C", repoRoot, "worktree", "add", "-b", branch, path, "HEAD"]);
+  return { path, branch };
+}
+async function copyUploadIntoWorktree(repoRoot, worktreePath, ingestDir, sourcePath) {
   const trimmed = sourcePath.trim();
   if (!trimmed) {
     return { ok: false, reason: "no file path was provided" };
@@ -4057,10 +4118,7 @@ async function copyUploadIntoProject(repoRoot, ingestDir, sourcePath) {
     return { ok: false, reason: `"${sourcePath}" does not exist` };
   }
   const relPath = join10(ingestDir, basename2(source));
-  const dest = join10(repoRoot, relPath);
-  if (resolve3(source) === resolve3(dest)) {
-    return { ok: true, relPath };
-  }
+  const dest = join10(worktreePath, relPath);
   try {
     await mkdir6(dirname7(dest), { recursive: true });
     await copyFile(source, dest);
@@ -4075,10 +4133,10 @@ async function copyUploadIntoProject(repoRoot, ingestDir, sourcePath) {
 function hasEnvVar(content, name) {
   return new RegExp(`^(\\s*(?:export\\s+)?${name})\\s*=`, "m").test(content);
 }
-async function readEnvVar(repoRoot, name) {
+async function readEnvVar(worktreePath, name) {
   let content;
   try {
-    content = await readFile8(join10(repoRoot, ".env"), "utf8");
+    content = await readFile8(join10(worktreePath, ".env"), "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
     return void 0;
@@ -4092,8 +4150,8 @@ async function readEnvVar(repoRoot, name) {
   if (!value || value.startsWith("<")) return void 0;
   return value;
 }
-async function writeSearchEnvValues(repoRoot, vars) {
-  const target = join10(repoRoot, ".env");
+async function writeSearchEnvValues(worktreePath, vars) {
+  const target = join10(worktreePath, ".env");
   let existing = "";
   try {
     existing = await readFile8(target, "utf8");
@@ -4108,27 +4166,61 @@ async function writeSearchEnvValues(repoRoot, vars) {
   await writeFile7(target, existing + prefix + lines, "utf8");
   return missing.map((v) => v.name);
 }
+async function listChangedFiles(worktreePath) {
+  const raw = await git(["-C", worktreePath, "status", "--porcelain", "-z"]);
+  const entries = raw.split("\0");
+  const files = [];
+  for (let i = 0; i < entries.length; i += 1) {
+    const entry = entries[i];
+    if (!entry) continue;
+    files.push(entry.slice(3));
+    if (["R", "C"].includes(entry[0]) || ["R", "C"].includes(entry[1])) i += 1;
+  }
+  return files;
+}
 function normalizeFindingPaths(findings) {
   return {
     ...findings,
     ingestionAnalysis: findings.ingestionAnalysis?.map((e) => ({
       ...e,
-      paths: e.paths.map(toRootRelative)
+      paths: e.paths.map(toWorktreeRelative)
     })),
     searchImplementationAnalysis: findings.searchImplementationAnalysis ? normalizeSearchLocation(findings.searchImplementationAnalysis) : void 0,
     confirmedEntities: findings.confirmedEntities?.map((e) => ({
       ...e,
-      paths: e.paths.map(toRootRelative)
+      paths: e.paths.map(toWorktreeRelative)
     }))
   };
 }
 function normalizeSearchLocation(path) {
-  const normalized = path ? toRootRelative(path).trim() : "";
+  const normalized = path ? toWorktreeRelative(path).trim() : "";
   return normalized && normalized.toLowerCase() !== "unknown" ? normalized : void 0;
 }
-function toRootRelative(p) {
+function toWorktreeRelative(p) {
   return p.replace(/^\/+/, "");
 }
+async function confirmDirtyWorkingTree(ctx, repoRoot) {
+  const MAX_LISTED_DIRTY_FILES = 10;
+  const dirty = await listChangedFiles(repoRoot);
+  const shown = dirty.slice(0, MAX_LISTED_DIRTY_FILES);
+  const overflow = dirty.length - shown.length;
+  const answer = await ctx.requestUserInput({
+    prompt: "Proceed using HEAD only? Uncommitted changes will NOT be included in the generated implementation.",
+    promptType: "acceptReject",
+    options: [],
+    messages: [
+      `${dirty.length} uncommitted change(s) detected. The wizard builds an isolated worktree from HEAD, so these are ignored:`,
+      ...shown.map((file) => `  \u2022 ${file}`),
+      ...overflow > 0 ? [`  \u2022 \u2026and ${overflow} more`] : [],
+      "Commit or stash them first to include them in the implementation."
+    ]
+  });
+  if (answer !== true) {
+    throw new Error(
+      "implement aborted: commit or stash your changes so they are built into the worktree, then re-run the wizard."
+    );
+  }
+}
 
 // src/lib/algoliaDocs.ts
 import { readFileSync, readdirSync, existsSync } from "node:fs";
@@ -4188,29 +4280,53 @@ function getFrameworkSpecificDoc(frameworks) {
   return loadAlgoliaDoc("js");
 }
 
+// src/lib/shell.ts
+function shellQuote(value) {
+  return "'" + value.replace(/'/g, "'\\''") + "'";
+}
+
+// src/actions/resolveEnvVarPrefix.ts
+import z28 from "zod";
+var resolveEnvVarPrefixSchema = z28.object({
+  publicEnvVarPrefix: detectLanguageSchema.shape.publicEnvVarPrefix
+});
+var resolveEnvVarPrefix = (frameworkName) => runAgent({
+  instructions: [
+    `The developer corrected the project's framework to "${frameworkName}".`,
+    `Determine publicEnvVarPrefix for this framework: check the project's own env var usage first (e.g. names already referenced in code, .env/.env.example); if none exists, fall back to this framework's known convention for exposing env vars to client-side code; use "" when the framework has no such convention (e.g. a backend-only framework).`,
+    'Use as few tools as possible, but do not guess. If you cant find the answer, say "unknown"',
+    "When done, call reportStatus"
+  ],
+  tools: ["listFiles", "changeDirectory", "readFile", "searchFiles"],
+  outputSchema: resolveEnvVarPrefixSchema,
+  modelSize: "small"
+});
+
 // src/actions/implement.ts
-var implementSchema = 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"]),
-  searchEnvVars: z28.array(
-    z28.object({
-      name: z28.string(),
-      value: z28.string()
+var implementSchema = z29.object({
+  filesChanged: z29.array(z29.string()),
+  summary: z29.string(),
+  worktreePath: z29.string().optional(),
+  ingestCommand: z29.string().optional(),
+  ingestScriptRan: z29.boolean().optional(),
+  ingestRecordCount: z29.number().optional(),
+  ingestDurationMs: z29.number().optional(),
+  ingestionSource: z29.enum(["local", "fileUpload", "generated"]),
+  searchEnvVars: z29.array(
+    z29.object({
+      name: z29.string(),
+      value: z29.string()
     })
   ).optional()
 });
-var implementationOutputSchema = z28.object({
-  summary: z28.string(),
-  ingestCommand: z28.string().optional()
+var implementationOutputSchema = z29.object({
+  summary: z29.string(),
+  ingestCommand: z29.string().optional()
 });
-var verificationOutputSchema = z28.object({
-  summary: z28.string(),
-  sufficient: z28.boolean(),
-  additionalInstructions: z28.string().optional()
+var verificationOutputSchema = z29.object({
+  summary: z29.string(),
+  sufficient: z29.boolean(),
+  additionalInstructions: z29.string().optional()
 });
 var MAX_IMPLEMENT_VERIFICATION_ATTEMPTS = 3;
 var DEFAULT_IMPLEMENT_USE_CASES = ["ingestion", "search"];
@@ -4241,54 +4357,10 @@ function searchUiTarget(language) {
 function frameworksForDoc(language) {
   return [matchUiFramework(language)?.doc ?? "js"];
 }
-function publicEnvPrefix(language) {
-  const frameworkNames = lower(language.frameworks);
-  if (frameworkNames.some((name) => name.includes("next"))) {
-    return "NEXT_PUBLIC_";
-  }
-  if (frameworkNames.some((name) => name.includes("nuxt"))) {
-    return "NUXT_PUBLIC_";
-  }
-  if (frameworkNames.some((name) => name.includes("astro"))) {
-    return "PUBLIC_";
-  }
-  if (frameworkNames.some((name) => name.includes("vite"))) {
-    return "VITE_";
-  }
-  return isJsProject(language) ? "PUBLIC_" : "";
-}
-var APP_ID_VAR_SUFFIX = "ALGOLIA_APP_ID";
-var SEARCH_KEY_VAR_SUFFIX = "ALGOLIA_SEARCH_API_KEY";
-var INDEX_VAR_SUFFIX = "ALGOLIA_INDEX_NAME";
-function appIdVar(language) {
-  return `${publicEnvPrefix(language)}${APP_ID_VAR_SUFFIX}`;
-}
-function searchKeyVar(language) {
-  return `${publicEnvPrefix(language)}${SEARCH_KEY_VAR_SUFFIX}`;
-}
-function searchIndexVar(language) {
-  return `${publicEnvPrefix(language)}${INDEX_VAR_SUFFIX}`;
-}
-function searchEnvVars(language, index, appId, searchKey) {
-  return [
-    {
-      name: appIdVar(language),
-      value: appId ?? "<your-algolia-app-id>"
-    },
-    {
-      name: searchKeyVar(language),
-      value: searchKey ?? "<your-algolia-search-only-api-key>"
-    },
-    // Wizard-supplied rather than written into the generated code: an agent
-    // that retypes the name leaves the UI querying an index that doesn't exist.
-    {
-      name: searchIndexVar(language),
-      value: index
-    }
-  ];
-}
 function baseInstructions(input) {
   return [
+    // Agents have renamed this (e.g. appending the project name), which the
+    // index-scoped keys then reject with a 403.
     `Target Algolia index, to be used exactly as written \u2014 never renamed, re-cased, prefixed, or suffixed: "${input.targetIndex}"`,
     `Project languages and frameworks: ${JSON.stringify(input.language)}`,
     "Make minimal, idiomatic changes; do not touch unrelated code.",
@@ -4306,14 +4378,14 @@ function sourceSpecificInstructions(input) {
       "Add env vars for any local source access (DB URL, API base, file paths) that is not a fixed repo path."
     ],
     fileUpload: [
-      `Records come from the developer's file, already copied into the project at "${input.uploadFilePath}". Read and parse that exact file.`,
+      `Records come from the developer's file, already copied into the worktree at "${input.uploadFilePath}". Read and parse that exact file.`,
       "Parse by extension: JSON = array of objects; CSV/TSV = header row maps to keys.",
       "Map parsed columns/fields to the confirmed entity attributes.",
       "Never fabricate, hardcode, or substitute a different file."
     ],
     generated: [
       "No real data source exists; use sample records for each confirmed entity.",
-      "Call the generateRecord tool once per entity (entityName, attributes, count 20-50); it invents the values and unique objectIDs and writes them to a JSON file, returning the file path. Do not write records or objectIDs yourself.",
+      "Call the generateRecord tool once per entity (entityName, attributes, count 20-50); it invents the values and unique objectIDs and writes them to a JSON file in the worktree, returning the file path. Do not write records or objectIDs yourself.",
       "In the script, read and parse each returned file path at runtime using your language's standard JSON support, instead of inlining the records as literals.",
       "Add a prominent TODO where the developer swaps the generated records (and the JSON file under `.algolia-wizard/data/`) for their real record source."
     ]
@@ -4360,13 +4432,16 @@ function searchInstructions(input) {
     ],
     `Add the search UI at ${input.searchLocation ? `"${input.searchLocation}"` : "the best shared, always-rendered layout location (e.g. a header/nav component)"} so it is reachable across the app \u2014 at least a working search input and results list against the target index.`,
     "If a search box already exists, replace it with yours.",
-    `Read the index name from the ${searchIndexVar(input.language)} env var, which the wizard sets to "${input.targetIndex}". Never hardcode an index name or derive one from the project, file, or component name.`,
+    `Read the index name from the ${publicIndexNameVar(input.publicEnvVarPrefix)} env var, which the wizard sets to "${input.targetIndex}". Never hardcode an index name or derive one from the project, file, or component name.`,
     "Read the App ID, the search-only API key, and the index name from env vars; never hardcode them. A search-only key is safe to expose client-side.",
-    // The key is provisioned only after verification passes, and the wizard
-    // reads .env to decide whether a key already exists — an agent-invented
-    // value there would be reused as if it were real.
+    // The key is provisioned only after verification passes, so the agent never
+    // sees one. It must also leave .env alone: the wizard reads that file to
+    // decide whether a key already exists, and an agent-invented value there
+    // would be reused as if it were real.
     `Add Algolia App ID "${input.appId}"; leave the search-only key as a placeholder. Do not create or edit .env \u2014 the wizard writes the resolved key there itself.`,
-    // The wizard writes these exact names into .env right after this step.
+    // Not the agent's to rename: the wizard writes these exact names into
+    // ".env" right after this step, so a renamed prefix would leave the code
+    // reading a var the wizard never wrote.
     `Use exactly these env var names in the code: ${input.searchEnvVars.map(({ name }) => name).join(", ")}.`,
     "Install any Algolia packages you import with the project's own package manager via runShell, and declare them in the project's dependency manifest.",
     "Match the styles of the application as closely as possible.",
@@ -4375,10 +4450,10 @@ function searchInstructions(input) {
 }
 function verificationInstructions(input) {
   return [
-    "Verify the Algolia implementation changes.",
+    "Verify the Algolia implementation changes in the current worktree.",
     `Verification tools found in the codebase: ${JSON.stringify(input.findings.verification ?? [])}.`,
     "Run the project's own checks (lint, type check, tests) via runShell, using the commands the project actually defines \u2014 its task runner, manifest scripts, or Makefile. Run every check that applies, not just the first.",
-    "If a check fails because packages or modules are missing, install the dependencies via runShell and re-run it rather than changing the code.",
+    "This worktree starts with no installed dependencies. If a check fails because packages or modules are missing, install the dependencies via runShell and re-run it rather than changing the code.",
     "For issues caused by the implementation, make minimal fixes with writeFile and re-run the checks.",
     "Do not make speculative fixes when no checks exist, a check cannot run, or failures are unrelated to these changes \u2014 note the limitation in your summary.",
     "Do not add new Algolia functionality here; only validate and make minimal correctness fixes.",
@@ -4473,11 +4548,11 @@ function ingestFailure(attempt, executions) {
   }
   return { reason: `it failed (exit ${attempt.exitCode ?? "unknown"})`, detail };
 }
-function makeToolContext(root, env = async () => ({})) {
+function makeToolContext(worktree, env = async () => ({})) {
   return createToolContext(
     DEFAULT_TOOL_LIMITS,
-    root,
-    createShellContext({ env, approve: storeApproval(root) })
+    worktree,
+    createShellContext({ env, approve: storeApproval(worktree) })
   );
 }
 function verificationRetryInstructions(verification) {
@@ -4485,7 +4560,7 @@ function verificationRetryInstructions(verification) {
     `Implementation insufficient. Address these findings before reporting completion: ${verification.additionalInstructions ?? verification.summary}`
   ];
 }
-async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
+async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWorktreePath) {
   const repoRoot = process.cwd();
   const scan = ctx.getStepOutput("project-scan");
   const entities = ctx.getStepOutput(
@@ -4501,6 +4576,21 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
     languages: ctx.getStepOutput("confirm-language")?.languages ?? scan.languages,
     frameworks: ctx.getStepOutput("confirm-framework")?.frameworks ?? scan.frameworks
   };
+  const normalizeFrameworkName = (name) => name.toLowerCase().replace(/[^a-z0-9]/g, "");
+  const confirmedPrimaryFramework = language.frameworks[0]?.name;
+  const frameworkWasCorrected = confirmedPrimaryFramework !== void 0 && !scan.frameworks.some(
+    (fw) => normalizeFrameworkName(fw.name) === normalizeFrameworkName(confirmedPrimaryFramework)
+  );
+  const publicEnvVarPrefixPromise = frameworkWasCorrected ? resolveEnvVarPrefix(confirmedPrimaryFramework).then(
+    (r) => r.publicEnvVarPrefix,
+    (err) => {
+      logger.warn(
+        { err, framework: confirmedPrimaryFramework },
+        "implement: could not re-resolve publicEnvVarPrefix after a framework correction; using the stale scan value"
+      );
+      return scan.publicEnvVarPrefix;
+    }
+  ) : Promise.resolve(scan.publicEnvVarPrefix);
   const selected = ctx.getStepOutput(
     "select-index"
   );
@@ -4551,6 +4641,9 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
   const targetIndex = selected?.selection;
   useWizard.getState().setTargetIndex(targetIndex ?? null);
   await assertGitRepoWithHead(repoRoot);
+  if (await isWorkingTreeDirty(repoRoot)) {
+    await confirmDirtyWorkingTree(ctx, repoRoot);
+  }
   const normalized = normalizeFindingPaths(findings);
   const confirmed2 = normalized.confirmedEntities;
   const searchLocation = normalized.searchImplementationAnalysis;
@@ -4562,288 +4655,328 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES) {
   if (useCases.includes("ingestion")) {
     ingestAppId = appId ?? (await requireApplication()).id;
   }
-  let uploadFilePath;
-  let uploadWarning;
-  if (ingestionSource === "fileUpload") {
-    const copied = await copyUploadIntoProject(
-      repoRoot,
-      INGEST_DIR,
-      uploadSourcePath ?? ""
-    );
-    if (copied.ok) {
-      uploadFilePath = copied.relPath;
-    } else {
-      ingestionSource = "generated";
-      uploadWarning = `\u26A0\uFE0F Could not use the uploaded file (${copied.reason}); generating sample records instead.`;
-      logger.warn(
-        { reason: copied.reason },
-        "implement: file upload unavailable; falling back to generated sample records"
-      );
-    }
-  }
-  const input = {
-    findings: normalized,
-    confirmed: confirmed2,
-    searchLocation,
-    targetIndex,
-    language,
-    appId,
-    searchEnvVars: searchEnvVars(language, targetIndex, appId),
-    ingestDir: INGEST_DIR,
-    ingestionSource,
-    uploadFilePath,
-    searchUiTarget: searchUiTarget(language)
-  };
-  const summaries = [];
-  if (uploadWarning) summaries.push(uploadWarning);
-  let envSearchKey;
-  let envAppIdMismatch = false;
-  if (useCases.includes("search") && appId) {
-    const envAppId = await readEnvVar(repoRoot, appIdVar(language));
-    if (envAppId === appId) {
-      envSearchKey = await readEnvVar(repoRoot, searchKeyVar(language));
-    } else if (envAppId) {
-      envAppIdMismatch = true;
-      summaries.push(
-        `\u26A0\uFE0F .env already sets ${appIdVar(language)}=${envAppId}, but the active Algolia application is ${appId}. The wizard left those values alone \u2014 update ${appIdVar(language)} and ${searchKeyVar(language)} by hand, or searches will fail.`
-      );
-      logger.warn(
-        { envAppId, appId },
-        "implement: .env holds credentials for a different Algolia application; not reusing its search key"
+  const worktree = existingWorktreePath ?? (await createWorktree(repoRoot)).path;
+  try {
+    process.chdir(worktree);
+    let uploadFilePath;
+    let uploadWarning;
+    if (ingestionSource === "fileUpload") {
+      const copied = await copyUploadIntoWorktree(
+        repoRoot,
+        worktree,
+        INGEST_DIR,
+        uploadSourcePath ?? ""
       );
+      if (copied.ok) {
+        uploadFilePath = copied.relPath;
+      } else {
+        ingestionSource = "generated";
+        uploadWarning = `\u26A0\uFE0F Could not use the uploaded file (${copied.reason}); generating sample records instead.`;
+        logger.warn(
+          { reason: copied.reason },
+          "implement: file upload unavailable; falling back to generated sample records"
+        );
+      }
     }
-  }
-  let finalSearchEnvVars = input.searchEnvVars;
-  let agentRuns = 0;
-  let ingestCommand;
-  let ingestScriptRan = false;
-  let ingestRecordCount;
-  let ingestDurationMs;
-  let ingestOutcomeMessage;
-  const ingestKeyAppId = ingestAppId;
-  const ingestionTools = ingestKeyAppId ? makeToolContext(repoRoot, async () => ({
-    [APP_ID_VAR]: ingestKeyAppId,
-    [API_KEY_VAR]: (await resolveWriteKey(targetIndex, ingestKeyAppId)).key,
-    [INDEX_NAME_VAR]: targetIndex
-  })) : void 0;
-  const searchTools = makeToolContext(repoRoot);
-  async function runImplementationUseCase(currentUseCase, extraInstructions = []) {
-    if (agentRuns > 0) ctx.recordStepExecution();
-    agentRuns += 1;
-    return runAgent({
-      instructions: buildAgentInstructions(
-        currentUseCase,
-        input,
-        extraInstructions
+    const publicEnvVarPrefix = await publicEnvVarPrefixPromise;
+    const input = {
+      findings: normalized,
+      confirmed: confirmed2,
+      searchLocation,
+      targetIndex,
+      language,
+      publicEnvVarPrefix,
+      appId,
+      searchEnvVars: publicSearchEnvVars(
+        publicEnvVarPrefix,
+        targetIndex,
+        appId
       ),
-      tools: toolsForUseCase(currentUseCase, input.ingestionSource),
-      outputSchema: implementationOutputSchema,
-      toolContext: currentUseCase === "ingestion" ? ingestionTools ?? searchTools : searchTools
-    });
-  }
-  async function runVerificationUseCase() {
-    if (agentRuns > 0) ctx.recordStepExecution();
-    agentRuns += 1;
-    return runAgent({
-      instructions: buildAgentInstructions("verification", input),
-      tools: toolsForUseCase("verification"),
-      outputSchema: verificationOutputSchema,
-      toolContext: searchTools
-    });
-  }
-  if (useCases.includes("ingestion")) {
-    let ingestFailureDetail;
-    const result = await runImplementationUseCase("ingestion");
-    summaries.push(formatSummary("ingestion", result.summary));
-    ingestCommand = result.ingestCommand;
-    const ingestionContext = ingestionTools ?? searchTools;
-    const executions = ingestionContext.shell.executions;
-    const {
-      run: ingestRun,
-      attempt: ingestAttempt,
-      recordCount
-    } = ingestOutcome(executions, ingestCommand);
-    ingestScriptRan = ingestRun != null;
-    ingestRecordCount = recordCount;
-    ingestDurationMs = ingestRun?.durationMs;
-    if (ingestScriptRan && ingestionContext.reviewed.length === 0) {
-      summaries.push(
-        "\u26A0\uFE0F The ingestion script ran without being shown to you for review. Read it in your project before trusting the index contents."
-      );
-      logger.warn(
-        { ingestCommand },
-        "implement: ingestion ran without a reviewScript call"
+      ingestDir: INGEST_DIR,
+      ingestionSource,
+      uploadFilePath,
+      searchUiTarget: searchUiTarget(language)
+    };
+    const summaries = [];
+    if (uploadWarning) summaries.push(uploadWarning);
+    let envSearchKey;
+    let envAppIdMismatch = false;
+    if (useCases.includes("search") && appId) {
+      const envAppId = await readEnvVar(
+        worktree,
+        publicAppIdVar(publicEnvVarPrefix)
       );
-    }
-    if (ingestScriptRan) {
-      ingestOutcomeMessage = `\u2705 Ingestion succeeded${ingestRecordCount != null ? ` \u2014 ${ingestRecordCount} record(s) indexed.` : "."}`;
-      if (ingestRecordCount != null) {
-        track("AI Wizard Ingest Successful", {
-          entity_name: confirmed2?.map((e) => e.name).join(", ") || "unknown",
-          record_count: ingestRecordCount,
-          duration_ms: ingestDurationMs ?? 0
-        });
+      if (envAppId === appId) {
+        envSearchKey = await readEnvVar(
+          worktree,
+          publicSearchKeyVar(publicEnvVarPrefix)
+        );
+      } else if (envAppId) {
+        envAppIdMismatch = true;
+        const appIdVarName = publicAppIdVar(publicEnvVarPrefix);
+        const searchKeyVarName = publicSearchKeyVar(publicEnvVarPrefix);
+        summaries.push(
+          `\u26A0\uFE0F .env already sets ${appIdVarName}=${envAppId}, but the active Algolia application is ${appId}. The wizard left those values alone \u2014 update ${appIdVarName} and ${searchKeyVarName} by hand, or searches will fail.`
+        );
+        logger.warn(
+          { envAppId, appId },
+          "implement: .env holds credentials for a different Algolia application; not reusing its search key"
+        );
       }
-    } else {
-      const { reason, detail } = ingestFailure(ingestAttempt, executions);
-      ingestOutcomeMessage = `\u26A0\uFE0F Records were not indexed \u2014 ${reason}.${ingestCommand ? " Run the command below when you are ready." : ""}`;
-      ingestFailureDetail = detail;
-      summaries.push(
-        `\u26A0\uFE0F Ingestion did not complete: ${reason}.${detail ? `
-${detail}` : ""}`
-      );
-      logger.warn(
-        {
-          ingestCommand,
-          reason,
-          approved: ingestAttempt?.approved,
-          exitCode: ingestAttempt?.exitCode,
-          timedOut: ingestAttempt?.timedOut,
-          commandsRun: executions.length
-        },
-        "implement: ingestion script did not complete successfully"
-      );
-      track("Error", {
-        step: "Push Data",
-        error: `ingestion did not complete: ${reason}`,
-        product_area: "AI Wizard"
+    }
+    let finalSearchEnvVars = input.searchEnvVars;
+    let agentRuns = 0;
+    let ingestCommand;
+    let ingestScriptRan = false;
+    let ingestRecordCount;
+    let ingestDurationMs;
+    let ingestOutcomeMessage;
+    const ingestKeyAppId = ingestAppId;
+    const ingestionTools = ingestKeyAppId ? makeToolContext(worktree, async () => ({
+      [APP_ID_VAR]: ingestKeyAppId,
+      [API_KEY_VAR]: (await resolveWriteKey(targetIndex, ingestKeyAppId)).key,
+      [INDEX_NAME_VAR]: targetIndex
+    })) : void 0;
+    const searchTools = makeToolContext(worktree);
+    async function runImplementationUseCase(currentUseCase, extraInstructions = []) {
+      if (agentRuns > 0) ctx.recordStepExecution();
+      agentRuns += 1;
+      return runAgent({
+        instructions: buildAgentInstructions(
+          currentUseCase,
+          input,
+          extraInstructions
+        ),
+        tools: toolsForUseCase(currentUseCase, input.ingestionSource),
+        outputSchema: implementationOutputSchema,
+        toolContext: currentUseCase === "ingestion" ? ingestionTools ?? searchTools : searchTools
       });
     }
-    const commandMessages = ingestCommand ? [`Ingestion command: ${ingestCommand}`] : [];
-    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: [
-        ingestOutcomeMessage,
-        ...ingestFailureDetail?.split("\n").filter((l) => l.trim()) ?? [],
-        ...commandMessages
-      ]
-    });
-  }
-  if (useCases.includes("search")) {
-    let extraInstructions = [];
-    useWizard.getState().clearWrittenFiles();
-    for (let attempt = 1; attempt <= MAX_IMPLEMENT_VERIFICATION_ATTEMPTS; attempt++) {
-      if (attempt > 1) {
-        logger.info(
-          {
-            attempt,
-            maxAttempts: MAX_IMPLEMENT_VERIFICATION_ATTEMPTS,
-            extraInstructions
-          },
-          "implement: retrying search implementation after failed verification"
+    async function runVerificationUseCase() {
+      if (agentRuns > 0) ctx.recordStepExecution();
+      agentRuns += 1;
+      return runAgent({
+        instructions: buildAgentInstructions("verification", input),
+        tools: toolsForUseCase("verification"),
+        outputSchema: verificationOutputSchema,
+        toolContext: searchTools
+      });
+    }
+    if (useCases.includes("ingestion")) {
+      let ingestFailureDetail;
+      const result = await runImplementationUseCase("ingestion");
+      summaries.push(formatSummary("ingestion", result.summary));
+      ingestCommand = result.ingestCommand;
+      const ingestionContext = ingestionTools ?? searchTools;
+      const executions = ingestionContext.shell.executions;
+      const {
+        run: ingestRun,
+        attempt: ingestAttempt,
+        recordCount
+      } = ingestOutcome(executions, ingestCommand);
+      ingestScriptRan = ingestRun != null;
+      ingestRecordCount = recordCount;
+      ingestDurationMs = ingestRun?.durationMs;
+      if (ingestScriptRan && ingestionContext.reviewed.length === 0) {
+        summaries.push(
+          "\u26A0\uFE0F The ingestion script ran without being shown to you for review. Read it in the worktree before trusting the index contents."
         );
-      }
-      const { summary } = await runImplementationUseCase(
-        "search",
-        extraInstructions
-      );
-      summaries.push(formatSummary("search", summary));
-      const verification = await runVerificationUseCase();
-      summaries.push(formatSummary("verification", verification.summary));
-      if (verification.sufficient) {
-        ctx.setUserInput("implementation", "success");
-        const searchFilesChanged = [
-          ...new Set(useWizard.getState().writtenFiles)
-        ].map((file) => relative6(repoRoot, file));
-        track("AI Wizard Frontend Component Generated", {
-          filePaths: searchFilesChanged
-        });
-        track("AI Wizard Wired to UI", {
-          location_heuristic: searchLocation ?? "unknown"
-        });
-        break;
-      }
-      if (attempt === MAX_IMPLEMENT_VERIFICATION_ATTEMPTS) {
-        ctx.setUserInput("implementation", "fail");
-        throw new Error(
-          `Implementation verification failed after ${MAX_IMPLEMENT_VERIFICATION_ATTEMPTS} attempts: ${verification.additionalInstructions ?? verification.summary}`
+        logger.warn(
+          { ingestCommand },
+          "implement: ingestion ran without a reviewScript call"
         );
       }
-      extraInstructions = verificationRetryInstructions(verification);
-    }
-    let searchKey;
-    let searchKeyError;
-    if (appId) {
-      try {
-        const resolved2 = await resolveSearchOnlyKey(
-          targetIndex,
-          appId,
-          envSearchKey
-        );
-        searchKey = resolved2.key;
+      if (ingestScriptRan) {
+        ingestOutcomeMessage = `\u2705 Ingestion succeeded${ingestRecordCount != null ? ` \u2014 ${ingestRecordCount} record(s) indexed.` : "."}`;
+        if (ingestRecordCount != null) {
+          track("AI Wizard Ingest Successful", {
+            entity_name: confirmed2?.map((e) => e.name).join(", ") || "unknown",
+            record_count: ingestRecordCount,
+            duration_ms: ingestDurationMs ?? 0
+          });
+        }
+      } else {
+        const { reason, detail } = ingestFailure(ingestAttempt, executions);
+        ingestOutcomeMessage = `\u26A0\uFE0F Records were not indexed \u2014 ${reason}.${ingestCommand ? " Run the command below when you are ready." : ""}`;
+        ingestFailureDetail = detail;
         summaries.push(
-          resolved2.source === "created" ? `Created a new search-only Algolia API key for the "${targetIndex}" index in app ${appId} \u2014 safe to expose in frontend code.` : `Reused the existing search-only Algolia API key for the "${targetIndex}" index in app ${appId}.`
+          `\u26A0\uFE0F Ingestion did not complete: ${reason}.${detail ? `
+${detail}` : ""}`
         );
-      } catch (err) {
-        searchKeyError = err.message;
         logger.warn(
-          { err: searchKeyError },
-          "implement: could not provision a search-only API key; the .env value stays a placeholder"
+          {
+            ingestCommand,
+            reason,
+            approved: ingestAttempt?.approved,
+            exitCode: ingestAttempt?.exitCode,
+            timedOut: ingestAttempt?.timedOut,
+            commandsRun: executions.length
+          },
+          "implement: ingestion script did not complete successfully"
         );
+        track("Error", {
+          step: "Push Data",
+          error: `ingestion did not complete: ${reason}`,
+          product_area: "AI Wizard"
+        });
       }
-    }
-    finalSearchEnvVars = searchEnvVars(language, targetIndex, appId, searchKey);
-    const resolvedSearchEnvVars = finalSearchEnvVars.filter(
-      (v) => !v.value.startsWith("<")
-    );
-    if (resolvedSearchEnvVars.length > 0) {
-      const written = await writeSearchEnvValues(
-        repoRoot,
-        resolvedSearchEnvVars
-      );
-      if (written.length > 0) {
-        summaries.push(`Wrote ${written.join(", ")} to .env.`);
+      const commandMessages = [`Open the worktree: cd ${shellQuote(worktree)}`];
+      if (ingestCommand) {
+        commandMessages.push(`Ingestion command: ${ingestCommand}`);
       }
-      const ignored = await ensureGitIgnored(repoRoot, join12(repoRoot, ".env"));
-      if (ignored === "added") {
-        summaries.push("Added .env to .gitignore.");
-      } else if (ignored === "tracked") {
-        summaries.push(
-          '\u26A0\uFE0F .env is tracked by git, so a .gitignore rule cannot un-stage it. Run "git rm --cached .env" before committing, or the credentials go into history.'
+      await ctx.requestUserInput({
+        prompt: "",
+        promptType: "enterToContinue",
+        options: [],
+        // The wizard never streams command output, so a failed run's tail is the
+        // only place the developer sees why it failed. One message per line:
+        // the panel's height accounting counts a message as one wrapped line
+        // (see Notices.tsx), so an embedded newline overflows it.
+        messages: [
+          ingestOutcomeMessage,
+          ...ingestFailureDetail?.split("\n").filter((l) => l.trim()) ?? [],
+          ...commandMessages
+        ]
+      });
+    }
+    if (useCases.includes("search")) {
+      let extraInstructions = [];
+      const preSearchFiles = new Set(await listChangedFiles(worktree));
+      for (let attempt = 1; attempt <= MAX_IMPLEMENT_VERIFICATION_ATTEMPTS; attempt++) {
+        if (attempt > 1) {
+          logger.info(
+            {
+              attempt,
+              maxAttempts: MAX_IMPLEMENT_VERIFICATION_ATTEMPTS,
+              extraInstructions
+            },
+            "implement: retrying search implementation after failed verification"
+          );
+        }
+        const { summary } = await runImplementationUseCase(
+          "search",
+          extraInstructions
         );
+        summaries.push(formatSummary("search", summary));
+        const verification = await runVerificationUseCase();
+        summaries.push(formatSummary("verification", verification.summary));
+        if (verification.sufficient) {
+          ctx.setUserInput("implementation", "success");
+          const searchFilesChanged = (await listChangedFiles(worktree)).filter(
+            (file) => !preSearchFiles.has(file)
+          );
+          track("AI Wizard Frontend Component Generated", {
+            filePaths: searchFilesChanged
+          });
+          track("AI Wizard Wired to UI", {
+            location_heuristic: searchLocation ?? "unknown"
+          });
+          break;
+        }
+        if (attempt === MAX_IMPLEMENT_VERIFICATION_ATTEMPTS) {
+          ctx.setUserInput("implementation", "fail");
+          throw new Error(
+            `Implementation verification failed after ${MAX_IMPLEMENT_VERIFICATION_ATTEMPTS} attempts: ${verification.additionalInstructions ?? verification.summary}`
+          );
+        }
+        extraInstructions = verificationRetryInstructions(verification);
       }
-      const stale = [];
-      for (const v of resolvedSearchEnvVars) {
-        if (written.includes(v.name)) continue;
-        const current = await readEnvVar(repoRoot, v.name);
-        if (current && current !== v.value) stale.push(v);
+      let searchKey;
+      let searchKeyError;
+      if (appId) {
+        try {
+          const resolved2 = await resolveSearchOnlyKey(
+            targetIndex,
+            appId,
+            envSearchKey
+          );
+          searchKey = resolved2.key;
+          summaries.push(
+            resolved2.source === "created" ? `Created a new search-only Algolia API key for the "${targetIndex}" index in app ${appId} \u2014 safe to expose in frontend code.` : `Reused the existing search-only Algolia API key for the "${targetIndex}" index in app ${appId}.`
+          );
+        } catch (err) {
+          searchKeyError = err.message;
+          logger.warn(
+            { err: searchKeyError },
+            "implement: could not provision a search-only API key; the .env value stays a placeholder"
+          );
+        }
       }
-      if (stale.length > 0 && !envAppIdMismatch) {
-        summaries.push(
-          `\u26A0\uFE0F .env already assigns a different value to ${stale.map((v) => `${v.name} (should be ${v.value})`).join(", ")} \u2014 the wizard left it alone. Fix it by hand, or searches will fail.`
+      finalSearchEnvVars = publicSearchEnvVars(
+        publicEnvVarPrefix,
+        targetIndex,
+        appId,
+        searchKey
+      );
+      const resolvedSearchEnvVars = finalSearchEnvVars.filter(
+        (v) => !v.value.startsWith("<")
+      );
+      if (resolvedSearchEnvVars.length > 0) {
+        const written = await writeSearchEnvValues(
+          worktree,
+          resolvedSearchEnvVars
         );
-        logger.warn(
-          { vars: stale.map((v) => v.name) },
-          "implement: .env holds different values for the resolved search credentials; not overwriting them"
+        if (written.length > 0) {
+          summaries.push(`Wrote ${written.join(", ")} to .env.`);
+        }
+        const ignored = await ensureGitIgnored(worktree, join12(worktree, ".env"));
+        if (ignored === "added") {
+          summaries.push("Added .env to .gitignore.");
+        } else if (ignored === "tracked") {
+          summaries.push(
+            '\u26A0\uFE0F .env is tracked by git, so a .gitignore rule cannot un-stage it. Run "git rm --cached .env" before committing, or the credentials go into history.'
+          );
+        }
+        const stale = [];
+        for (const v of resolvedSearchEnvVars) {
+          if (written.includes(v.name)) continue;
+          const current = await readEnvVar(worktree, v.name);
+          if (current && current !== v.value) stale.push(v);
+        }
+        if (stale.length > 0 && !envAppIdMismatch) {
+          summaries.push(
+            `\u26A0\uFE0F .env already assigns a different value to ${stale.map((v) => `${v.name} (should be ${v.value})`).join(", ")} \u2014 the wizard left it alone. Fix it by hand, or searches will fail.`
+          );
+          logger.warn(
+            { vars: stale.map((v) => v.name) },
+            "implement: .env holds different values for the resolved search credentials; not overwriting them"
+          );
+        }
+      }
+      const unresolvedSearchEnvVars = finalSearchEnvVars.filter(
+        (v) => v.value.startsWith("<")
+      );
+      if (unresolvedSearchEnvVars.length > 0) {
+        summaries.push(
+          `Could not resolve a value for ${unresolvedSearchEnvVars.map((v) => v.name).join(", ")} \u2014 fill it in manually in .env.` + // Without the reason the line is a dead end.
+          (searchKeyError ? ` Reason: ${searchKeyError}` : "")
         );
       }
+    } else {
+      ctx.setUserInput("implementation", "success");
     }
-    const unresolvedSearchEnvVars = finalSearchEnvVars.filter(
-      (v) => v.value.startsWith("<")
-    );
-    if (unresolvedSearchEnvVars.length > 0) {
-      summaries.push(
-        `Could not resolve a value for ${unresolvedSearchEnvVars.map((v) => v.name).join(", ")} \u2014 fill it in manually in .env.` + (searchKeyError ? ` Reason: ${searchKeyError}` : "")
+    const filesChanged = await listChangedFiles(worktree);
+    if (filesChanged.length === 0) {
+      logger.warn(
+        "implement: agent reported success but no files changed in the worktree"
       );
     }
-  } else {
-    ctx.setUserInput("implementation", "success");
+    return {
+      ingestionSource,
+      filesChanged,
+      summary: summaries.join("\n\n"),
+      worktreePath: worktree,
+      ...useCases.includes("ingestion") && ingestCommand ? {
+        ingestCommand,
+        ingestScriptRan,
+        ...ingestRecordCount != null ? { ingestRecordCount } : {},
+        ...ingestDurationMs != null ? { ingestDurationMs } : {}
+      } : {},
+      ...useCases.includes("search") ? { searchEnvVars: finalSearchEnvVars } : {}
+    };
+  } finally {
+    process.chdir(repoRoot);
   }
-  return {
-    ingestionSource,
-    summary: summaries.join("\n\n"),
-    ...useCases.includes("ingestion") && ingestCommand ? {
-      ingestCommand,
-      ingestScriptRan,
-      ...ingestRecordCount != null ? { ingestRecordCount } : {},
-      ...ingestDurationMs != null ? { ingestDurationMs } : {}
-    } : {},
-    ...useCases.includes("search") ? { searchEnvVars: finalSearchEnvVars } : {}
-  };
 }
 
 // src/workflows/default.ts
@@ -4882,8 +5015,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)
     }),
@@ -4915,7 +5048,10 @@ var defaultWorkflow = {
         ctx.notify({
           messages: ["Building your Algolia search experience\u2026"]
         });
-        return implement(ctx, ["search"]);
+        const ingestion2 = ctx.getStepOutput(
+          "ingestion"
+        );
+        return implement(ctx, ["search"], ingestion2?.worktreePath);
       }
     }),
     defineStep({
@@ -4930,8 +5066,9 @@ var defaultWorkflow = {
           "ingestion"
         );
         return reviewStep(ctx, {
-          // ingestCommand was already shown verbatim as a notice; an
-          // LLM-paraphrased restatement in nextSteps risks being wrong.
+          // The ingestion step already showed the user the exact `ingestCommand`
+          // and worktree path as a notice, so nextSteps must not restate it —
+          // an LLM-paraphrased command risks being wrong.
           nextStepsGuidance: ingestion2?.ingestScriptRan ? "The wizard already ran the ingestion script and records are in the index. Do NOT tell the user to run it again; instead point them at the target index to confirm the records. Do not restate the ingestion command \u2014 the wizard already showed it to them." : "Tell the user to run the ingestion script; do not restate the exact command \u2014 the wizard already showed it to them above."
         });
       }
@@ -4951,6 +5088,7 @@ function getWorkflow(id) {
 var projectScan2 = {
   languages: [{ name: "TypeScript", version: "5.7.2" }],
   frameworks: [{ name: "Next.js", version: "15.1.0" }],
+  publicEnvVarPrefix: "NEXT_PUBLIC_",
   ingestionAnalysis: [
     {
       name: "Product",
@@ -4977,6 +5115,7 @@ var selectIndex = {
   selection: "wizard_seed_products"
 };
 var ingestion = {
+  filesChanged: ["algolia/ingest.mjs", "algolia/records.json", "package.json"],
   summary: "Generated sample Product records and an ingestion script that pushes them to the target index with algoliasearch.",
   ingestCommand: "node algolia/ingest.mjs",
   ingestScriptRan: true,
@@ -4988,6 +5127,7 @@ var confirmFramework2 = {
   frameworks: projectScan2.frameworks
 };
 var search = {
+  filesChanged: ["src/components/Search.tsx", "src/components/Header.tsx", ".env"],
   summary: "Added an InstantSearch-powered search box and results list, mounted in the shared header component.",
   ingestionSource: "generated",
   searchEnvVars: [
@@ -5000,7 +5140,7 @@ var review = {
     "Ingested 25 generated Product records into wizard_seed_products.",
     "Added an InstantSearch search experience to the shared header."
   ],
-  reviewPrompt: "Review the Algolia ingestion and search changes.",
+  reviewPrompt: "Review the Algolia ingestion and search changes in this worktree.",
   nextSteps: ["Point the ingestion script at your real product data."]
 };
 var SEEDS = {
@@ -5117,9 +5257,9 @@ Options:
                    steps pre-filled with test data. Pass with no value to print
                    the step ids. See CONTRIBUTING.md.
   --no-telemetry   Send no telemetry or analytics for this run.
-  --reset-on-run   Wipe this project's wizard state (run state, AI consent)
-                   before starting, so the run behaves like a first-ever
-                   run. Also drops every API key the wizard has
+  --reset-on-run   Wipe this project's wizard state (run state, AI consent,
+                   worktrees) before starting, so the run behaves like a
+                   first-ever run. Also drops every API key the wizard has
                    stored in your keychain (or, where the platform has none,
                    the encrypted file it falls back to \u2014 see CONTRIBUTING.md),
                    for this project and any other, so later runs create new
@@ -5159,7 +5299,7 @@ function parseCliArgs(argv) {
 }
 
 // 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 join13 } from "node:path";
 var KEEP = ["wizard.log"];
 async function resetProjectState() {
@@ -5167,7 +5307,7 @@ async function resetProjectState() {
   await forgetResolvedKeys();
   let entries;
   try {
-    entries = await readdir3(dir);
+    entries = await readdir4(dir);
   } catch {
     return { dir, removed: [] };
   }
@@ -5180,6 +5320,45 @@ async function resetProjectState() {
   return { dir, removed: targets };
 }
 
+// src/lib/terminalSize.ts
+var MIN_ROWS = 30;
+var MIN_COLUMNS = 100;
+async function requestTerminalSize(stdout = process.stdout, {
+  rows = MIN_ROWS,
+  columns = MIN_COLUMNS,
+  timeoutMs = 150,
+  settleMs = 120
+} = {}) {
+  if (!stdout.isTTY) return;
+  const currentRows = stdout.rows ?? 0;
+  const currentColumns = stdout.columns ?? 0;
+  if (currentRows >= rows && currentColumns >= columns) return;
+  stdout.write(
+    `\x1B[8;${Math.max(currentRows, rows)};${Math.max(currentColumns, columns)}t`
+  );
+  const resized = await waitForResize(stdout, timeoutMs);
+  if (!resized) return;
+  await delay(settleMs);
+  stdout.write("\x1B[2J\x1B[H");
+}
+function waitForResize(stdout, timeoutMs) {
+  return new Promise((resolve4) => {
+    const finish = (didResize) => () => {
+      clearTimeout(timer);
+      stdout.off("resize", onResize);
+      resolve4(didResize);
+    };
+    const onResize = finish(true);
+    const timer = setTimeout(finish(false), timeoutMs);
+    stdout.once("resize", onResize);
+  });
+}
+function delay(ms) {
+  return new Promise((resolve4) => {
+    setTimeout(resolve4, ms);
+  });
+}
+
 // src/main.tsx
 import { jsx as jsx15 } from "react/jsx-runtime";
 async function startup() {
@@ -5264,6 +5443,7 @@ async function run(workflow) {
   }
   runWorkflow(workflow, app.id);
 }
+await requestTerminalSize();
 var started = await startup();
 if (typeof started === "number") {
   process.exitCode = started;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@algolia/wizard",
-  "version": "0.19.0-rc.111.189",
+  "version": "0.20.0",
   "description": "Magically implement Algolia functionality in your codebase",
   "type": "module",
   "engines": {