@algolia/wizard 0.24.0-rc.111.205 → 0.25.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,
@@ -1263,7 +1259,7 @@ var accessItems = [
   {
     tag: "WRITE",
     title: "Code changes",
-    description: "creates & edits files (search UI, config) directly in your branch."
+    description: "creates & edits files (search UI, config) in a throwaway git worktree \u2014 your checkout is never touched."
   },
   {
     tag: "EXEC",
@@ -1278,7 +1274,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 = [
@@ -2558,7 +2554,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}`;
@@ -3183,6 +3178,10 @@ function storeApproval(root) {
     return answer === "approve" ? "approve" : "reject";
   };
 }
+var EXPLORATORY_COMMANDS = /* @__PURE__ */ new Set(["ls", "find", "tree", "dir"]);
+function isExploratoryCommand(command) {
+  return command.split(/&&|;|\|/).map((segment) => segment.trim().split(/\s+/)[0]).some((word) => word !== void 0 && EXPLORATORY_COMMANDS.has(word));
+}
 async function approveAndRun(ctx, command, cwd, explanation) {
   const decision = await ctx.shell.approve({ command, cwd, explanation });
   if (decision === "reject") {
@@ -3227,7 +3226,7 @@ async function approveAndRun(ctx, command, cwd, explanation) {
 }
 function runShellTool(ctx) {
   return tool8({
-    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. The user sees and approves every command before it runs, so write a clear `explanation`. If the user rejects a command, do not retry it \u2014 propose a different approach.",
+    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. To inspect the project, use listFiles or searchFiles instead of ls/find \u2014 this tool refuses those. The user sees and approves every command before it runs, so write a clear `explanation`. If the user rejects a command, do not retry it \u2014 propose a different approach.",
     inputSchema: z15.object({
       command: z15.string().describe(
         "The command to run, exactly as it would be typed in a shell. Pipes, && and redirects are allowed."
@@ -3245,6 +3244,9 @@ function runShellTool(ctx) {
       }
       const resolved2 = resolveInRoot(ctx, cwd ?? ".");
       if (!resolved2.ok) return resolved2.error;
+      if (isExploratoryCommand(command)) {
+        return "Refused: use listFiles or searchFiles to inspect the project instead of ls/find/tree.";
+      }
       logger.info({ command, cwd: resolved2.target }, "called runShell tool");
       return serializePrompt(
         () => approveAndRun(ctx, command, resolved2.target, explanation)
@@ -3339,7 +3341,7 @@ function defaultCreateModel() {
 }
 function generateRecordTool(ctx, createModel = defaultCreateModel) {
   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."),
@@ -3495,7 +3497,30 @@ var MODEL_BY_SIZE = {
   medium: "claude-sonnet-4-6",
   large: "claude-opus-4-8"
 };
+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;
 async function runAgent(req) {
+  for (let attempt = 0; attempt <= REPORT_STATUS_RETRIES; attempt++) {
+    try {
+      return await runAgentAttempt(req, attempt);
+    } catch (err) {
+      const isMissingReport = err instanceof Error && err.message === MISSING_REPORT_STATUS_ERROR_MESSAGE;
+      if (!isMissingReport) {
+        throw err;
+      }
+      if (attempt === REPORT_STATUS_RETRIES) {
+        throw new Error(MISSING_REPORT_USER_MESSAGE);
+      }
+      logger.warn(
+        { attempt: attempt + 1 },
+        "retrying runAgent after missing reportStatus"
+      );
+    }
+  }
+  throw new Error("unreachable");
+}
+async function runAgentAttempt(req, attempt) {
   const start = Date.now();
   logger.info({ startedAt: new Date(start).toISOString() }, "runAgent started");
   const token = getAuthToken();
@@ -3515,7 +3540,13 @@ async function runAgent(req) {
     ...hasReadTools ? [
       "When you need to read or search multiple files, issue those tool calls together in one step rather than one at a time."
     ] : [],
-    "Call notifyUser whenever you start a new phase of work or your focus shifts (e.g. moving from reading code to writing files) \u2014 a short, plain-language, high-level update. Do not call it for every tool use."
+    "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.",
+    // 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.
+    ...attempt > 0 ? [
+      "This run is a retry after a previous attempt that did not finish. Files, shell commands, or ingestion may already have been applied in this workspace \u2014 inspect what is already there and continue from it rather than repeating that work."
+    ] : []
   ];
   const agent = new ToolLoopAgent({
     model: anthropic(MODEL_BY_SIZE[req.modelSize ?? "medium"]),
@@ -3582,7 +3613,18 @@ async function runAgent(req) {
   const toolResults = await stream.toolResults;
   const report = [...toolResults].reverse().find((r) => r.toolName === "reportStatus");
   if (!report) {
-    throw new Error("Agent finished without calling reportStatus");
+    const steps = await stream.steps;
+    const lastStep = steps[steps.length - 1];
+    logger.error(
+      {
+        finishReason: lastStep?.finishReason,
+        rawFinishReason: lastStep?.rawFinishReason,
+        stepCount: steps.length,
+        lastStepToolCalls: lastStep?.toolCalls?.map((c) => c.toolName)
+      },
+      "Agent finished without calling reportStatus"
+    );
+    throw new Error(MISSING_REPORT_STATUS_ERROR_MESSAGE);
   }
   const result = report.output;
   if (result.status !== "success") {
@@ -3705,7 +3747,7 @@ async function runAnalysis(mode, extraInstructions = []) {
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.24.0-rc.111.205",
+  version: "0.25.0",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {
@@ -4072,10 +4114,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 [
@@ -4110,13 +4153,15 @@ ${formatCompletedSteps(ctx.completedSteps)}`,
 
 // src/actions/implement.ts
 import z29 from "zod";
-import { join as join12, relative as relative6 } from "node:path";
+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) => {
@@ -4139,7 +4184,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" };
@@ -4153,10 +4235,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);
@@ -4171,10 +4250,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;
@@ -4188,8 +4267,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");
@@ -4204,27 +4283,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";
@@ -4284,6 +4397,11 @@ 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({
@@ -4303,7 +4421,9 @@ var resolveEnvVarPrefix = (frameworkName) => runAgent({
 
 // src/actions/implement.ts
 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(),
@@ -4356,6 +4476,8 @@ function frameworksForDoc(language) {
 }
 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.",
@@ -4373,14 +4495,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."
     ]
@@ -4429,11 +4551,14 @@ function searchInstructions(input) {
     "If a search box already exists, replace it with yours.",
     `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.",
@@ -4442,10 +4567,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.",
@@ -4540,11 +4665,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) {
@@ -4552,7 +4677,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(
@@ -4633,6 +4758,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;
@@ -4644,303 +4772,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 publicEnvVarPrefix = await publicEnvVarPrefixPromise;
-  const input = {
-    findings: normalized,
-    confirmed: confirmed2,
-    searchLocation,
-    targetIndex,
-    language,
-    publicEnvVarPrefix,
-    appId,
-    searchEnvVars: publicSearchEnvVars(publicEnvVarPrefix, 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,
-      publicAppIdVar(publicEnvVarPrefix)
-    );
-    if (envAppId === appId) {
-      envSearchKey = await readEnvVar(
+  const worktree = existingWorktreePath ?? (await createWorktree(repoRoot)).path;
+  try {
+    process.chdir(worktree);
+    let uploadFilePath;
+    let uploadWarning;
+    if (ingestionSource === "fileUpload") {
+      const copied = await copyUploadIntoWorktree(
         repoRoot,
-        publicSearchKeyVar(publicEnvVarPrefix)
-      );
-    } else if (envAppId) {
-      envAppIdMismatch = true;
-      const appIdVarName = publicAppIdVar(publicEnvVarPrefix);
-      const searchKeyVarName = publicSearchKeyVar(publicEnvVarPrefix);
-      summaries.push(
-        `\u26A0\uFE0F .env already sets ${appIdVarName}=${envAppId}, but the active Algolia application is ${appId}. The wizard left those values alone \u2014 update ${appIdVarName} and ${searchKeyVarName} by hand, or searches will fail.`
-      );
-      logger.warn(
-        { envAppId, appId },
-        "implement: .env holds credentials for a different Algolia application; not reusing its search key"
+        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 = publicSearchEnvVars(
-      publicEnvVarPrefix,
-      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
@@ -5012,7 +5165,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({
@@ -5027,8 +5183,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."
         });
       }
@@ -5075,6 +5232,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,
@@ -5086,6 +5244,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: [
@@ -5098,7 +5257,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 = {
@@ -5215,9 +5374,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
@@ -5257,7 +5416,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() {
@@ -5265,7 +5424,7 @@ async function resetProjectState() {
   await forgetResolvedKeys();
   let entries;
   try {
-    entries = await readdir3(dir);
+    entries = await readdir4(dir);
   } catch {
     return { dir, removed: [] };
   }

package/package.json

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