@algolia/wizard 0.5.0 → 0.6.0-rc.51.22

package/dist/main.js

@@ -796,12 +796,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",
@@ -907,7 +907,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, Gemfile, go.mod, pom.xml\u2026), configs & source to detect your stack. Read-only; nothing is uploaded."
   },
   {
     tag: "WRITE",
@@ -2155,15 +2155,647 @@ 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 readFile7 } from "node:fs/promises";
+import { join as join10 } from "node:path";
+
+// src/lib/languages.ts
+import { readdir as readdir2 } 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 PY_VENV = `${INGEST_DIR}/.venv`;
+var PY_VENV_PYTHON = `${PY_VENV}/bin/python`;
+var PY_REQUIREMENTS = `${INGEST_DIR}/requirements.txt`;
+var CSHARP_PROJECT = `${INGEST_DIR}/ingest/ingest.csproj`;
+var SWIFT_PACKAGE_DIR = `${INGEST_DIR}/Ingest`;
+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"]
+  },
+  python: {
+    id: "python",
+    displayName: "Python",
+    aliases: ["python", "python3", "py", "cpython"],
+    manifests: [
+      "pyproject.toml",
+      "requirements.txt",
+      "setup.py",
+      "setup.cfg",
+      "Pipfile"
+    ],
+    // Deliberately one path for every Python repo: a wizard-owned venv under
+    // .algolia-wizard. Reusing the project's uv/poetry environment would mean
+    // mutating the developer's real dependency manifest and lockfile, and the
+    // declare-here/install-there split is the main way ingestion silently ends
+    // up without the SDK installed. The tradeoff: the script can import the
+    // Algolia client and anything it declares itself, but not the project's own
+    // packages (see the optional root-requirements step below).
+    packageManagers: [
+      {
+        id: "pip-venv",
+        dependency: { mode: "agent-declares", file: PY_REQUIREMENTS },
+        installSteps: [
+          { argv: ["python3", "-m", "venv", PY_VENV] },
+          {
+            argv: [PY_VENV_PYTHON, "-m", "pip", "install", "-r", PY_REQUIREMENTS]
+          },
+          // Best-effort access to the project's own dependencies (DB drivers,
+          // ORMs) when the repo pins them the classic way.
+          {
+            argv: [
+              PY_VENV_PYTHON,
+              "-m",
+              "pip",
+              "install",
+              "-r",
+              "requirements.txt"
+            ],
+            requiresFile: "requirements.txt",
+            optional: true
+          }
+        ],
+        ingest: {
+          kind: "auto",
+          argv: [PY_VENV_PYTHON, ENTRYPOINT_TOKEN],
+          entrypointExtensions: [".py"]
+        }
+      }
+    ],
+    sdk: {
+      packageName: "algoliasearch",
+      versionPin: ">=4,<5",
+      docKey: "python"
+    },
+    ingestEntrypointExample: `${INGEST_DIR}/ingest.py`,
+    verification: [
+      {
+        label: "python compileall",
+        argv: ["python3", "-m", "compileall", "-q", INGEST_DIR]
+      }
+    ],
+    envReadInstruction: "Read them from `os.environ`.",
+    skipDirs: [
+      "venv",
+      "__pycache__",
+      "site-packages",
+      "dist",
+      "build",
+      "htmlcov"
+    ]
+  },
+  ruby: {
+    id: "ruby",
+    displayName: "Ruby",
+    aliases: ["ruby", "rb", "rails", "ruby on rails", "rubyonrails"],
+    manifests: ["Gemfile", "*.gemspec"],
+    packageManagers: [
+      {
+        id: "bundler",
+        dependency: { mode: "agent-declares", file: "Gemfile" },
+        installSteps: [{ argv: ["bundle", "install"] }],
+        ingest: {
+          kind: "auto",
+          argv: ["bundle", "exec", "ruby", ENTRYPOINT_TOKEN],
+          entrypointExtensions: [".rb"]
+        }
+      }
+    ],
+    sdk: { packageName: "algolia", versionPin: "~> 3.0", docKey: "ruby" },
+    ingestEntrypointExample: `${INGEST_DIR}/ingest.rb`,
+    // Ruby has no directory-level syntax check (`ruby -c` is one file at a
+    // time), so verification relies on the agent's own review here.
+    verification: [],
+    envReadInstruction: "Read them from `ENV.fetch('NAME')`.",
+    skipDirs: ["vendor", "tmp", "log", "coverage"]
+  },
+  php: {
+    id: "php",
+    displayName: "PHP",
+    aliases: ["php", "laravel", "symfony"],
+    manifests: ["composer.json"],
+    packageManagers: [
+      {
+        id: "composer",
+        // `composer require` both declares and installs, and unlike editing
+        // composer.json by hand it can't leave composer.lock out of date (which
+        // makes a later `composer install` refuse to run).
+        dependency: { mode: "wizard-installs" },
+        installSteps: [
+          {
+            argv: [
+              "composer",
+              "require",
+              "algolia/algoliasearch-client-php:^4",
+              "--no-interaction",
+              // Repo post-install scripts are the project's code, not ours to
+              // trigger; Laravel's package:discover also fails in a bare tree.
+              "--no-scripts"
+            ]
+          }
+        ],
+        ingest: {
+          kind: "auto",
+          argv: ["php", ENTRYPOINT_TOKEN],
+          entrypointExtensions: [".php"]
+        }
+      }
+    ],
+    sdk: {
+      packageName: "algolia/algoliasearch-client-php",
+      versionPin: "^4",
+      docKey: "php"
+    },
+    ingestEntrypointExample: `${INGEST_DIR}/ingest.php`,
+    verification: [],
+    envReadInstruction: "Read them from `getenv('NAME')`.",
+    skipDirs: ["vendor", "node_modules"]
+  },
+  go: {
+    id: "go",
+    displayName: "Go",
+    aliases: ["go", "golang"],
+    manifests: ["go.mod"],
+    packageManagers: [
+      {
+        id: "gomod",
+        // Imports in the generated file are the declaration; `go mod tidy`
+        // resolves and fetches them.
+        dependency: { mode: "code-imports" },
+        installSteps: [{ argv: ["go", "mod", "tidy"] }],
+        ingest: {
+          kind: "auto",
+          argv: ["go", "run", ENTRYPOINT_TOKEN],
+          entrypointExtensions: [".go"]
+        }
+      }
+    ],
+    sdk: {
+      packageName: "github.com/algolia/algoliasearch-client-go/v4",
+      versionPin: "v4",
+      docKey: "go"
+    },
+    ingestEntrypointExample: `${INGEST_DIR}/ingest.go`,
+    verification: [
+      { label: "go vet", argv: ["go", "vet", "./..."], requiresFile: "go.mod" }
+    ],
+    envReadInstruction: "Read them from `os.Getenv`.",
+    skipDirs: ["vendor", "bin"]
+  },
+  java: {
+    id: "java",
+    displayName: "Java",
+    aliases: ["java"],
+    manifests: ["pom.xml", "build.gradle", "build.gradle.kts"],
+    packageManagers: [
+      {
+        id: "maven",
+        detectFiles: ["pom.xml"],
+        dependency: { mode: "agent-declares", file: "pom.xml" },
+        installSteps: [{ argv: ["mvn", "-q", "-DskipTests", "compile"] }],
+        // The main class is a wizard constant the instructions require the agent
+        // to use, so execution can't be redirected by agent output. Runnable only
+        // because the install step above compiles src/main/java first — which is
+        // why the entrypoint lives there rather than under .algolia-wizard/.
+        ingest: {
+          kind: "auto",
+          argv: [
+            "mvn",
+            "-q",
+            "org.codehaus.mojo:exec-maven-plugin:3.5.0:java",
+            "-Dexec.mainClass=AlgoliaWizardIngest"
+          ],
+          entrypointExtensions: [".java"]
+        }
+      },
+      {
+        id: "gradle",
+        detectFiles: ["build.gradle", "build.gradle.kts"],
+        dependency: { mode: "agent-declares", file: "build.gradle" },
+        installSteps: [],
+        // Auto-running means executing the repo's own ./gradlew wrapper; out of
+        // scope for now, so the wizard writes the code and prints the command.
+        ingest: {
+          kind: "manual",
+          entrypointExtensions: [".java"],
+          runCommand: "./gradlew runAlgoliaIngest"
+        }
+      }
+    ],
+    sdk: {
+      packageName: "com.algolia:algoliasearch",
+      versionPin: "4.+",
+      docKey: "java",
+      alsoRequires: "The class must be named AlgoliaWizardIngest, in the default package (no `package` statement), with a `public static void main`."
+    },
+    // Not under .algolia-wizard/: Maven and Gradle only compile src/main/<lang>,
+    // so a class outside it never makes it onto the classpath and the run command
+    // fails with "class not found".
+    ingestEntrypointExample: "src/main/java/AlgoliaWizardIngest.java",
+    verification: [
+      {
+        label: "mvn compile",
+        argv: ["mvn", "-q", "-DskipTests", "compile"],
+        requiresFile: "pom.xml"
+      }
+    ],
+    envReadInstruction: "Read them from `System.getenv`.",
+    skipDirs: ["target", "build", "out"]
+  },
+  kotlin: {
+    id: "kotlin",
+    displayName: "Kotlin",
+    aliases: ["kotlin", "kt", "ktor"],
+    manifests: ["build.gradle.kts", "build.gradle", "pom.xml"],
+    packageManagers: [
+      {
+        id: "gradle",
+        dependency: { mode: "agent-declares", file: "build.gradle.kts" },
+        installSteps: [],
+        ingest: {
+          kind: "manual",
+          entrypointExtensions: [".kt"],
+          runCommand: "./gradlew runAlgoliaIngest"
+        }
+      }
+    ],
+    sdk: {
+      packageName: "com.algolia:algoliasearch-client-kotlin",
+      versionPin: "3.+",
+      docKey: "kotlin",
+      // The published client's commonMain ships only ktor-client-core; without an
+      // engine the script compiles and then fails at its first request.
+      alsoRequires: "The Kotlin client bundles no HTTP engine, so also declare one (e.g. io.ktor:ktor-client-okhttp). Name the object AlgoliaWizardIngest in the default package, with a @JvmStatic main."
+    },
+    ingestEntrypointExample: "src/main/kotlin/AlgoliaWizardIngest.kt",
+    verification: [],
+    envReadInstruction: "Read them from `System.getenv`.",
+    skipDirs: ["build", "out"]
+  },
+  scala: {
+    id: "scala",
+    displayName: "Scala",
+    aliases: ["scala", "sbt"],
+    manifests: ["build.sbt", "build.sc"],
+    packageManagers: [
+      {
+        id: "sbt",
+        dependency: { mode: "agent-declares", file: "build.sbt" },
+        installSteps: [],
+        ingest: {
+          kind: "manual",
+          entrypointExtensions: [".scala"],
+          runCommand: 'sbt "runMain AlgoliaWizardIngest"'
+        }
+      }
+    ],
+    sdk: {
+      packageName: "com.algolia:algoliasearch-scala_2.13",
+      versionPin: "2.+",
+      docKey: "scala",
+      alsoRequires: "Name the object AlgoliaWizardIngest in the default package (no `package` statement) so `runMain AlgoliaWizardIngest` resolves it."
+    },
+    ingestEntrypointExample: "src/main/scala/AlgoliaWizardIngest.scala",
+    verification: [],
+    envReadInstruction: "Read them from `sys.env`.",
+    // `project/` holds sbt's build definition, but the name is generic enough
+    // that some repos use it for source; scanning it is cheap, missing source
+    // is not.
+    skipDirs: ["target"]
+  },
+  csharp: {
+    id: "csharp",
+    displayName: "C#",
+    aliases: ["c#", "csharp", "cs", ".net", "dotnet", "net", "asp.net"],
+    manifests: ["*.csproj", "*.sln", "global.json"],
+    packageManagers: [
+      {
+        id: "dotnet",
+        // A self-contained project under .algolia-wizard keeps the ingest script
+        // out of the repo's own build graph.
+        dependency: { mode: "agent-declares", file: CSHARP_PROJECT },
+        installSteps: [{ argv: ["dotnet", "restore", CSHARP_PROJECT] }],
+        ingest: {
+          kind: "auto",
+          argv: ["dotnet", "run", "--project", ENTRYPOINT_TOKEN],
+          entrypointExtensions: [".csproj"]
+        }
+      }
+    ],
+    sdk: {
+      packageName: "Algolia.Search",
+      versionPin: "7.*",
+      docKey: "csharp"
+    },
+    ingestEntrypointExample: CSHARP_PROJECT,
+    verification: [
+      {
+        label: "dotnet build",
+        argv: ["dotnet", "build", CSHARP_PROJECT, "--nologo"],
+        requiresFile: CSHARP_PROJECT
+      }
+    ],
+    envReadInstruction: 'Read them from `Environment.GetEnvironmentVariable("NAME")`.',
+    // Deliberately not `packages`: modern .NET uses PackageReference, and
+    // `packages/` is where pnpm/Lerna/Turborepo monorepos keep all their source —
+    // skipping it would hide the entities the scan is looking for.
+    skipDirs: ["bin", "obj"]
+  },
+  swift: {
+    id: "swift",
+    displayName: "Swift",
+    aliases: ["swift", "swiftui", "ios", "vapor"],
+    manifests: ["Package.swift", "*.xcodeproj", "*.xcworkspace"],
+    packageManagers: [
+      {
+        id: "swiftpm",
+        dependency: {
+          mode: "agent-declares",
+          file: `${SWIFT_PACKAGE_DIR}/Package.swift`
+        },
+        // `swift build` resolves and fetches; a cold build of the client is slow
+        // (minutes), which is why the caller degrades to the manual command when
+        // this fails.
+        installSteps: [
+          {
+            argv: ["swift", "build", "--package-path", SWIFT_PACKAGE_DIR],
+            requiresFile: `${SWIFT_PACKAGE_DIR}/Package.swift`
+          }
+        ],
+        ingest: {
+          kind: "auto",
+          argv: ["swift", "run", "--package-path", SWIFT_PACKAGE_DIR],
+          entrypointExtensions: [".swift"]
+        }
+      }
+    ],
+    sdk: {
+      packageName: "algoliasearch-client-swift",
+      // SwiftPM range syntax, not an exact version — a bare "9.0.0" in a
+      // Package.swift dependency pins the patch.
+      versionPin: 'from: "9.0.0"',
+      docKey: "swift"
+    },
+    ingestEntrypointExample: `${SWIFT_PACKAGE_DIR}/Sources/Ingest/main.swift`,
+    verification: [
+      {
+        label: "swift build",
+        argv: ["swift", "build", "--package-path", SWIFT_PACKAGE_DIR],
+        requiresFile: `${SWIFT_PACKAGE_DIR}/Package.swift`
+      }
+    ],
+    envReadInstruction: "Read them from `ProcessInfo.processInfo.environment`.",
+    skipDirs: ["Pods", "DerivedData", "Carthage", ".build"]
+  },
+  dart: {
+    id: "dart",
+    displayName: "Dart",
+    aliases: ["dart", "flutter"],
+    manifests: ["pubspec.yaml"],
+    packageManagers: [
+      {
+        id: "flutter-pub",
+        detectFiles: [".metadata"],
+        dependency: { mode: "agent-declares", file: "pubspec.yaml" },
+        installSteps: [{ argv: ["flutter", "pub", "get"] }],
+        ingest: {
+          kind: "auto",
+          argv: ["dart", "run", ENTRYPOINT_TOKEN],
+          entrypointExtensions: [".dart"]
+        }
+      },
+      {
+        id: "pub",
+        dependency: { mode: "agent-declares", file: "pubspec.yaml" },
+        installSteps: [{ argv: ["dart", "pub", "get"] }],
+        ingest: {
+          kind: "auto",
+          argv: ["dart", "run", ENTRYPOINT_TOKEN],
+          entrypointExtensions: [".dart"]
+        }
+      }
+    ],
+    sdk: {
+      packageName: "algolia_client_search",
+      versionPin: "^1.0.0",
+      docKey: "dart"
+    },
+    ingestEntrypointExample: `${INGEST_DIR}/ingest.dart`,
+    verification: [
+      {
+        label: "dart analyze",
+        argv: ["dart", "analyze", INGEST_DIR],
+        requiresFile: "pubspec.yaml"
+      }
+    ],
+    envReadInstruction: "Read them from `Platform.environment`.",
+    skipDirs: ["build"]
+  }
+};
+var DEFAULT_LANGUAGE_ID = "javascript";
+function normalizeLanguageName(name) {
+  return name.toLowerCase().trim().replace(/[\s_-]+/g, "");
+}
+var ALIAS_TO_ID = /* @__PURE__ */ new Map();
+for (const profile2 of Object.values(LANGUAGE_PROFILES)) {
+  for (const alias of [profile2.id, profile2.displayName, ...profile2.aliases]) {
+    ALIAS_TO_ID.set(normalizeLanguageName(alias), profile2.id);
+  }
+}
+function resolveLanguageProfile(name) {
+  const id = ALIAS_TO_ID.get(normalizeLanguageName(name));
+  return id ? LANGUAGE_PROFILES[id] : void 0;
+}
+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((profile2) => [
+    ...profile2.packageManagers.flatMap((pm) => [
+      ...pm.installSteps.map((s) => s.argv[0]),
+      ...pm.ingest.kind === "auto" ? [pm.ingest.argv[0]] : []
+    ]),
+    ...profile2.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)];
+}
+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, profile2, listing) {
+  for (const manifest of profile2.manifests) {
+    if (await manifestPresent(root, manifest, listing)) return true;
+  }
+  return false;
+}
+async function detectProfilesFromManifests(root) {
+  const listing = {};
+  const found = [];
+  for (const profile2 of Object.values(LANGUAGE_PROFILES)) {
+    if (await profileManifestPresent(root, profile2, listing)) found.push(profile2);
+  }
+  return found;
+}
+async function hasProfileManifest(root, profile2) {
+  return profileManifestPresent(root, profile2, {});
+}
+async function resolveToolchain(root, profile2) {
+  const matched = profile2.packageManagers.find(
+    (pm) => [...pm.lockfiles ?? [], ...pm.detectFiles ?? []].some(
+      (f) => existsSync2(join9(root, f))
+    )
+  );
+  const packageManager = matched ?? profile2.packageManagers[0];
+  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 (profile2.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: profile2, 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(profile2) {
+  const parts = profile2.ingestEntrypointExample.split("/");
+  return parts.slice(0, -1).join("/") || ".";
+}
+function dependencyInstruction(toolchain) {
+  const { profile: profile2, packageManager } = toolchain;
+  const { packageName, versionPin } = profile2.sdk;
+  const also = profile2.sdk.alsoRequires ? ` ${profile2.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);
   }
@@ -2196,7 +2828,7 @@ function searchFilesTool(ctx) {
       for (const file of await walkFiles(resolved.target)) {
         let content;
         try {
-          content = await readFile6(file, "utf8");
+          content = await readFile7(file, "utf8");
         } catch {
           continue;
         }
@@ -2220,6 +2852,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";
 function runCommand(command, args, cwd) {
@@ -2239,69 +2875,89 @@ function runCommand(command, args, cwd) {
   });
 }
 
-// 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);
+  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]);
-    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 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) {
+    if (id === DEFAULT_LANGUAGE_ID) {
+      const result = await javascriptChecks();
+      if ("checks" in result) checks.push(...result.checks);
+      else limitations.push(result.limitation);
+      continue;
+    }
+    const profile2 = LANGUAGE_PROFILES[id];
+    const runnable = profile2.verification.filter(
+      (spec) => !spec.requiresFile || existsSync3(join11(process.cwd(), spec.requiresFile))
+    );
+    if (runnable.length === 0) {
+      limitations.push(
+        `No mechanical verification available for ${profile2.displayName} in this repo.`
+      );
+      continue;
+    }
+    for (const spec of runnable) {
+      checks.push(
+        await runCheck(spec.argv.join(" "), spec.argv[0], [
+          ...spec.argv.slice(1)
+        ])
+      );
+    }
+  }
+  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);
     }
   });
 }
@@ -2427,12 +3083,13 @@ 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]
   };
 }
 
@@ -2469,7 +3126,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())
@@ -2505,7 +3162,11 @@ async function runAgent(req) {
     baseURL: PROXY_BASE_URL,
     fetch: proxyFetch
   });
-  const toolContext = createToolContext();
+  const toolContext = createToolContext(
+    void 0,
+    void 0,
+    req.languages
+  );
   const readTools = ["readFile", "searchFiles", "listFiles"];
   const hasReadTools = !req.tools || req.tools.some((t) => readTools.includes(t));
   const instructions = [
@@ -2596,8 +3257,11 @@ var detectLanguageSchema = z16.object({
 var detectLanguage = () => runAgent({
   instructions: [
     "Analyze the codebase and determine the programming languages and frameworks used",
-    "If a superset language is found, exclude the subset language. TS-over-JS.",
+    "Start from the dependency manifests: package.json, pyproject.toml, requirements.txt, Gemfile, composer.json, go.mod, pom.xml, build.gradle(.kts), *.csproj, build.sbt, Package.swift, pubspec.yaml.",
+    "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. Kotlin-over-Java when Kotlin is primary.",
     "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"',
@@ -2646,6 +3310,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, Django models.py, Rails app/models, Laravel Eloquent models, JPA @Entity classes, Go structs, C# entity classes, Pydantic models.",
       "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",
@@ -2657,8 +3322,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"
     ],
@@ -2667,8 +3333,8 @@ 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.",
-      'Return the tool names as an array, e.g. ["eslint", "prettier", "tsc"].',
+      "Look at the dependency manifest and config files for the project's languages: package.json scripts with tsconfig/eslint/prettier, pyproject.toml or setup.cfg (ruff, mypy, black), Gemfile with .rubocop.yml, composer.json scripts (phpstan, pint), go.mod with a golangci-lint config, Maven/Gradle verification tasks, .NET analyzers, analysis_options.yaml.",
+      'Return the tool names as an array, e.g. ["eslint", "prettier", "tsc"] or ["ruff", "mypy"].',
       "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",
       "When done, call reportStatus"
@@ -2695,7 +3361,7 @@ async function runAnalysis(mode, extraInstructions = []) {
 // package.json
 var package_default = {
   name: "@algolia/wizard",
-  version: "0.5.0",
+  version: "0.6.0-rc.51.22",
   description: "Magically implement Algolia functionality in your codebase",
   type: "module",
   engines: {
@@ -2798,82 +3464,175 @@ 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";
+var CURATED_LANGUAGES = Object.values(LANGUAGE_PROFILES).map(
+  (profile2) => profile2.displayName
+);
+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 fold = (s) => s.toLowerCase().replace(/[^a-z0-9]/g, "");
+  return fold(a) !== "" && fold(a) === fold(b);
+}
+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 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 };
@@ -2901,7 +3660,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) {
@@ -2911,7 +3670,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
@@ -2921,7 +3680,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,
@@ -2930,10 +3689,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
@@ -3026,15 +3785,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
@@ -3058,7 +3817,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/") || step.includes("AlgoliaWizardIngest");
     const isWorktreeCommand = step.includes("/worktrees/");
     return {
       text: `\u2192 ${step}`,
@@ -3101,12 +3860,13 @@ 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 { existsSync as existsSync4 } from "node:fs";
+import { copyFile, mkdir as mkdir6, readdir as readdir4, readFile as readFile8, 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";
@@ -3140,8 +3900,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 {
@@ -3151,7 +3911,7 @@ async function pruneOldWorktrees(repoRoot) {
         "worktree",
         "remove",
         "--force",
-        join10(dir, slug)
+        join12(dir, slug)
       ]);
       await git(["-C", repoRoot, "branch", "-D", branch]);
     } catch (err) {
@@ -3165,24 +3925,19 @@ 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);
+function spawnStep(worktreePath, argv) {
   return new Promise((resolve4) => {
     let output = "";
-    const child = spawn3(pm, ["install"], {
+    const child = spawn3(argv[0], [...argv.slice(1)], {
       cwd: worktreePath,
+      shell: false,
       stdio: ["ignore", "pipe", "pipe"]
     });
     child.stdout?.on("data", (d) => output += d);
@@ -3191,7 +3946,7 @@ async function installWorktreeDeps(worktreePath) {
       "error",
       (err) => resolve4({
         ok: false,
-        output: `Failed to run ${pm} install: ${err.message}`
+        output: `Failed to run ${argv.join(" ")}: ${err.message}`
       })
     );
     child.on(
@@ -3200,8 +3955,41 @@ async function installWorktreeDeps(worktreePath) {
     );
   });
 }
-var INGEST_RUNTIMES = ["node", "python", "python3", "bun"];
-function validateIngestEntrypoint(worktreePath, entrypoint) {
+async function installWorktreeDeps(worktreePath, toolchain) {
+  const { profile: profile2, installSteps, packageManager } = toolchain;
+  const declared = packageManager.dependency.mode === "agent-declares" ? packageManager.dependency.file : void 0;
+  const haveSomethingToInstall = await hasProfileManifest(worktreePath, profile2) || declared !== void 0 && existsSync4(join12(worktreePath, declared));
+  if (!haveSomethingToInstall) {
+    return {
+      ok: true,
+      output: `no ${profile2.displayName} manifest; skipped install`
+    };
+  }
+  if (installSteps.length === 0) {
+    return {
+      ok: true,
+      output: `${profile2.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() };
+}
+function validateIngestEntrypoint(worktreePath, entrypoint, allowedExtensions) {
   if (!entrypoint || entrypoint.startsWith("-")) {
     return {
       ok: false,
@@ -3216,18 +4004,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: profile2, packageManager } = toolchain;
+  if (ingest.kind !== "auto") {
     return {
       ran: false,
       ok: false,
       output: "",
-      reason: `runtime "${runtime}" is not an allowed interpreter (${INGEST_RUNTIMES.join(", ")})`
+      reason: `${profile2.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 };
   }
@@ -3248,9 +4047,10 @@ async function runIngestScript(worktreePath, runtime, entrypoint, env = {}) {
       reason: `entrypoint "${entrypoint}" does not exist`
     };
   }
+  const argv = resolveIngestArgv(ingest, entrypoint);
   return new Promise((resolveRun) => {
     let output = "";
-    const child = spawn3(runtime, [entrypoint], {
+    const child = spawn3(argv[0], argv.slice(1), {
       cwd: worktreePath,
       shell: false,
       stdio: ["ignore", "pipe", "pipe"],
@@ -3263,7 +4063,7 @@ async function runIngestScript(worktreePath, runtime, entrypoint, env = {}) {
       (err) => resolveRun({
         ran: true,
         ok: false,
-        output: `Failed to run ${runtime} ${entrypoint}: ${err.message}`
+        output: `Failed to run ${argv.join(" ")}: ${err.message}`
       })
     );
     child.on(
@@ -3285,8 +4085,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);
@@ -3302,7 +4102,7 @@ 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");
@@ -3422,69 +4222,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({
@@ -3519,12 +4283,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({
@@ -3534,28 +4297,9 @@ 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) {
+var INGEST_DIR2 = ".algolia-wizard";
+function publicEnvPrefix(language, strategy) {
+  if (strategy === "cdn-template" || strategy === "none") return "";
   const frameworkNames = language.frameworks.map(
     (framework) => framework.name.toLowerCase()
   );
@@ -3573,8 +4317,8 @@ function publicEnvPrefix(language) {
   }
   return "PUBLIC_";
 }
-function searchEnvVars(language, appId, searchKey) {
-  const prefix = publicEnvPrefix(language);
+function searchEnvVars(language, strategy, appId, searchKey) {
+  const prefix = publicEnvPrefix(language, strategy);
   return [
     {
       name: `${prefix}ALGOLIA_APP_ID`,
@@ -3586,6 +4330,42 @@ function searchEnvVars(language, appId, searchKey) {
     }
   ];
 }
+async function resolveIngestionProfile(ctx, language, repoRoot) {
+  const fallback = LANGUAGE_PROFILES[DEFAULT_LANGUAGE_ID];
+  const confirmed3 = language.languages.map((l) => resolveLanguageProfile(l.name)).filter((p) => p !== void 0);
+  const onDisk = await detectProfilesFromManifests(repoRoot);
+  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()
+  ];
+  if (candidates.length === 0) {
+    const chosen = confirmed3[0] ?? onDisk[0] ?? fallback;
+    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((p) => p.id !== DEFAULT_LANGUAGE_ID);
+  if (backends.length === 1) return backends[0];
+  if (backends.length === 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}`,
@@ -3613,37 +4393,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: profile2, 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. "${profile2.ingestEntrypointExample}"), ending in one of ${extensions}. The wizard runs it with \`${describeIngestCommand(ingest, profile2.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. "${profile2.ingestEntrypointExample}"), ending in one of ${extensions}. The wizard does NOT run ${profile2.displayName} ${toolchain.packageManager.id} projects itself \u2014 it tells the developer to run \`${describeIngestCommand(ingest, profile2.ingestEntrypointExample)}\`, so also add whatever build configuration that command needs.`;
   return [
     ...input.confirmed && input.confirmed.length ? [
-      `Create an ingestion script under "${input.ingestDir}/" at the repo root.`,
+      `Write the ingestion script in ${profile2.displayName}, at "${ingestScriptDir(profile2)}/" 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. ${profile2.envReadInstruction} The wizard sets these when it runs the script.`,
+      `Use the official Algolia ${profile2.displayName} client (${profile2.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", profile2.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)"}.`,
@@ -3651,8 +4442,7 @@ 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."
   ];
 }
@@ -3660,7 +4450,7 @@ function verificationInstructions(input) {
   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.",
@@ -3715,8 +4505,8 @@ function formatSummary(useCase, summary) {
   const label = useCase === "ingestion" ? "Ingestion" : useCase === "search" ? "Search" : "Verification";
   return `${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+)/);
@@ -3798,7 +4588,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;
@@ -3822,7 +4612,7 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
       const copied = await copyUploadIntoWorktree(
         repoRoot,
         worktree,
-        INGEST_DIR,
+        INGEST_DIR2,
         uploadSourcePath ?? ""
       );
       if (copied.ok) {
@@ -3836,26 +4626,59 @@ 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(DEFAULT_LANGUAGE_ID)
+    );
+    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),
-      ingestDir: INGEST_DIR,
+      searchEnvVars: searchEnvVars(language, searchStrategy, appId, searchKey),
+      ingestDir: INGEST_DIR2,
       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 = searchStrategy === "cdn-template" || searchStrategy === "none" ? void 0 : ingestionProfile.id === DEFAULT_LANGUAGE_ID ? toolchain : await resolveToolchain(
+      worktree,
+      LANGUAGE_PROFILES[DEFAULT_LANGUAGE_ID]
+    );
+    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;
@@ -3874,13 +4697,16 @@ 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;
@@ -3897,15 +4723,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" && !installFailed) {
         ctx.clearNotices();
         const runNow = await ctx.requestUserInput({
           prompt: `Run the ingestion script now? This writes records to the "${targetIndex}" index.`,
@@ -3917,13 +4744,13 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
           const profile2 = 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 run = await runIngestScript(
             worktree,
-            ingestRuntime,
+            toolchain,
             ingestEntrypoint,
             {
               [APP_ID_VAR]: profile2.appId,
@@ -3937,7 +4764,7 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
             ingestRecordCount = parseIngestRecordCount(run.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
               });
@@ -3950,7 +4777,7 @@ async function implement(ctx, useCases = DEFAULT_IMPLEMENT_USE_CASES, existingWo
             outcomeMessage = `\u26A0\uFE0F The ingestion script did not run: ${run.reason}`;
             logger.warn(
               {
-                runtime: ingestRuntime,
+                language: ingestionProfile.id,
                 entrypoint: ingestEntrypoint,
                 reason: run.reason
               },
@@ -3973,7 +4800,7 @@ ${run.output}` : status;
             outcomeMessage = `\u274C Ingestion failed.${run.output ? ` ${run.output}` : ""}`;
             logger.warn(
               {
-                runtime: ingestRuntime,
+                language: ingestionProfile.id,
                 entrypoint: ingestEntrypoint,
                 output: run.output
               },
@@ -3990,10 +4817,15 @@ ${run.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.`
+          );
+        }
       }
       await ctx.requestUserInput({
         // No question being asked here, just an acknowledgement — the
@@ -4004,7 +4836,21 @@ ${run.output}` : status;
         messages: ingestOutcomeMessage ? [ingestOutcomeMessage, ...commandMessages] : commandMessages
       });
     }
-    if (useCases.includes("search")) {
+    const skipSearch = useCases.includes("search") && input.searchStrategy === "none";
+    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).`
+      );
+      ctx.setUserInput("implementation", "success");
+      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++) {
@@ -4077,7 +4923,7 @@ ${run.output}` : status;
     }
     if (installFailed) {
       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 ${ingestionProfile.displayName} dependencies in the worktree before the command below, or it will fail on a missing package.`
       );
     }
     return {
@@ -4085,10 +4931,10 @@ ${run.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,