@algolia/wizard 0.9.0-rc.71.62 → 0.9.0-rc.73.63

package/dist/main.js

@@ -892,12 +892,12 @@ var sidebarItems = [
     description: "push 100 records to Algolia in seconds"
   },
   {
-    title: "detect your framework",
-    description: "React, Vue, Angular, Vanilla JS"
+    title: "detect your stack",
+    description: "React, Vue, Angular, Rails, Django, Laravel & more"
   },
   {
     title: "scaffold a search UI",
-    description: "a styled InstantSearch component, wired into your app"
+    description: "a styled InstantSearch UI, wired into your app or templates"
   },
   {
     title: "ship it",
@@ -1003,7 +1003,7 @@ var accessItems = [
   {
     tag: "READ",
     title: "Project files",
-    description: "reads package.json, configs & source to detect your stack. Read-only; nothing is uploaded."
+    description: "reads your dependency manifests (package.json\u2026), configs & source to detect your stack. Read-only; nothing is uploaded."
   },
   {
     tag: "WRITE",
@@ -2221,15 +2221,282 @@ function writeCredentialsTool(ctx) {
 // src/lib/tools/searchFiles.ts
 import { tool as tool7 } from "ai";
 import z10 from "zod";
-import { readdir as readdir2, readFile as readFile6 } from "node:fs/promises";
+import { readdir as readdir3, readFile as readFile8 } from "node:fs/promises";
+import { join as join10 } from "node:path";
+
+// src/lib/languages.ts
+import { readdir as readdir2, readFile as readFile7 } from "node:fs/promises";
+import { existsSync as existsSync2 } from "node:fs";
+import { join as join9 } from "node:path";
+
+// src/lib/tools/utils/packageManager.ts
+import { readFile as readFile6 } from "node:fs/promises";
+import { existsSync } from "node:fs";
 import { join as join8 } from "node:path";
+var LOCKFILES = [
+  ["pnpm-lock.yaml", "pnpm"],
+  ["yarn.lock", "yarn"],
+  ["bun.lockb", "bun"],
+  ["bun.lock", "bun"],
+  ["package-lock.json", "npm"]
+];
+async function readPackageJson(cwd = process.cwd()) {
+  return JSON.parse(await readFile6(join8(cwd, "package.json"), "utf8"));
+}
+function packageManagerFrom(pkg) {
+  return pkg.packageManager?.split("@")[0] ?? "npm";
+}
+function packageManagerFromLockfile(cwd) {
+  return LOCKFILES.find(([file]) => existsSync(join8(cwd, file)))?.[1];
+}
+async function detectPackageManager(cwd) {
+  try {
+    const pkg = await readPackageJson(cwd);
+    if (pkg.packageManager) return packageManagerFrom(pkg);
+  } catch {
+  }
+  return packageManagerFromLockfile(cwd) ?? "npm";
+}
+
+// src/lib/shell.ts
+function shellQuote(value) {
+  return "'" + value.replace(/'/g, "'\\''") + "'";
+}
+
+// src/lib/languages.ts
+var ENTRYPOINT_TOKEN = "{entrypoint}";
+var INGEST_DIR = ".algolia-wizard";
+var LANGUAGE_PROFILES = {
+  javascript: {
+    id: "javascript",
+    displayName: "JavaScript/TypeScript",
+    aliases: [
+      "javascript",
+      "js",
+      "typescript",
+      "ts",
+      "node",
+      "nodejs",
+      "node.js",
+      "bun",
+      "deno",
+      "ecmascript",
+      "jsx",
+      "tsx"
+    ],
+    manifests: ["package.json"],
+    // The concrete npm-family manager is resolved by detectPackageManager (it
+    // honours the package.json `packageManager` field, which lockfiles can't
+    // express), so one spec covers all four and `resolveToolchain` rewrites the
+    // binary below.
+    packageManagers: [
+      {
+        id: "npm",
+        dependency: { mode: "agent-declares", file: "package.json" },
+        installSteps: [{ argv: ["npm", "install"] }],
+        ingest: {
+          kind: "auto",
+          argv: ["node", ENTRYPOINT_TOKEN],
+          entrypointExtensions: [".mjs", ".cjs", ".js"]
+        }
+      }
+    ],
+    sdk: { packageName: "algoliasearch", versionPin: "^5", docKey: "js" },
+    ingestEntrypointExample: `${INGEST_DIR}/ingest.mjs`,
+    // package.json scripts are repo-defined, so they're resolved at run time by
+    // repoVerification rather than listed here.
+    verification: [],
+    envReadInstruction: "Read them from `process.env`.",
+    skipDirs: ["node_modules", "dist", "build", "coverage", ".next", "out"]
+  }
+};
+var DEFAULT_LANGUAGE_ID = "javascript";
+var JAVASCRIPT = "javascript";
+var CURATED_LANGUAGES = Object.values(
+  LANGUAGE_PROFILES
+).map((profile) => profile.displayName);
+function isBackendLanguage(profile) {
+  return profile.id !== JAVASCRIPT;
+}
+function normalizeLanguageName(name) {
+  return name.toLowerCase().trim().replace(/[\s_-]+/g, "");
+}
+var ALIAS_TO_ID = /* @__PURE__ */ new Map();
+for (const profile of Object.values(LANGUAGE_PROFILES)) {
+  for (const alias of [profile.id, profile.displayName, ...profile.aliases]) {
+    ALIAS_TO_ID.set(normalizeLanguageName(alias), profile.id);
+  }
+}
+function resolveLanguageProfile(name) {
+  const id = ALIAS_TO_ID.get(normalizeLanguageName(name));
+  return id ? LANGUAGE_PROFILES[id] : void 0;
+}
+function isSameLanguage(a, b) {
+  const x = resolveLanguageProfile(a);
+  const y = resolveLanguageProfile(b);
+  if (x && y) return x.id === y.id;
+  if (x || y) return false;
+  const folded = normalizeLanguageName(a);
+  return folded !== "" && folded === normalizeLanguageName(b);
+}
+var BASE_SKIP_DIRS = ["node_modules", ".git", "dist"];
+var ALL_SKIP_DIRS = /* @__PURE__ */ new Set([
+  ...BASE_SKIP_DIRS,
+  ...Object.values(LANGUAGE_PROFILES).flatMap((p) => p.skipDirs)
+]);
+var ALLOWED_BINARIES = new Set(
+  Object.values(LANGUAGE_PROFILES).flatMap((profile) => [
+    ...profile.packageManagers.flatMap((pm) => [
+      ...pm.installSteps.map((s) => s.argv[0]),
+      ...pm.ingest.kind === "auto" ? [pm.ingest.argv[0]] : []
+    ]),
+    ...profile.verification.map((v) => v.argv[0])
+  ])
+);
+var JS_PACKAGE_MANAGERS = /* @__PURE__ */ new Set(["npm", "pnpm", "yarn", "bun"]);
+function isWorktreeRelativeCommand(command) {
+  return command.includes("/");
+}
+function withCommand(argv, command) {
+  return [command, ...argv.slice(1)];
+}
+function resolveDeclaredManifest(root, packageManager) {
+  const { dependency } = packageManager;
+  if (dependency.mode !== "agent-declares" || !dependency.alternatives?.length) {
+    return packageManager;
+  }
+  const present = [dependency.file, ...dependency.alternatives].find(
+    (file) => existsSync2(join9(root, file))
+  );
+  if (!present || present === dependency.file) return packageManager;
+  return { ...packageManager, dependency: { ...dependency, file: present } };
+}
+async function manifestPresent(root, manifest, listing) {
+  if (!manifest.startsWith("*.")) return existsSync2(join9(root, manifest));
+  if (!listing.entries) {
+    const entries = await readdir2(root).catch(() => []);
+    listing.entries = Array.isArray(entries) ? entries : [];
+  }
+  const suffix = manifest.slice(1);
+  return listing.entries.some((e) => e.endsWith(suffix));
+}
+async function profileManifestPresent(root, profile, listing) {
+  for (const manifest of profile.manifests) {
+    if (await manifestPresent(root, manifest, listing)) return true;
+  }
+  return false;
+}
+async function detectProfilesFromManifests(root) {
+  const listing = {};
+  const found = [];
+  for (const profile of Object.values(LANGUAGE_PROFILES)) {
+    if (await profileManifestPresent(root, profile, listing)) found.push(profile);
+  }
+  return found;
+}
+async function hasProfileManifest(root, profile) {
+  return profileManifestPresent(root, profile, {});
+}
+async function pickIngestionCandidates(root, confirmedNames) {
+  const confirmed3 = confirmedNames.map((name) => resolveLanguageProfile(name)).filter((p) => p !== void 0);
+  const onDisk = await detectProfilesFromManifests(root);
+  const onDiskIds = new Set(onDisk.map((p) => p.id));
+  const candidates = [
+    ...new Map(
+      confirmed3.filter((p) => onDiskIds.has(p.id)).map((p) => [p.id, p])
+    ).values()
+  ];
+  return { candidates, confirmed: confirmed3, onDisk };
+}
+async function resolveToolchain(root, profile) {
+  const signals = (pm) => [
+    ...pm.lockfiles ?? [],
+    ...pm.detectFiles ?? []
+  ];
+  const matched = profile.packageManagers.find(
+    (pm) => signals(pm).some((f) => existsSync2(join9(root, f)))
+  );
+  const fallback = profile.packageManagers.find((pm) => signals(pm).length === 0) ?? profile.packageManagers[0];
+  const packageManager = resolveDeclaredManifest(root, matched ?? fallback);
+  let { installSteps, ingest } = packageManager;
+  installSteps = installSteps.map(
+    (step) => isWorktreeRelativeCommand(step.argv[0]) ? { ...step, argv: withCommand(step.argv, join9(root, step.argv[0])) } : step
+  );
+  if (ingest.kind === "auto" && isWorktreeRelativeCommand(ingest.argv[0])) {
+    ingest = {
+      ...ingest,
+      argv: withCommand(ingest.argv, join9(root, ingest.argv[0]))
+    };
+  }
+  if (profile.id === "javascript") {
+    const pm = await detectPackageManager(root);
+    if (JS_PACKAGE_MANAGERS.has(pm)) {
+      installSteps = installSteps.map((step) => ({
+        ...step,
+        argv: withCommand(step.argv, pm)
+      }));
+      if (pm === "bun" && ingest.kind === "auto") {
+        ingest = { ...ingest, argv: withCommand(ingest.argv, "bun") };
+      }
+    }
+  }
+  return { profile, packageManager, installSteps, ingest };
+}
+function resolveIngestArgv(ingest, entrypoint) {
+  if (ingest.kind !== "auto") {
+    throw new Error("resolveIngestArgv called for a manual-run toolchain");
+  }
+  return ingest.argv.map(
+    (part) => part === ENTRYPOINT_TOKEN ? entrypoint : part
+  );
+}
+function describeIngestCommand(ingest, entrypoint) {
+  if (ingest.kind !== "auto") return ingest.runCommand;
+  return ingest.argv.map((part) => part === ENTRYPOINT_TOKEN ? shellQuote(entrypoint) : part).join(" ");
+}
+function ingestScriptDir(profile) {
+  const parts = profile.ingestEntrypointExample.split("/");
+  return parts.slice(0, -1).join("/") || ".";
+}
+function localSourceLimitation(root, profile) {
+  const caveat = profile.localSourceCaveat;
+  if (!caveat) return void 0;
+  return existsSync2(join9(root, caveat.unless)) ? void 0 : caveat.message;
+}
+async function missingBuildTask(root, toolchain) {
+  const { ingest, packageManager } = toolchain;
+  if (ingest.kind !== "manual" || !ingest.requiresBuildTask) return void 0;
+  if (packageManager.dependency.mode !== "agent-declares") return void 0;
+  const buildFile = join9(root, packageManager.dependency.file);
+  const contents = await readFile7(buildFile, "utf8").catch(() => void 0);
+  if (contents === void 0) return void 0;
+  return contents.includes(ingest.requiresBuildTask) ? void 0 : ingest.requiresBuildTask;
+}
+function sdkVersionPin(profile, packageManager) {
+  return packageManager.sdkVersionPin ?? profile.sdk.versionPin;
+}
+function dependencyInstruction(toolchain) {
+  const { profile, packageManager } = toolchain;
+  const { packageName } = profile.sdk;
+  const versionPin = sdkVersionPin(profile, packageManager);
+  const also = profile.sdk.alsoRequires ? ` ${profile.sdk.alsoRequires}` : "";
+  switch (packageManager.dependency.mode) {
+    case "wizard-installs":
+      return `The wizard installs ${packageName} ${versionPin} in the worktree after you finish \u2014 import it directly and do not edit dependency manifests for it.${also}`;
+    case "code-imports":
+      return `Import ${packageName} in the script; the wizard resolves and fetches it in the worktree after you finish. Do not edit dependency manifests by hand.${also}`;
+    case "agent-declares":
+      return `Declare ${packageName} ${versionPin} in "${packageManager.dependency.file}" (create the file if needed), plus any other dependency your script imports; the wizard installs them in the worktree after you finish.${also}`;
+  }
+}
+
+// src/lib/tools/searchFiles.ts
 var MAX_QUERY_LENGTH = 1e3;
 async function walkFiles(dir) {
-  const skip = /* @__PURE__ */ new Set(["node_modules", ".git", "dist"]);
   const out = [];
-  for (const e of await readdir2(dir, { withFileTypes: true })) {
-    if (e.name.startsWith(".") || skip.has(e.name)) continue;
-    const full = join8(dir, e.name);
+  for (const e of await readdir3(dir, { withFileTypes: true })) {
+    if (e.name.startsWith(".") || ALL_SKIP_DIRS.has(e.name)) continue;
+    const full = join10(dir, e.name);
     if (e.isDirectory()) out.push(...await walkFiles(full));
     else if (e.isFile()) out.push(full);
   }
@@ -2262,7 +2529,7 @@ function searchFilesTool(ctx) {
       for (const file of await walkFiles(resolved.target)) {
         let content;
         try {
-          content = await readFile6(file, "utf8");
+          content = await readFile8(file, "utf8");
         } catch {
           continue;
         }
@@ -2286,6 +2553,10 @@ function searchFilesTool(ctx) {
 import { tool as tool8 } from "ai";
 import z11 from "zod";
 
+// src/lib/tools/repoVerification.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { join as join11 } from "node:path";
+
 // src/lib/tools/utils/runCommand.ts
 import { spawn as spawn2 } from "node:child_process";
 var INSTALL_TIMEOUT_MS = 15 * 6e4;
@@ -2337,71 +2608,89 @@ Timed out after ${seconds}s: ${command} ${args.join(" ")}`.trim(),
   });
 }
 
-// src/lib/tools/utils/packageManager.ts
-import { readFile as readFile7 } from "node:fs/promises";
-import { existsSync } from "node:fs";
-import { join as join9 } from "node:path";
-var LOCKFILES = [
-  ["pnpm-lock.yaml", "pnpm"],
-  ["yarn.lock", "yarn"],
-  ["bun.lockb", "bun"],
-  ["bun.lock", "bun"],
-  ["package-lock.json", "npm"]
-];
-async function readPackageJson(cwd = process.cwd()) {
-  return JSON.parse(await readFile7(join9(cwd, "package.json"), "utf8"));
-}
-function packageManagerFrom(pkg) {
-  return pkg.packageManager?.split("@")[0] ?? "npm";
-}
-function packageManagerFromLockfile(cwd) {
-  return LOCKFILES.find(([file]) => existsSync(join9(cwd, file)))?.[1];
-}
-async function detectPackageManager(cwd) {
-  try {
-    const pkg = await readPackageJson(cwd);
-    if (pkg.packageManager) return packageManagerFrom(pkg);
-  } catch {
-  }
-  return packageManagerFromLockfile(cwd) ?? "npm";
-}
-
 // src/lib/tools/repoVerification.ts
 var VERIFICATION_SCRIPT_CANDIDATES = ["lint", "typecheck", "check"];
-async function runRepoVerificationCheck() {
+async function runCheck(command, binary, args) {
+  const { code, output } = await runCommand(binary, args, {
+    timeoutMs: VERIFY_TIMEOUT_MS
+  });
+  return { command, exitCode: code, ok: code === 0, output: output.trim() };
+}
+async function javascriptChecks() {
   let pkg;
   try {
     pkg = await readPackageJson();
   } catch (err) {
-    const limitation = `Could not read package.json to detect verification conventions: ${err.message}`;
-    return { ok: false, checks: [], limitation };
+    return {
+      limitation: `Could not read package.json to detect verification conventions: ${err.message}`
+    };
   }
   const scripts = pkg.scripts ?? {};
   const present = VERIFICATION_SCRIPT_CANDIDATES.filter((s) => s in scripts);
   if (present.length === 0) {
-    const limitation = `No verification script found in package.json (looked for: ${VERIFICATION_SCRIPT_CANDIDATES.join(", ")}).`;
-    return { ok: false, checks: [], limitation };
+    return {
+      limitation: `No verification script found in package.json (looked for: ${VERIFICATION_SCRIPT_CANDIDATES.join(", ")}).`
+    };
   }
   const pm = await detectPackageManager(process.cwd());
   const checks = [];
   for (const script of present) {
-    const command = `${pm} run ${script}`;
-    const { code, output } = await runCommand(pm, ["run", script], {
-      timeoutMs: VERIFY_TIMEOUT_MS
-    });
-    checks.push({ command, exitCode: code, ok: code === 0, output: output.trim() });
+    checks.push(
+      await runCheck(`${pm} run ${script}`, pm, ["run", script])
+    );
   }
-  return { ok: checks.every((c) => c.ok), checks };
+  return { checks };
+}
+async function registryChecks(id) {
+  const profile = LANGUAGE_PROFILES[id];
+  const runnable = profile.verification.filter(
+    (spec) => !spec.requiresFile || existsSync3(join11(process.cwd(), spec.requiresFile))
+  );
+  if (runnable.length === 0) {
+    return {
+      limitation: `No mechanical verification available for ${profile.displayName} in this repo.`
+    };
+  }
+  const checks = [];
+  for (const spec of runnable) {
+    checks.push(
+      await runCheck(spec.argv.join(" "), spec.argv[0], [...spec.argv.slice(1)])
+    );
+  }
+  return { checks };
+}
+async function runRepoVerificationCheck(languages = [DEFAULT_LANGUAGE_ID]) {
+  const ids = [...new Set(languages)];
+  if (ids.length === 0) ids.push(DEFAULT_LANGUAGE_ID);
+  const checks = [];
+  const limitations = [];
+  for (const id of ids) {
+    const result = id === JAVASCRIPT ? await javascriptChecks() : await registryChecks(id);
+    if ("checks" in result) checks.push(...result.checks);
+    else limitations.push(result.limitation);
+  }
+  if (checks.length === 0) {
+    return {
+      ok: false,
+      checks: [],
+      limitation: limitations.join(" ") || "No verification checks available."
+    };
+  }
+  return {
+    ok: checks.every((c) => c.ok),
+    checks,
+    ...limitations.length ? { limitation: limitations.join(" ") } : {}
+  };
 }
 
 // src/lib/tools/verifyImplementation.ts
-function verifyImplementationTool() {
+function verifyImplementationTool(ctx) {
   return tool8({
-    description: "Run the repo's mechanical verification check for generated implementation changes. Detects lint/typecheck/check from package.json and returns structured pass/fail evidence for the verifier to interpret.",
+    description: "Run the repo's mechanical verification checks for generated implementation changes. Uses the conventions of the repo's languages (package.json lint/typecheck/check scripts for JavaScript, the equivalent compile/analyze command elsewhere) and returns structured pass/fail evidence for the verifier to interpret.",
     inputSchema: z11.object(),
     execute: async () => {
-      logger.info("called verifyImplementation tool");
-      return runRepoVerificationCheck();
+      logger.info({ languages: ctx.languages }, "called verifyImplementation tool");
+      return runRepoVerificationCheck(ctx.languages);
     }
   });
 }
@@ -2527,12 +2816,17 @@ var DEFAULT_TOOL_LIMITS = {
   read: 20,
   match: 100
 };
-function createToolContext(limits = DEFAULT_TOOL_LIMITS, cwd = process.cwd()) {
+function createToolContext({
+  limits = DEFAULT_TOOL_LIMITS,
+  cwd = process.cwd(),
+  languages = [DEFAULT_LANGUAGE_ID]
+} = {}) {
   return {
     root: cwd,
     cwd,
     limits,
-    counts: { list: 0, search: 0, read: 0 }
+    counts: { list: 0, search: 0, read: 0 },
+    languages: languages.length ? languages : [DEFAULT_LANGUAGE_ID]
   };
 }
 
@@ -2569,7 +2863,7 @@ function createTools(ctx, { output, tools }) {
     searchFiles: withLogging("searchFiles", searchFilesTool(ctx)),
     verifyImplementation: withLogging(
       "verifyImplementation",
-      verifyImplementationTool()
+      verifyImplementationTool(ctx)
     ),
     generateRecord: withLogging("generateRecord", generateRecordTool(ctx)),
     notifyUser: withLogging("notifyUser", notifyUserTool())
@@ -2605,7 +2899,7 @@ async function runAgent(req) {
     baseURL: PROXY_BASE_URL,
     fetch: proxyFetch
   });
-  const toolContext = createToolContext();
+  const toolContext = createToolContext({ languages: req.languages });
   const readTools = ["readFile", "searchFiles", "listFiles"];
   const hasReadTools = !req.tools || req.tools.some((t) => readTools.includes(t));
   const instructions = [
@@ -2696,8 +2990,11 @@ var detectLanguageSchema = z16.object({
 var detectLanguage = () => runAgent({
   instructions: [
     "Analyze the codebase and determine the programming languages and frameworks used",
+    "Start from the dependency manifests: package.json.",
+    "List the language that owns the backend/data code first \u2014 that is the one an ingestion script will be written in.",
     "If a superset language is found, exclude the subset language. TS-over-JS.",
     "If a meta-framework is used, exclude the framework. Next-over-React.",
+    "Frameworks include backend and server-rendering frameworks (e.g. Rails, Django, Laravel, Symfony, Spring Boot, ASP.NET Core, Flask, Gin, Ktor) as well as frontend ones (React, Vue, Angular, Svelte) and mobile ones (Flutter, SwiftUI).",
     "Return the exact version",
     "Exclude things like CSS frameworks, build tools, or testing frameworks",
     'Use as few tools as possible, but do not guess. If you cant find the answer, say "unknown"',
@@ -2746,6 +3043,7 @@ var MODE_CONFIG = {
       "Analyze the codebase to find the data entities (models) that should be ingested into Algolia.",
       "For each entity, return its name, the file path(s) where it is defined, and its indexable attribute keys (the fields a user would search or filter on).",
       "Inspect the source of each entity to extract real field names for attributes \u2014 do not guess or leave attributes empty.",
+      "Entities live wherever the stack keeps them: TypeScript interfaces or a Prisma schema.",
       "Prefer domain models (e.g. Document, Product, User) over framework or infrastructure types.",
       "Use as few tools as possible, but do not guess. If you cannot find any entities, return an empty array.",
       "Ignore directories that may be related to testing, like `/fixtures`, `/tests`, etc",
@@ -2757,8 +3055,9 @@ var MODE_CONFIG = {
     instructions: [
       "Analyze the codebase to determine the single best location to add search UI functionality.",
       "Prefer a shared, always-rendered layout location (e.g. a header or navigation component) so search is reachable across the app.",
-      "Return one file path as searchImplementationAnalysis (e.g. /layouts/header.tsx).",
-      'Use as few tools as possible, but do not guess. If you cannot find a clear location, say "unknown".',
+      "It may be a client-side component or a server-rendered template \u2014 return whichever the project actually renders its UI from (e.g. /layouts/header.tsx, app/views/layouts/application.html.erb, templates/base.html, resources/views/layouts/app.blade.php, templates/base.html.twig).",
+      "Return one file path as searchImplementationAnalysis.",
+      'Use as few tools as possible, but do not guess. If the project renders no UI at all (an API-only service), say "unknown".',
       "Ignore directories that may be related to testing, like `/fixtures`, `/tests`, etc",
       "When done, call reportStatus"
     ],
@@ -2767,7 +3066,7 @@ var MODE_CONFIG = {
   verification: {
     instructions: [
       "Analyze the codebase to determine which code-quality tools are available to validate changes.",
-      "Look at package.json scripts, config files (e.g. .eslintrc, tsconfig, prettier), and dev dependencies.",
+      "Look at the dependency manifest and config files for the project's languages: package.json scripts with tsconfig/eslint/prettier.",
       'Return the tool names as an array, e.g. ["eslint", "prettier", "tsc"].',
       "Use as few tools as possible, but do not guess. If you cannot find any, return an empty array.",
       "Ignore directories that may be related to testing, like `/fixtures`, `/tests`, etc",
@@ -2795,7 +3094,7 @@ async function runAnalysis(mode, extraInstructions = []) {
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.9.0-rc.71.62",
+  version: "0.9.0-rc.73.63",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {
@@ -2898,82 +3197,185 @@ function parseEntries(raw) {
   return raw.split(",").map(clean).filter(Boolean).slice(0, MAX_ENTRIES).map((name) => ({ name, version: "unknown" }));
 }
 var summarize = (entries) => entries.length ? entries.map((e) => e.name).join(", ") : "none";
-async function askList(ctx, prompt, { required = false } = {}) {
+
+// src/actions/confirmLanguage.ts
+import z19 from "zod";
+var confirmLanguageSchema = z19.object({
+  languages: detectLanguageSchema.shape.languages
+});
+var OTHER_OPTION = "Other";
+function confirmed(languages) {
+  track("AI Wizard Language Confirmed", { languages });
+  return { languages };
+}
+async function askOtherLanguage(ctx) {
+  let prompt = "enter the language for your ingestion script";
   for (; ; ) {
     const answer = await ctx.requestUserInput({
       prompt,
       promptType: "textInput",
-      options: [],
-      helpText: 'Comma-separated, e.g. "TypeScript, Node".'
+      options: []
     });
     if (typeof answer !== "string") {
-      throw new Error("askList received an unexpected non-text result");
+      throw new Error("confirmLanguage received an unexpected non-text result");
     }
-    const entries = parseEntries(answer);
-    if (entries.length || !required) return entries;
-    prompt = "Please enter at least one entry:";
+    const name = parseEntries(answer)[0]?.name;
+    if (name) return name;
+    prompt = "please enter a language name:";
   }
 }
-
-// src/actions/confirmLanguage.ts
-import z19 from "zod";
-var confirmLanguageSchema = z19.object({
-  languages: detectLanguageSchema.shape.languages
-});
 async function confirmLanguage(ctx) {
   const detected = ctx.getStepOutput("project-scan");
-  const answer = await ctx.requestUserInput({
-    prompt: "Did we detect your language(s) correctly?",
-    promptType: "acceptReject",
-    options: ["Yes", "No"],
-    messages: [`Languages: ${summarize(detected.languages)}`]
-  });
-  const languages = answer === true ? detected.languages : await askList(ctx, "List the languages your project uses:", {
-    required: true
-  });
-  track("AI Wizard Language Confirmed", {
-    languages
+  const detectedLanguages = detected.languages ?? [];
+  const others = (chosen) => detectedLanguages.filter((l) => !isSameLanguage(l.name, chosen));
+  const primary = detectedLanguages[0];
+  if (primary) {
+    const accepted = await ctx.requestUserInput({
+      prompt: `Write the ingestion script in ${primary.name}?`,
+      promptType: "acceptReject",
+      options: [`Confirm ${primary.name}`, "Use a different language"],
+      secondary: [{ kind: "badge", value: "[DETECTED]" }, void 0],
+      messages: detectedLanguages.length > 1 ? [`Detected: ${summarize(detectedLanguages)}`] : []
+    });
+    if (accepted === true) return confirmed(detectedLanguages);
+  }
+  const options = [...CURATED_LANGUAGES];
+  for (const language of detectedLanguages) {
+    if (!options.some((o) => isSameLanguage(o, language.name))) {
+      options.push(language.name);
+    }
+  }
+  options.push(OTHER_OPTION);
+  const detectedFor = (option) => detectedLanguages.find((l) => isSameLanguage(option, l.name));
+  const secondary = options.map(
+    (o) => detectedFor(o) ? { kind: "badge", value: "[DETECTED]" } : void 0
+  );
+  const defaultSelectedIndex = Math.max(
+    options.findIndex((o) => detectedFor(o)),
+    0
+  );
+  const selection = await ctx.requestUserInput({
+    prompt: "select the language for your ingestion script",
+    promptType: "multipleChoice",
+    options,
+    secondary,
+    defaultSelectedIndex
   });
-  return { languages };
+  if (typeof selection !== "string") {
+    throw new Error("confirmLanguage received an unexpected non-text result");
+  }
+  const name = selection === OTHER_OPTION ? await askOtherLanguage(ctx) : selection;
+  const version = detectedFor(name)?.version ?? "unknown";
+  return confirmed([{ name, version }, ...others(name)]);
 }
 
 // src/actions/confirmFramework.ts
 import z20 from "zod";
-var confirmFrameworkSchema = z20.object({
-  frameworks: detectLanguageSchema.shape.frameworks
-});
-var CURATED_FRAMEWORKS = [
-  "Next.js",
-  "React",
-  "Vue",
-  "Angular",
-  "Svelte",
-  "Vanilla JS"
+
+// src/lib/frameworks.ts
+var BACKEND_ONLY_FRAMEWORK = "Backend only / API";
+var FRAMEWORKS = [
+  // Frontend — InstantSearch component flavors.
+  { name: "Next.js", strategy: "react", aliases: ["next", "nextjs"] },
+  { name: "React", strategy: "react", aliases: ["reactjs"] },
+  { name: "Vue", strategy: "vue", aliases: ["vuejs", "nuxt", "nuxtjs"] },
+  { name: "Angular", strategy: "angular", aliases: ["angularjs"] },
+  // No Svelte InstantSearch flavor exists, so it uses InstantSearch.js.
+  { name: "Svelte", strategy: "js", aliases: ["sveltekit"] },
+  {
+    name: "Vanilla JS",
+    strategy: "js",
+    aliases: ["vanilla", "javascript", "js", "astro", "vite"]
+  },
+  // Backend — Algolia's official framework integrations. Server-rendered
+  // templates get InstantSearch.js from a CDN.
+  {
+    name: "Rails",
+    strategy: "cdn-template",
+    aliases: ["rubyonrails", "ruby on rails", "erb"]
+  },
+  { name: "Django", strategy: "cdn-template", aliases: ["jinja", "jinja2"] },
+  { name: "Laravel", strategy: "cdn-template", aliases: ["blade"] },
+  { name: "Symfony", strategy: "cdn-template", aliases: ["twig"] },
+  // Mobile — Algolia ships InstantSearch iOS/Android and Dart clients, but the
+  // wizard can't scaffold a native UI, so it points at the docs instead.
+  { name: "Flutter", strategy: "none", aliases: [] },
+  { name: "iOS", strategy: "none", aliases: ["swiftui", "uikit"] },
+  { name: "Android", strategy: "none", aliases: ["jetpack compose", "compose"] },
+  { name: BACKEND_ONLY_FRAMEWORK, strategy: "cdn-template", aliases: [] }
 ];
-var OTHER_OPTION = "Other";
+var CURATED_FRAMEWORKS = FRAMEWORKS.map(
+  (f) => f.name
+);
 var normalize = (s) => s.toLowerCase().replace(/[^a-z0-9]/g, "");
-var FRAMEWORK_ALIASES = {
-  next: "nextjs",
-  nextjs: "nextjs",
-  react: "react",
-  reactjs: "react",
-  vue: "vue",
-  vuejs: "vue",
-  angular: "angular",
-  angularjs: "angular",
-  svelte: "svelte",
-  sveltekit: "svelte",
-  vanillajs: "vanillajs",
-  vanilla: "vanillajs",
-  javascript: "vanillajs",
-  js: "vanillajs"
-};
-var isSameFramework = (a, b) => {
-  const x = FRAMEWORK_ALIASES[normalize(a)] ?? normalize(a);
-  const y = FRAMEWORK_ALIASES[normalize(b)] ?? normalize(b);
+var ALIAS_TO_NAME = /* @__PURE__ */ new Map();
+for (const framework of FRAMEWORKS) {
+  for (const alias of [framework.name, ...framework.aliases]) {
+    ALIAS_TO_NAME.set(normalize(alias), framework.name);
+  }
+}
+var STRATEGY_BY_NAME = new Map(FRAMEWORKS.map((f) => [f.name, f.strategy]));
+function canonicalFrameworkName(name) {
+  return ALIAS_TO_NAME.get(normalize(name));
+}
+function isSameFramework(a, b) {
+  const x = canonicalFrameworkName(a) ?? normalize(a);
+  const y = canonicalFrameworkName(b) ?? normalize(b);
   return x !== "" && x === y;
-};
-function confirmed(name, version) {
+}
+function resolveSearchStrategy(frameworkName, hasJavaScriptInStack) {
+  const canonical = frameworkName ? canonicalFrameworkName(frameworkName) : void 0;
+  const strategy = canonical ? STRATEGY_BY_NAME.get(canonical) : void 0;
+  if (strategy) return strategy;
+  return hasJavaScriptInStack ? "js" : "cdn-template";
+}
+function searchDocKey(strategy) {
+  return strategy === "cdn-template" ? "templates" : strategy;
+}
+function bundlesJavaScript(strategy) {
+  return strategy !== "cdn-template" && strategy !== "none";
+}
+function canScaffoldSearchUI(strategy) {
+  return strategy !== "none";
+}
+var ENV_PREFIXES = [
+  { aliases: ["next", "nextjs"], prefix: "NEXT_PUBLIC_" },
+  { aliases: ["nuxt", "nuxtjs"], prefix: "NUXT_PUBLIC_" },
+  { aliases: ["astro"], prefix: "PUBLIC_" },
+  { aliases: ["vite"], prefix: "VITE_" }
+];
+var DEFAULT_ENV_PREFIX = "PUBLIC_";
+function publicEnvPrefix(frameworkNames, strategy) {
+  if (!bundlesJavaScript(strategy)) return "";
+  const present = new Set(frameworkNames.map(normalize));
+  for (const { aliases, prefix } of ENV_PREFIXES) {
+    if (aliases.some((alias) => present.has(alias))) return prefix;
+  }
+  return DEFAULT_ENV_PREFIX;
+}
+function describeSearchTarget(strategy, frameworkName) {
+  switch (strategy) {
+    case "react":
+      return "React (react-instantsearch)";
+    case "vue":
+      return "Vue (vue-instantsearch)";
+    case "angular":
+      return "Angular (angular-instantsearch)";
+    case "js":
+      return "plain JavaScript (InstantSearch.js)";
+    case "cdn-template":
+      return `${frameworkName ?? "server-rendered"} templates (InstantSearch.js via CDN)`;
+    case "none":
+      return frameworkName ?? "a native mobile app";
+  }
+}
+
+// src/actions/confirmFramework.ts
+var confirmFrameworkSchema = z20.object({
+  frameworks: detectLanguageSchema.shape.frameworks
+});
+var OTHER_OPTION2 = "Other";
+function confirmed2(name, version) {
   const frameworks = [{ name, version: version ?? "unknown" }];
   track("AI Wizard Frontend Framework Confirmed", { frameworks });
   return { frameworks };
@@ -3001,7 +3403,7 @@ async function confirmFramework(ctx) {
   for (const fw of detectedFrameworks) {
     if (!options.some((o) => isSameFramework(o, fw.name))) options.push(fw.name);
   }
-  options.push(OTHER_OPTION);
+  options.push(OTHER_OPTION2);
   const detectedFor = (option) => detectedFrameworks.find((fw) => isSameFramework(option, fw.name));
   const primary = detectedFrameworks[0];
   if (primary) {
@@ -3011,7 +3413,7 @@ async function confirmFramework(ctx) {
       options: [`Confirm ${primary.name}`, "Use a different framework"],
       secondary: [{ kind: "badge", value: "[DETECTED]" }, void 0]
     });
-    if (accepted === true) return confirmed(primary.name, primary.version);
+    if (accepted === true) return confirmed2(primary.name, primary.version);
   }
   const secondary = options.map(
     (o) => detectedFor(o) ? { kind: "badge", value: "[DETECTED]" } : void 0
@@ -3021,7 +3423,7 @@ async function confirmFramework(ctx) {
     0
   );
   const selection = await ctx.requestUserInput({
-    prompt: "select a framework",
+    prompt: "select the framework that renders your UI",
     promptType: "multipleChoice",
     options,
     secondary,
@@ -3030,10 +3432,10 @@ async function confirmFramework(ctx) {
   if (typeof selection !== "string") {
     throw new Error("confirmFramework received an unexpected non-text result");
   }
-  if (selection === OTHER_OPTION) {
-    return confirmed(await askOtherFramework(ctx));
+  if (selection === OTHER_OPTION2) {
+    return confirmed2(await askOtherFramework(ctx));
   }
-  return confirmed(selection, detectedFor(selection)?.version);
+  return confirmed2(selection, detectedFor(selection)?.version);
 }
 
 // src/actions/promptUser.ts
@@ -3126,15 +3528,15 @@ async function confirmEntities(ctx) {
     onSubmit: () => {
     }
   });
-  const confirmed2 = typeof selection === "string" ? entities.filter((e) => e.name === selection) : [];
-  if (confirmed2.length === 0) {
+  const confirmed3 = typeof selection === "string" ? entities.filter((e) => e.name === selection) : [];
+  if (confirmed3.length === 0) {
     throw new Error("User cancelled entity selection \u2014 analysis halted.");
   }
-  ctx.setUserInput("confirmedEntities", confirmed2);
+  ctx.setUserInput("confirmedEntities", confirmed3);
   track("AI Wizard Entities Confirmed", {
-    entities: toEntitySummary(confirmed2)
+    entities: toEntitySummary(confirmed3)
   });
-  return { ingestionAnalysis: entities, confirmedEntities: confirmed2 };
+  return { ingestionAnalysis: entities, confirmedEntities: confirmed3 };
 }
 
 // src/actions/review.ts
@@ -3158,7 +3560,7 @@ ${JSON.stringify(s.output, null, 2)}`
 }
 function formatReviewSummary(result) {
   const nextStepLines = result.nextSteps.map((step) => {
-    const isIngestCommand = step.includes(".algolia-wizard/ingest.sh");
+    const isIngestCommand = step.includes("algolia-wizard/");
     const isWorktreeCommand = step.includes("/worktrees/");
     return {
       text: `\u2192 ${step}`,
@@ -3200,13 +3602,14 @@ ${formatCompletedSteps(ctx.completedSteps)}`,
 import z24 from "zod";
 
 // src/lib/worktree.ts
-import { execFile, spawn as spawn3 } from "node:child_process";
-import { copyFile, mkdir as mkdir6, readdir as readdir3, readFile as readFile8, stat as stat2, writeFile as writeFile6 } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { existsSync as existsSync4 } from "node:fs";
+import { copyFile, mkdir as mkdir6, readdir as readdir4, readFile as readFile9, stat as stat2, writeFile as writeFile6 } from "node:fs/promises";
 import {
   basename as basename2,
   dirname as dirname7,
   isAbsolute as isAbsolute2,
-  join as join10,
+  join as join12,
   relative as relative2,
   resolve as resolve3
 } from "node:path";
@@ -3240,8 +3643,8 @@ async function isWorkingTreeDirty(repoRoot) {
   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);
+  const dir = join12(stateDir(repoRoot), "worktrees");
+  const stale = (await readdir4(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 {
@@ -3251,7 +3654,7 @@ async function pruneOldWorktrees(repoRoot) {
         "worktree",
         "remove",
         "--force",
-        join10(dir, slug)
+        join12(dir, slug)
       ]);
       await git(["-C", repoRoot, "branch", "-D", branch]);
     } catch (err) {
@@ -3265,43 +3668,55 @@ async function pruneOldWorktrees(repoRoot) {
 async function createWorktree(repoRoot) {
   const branch = `${WIZARD_BRANCH_PREFIX}${Date.now()}`;
   const dirSlug = branch.replace(/\//g, "-");
-  const path = join10(stateDir(repoRoot), "worktrees", dirSlug);
+  const path = join12(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 installWorktreeDeps(worktreePath) {
-  try {
-    await readPackageJson(worktreePath);
-  } catch {
-    return { ok: true, output: "no package.json; skipped install" };
-  }
-  const pm = await detectPackageManager(worktreePath);
-  return new Promise((resolve4) => {
-    let output = "";
-    const child = spawn3(pm, ["install"], {
-      cwd: worktreePath,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    child.stdout?.on("data", (d) => output += d);
-    child.stderr?.on("data", (d) => output += d);
-    child.on(
-      "error",
-      (err) => resolve4({
-        ok: false,
-        output: `Failed to run ${pm} install: ${err.message}`
-      })
-    );
-    child.on(
-      "close",
-      (code) => resolve4({ ok: code === 0, output: output.trim() })
-    );
+async function spawnStep(worktreePath, argv) {
+  const { code, output } = await runCommand(argv[0], [...argv.slice(1)], {
+    cwd: worktreePath,
+    timeoutMs: INSTALL_TIMEOUT_MS
   });
+  return { ok: code === 0, output: output.trim() };
+}
+async function installWorktreeDeps(worktreePath, toolchain) {
+  const { profile, installSteps, packageManager } = toolchain;
+  const declared = packageManager.dependency.mode === "agent-declares" ? packageManager.dependency.file : void 0;
+  const haveSomethingToInstall = await hasProfileManifest(worktreePath, profile) || declared !== void 0 && existsSync4(join12(worktreePath, declared));
+  if (!haveSomethingToInstall) {
+    return {
+      ok: true,
+      output: `no ${profile.displayName} manifest; skipped install`
+    };
+  }
+  if (installSteps.length === 0) {
+    return {
+      ok: true,
+      output: `${profile.displayName} (${toolchain.packageManager.id}) has no wizard-run install step`
+    };
+  }
+  const outputs = [];
+  for (const step of installSteps) {
+    if (step.requiresFile && !existsSync4(join12(worktreePath, step.requiresFile)))
+      continue;
+    const result = await spawnStep(worktreePath, step.argv);
+    if (result.output) outputs.push(result.output);
+    if (result.ok) continue;
+    if (step.optional) {
+      logger.warn(
+        { step: step.argv.join(" "), output: result.output },
+        "installWorktreeDeps: optional install step failed; continuing"
+      );
+      continue;
+    }
+    return { ok: false, output: outputs.join("\n").trim() };
+  }
+  return { ok: true, output: outputs.join("\n").trim() };
 }
-var INGEST_RUNTIMES = ["node", "python", "python3", "bun"];
-function validateIngestEntrypoint(worktreePath, entrypoint) {
+function validateIngestEntrypoint(worktreePath, entrypoint, allowedExtensions) {
   if (!entrypoint || entrypoint.startsWith("-")) {
     return {
       ok: false,
@@ -3316,18 +3731,29 @@ function validateIngestEntrypoint(worktreePath, entrypoint) {
       reason: `entrypoint "${entrypoint}" resolves outside the worktree`
     };
   }
+  if (allowedExtensions?.length && !allowedExtensions.some((ext) => entrypoint.endsWith(ext))) {
+    return {
+      ok: false,
+      reason: `entrypoint "${entrypoint}" is not one of ${allowedExtensions.join(", ")}`
+    };
+  }
   return { ok: true, target };
 }
-async function runIngestScript(worktreePath, runtime, entrypoint, env = {}) {
-  if (!INGEST_RUNTIMES.includes(runtime)) {
+async function runIngestScript(worktreePath, toolchain, entrypoint, env = {}) {
+  const { ingest, profile, packageManager } = toolchain;
+  if (ingest.kind !== "auto") {
     return {
       ran: false,
       ok: false,
       output: "",
-      reason: `runtime "${runtime}" is not an allowed interpreter (${INGEST_RUNTIMES.join(", ")})`
+      reason: `${profile.displayName} (${packageManager.id}) projects must be run manually: ${ingest.runCommand}`
     };
   }
-  const validated = validateIngestEntrypoint(worktreePath, entrypoint);
+  const validated = validateIngestEntrypoint(
+    worktreePath,
+    entrypoint,
+    ingest.entrypointExtensions
+  );
   if (!validated.ok) {
     return { ran: false, ok: false, output: "", reason: validated.reason };
   }
@@ -3348,29 +3774,13 @@ async function runIngestScript(worktreePath, runtime, entrypoint, env = {}) {
       reason: `entrypoint "${entrypoint}" does not exist`
     };
   }
-  return new Promise((resolveRun) => {
-    let output = "";
-    const child = spawn3(runtime, [entrypoint], {
-      cwd: worktreePath,
-      shell: false,
-      stdio: ["ignore", "pipe", "pipe"],
-      env: { ...process.env, ...env }
-    });
-    child.stdout?.on("data", (d) => output += d);
-    child.stderr?.on("data", (d) => output += d);
-    child.on(
-      "error",
-      (err) => resolveRun({
-        ran: true,
-        ok: false,
-        output: `Failed to run ${runtime} ${entrypoint}: ${err.message}`
-      })
-    );
-    child.on(
-      "close",
-      (code) => resolveRun({ ran: true, ok: code === 0, output: output.trim() })
-    );
+  const argv = resolveIngestArgv(ingest, entrypoint);
+  const { code, output } = await runCommand(argv[0], argv.slice(1), {
+    cwd: worktreePath,
+    env,
+    timeoutMs: INGEST_TIMEOUT_MS
   });
+  return { ran: true, ok: code === 0, output: output.trim() };
 }
 async function copyUploadIntoWorktree(repoRoot, worktreePath, ingestDir, sourcePath) {
   const trimmed = sourcePath.trim();
@@ -3385,8 +3795,8 @@ async function copyUploadIntoWorktree(repoRoot, worktreePath, ingestDir, sourceP
   } catch {
     return { ok: false, reason: `"${sourcePath}" does not exist` };
   }
-  const relPath = join10(ingestDir, basename2(source));
-  const dest = join10(worktreePath, relPath);
+  const relPath = join12(ingestDir, basename2(source));
+  const dest = join12(worktreePath, relPath);
   try {
     await mkdir6(dirname7(dest), { recursive: true });
     await copyFile(source, dest);
@@ -3402,10 +3812,10 @@ function hasEnvVar(content, name) {
   return new RegExp(`^(\\s*(?:export\\s+)?${name})\\s*=`, "m").test(content);
 }
 async function writeSearchEnvValues(worktreePath, vars) {
-  const target = join10(worktreePath, ".env");
+  const target = join12(worktreePath, ".env");
   let existing = "";
   try {
-    existing = await readFile8(target, "utf8");
+    existing = await readFile9(target, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
   }
@@ -3522,69 +3932,33 @@ async function resolveSearchOnlyKey(index) {
 }
 
 // src/lib/algoliaDocs.ts
-import { readFileSync, readdirSync, existsSync as existsSync2 } from "node:fs";
-import { dirname as dirname8, join as join11 } from "node:path";
+import { readFileSync, existsSync as existsSync5 } from "node:fs";
+import { dirname as dirname8, join as join13 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-var DOCS_SUBPATH = join11("docs", "algolia-sdk");
+var DOCS_SUBPATH = join13("docs", "algolia-sdk");
 function findDocsDir() {
   let dir = dirname8(fileURLToPath2(import.meta.url));
   for (; ; ) {
-    const candidate = join11(dir, DOCS_SUBPATH);
-    if (existsSync2(candidate)) return candidate;
+    const candidate = join13(dir, DOCS_SUBPATH);
+    if (existsSync5(candidate)) return candidate;
     const parent = dirname8(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
 }
-function loadAlgoliaDoc(language) {
-  const docsDir = findDocsDir();
-  if (!docsDir) {
-    logger.warn(
-      "algoliaDocs: docs/algolia-sdk not found; skipping SDK reference"
-    );
-    return "";
-  }
-  const files = readdirSync(docsDir).filter((f) => f.includes(language));
-  if (files.length === 0) {
-    logger.warn(
-      { language },
-      "algoliaDocs: no SDK reference found for language; skipping"
-    );
-    return "";
-  }
-  return readFileSync(join11(docsDir, files[0]), "utf8").trim();
-}
-function getNamedDoc(name, language) {
+function getNamedDoc(name, key) {
   const docsDir = findDocsDir();
   if (!docsDir) {
     logger.warn("docs/algolia-sdk not found");
     return "";
   }
-  const file = join11(docsDir, `${name}-${language}.md`);
-  if (!existsSync2(file)) {
-    logger.warn({ name, language }, "named SDK reference not found");
+  const file = join13(docsDir, `${name}-${key}.md`);
+  if (!existsSync5(file)) {
+    logger.warn({ name, key }, "named SDK reference not found");
     return "";
   }
   return readFileSync(file, "utf8").trim();
 }
-function getFrameworkSpecificDoc(frameworks) {
-  const fw = frameworks.map((f) => f.toLowerCase());
-  if (fw.includes("vue") || fw.includes("nuxt")) {
-    return loadAlgoliaDoc("vue");
-  }
-  if (fw.includes("react") || fw.includes("next.js")) {
-    return loadAlgoliaDoc("react");
-  }
-  if (fw.includes("angular")) {
-    return loadAlgoliaDoc("angular");
-  }
-  return loadAlgoliaDoc("js");
-}
-
-// src/lib/shell.ts
-function shellQuote(value) {
-  return "'" + value.replace(/'/g, "'\\''") + "'";
-}
 
 // src/actions/implement.ts
 var implementSchema = z24.object({
@@ -3619,12 +3993,11 @@ var implementSchema = z24.object({
 });
 var implementationOutputSchema = z24.object({
   summary: z24.string(),
-  // Ingestion only: how to run the generated script, as a structured pair the
-  // wizard turns into an argv (`<runtime> <entrypoint>`) — never a free-form
-  // command string. `runtime` is constrained to an allowlisted interpreter and
-  // `entrypoint` is validated to a worktree-relative path before execution, so
-  // the agent cannot inject extra commands or swap the interpreter.
-  runtime: z24.enum(INGEST_RUNTIMES).optional(),
+  // Ingestion only: the script the wizard should run, as a bare path — never a
+  // command string, and never the interpreter. The command comes from the
+  // resolved language toolchain (a registry constant); this path is validated to
+  // a worktree-relative file with a runnable extension and substituted into it.
+  // So the agent contributes no part of the command that gets executed.
   entrypoint: z24.string().optional()
 });
 var verificationOutputSchema = z24.object({
@@ -3634,47 +4007,11 @@ var verificationOutputSchema = z24.object({
 });
 var MAX_IMPLEMENT_VERIFICATION_ATTEMPTS = 3;
 var DEFAULT_IMPLEMENT_USE_CASES = ["ingestion", "search"];
-var INGEST_DIR = ".algolia-wizard";
-function detectUiFramework(language) {
-  const names = language.frameworks.map((f) => f.name.toLowerCase());
-  if (names.some((n) => n.includes("vue") || n.includes("nuxt"))) return "Vue";
-  if (names.some((n) => n.includes("react") || n.includes("next")))
-    return "React";
-  if (names.some((n) => n.includes("angular"))) return "Angular";
-  return "JavaScript";
-}
-function frameworksForDoc(framework) {
-  switch (framework) {
-    case "React":
-      return ["react"];
-    case "Vue":
-      return ["vue"];
-    case "Angular":
-      return ["angular"];
-    case "JavaScript":
-      return [];
-  }
-}
-function publicEnvPrefix(language) {
-  const frameworkNames = language.frameworks.map(
-    (framework) => framework.name.toLowerCase()
+function buildSearchEnvVars(language, strategy, appId, searchKey) {
+  const prefix = publicEnvPrefix(
+    language.frameworks.map((framework) => framework.name),
+    strategy
   );
-  if (frameworkNames.some((name) => name.includes("next"))) {
-    return "NEXT_PUBLIC_";
-  }
-  if (frameworkNames.some((name) => name.includes("nuxt"))) {
-    return "NUXT_PUBLIC_";
-  }
-  if (frameworkNames.some((name) => name.includes("astro"))) {
-    return "PUBLIC_";
-  }
-  if (frameworkNames.some((name) => name.includes("vite"))) {
-    return "VITE_";
-  }
-  return "PUBLIC_";
-}
-function searchEnvVars(language, appId, searchKey) {
-  const prefix = publicEnvPrefix(language);
   return [
     {
       name: `${prefix}ALGOLIA_APP_ID`,
@@ -3686,6 +4023,38 @@ function searchEnvVars(language, appId, searchKey) {
     }
   ];
 }
+async function resolveIngestionProfile(ctx, language, repoRoot) {
+  const { candidates, confirmed: confirmed3, onDisk } = await pickIngestionCandidates(
+    repoRoot,
+    language.languages.map((l) => l.name)
+  );
+  if (candidates.length === 0) {
+    const chosen = confirmed3[0] ?? onDisk[0] ?? LANGUAGE_PROFILES[DEFAULT_LANGUAGE_ID];
+    logger.warn(
+      {
+        confirmed: language.languages.map((l) => l.name),
+        onDisk: onDisk.map((p) => p.id),
+        chosen: chosen.id
+      },
+      "implement: no confirmed language matched a manifest on disk; falling back"
+    );
+    return chosen;
+  }
+  if (candidates.length === 1) return candidates[0];
+  const backends = candidates.filter(isBackendLanguage);
+  if (backends.length === 1) return backends[0];
+  if (backends.length === 0) return candidates[0];
+  if (isBackendLanguage(candidates[0])) return candidates[0];
+  const options = backends.map((p) => p.displayName);
+  const selection = await ctx.requestUserInput({
+    prompt: "Which language should the ingestion script use?",
+    promptType: "multipleChoice",
+    options,
+    defaultSelectedIndex: 0
+  });
+  const picked = typeof selection === "string" ? backends.find((p) => p.displayName === selection) : void 0;
+  return picked ?? backends[0];
+}
 function baseInstructions(input) {
   return [
     `Target Algolia index: ${input.targetIndex}`,
@@ -3713,37 +4082,48 @@ function sourceSpecificInstructions(input) {
     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 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 (e.g. JSON.parse(readFileSync(...)) in Node/Bun, json.load(open(...)) in Python) instead of inlining the records as literals.",
+      "In the script, read and parse each returned JSON file path at runtime using the idiomatic file read for the language you are writing in (the SDK reference above shows one) 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."
     ]
   };
   return byLine[input.ingestionSource];
 }
 function ingestionInstructions(input) {
+  const { ingestionProfile: profile, toolchain } = input;
+  const { ingest } = toolchain;
+  const extensions = ingest.entrypointExtensions.join(", ");
+  const runInstruction = ingest.kind === "auto" ? `Return "entrypoint": the script path relative to the worktree root (e.g. "${profile.ingestEntrypointExample}"), ending in one of ${extensions}. The wizard runs it with \`${describeIngestCommand(ingest, profile.ingestEntrypointExample)}\`, so it must be a plain path with no flags or arguments and must run as-is under that command.` : `Return "entrypoint": the script path relative to the worktree root (e.g. "${profile.ingestEntrypointExample}"), ending in one of ${extensions}. The wizard does NOT run ${profile.displayName} ${toolchain.packageManager.id} projects itself \u2014 it tells the developer to run \`${describeIngestCommand(ingest, profile.ingestEntrypointExample)}\`, so also add whatever build configuration that command needs${ingest.kind === "manual" && ingest.requiresBuildTask ? `, including a "${ingest.requiresBuildTask}" task in "${toolchain.packageManager.dependency.mode === "agent-declares" ? toolchain.packageManager.dependency.file : "the build file"}" that runs the script` : ""}.`;
   return [
     ...input.confirmed && input.confirmed.length ? [
-      `Create an ingestion script under "${input.ingestDir}/" at the repo root.`,
+      `Write the ingestion script in ${profile.displayName}, at "${ingestScriptDir(profile)}/" in the repo.`,
       `Ingest only these confirmed entities (name, source paths, attributes): ${JSON.stringify(input.confirmed)}.`,
-      `Ingesting writes to Algolia, so the script needs a write API key and App ID \u2014 read them from the ${API_KEY_VAR} and ${APP_ID_VAR} environment variables rather than hardcoding them. The wizard sets these when it runs the script.`,
-      "Use the appropriate Algolia package in the ingestion script. Do not use the raw HTTP API.",
+      `Ingesting writes to Algolia, so the script needs a write API key and App ID \u2014 read them from the ${API_KEY_VAR} and ${APP_ID_VAR} environment variables rather than hardcoding them. ${profile.envReadInstruction} The wizard sets these when it runs the script.`,
+      `Use the official Algolia ${profile.displayName} client (${profile.sdk.packageName}). Do not use the raw HTTP API, and do not use a client for another language.`,
       "After a successful ingest, the script must print exactly one line to stdout in the form `ALGOLIA_WIZARD_RECORD_COUNT=<n>`, where <n> is the total number of records pushed to Algolia. Print it last, on its own line, with no surrounding text.",
-      getNamedDoc("save-records", "js"),
-      'Add algoliasearch to package.json "dependencies" with a valid version range; the wizard installs the worktree deps after you finish.',
+      getNamedDoc("save-records", profile.sdk.docKey),
+      dependencyInstruction(toolchain),
       "The summary should be extremely concise.",
-      `Return how to run the script as two fields, not a command string: "runtime" (one of ${INGEST_RUNTIMES.join(", ")}) and "entrypoint" (the script path relative to the worktree root, e.g. "${input.ingestDir}/ingest.mjs"). The wizard runs \`<runtime> <entrypoint>\` directly, so the entrypoint must be a plain path with no flags or arguments. Write a script one of those interpreters can run as-is.`,
+      runInstruction,
       ...sourceSpecificInstructions(input)
     ] : []
   ];
 }
 function searchInstructions(input) {
-  const doc = getFrameworkSpecificDoc(frameworksForDoc(input.uiFramework));
+  const doc = getNamedDoc(
+    "instantsearch-setup",
+    searchDocKey(input.searchStrategy)
+  );
+  const isTemplate = input.searchStrategy === "cdn-template";
+  const placement = isTemplate ? input.searchLocation ? `Add the search UI to the server-rendered template at "${input.searchLocation}" \u2014 ideally a shared layout, so it is reachable across the app.` : `This project has no shared template to host the UI, so create a standalone page at "${input.ingestDir}/search-demo.html" the developer can open directly, and add a TODO explaining how to move the snippet into their own layout.` : `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.`;
   return [
     "Implement an in-app Algolia search experience.",
-    `Build the search UI for ${input.uiFramework}.`,
-    "Follow the Algolia JS SDK reference below for client setup and InstantSearch wiring; prefer it over prior knowledge:",
+    `Build the search UI for ${describeSearchTarget(input.searchStrategy, input.frameworkName)}.`,
+    "Follow the Algolia reference below for client setup and InstantSearch wiring; prefer it over prior knowledge:",
     doc,
-    `Add the search UI at ${input.searchLocation ? `"${input.searchLocation}"` : "the best shared, always-rendered layout location (e.g. a header/nav component)"} so it is reachable across the app \u2014 at least a working SearchBox and Hits against the "${input.targetIndex}" index.`,
-    "Read the App ID and a search-only API key from public env vars; never hardcode them. A search-only key is safe to expose client-side.",
+    placement,
+    `It needs at least a working SearchBox and Hits against the "${input.targetIndex}" index.`,
+    isTemplate ? "Load InstantSearch from a CDN with script tags as shown in the reference. Do not add JavaScript package dependencies, a bundler, or a build step." : 'Add any Algolia/InstantSearch packages you import to package.json "dependencies" with a valid version range; the wizard installs them in the worktree after you finish.',
+    isTemplate ? "Read the App ID and search-only API key from server-side configuration/environment and render them into the page (e.g. as data- attributes the script reads); never hardcode them, and never put a write/admin key in HTML." : "Read the App ID and a search-only API key from public env vars; never hardcode them. A search-only key is safe to expose client-side.",
     // appId always resolves (loadActiveProfile throws otherwise); only the
     // search-only key is best-effort and can fall back to a placeholder.
     `Values: App ID "${input.appId}", search-only key ${input.searchKey ? `"${input.searchKey}"` : "(placeholder for the developer to fill in)"}.`,
@@ -3751,20 +4131,22 @@ function searchInstructions(input) {
     // resolved app id / search-only key into ".env" under these exact names
     // right after this step, so a renamed prefix here would leave the code
     // reading a var the wizard never wrote.
-    `Use exactly these public env var names in the code: ${input.searchEnvVars.map(({ name }) => name).join(", ")}.`,
-    'Add any Algolia/InstantSearch packages you import to package.json "dependencies" with a valid version range; the wizard installs them in the worktree after you finish.',
+    `Use exactly these env var names: ${input.searchEnvVars.map(({ name }) => name).join(", ")}.`,
     "The summary should be extremely concise; do not mention env var setup or manual testing steps \u2014 the wizard writes the resolved credentials to .env and reports that separately."
   ];
 }
 function verificationInstructions(input) {
+  const protectedDirs = [
+    .../* @__PURE__ */ new Set([input.ingestDir, ingestScriptDir(input.ingestionProfile)])
+  ];
   return [
     "Verify the Algolia implementation changes in the current worktree.",
     `Verification tools found in the codebase: ${JSON.stringify(input.findings.verification ?? [])}.`,
-    "Call verifyImplementation at least once; it runs every repo-defined lint/typecheck/check script and returns per-check results plus an aggregate ok.",
+    `Call verifyImplementation at least once; it runs the mechanical checks available for this repo's languages (${input.verificationLanguages.join(", ")}) and returns per-check results plus an aggregate ok.`,
     "For issues caused by the implementation, make minimal fixes with writeFile and re-run verifyImplementation.",
     "Do not make speculative fixes when verifyImplementation cannot run, no checks exist, or failures are unrelated to these changes \u2014 note the limitation in your summary.",
     "Do not add new Algolia functionality here; only validate and make minimal correctness fixes.",
-    `Do not modify "${input.ingestDir}/" unless verifyImplementation reports an actionable issue in its files.`,
+    `Do not modify ${protectedDirs.map((dir) => `"${dir}/"`).join(" or ")} unless verifyImplementation reports an actionable issue in its files.`,
     "Always call reportStatus with status=success once verification has run, even when sufficient=false.",
     "Set sufficient=true only when the implementation is complete and checks pass (or fail for a clearly unrelated reason).",
     "Set sufficient=false when the implementation is incomplete or has implementation-caused failures; include concrete additionalInstructions for the next pass."
@@ -3773,14 +4155,17 @@ function verificationInstructions(input) {
 var IMPLEMENT_CONFIG = {
   ingestion: {
     title: "Algolia ingestion",
+    label: "Ingestion",
     buildInstructions: ingestionInstructions
   },
   search: {
     title: "Algolia search",
+    label: "Search",
     buildInstructions: searchInstructions
   },
   verification: {
     title: "Algolia verification",
+    label: "Verification",
     buildInstructions: verificationInstructions
   }
 };
@@ -3812,11 +4197,10 @@ function buildAgentInstructions(useCase, input, extraInstructions = []) {
   ];
 }
 function formatSummary(useCase, summary) {
-  const label = useCase === "ingestion" ? "Ingestion" : useCase === "search" ? "Search" : "Verification";
-  return `${label}: ${summary}`;
+  return `${IMPLEMENT_CONFIG[useCase].label}: ${summary}`;
 }
-function buildIngestCommand(worktree, runtime, entrypoint) {
-  return `cd ${shellQuote(worktree)} && ${runtime} ${shellQuote(entrypoint)}`;
+function buildIngestCommand(worktree, toolchain, entrypoint) {
+  return `cd ${shellQuote(worktree)} && ${describeIngestCommand(toolchain.ingest, entrypoint)}`;
 }
 function parseIngestRecordCount(output) {
   const match = output.match(/ALGOLIA_WIZARD_RECORD_COUNT=(\d+)/);
@@ -3898,7 +4282,7 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
     await confirmDirtyWorkingTree(ctx, repoRoot);
   }
   const normalized = normalizeFindingPaths(findings);
-  const confirmed2 = normalized.confirmedEntities;
+  const confirmed3 = normalized.confirmedEntities;
   const searchLocation = normalized.searchImplementationAnalysis;
   let appId;
   let searchKey;
@@ -3936,31 +4320,66 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
         );
       }
     }
+    const ingestionProfile = await resolveIngestionProfile(
+      ctx,
+      language,
+      worktree
+    );
+    const toolchain = await resolveToolchain(worktree, ingestionProfile);
+    const verificationLanguages = [
+      .../* @__PURE__ */ new Set([
+        ingestionProfile.id,
+        ...(await detectProfilesFromManifests(worktree)).map((p) => p.id)
+      ])
+    ];
+    const frameworkName = language.frameworks[0]?.name;
+    const searchStrategy = resolveSearchStrategy(
+      frameworkName,
+      verificationLanguages.includes(JAVASCRIPT)
+    );
+    logger.info(
+      {
+        language: ingestionProfile.id,
+        packageManager: toolchain.packageManager.id,
+        ingest: toolchain.ingest.kind,
+        framework: frameworkName,
+        searchStrategy
+      },
+      "implement: resolved ingestion toolchain and search strategy"
+    );
     const input = {
       findings: normalized,
-      confirmed: confirmed2,
+      confirmed: confirmed3,
       searchLocation,
       targetIndex,
       language,
       appId,
       searchKey,
-      searchEnvVars: searchEnvVars(language, appId, searchKey),
+      searchEnvVars: buildSearchEnvVars(
+        language,
+        searchStrategy,
+        appId,
+        searchKey
+      ),
       ingestDir: INGEST_DIR,
       ingestionSource,
       uploadFilePath,
-      // language.frameworks already prefers the confirm-framework step output,
-      // so the user's confirmed stack (not just raw detection) picks the flavor.
-      uiFramework: detectUiFramework(language)
+      searchStrategy,
+      frameworkName,
+      ingestionProfile,
+      toolchain,
+      verificationLanguages
     };
+    const searchToolchain = !bundlesJavaScript(searchStrategy) ? void 0 : ingestionProfile.id === JAVASCRIPT ? toolchain : await resolveToolchain(worktree, LANGUAGE_PROFILES[JAVASCRIPT]);
+    const toolchainForUseCase = (useCase) => useCase === "search" ? searchToolchain : toolchain;
     const summaries = [];
     if (uploadWarning) summaries.push(uploadWarning);
     let agentRuns = 0;
-    let ingestRuntime;
     let ingestEntrypoint;
     let ingestScriptRan = false;
     let ingestRecordCount;
     let ingestDurationMs;
-    let installFailed = false;
+    const failedInstalls = /* @__PURE__ */ new Set();
     let ingestOutcomeMessage;
     async function runImplementationUseCase(currentUseCase, extraInstructions = []) {
       if (agentRuns > 0) ctx.recordStepExecution();
@@ -3974,16 +4393,19 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
         tools: toolsForUseCase(currentUseCase, input.ingestionSource),
         outputSchema: implementationOutputSchema
       });
+      const useCaseToolchain = toolchainForUseCase(currentUseCase);
+      if (!useCaseToolchain) return result;
       ctx.notify({
         messages: [`Installing dependencies for ${currentUseCase}\u2026`]
       });
       const installLogId = ctx.logStart("installWorktreeDeps", {
-        useCase: currentUseCase
+        useCase: currentUseCase,
+        language: useCaseToolchain.profile.id
       });
-      const install = await installWorktreeDeps(worktree);
+      const install = await installWorktreeDeps(worktree, useCaseToolchain);
       ctx.logEnd(installLogId, install.ok ? "success" : "error");
       if (!install.ok) {
-        installFailed = true;
+        failedInstalls.add(useCaseToolchain.profile.displayName);
         logger.warn(
           { useCase: currentUseCase, output: install.output },
           "implement: dependency install in worktree failed; generated commands may not run until deps are installed"
@@ -3997,15 +4419,16 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
       return runAgent({
         instructions: buildAgentInstructions("verification", input),
         tools: toolsForUseCase("verification"),
-        outputSchema: verificationOutputSchema
+        outputSchema: verificationOutputSchema,
+        // So verifyImplementation runs this repo's checks, not just npm scripts.
+        languages: input.verificationLanguages
       });
     }
     if (useCases.includes("ingestion")) {
-      const { summary, runtime, entrypoint } = await runImplementationUseCase("ingestion");
+      const { summary, entrypoint } = await runImplementationUseCase("ingestion");
       summaries.push(formatSummary("ingestion", summary));
-      ingestRuntime = runtime;
       ingestEntrypoint = entrypoint;
-      if (ingestRuntime && ingestEntrypoint && !installFailed) {
+      if (ingestEntrypoint && toolchain.ingest.kind === "auto" && failedInstalls.size === 0) {
         ctx.clearNotices();
         const runNow = await ctx.requestUserInput({
           prompt: `Run the ingestion script now? This writes records to the "${targetIndex}" index.`,
@@ -4017,13 +4440,13 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
           const profile = await loadActiveProfile();
           ctx.notify({ messages: [`Writing records to "${targetIndex}"\u2026`] });
           const scriptLogId = ctx.logStart("runIngestScript", {
-            runtime: ingestRuntime,
+            language: ingestionProfile.id,
             entrypoint: ingestEntrypoint
           });
           const startedAt = Date.now();
           const run2 = await runIngestScript(
             worktree,
-            ingestRuntime,
+            toolchain,
             ingestEntrypoint,
             {
               [APP_ID_VAR]: profile.appId,
@@ -4037,7 +4460,7 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
             ingestRecordCount = parseIngestRecordCount(run2.output);
             if (ingestRecordCount != null) {
               track("AI Wizard Ingest Successful", {
-                entity_name: confirmed2?.map((e) => e.name).join(", ") || "unknown",
+                entity_name: confirmed3?.map((e) => e.name).join(", ") || "unknown",
                 record_count: ingestRecordCount,
                 duration_ms: ingestDurationMs
               });
@@ -4050,7 +4473,7 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
             outcomeMessage = `\u26A0\uFE0F The ingestion script did not run: ${run2.reason}`;
             logger.warn(
               {
-                runtime: ingestRuntime,
+                language: ingestionProfile.id,
                 entrypoint: ingestEntrypoint,
                 reason: run2.reason
               },
@@ -4073,7 +4496,7 @@ ${run2.output}` : status;
             outcomeMessage = `\u274C Ingestion failed.${run2.output ? ` ${run2.output}` : ""}`;
             logger.warn(
               {
-                runtime: ingestRuntime,
+                language: ingestionProfile.id,
                 entrypoint: ingestEntrypoint,
                 output: run2.output
               },
@@ -4090,10 +4513,28 @@ ${run2.output}` : status;
         }
       }
       const commandMessages = [`Open the worktree: cd ${shellQuote(worktree)}`];
-      if (ingestRuntime && ingestEntrypoint) {
+      if (ingestEntrypoint) {
         commandMessages.push(
-          `Ingestion command: ${buildIngestCommand(worktree, ingestRuntime, ingestEntrypoint)}`
+          `Ingestion command: ${buildIngestCommand(worktree, toolchain, ingestEntrypoint)}`
         );
+        if (toolchain.ingest.kind === "manual") {
+          commandMessages.push(
+            `The wizard does not run ${ingestionProfile.displayName} ${toolchain.packageManager.id} projects \u2014 run the command above yourself to ingest.`
+          );
+          const missingTask = await missingBuildTask(worktree, toolchain);
+          if (missingTask) {
+            const warning = `\u26A0\uFE0F The command above needs a "${missingTask}" task, which is not in ${toolchain.packageManager.dependency.mode === "agent-declares" ? toolchain.packageManager.dependency.file : "the build file"} \u2014 add it before running, or run the script through your IDE instead.`;
+            commandMessages.push(warning);
+            summaries.push(warning);
+          }
+        }
+      }
+      if (ingestionSource === "local") {
+        const limitation = localSourceLimitation(worktree, ingestionProfile);
+        if (limitation) {
+          commandMessages.push(`\u26A0\uFE0F ${limitation}`);
+          summaries.push(`\u26A0\uFE0F ${limitation}`);
+        }
       }
       await ctx.requestUserInput({
         // No question being asked here, just an acknowledgement — the
@@ -4104,7 +4545,20 @@ ${run2.output}` : status;
         messages: ingestOutcomeMessage ? [ingestOutcomeMessage, ...commandMessages] : commandMessages
       });
     }
-    if (useCases.includes("search")) {
+    const skipSearch = useCases.includes("search") && !canScaffoldSearchUI(input.searchStrategy);
+    if (skipSearch) {
+      const target = describeSearchTarget(
+        input.searchStrategy,
+        input.frameworkName
+      );
+      summaries.push(
+        `Search UI skipped: the wizard can't scaffold a native search UI for ${target}. Your records are in the "${targetIndex}" index \u2014 build the UI with Algolia's mobile InstantSearch libraries (https://www.algolia.com/doc/guides/building-search-ui/what-is-instantsearch/ios/ for iOS, .../android for Android).`
+      );
+      track("AI Wizard Search UI Skipped", {
+        framework: input.frameworkName ?? "unknown"
+      });
+    }
+    if (useCases.includes("search") && !skipSearch) {
       let extraInstructions = [];
       const preSearchFiles = new Set(await listChangedFiles(worktree));
       for (let attempt = 1; attempt <= MAX_IMPLEMENT_VERIFICATION_ATTEMPTS; attempt++) {
@@ -4175,9 +4629,9 @@ ${run2.output}` : status;
         "implement: agent reported success but no files changed in the worktree"
       );
     }
-    if (installFailed) {
+    if (failedInstalls.size > 0) {
       summaries.push(
-        '\u26A0\uFE0F Dependency install in the worktree failed. Run your package manager install in the worktree before the command below, or it will fail with "Cannot find module".'
+        `\u26A0\uFE0F Dependency install in the worktree failed. Install the ${[...failedInstalls].join(" and ")} dependencies in the worktree before the command below, or it will fail on a missing package.`
       );
     }
     return {
@@ -4185,10 +4639,10 @@ ${run2.output}` : status;
       filesChanged,
       summary: summaries.join("\n\n"),
       worktreePath: worktree,
-      ...useCases.includes("ingestion") && ingestRuntime && ingestEntrypoint ? {
+      ...useCases.includes("ingestion") && ingestEntrypoint ? {
         ingestCommand: buildIngestCommand(
           worktree,
-          ingestRuntime,
+          toolchain,
           ingestEntrypoint
         ),
         ingestScriptRan,
@@ -4517,20 +4971,20 @@ function parseCliArgs(argv) {
 }
 
 // src/lib/resetState.ts
-import { readdir as readdir4, rm as rm2 } from "node:fs/promises";
-import { join as join12 } from "node:path";
+import { readdir as readdir5, rm as rm2 } from "node:fs/promises";
+import { join as join14 } from "node:path";
 var KEEP = ["wizard.log"];
 async function resetProjectState() {
   const dir = stateDir();
   let entries;
   try {
-    entries = await readdir4(dir);
+    entries = await readdir5(dir);
   } catch {
     return { dir, removed: [] };
   }
   const targets = entries.filter((name) => !KEEP.includes(name));
   await Promise.all(
-    targets.map((name) => rm2(join12(dir, name), { recursive: true, force: true }))
+    targets.map((name) => rm2(join14(dir, name), { recursive: true, force: true }))
   );
   return { dir, removed: targets };
 }