@posthog/wizard 2.83.0 → 2.84.0

package/dist/{posthog-integration-DxRkw5DI.js → posthog-integration-mIQGBc1f.js}

@@ -1,25 +1,26 @@
 import { n as ErrorCodes } from "./emit-BqLCdV8Y.js";
-import { c as WIZARD_LOG_FILE, f as VERSION, h as RUN_SURFACE, i as getLogFilePath, o as logToFile, s as WIZARD_BENCHMARK_FILE, t as configureLogFile, v as runtimeEnv } from "./debug-BTUMatFI.js";
-import { $ as WIZARD_PROVISIONING_SCOPES, E as Harness, H as SETUP_REPORT_FILE, J as WIZARD_INTERACTION_EVENT_NAME, K as WIZARD_CONTACT_EMAIL, N as POSTHOG_DOCS_URL, O as Integration, Q as WIZARD_ORCHESTRATOR_SEEDED_TASKS_FLAG_KEY, S as GPT5_6_TERRA_MODEL, U as SONNET_5_MODEL, W as Sequence, X as WIZARD_ORCHESTRATOR_FLAG_KEY, Y as WIZARD_OAUTH_SCOPES, Z as WIZARD_ORCHESTRATOR_OVERRIDE_FLAG_KEY, a as ciExcludedTaskTypes, b as GPT5_6_LUNA_MODEL, c as AGENTIC_DETECTION_RETRY_TIMEOUT_MS, it as getSkillsBaseUrl, n as analytics, nt as WIZARD_SELF_DRIVING_USE_PI_HARNESS_FLAG_KEY, o as mayReportScanResults, p as DETECTION_TIMEOUT_MS, s as AGENTIC_DETECTION_FIRST_ATTEMPT_TIMEOUT_MS, v as EVENT_PLAN_FILE, w as HAIKU_MODEL, x as GPT5_6_SOL_MODEL } from "./analytics-GQv--mQm.js";
-import { a as WizardError, r as skillErrorCode, t as classifyRunFailure } from "./errors-DhFeR8Sp.js";
-import { r as withUtm, t as openTrackedLink } from "./links-5Blqk4Im.js";
-import { a as safeReadFile, i as readProjectFile, n as boundedGlob, o as walkProjectFiles } from "./bounded-fs-B31zq2ir.js";
-import { n as detectNodePackageManagers, t as detectAllPackageManagers } from "./package-manager-BqRNp5y_.js";
-import { n as getInstalledPackageVersion, r as hasDeclaredDependency, t as getDeclaredVersion } from "./package-json-2UrhE6kP.js";
-import { i as createVersionBucket, n as isUsingTypeScript, r as tryGetPackageJson } from "./setup-utils-B5E1rXLa.js";
-import { n as currentAccessToken } from "./oauth-session-CfkZ339p.js";
-import { f as gatewayAuth, m as useRunGatewayCredential, s as AgentSignals } from "./gateway-CJ8Jqbll.js";
-import { a as requireKnownModel, o as triageModelFor, r as isValidModel } from "./models-CLTglHFZ.js";
-import { R as WIZARD_TOOL_NAMES, at as isEnvFileName, ct as createTriageLLMProvider, et as createWizardAskBridge, i as runAgent$1, it as MAX_ENV_KEY_SET, n as buildRunTags, nt as LONGER_ASK_TIMEOUT_MS, ot as parseEnvKeyNames, p as registerCleanup, r as initializeAgent, rt as shouldDisableAsk, st as toPromptSafeRelativePath } from "./agent-interface-fcDXqb-_.js";
-import { n as mcpUrlFor } from "./host-resolution-Cht8bL39.js";
-import { a as piBackend, d as createEmitLog, f as createEmitSpinner, p as createProgressCollector, u as createAioCapture } from "./pi-2pYz2OY3.js";
-import { _ as TaskStatus, f as uncoveredBySink, g as SkipReason, h as QueueStore, m as QUEUE_DIR_NAME, u as dependencyClosure } from "./queue-tools-10w8lhEs.js";
-import { a as flushScanReport, p as scanInstalledSkill$1, s as formatYaraAbortMessage, v as installSkillById, y as fetchSkillMenu } from "./yara-hooks-BPYhN9WM.js";
-import { a as assembleTaskPrompt, d as taskModelSpec, i as assembleSeedPrompt, n as agentRunTools, o as loadAgentRegistry, s as promptModelFor, t as ASK_TOOL, u as resolveTask } from "./agent-prompt-loader-F9gGPMt0.js";
-import { r as requestDeepLink } from "./provisioning-c5JJ30KX.js";
+import { c as WIZARD_LOG_FILE, f as VERSION, h as RUN_SURFACE, i as getLogFilePath, o as logToFile, s as WIZARD_BENCHMARK_FILE, t as configureLogFile, v as runtimeEnv } from "./debug-BfO_Txo8.js";
+import { $ as WIZARD_ORCHESTRATOR_SEEDED_TASKS_FLAG_KEY, C as GPT5_6_TERRA_MODEL, D as Harness, G as Sequence, P as POSTHOG_DOCS_URL, Q as WIZARD_ORCHESTRATOR_OVERRIDE_FLAG_KEY, S as GPT5_6_SOL_MODEL, T as HAIKU_MODEL, U as SETUP_REPORT_FILE, W as SONNET_5_MODEL, X as WIZARD_OAUTH_SCOPES, Y as WIZARD_INTERACTION_EVENT_NAME, Z as WIZARD_ORCHESTRATOR_FLAG_KEY, a as ciExcludedTaskTypes, at as getSkillsBaseUrl, c as AGENTIC_DETECTION_FIRST_ATTEMPT_TIMEOUT_MS, et as WIZARD_PROVISIONING_SCOPES, it as WIZARD_USER_AGENT, k as Integration, l as AGENTIC_DETECTION_RETRY_TIMEOUT_MS, m as DETECTION_TIMEOUT_MS, n as analytics, o as mayReportScanResults, q as WIZARD_CONTACT_EMAIL, rt as WIZARD_SELF_DRIVING_USE_PI_HARNESS_FLAG_KEY, s as reportableDiscoveredFeatures, x as GPT5_6_LUNA_MODEL, y as EVENT_PLAN_FILE } from "./analytics-Drox5LSW.js";
+import { a as WizardError, r as skillErrorCode, t as classifyRunFailure } from "./errors-BXlWujEw.js";
+import { r as withUtm, t as openTrackedLink } from "./links-CatXPRxH.js";
+import { a as safeReadFile, i as readProjectFile, n as boundedGlob, o as walkProjectFiles } from "./bounded-fs-TRL6IsoU.js";
+import { n as detectNodePackageManagers, t as detectAllPackageManagers } from "./package-manager-B-9I_fAT.js";
+import { n as getInstalledPackageVersion, r as hasDeclaredDependency, t as getDeclaredVersion } from "./package-json-z1agAYXs.js";
+import { i as createVersionBucket, n as isUsingTypeScript, r as tryGetPackageJson } from "./setup-utils-CQY8PHjR.js";
+import { n as currentAccessToken } from "./oauth-session-9EU3ky0v.js";
+import { c as AgentSignals, h as useRunGatewayCredential, p as gatewayAuth } from "./gateway-CLQQb96F.js";
+import { a as requireKnownModel, o as triageModelFor, r as isValidModel } from "./models-B0huHItG.js";
+import { R as WIZARD_TOOL_NAMES, at as isEnvFileName, ct as createTriageLLMProvider, et as createWizardAskBridge, i as runAgent$1, it as MAX_ENV_KEY_SET, n as buildRunTags, nt as LONGER_ASK_TIMEOUT_MS, ot as parseEnvKeyNames, p as registerCleanup, r as initializeAgent, rt as shouldDisableAsk, st as toPromptSafeRelativePath } from "./agent-interface-BNssNetq.js";
+import { s as resolveBaseUrl } from "./urls-WeqfBLP4.js";
+import { n as mcpUrlFor } from "./host-resolution-DftfSjJD.js";
+import { a as piBackend, d as createEmitLog, f as createEmitSpinner, p as createProgressCollector, u as createAioCapture } from "./pi-BSnSk6rv.js";
+import { _ as TaskStatus, f as uncoveredBySink, g as SkipReason, h as QueueStore, m as QUEUE_DIR_NAME, u as dependencyClosure } from "./queue-tools-PFG6H93Q.js";
+import { a as flushScanReport, b as fetchSkillMenu, m as scanInstalledSkill$1, s as formatYaraAbortMessage, y as installSkillById } from "./yara-hooks-aDbdsitJ.js";
+import { a as assembleTaskPrompt, c as promptModelFor, d as resolveTask, f as taskModelSpec, i as assembleSeedPrompt, n as agentRunTools, o as detectedFacts, s as loadAgentRegistry, t as ASK_TOOL } from "./agent-prompt-loader-iV11XVEF.js";
+import { r as requestDeepLink } from "./provisioning-CHUjae9V.js";
 import * as semver from "semver";
 import { major, minVersion } from "semver";
-import fs, { cpSync, existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from "fs";
+import fs, { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from "fs";
 import * as path$3 from "path";
 import path, { isAbsolute, join, relative, resolve, sep } from "path";
 import * as path$2 from "node:path";
@@ -27,7 +28,7 @@ import { execSync } from "node:child_process";
 import * as fs$2 from "node:fs";
 import fg from "fast-glob";
 import fs$1 from "fs/promises";
-import { randomUUID } from "crypto";
+import { createHash, randomUUID } from "crypto";
 import { z } from "zod";
 import { zodToJsonSchema } from "zod-to-json-schema";
 //#region src/agent/runner/shared/bootstrap.ts
@@ -1473,7 +1474,7 @@ Important: You must read a file immediately before attempting to write it, even
 */
 function assemblePrompt(runDef, ctx) {
 	const parts = [];
-	parts.push(defaultProjectPrompt(ctx));
+	parts.push(defaultProjectPrompt(ctx) + detectedFacts(ctx.facts));
 	if (runDef.customPrompt) parts.push(runDef.customPrompt(ctx));
 	if (ctx.skillPath) parts.push(skillPrompt(ctx.skillPath, runDef.reportFile));
 	return parts.join("\n\n");
@@ -1583,6 +1584,7 @@ async function executeLinear({ config, input, boot, emit, interaction, signal, t
 		projectApiKey,
 		host,
 		skillPath,
+		facts: config.projectFacts?.() ?? [],
 		orgAiDataProcessingApproved: input.apiUser?.organization?.is_ai_data_processing_approved ?? null,
 		teamProductOptIns: project ? {
 			sessionReplay: project.session_recording_opt_in ?? null,
@@ -2517,7 +2519,8 @@ or integrate manually here:
 		projectApiKey: boot.credentials.projectApiKey,
 		host: boot.credentials.host,
 		examplePath,
-		commandmentsPath
+		commandmentsPath,
+		facts: config.projectFacts?.() ?? []
 	};
 	logToFile(`[orchestrator] START program=${programId} dir=${input.installDir} run=${runId}`);
 	analytics.wizardCapture("orchestrator started", { program_id: programId });
@@ -3247,7 +3250,7 @@ function safeErrorMessage(error) {
 * chunk does not grow.
 */
 async function scanInstalledSkill(skillDir, llmProvider) {
-	return (await import("./yara-hooks-BwhEDXIt.js")).scanInstalledSkill(skillDir, llmProvider);
+	return (await import("./yara-hooks-MDtFbuoM.js")).scanInstalledSkill(skillDir, llmProvider);
 }
 /**
 * The MCP tutorial's prompt stream: one prompt against the PostHog MCP server,
@@ -3256,7 +3259,7 @@ async function scanInstalledSkill(skillDir, llmProvider) {
 * startup chunk does not grow.
 */
 async function* streamMcpPrompt(args) {
-	yield* (await import("./mcp-prompt-streaming-B5lIQ0l1.js")).streamMcpPrompt(args);
+	yield* (await import("./mcp-prompt-streaming-M6UnLgGX.js")).streamMcpPrompt(args);
 }
 //#endregion
 //#region src/programs/frameworks/python/utils.ts
@@ -6754,6 +6757,42 @@ async function loadWizardFlags() {
 	};
 }
 //#endregion
+//#region src/programs/codebase-scan/tags.ts
+/**
+* Analytics tags a program derives from the codebase scan. They are scan
+* results, so they leave the machine under the same consent as the scan
+* report. Local suggestions read the scan itself and never wait on this.
+*/
+/** frameworkContext key holding the tags, kept until sharing is granted. */
+const SCAN_TAGS_KEY = "codebaseScanTags";
+/** Scan results may leave the machine: sharing is granted and telemetry is on. */
+function maySendScanResults(session) {
+	return !session.noTelemetry && mayReportScanResults(session);
+}
+function getScanTags(session) {
+	return session.frameworkContext["codebaseScanTags"] ?? {};
+}
+function setTags(tags) {
+	for (const [key, value] of Object.entries(tags)) analytics.setTag(key, value);
+}
+/**
+* Tag later analytics events with what the scan found. A CI or headless run
+* starts with sharing granted, so the tags apply at once. An interactive run
+* keeps them until `reportCodebaseScan` sees the user grant sharing.
+*/
+function tagScanResults(session, setFrameworkContext, tags) {
+	const merged = {
+		...getScanTags(session),
+		...tags
+	};
+	setFrameworkContext(SCAN_TAGS_KEY, merged);
+	if (maySendScanResults(session)) setTags(merged);
+}
+/** Apply the kept tags once sharing is granted. Setting a tag twice is harmless. */
+function applyScanTags(session) {
+	if (maySendScanResults(session)) setTags(getScanTags(session));
+}
+//#endregion
 //#region src/programs/detection/agentic.ts
 /**
 * Agentic project detection.
@@ -6981,8 +7020,14 @@ function reachesUi(event) {
 /** Scan through `runAgent` with the bound triage model, then the SDK fallback. */
 async function detectProjectsWithAgent(session, options) {
 	if (!session.credentials) throw new Error("Detection requires authenticated credentials.");
-	const { targets, programId, purpose = "set up a PostHog integration", recommend = false, rerankIds, onEvent, onProgress } = options;
 	const flags = await loadWizardFlags();
+	null?.getDecisionsMode(flags.flags);
+	return await scanProjectsWithAgent(session, options, flags);
+}
+/** The agent run behind {@link detectProjectsWithAgent}. */
+async function scanProjectsWithAgent(session, options, flags) {
+	if (!session.credentials) throw new Error("Detection requires authenticated credentials.");
+	const { targets, programId, purpose = "set up a PostHog integration", recommend = false, rerankIds, onEvent, onProgress } = options;
 	const reportSchema = detectionReportSchema(recommend);
 	const schema = zodToJsonSchema(reportSchema);
 	const config = {
@@ -7291,2475 +7336,645 @@ function extractTomlSectionKeys(sectionBody, opts = {}) {
 	return depNames;
 }
 //#endregion
-//#region src/programs/warehouse-sources/registry.ts
-const CORE_SOURCE_DETECTORS = [
-	{
-		kind: "Postgres",
-		label: "PostgreSQL",
-		mode: "in-cli",
-		signals: {
-			npm: [
-				"pg",
-				"postgres",
-				"postgres.js",
-				"knex",
-				"sequelize"
-			],
-			python: [
-				"psycopg",
-				"psycopg2",
-				"psycopg2-binary",
-				"asyncpg"
-			],
-			ruby: ["pg"],
-			envKeys: [
-				/^DATABASE_URL$/,
-				/^POSTGRES_/,
-				/^PG(HOST|DATABASE|USER|PORT)$/
-			]
-		},
-		supersededBy: ["Neon", "Supabase"]
-	},
-	{
-		kind: "MySQL",
-		label: "MySQL",
-		mode: "in-cli",
-		signals: {
-			npm: ["mysql", "mysql2"],
-			python: [
-				"pymysql",
-				"mysqlclient",
-				"mysql-connector-python"
-			],
-			ruby: ["mysql2"],
-			envKeys: [/^MYSQL_/]
-		}
-	},
-	{
-		kind: "MongoDB",
-		label: "MongoDB",
-		mode: "in-cli",
-		signals: {
-			npm: ["mongodb", "mongoose"],
-			python: ["pymongo", "motor"],
-			ruby: ["mongo", "mongoid"],
-			envKeys: [/^MONGO(DB)?_/]
-		}
-	},
-	{
-		kind: "Snowflake",
-		label: "Snowflake",
-		mode: "in-cli",
-		signals: {
-			npm: ["snowflake-sdk"],
-			python: ["snowflake-connector-python", "snowflake-sqlalchemy"],
-			envKeys: [/^SNOWFLAKE_/]
-		}
-	},
-	{
-		kind: "BigQuery",
-		label: "BigQuery",
-		mode: "deep-link",
-		signals: {
-			npm: ["@google-cloud/bigquery"],
-			python: ["google-cloud-bigquery"],
-			envKeys: [/^BIGQUERY_/]
-		}
-	},
-	{
-		kind: "Redshift",
-		label: "Redshift",
-		mode: "in-cli",
-		signals: {
-			npm: ["node-redshift"],
-			python: ["redshift-connector"],
-			envKeys: [/^REDSHIFT_/]
-		}
-	},
-	{
-		kind: "MSSQL",
-		label: "SQL Server",
-		mode: "in-cli",
-		signals: {
-			npm: ["mssql", "tedious"],
-			python: ["pyodbc", "pymssql"],
-			envKeys: [/^MSSQL_/]
-		}
-	},
-	{
-		kind: "Supabase",
-		label: "Supabase",
-		mode: "in-cli",
-		signals: {
-			npm: ["@supabase/supabase-js"],
-			python: ["supabase"],
-			envKeys: [/^SUPABASE_/]
-		}
-	},
-	{
-		kind: "ClickHouse",
-		label: "ClickHouse",
-		mode: "in-cli",
-		signals: {
-			npm: ["@clickhouse/client"],
-			python: ["clickhouse-connect", "clickhouse-driver"],
-			envKeys: [/^CLICKHOUSE_/]
-		}
-	},
-	{
-		kind: "Convex",
-		label: "Convex",
-		mode: "in-cli",
-		signals: {
-			npm: ["convex"],
-			python: ["convex"],
-			envKeys: [/^CONVEX_/, /^NEXT_PUBLIC_CONVEX_URL$/]
-		}
-	},
-	{
-		kind: "Firebase",
-		label: "Firebase",
-		mode: "deep-link",
-		signals: {
-			npm: ["firebase-admin", "firebase"],
-			python: ["firebase-admin"],
-			envKeys: [/^FIREBASE_/, /^NEXT_PUBLIC_FIREBASE_/]
-		}
-	},
-	{
-		kind: "Neon",
-		label: "Neon",
-		mode: "in-cli",
-		signals: {
-			npm: ["@neondatabase/serverless"],
-			envKeys: [/^NEON_/]
-		}
-	},
-	{
-		kind: "PlanetScaleMySQL",
-		label: "PlanetScale MySQL",
-		mode: "in-cli",
-		signals: {
-			npm: ["@planetscale/database"],
-			envKeys: [/^PLANETSCALE_/]
-		}
-	},
-	{
-		kind: "DynamoDB",
-		label: "DynamoDB",
-		mode: "in-cli",
-		signals: {
-			npm: ["@aws-sdk/client-dynamodb", "@aws-sdk/lib-dynamodb"],
-			python: ["pynamodb"]
-		}
-	},
-	{
-		kind: "Motherduck",
-		label: "MotherDuck",
-		mode: "in-cli",
-		signals: {
-			npm: ["@motherduck/wasm-client"],
-			envKeys: [/^MOTHERDUCK_/]
-		}
-	},
-	{
-		kind: "Databricks",
-		label: "Databricks",
-		mode: "in-cli",
-		signals: {
-			npm: ["@databricks/sql"],
-			python: ["databricks-sql-connector", "databricks-sdk"],
-			envKeys: [/^DATABRICKS_/]
-		}
-	},
-	{
-		kind: "Singlestore",
-		label: "SingleStore",
-		mode: "in-cli",
-		signals: {
-			python: ["singlestoredb"],
-			envKeys: [/^SINGLESTORE_/]
-		}
-	},
-	{
-		kind: "Stripe",
-		label: "Stripe",
-		mode: "in-cli",
-		signals: {
-			npm: [
-				"stripe",
-				"@stripe/stripe-js",
-				"@stripe/react-stripe-js"
-			],
-			python: ["stripe"],
-			ruby: ["stripe"],
-			envKeys: [/^STRIPE_(SECRET|API)_KEY$/]
-		}
-	},
-	{
-		kind: "Clerk",
-		label: "Clerk",
-		mode: "in-cli",
-		signals: {
-			npm: [
-				"@clerk/nextjs",
-				"@clerk/clerk-react",
-				"@clerk/backend",
-				"@clerk/express",
-				"@clerk/fastify",
-				"@clerk/remix"
-			],
-			envKeys: [/^CLERK_SECRET_KEY$/, /^NEXT_PUBLIC_CLERK_/]
-		}
-	},
-	{
-		kind: "Resend",
-		label: "Resend",
-		mode: "in-cli",
-		signals: {
-			npm: ["resend"],
-			python: ["resend"],
-			envKeys: [/^RESEND_API_KEY$/]
-		}
-	},
-	{
-		kind: "Shopify",
-		label: "Shopify",
-		mode: "in-cli",
-		signals: {
-			npm: ["@shopify/shopify-api", "shopify-api-node"],
-			python: ["shopifyapi"],
-			envKeys: [/^SHOPIFY_/]
-		}
-	},
-	{
-		kind: "Klaviyo",
-		label: "Klaviyo",
-		mode: "in-cli",
-		signals: {
-			npm: ["klaviyo-api"],
-			python: ["klaviyo-api"],
-			envKeys: [/^KLAVIYO_/]
-		}
-	},
-	{
-		kind: "Chargebee",
-		label: "Chargebee",
-		mode: "in-cli",
-		signals: {
-			npm: ["chargebee"],
-			python: ["chargebee"],
-			envKeys: [/^CHARGEBEE_/]
-		}
-	},
-	{
-		kind: "Paddle",
-		label: "Paddle",
-		mode: "in-cli",
-		signals: {
-			npm: ["@paddle/paddle-node-sdk", "@paddle/paddle-js"],
-			envKeys: [/^PADDLE_/]
-		}
-	},
-	{
-		kind: "Polar",
-		label: "Polar",
-		mode: "in-cli",
-		signals: {
-			npm: ["@polar-sh/sdk", "@polar-sh/nextjs"],
-			envKeys: [/^POLAR_/]
-		}
-	},
-	{
-		kind: "Mailchimp",
-		label: "Mailchimp",
-		mode: "in-cli",
-		signals: {
-			npm: ["@mailchimp/mailchimp_marketing"],
-			python: ["mailchimp-marketing"],
-			envKeys: [/^MAILCHIMP_/]
-		}
-	},
-	{
-		kind: "CustomerIO",
-		label: "Customer.io",
-		mode: "in-cli",
-		signals: {
-			npm: ["customerio-node"],
-			python: ["customerio"],
-			envKeys: [/^CUSTOMER_?IO_/]
+//#region src/programs/codebase-scan/fingerprint.ts
+/**
+* `host/path` for a git remote, lowercased, with no scheme, user, port or
+* `.git`: `git@github.com:PostHog/wizard.git` → `github.com/posthog/wizard`.
+*/
+function normalizeGitRemote(remote) {
+	let value = remote.trim().toLowerCase();
+	const scheme = /^[a-z][a-z0-9+.-]*:\/\//.exec(value);
+	if (scheme) value = value.slice(scheme[0].length);
+	else value = value.replace(/^([^/:]+):/, "$1/");
+	value = value.replace(/^[^@/]+@/, "");
+	value = value.replace(/^([^/:]+):\d+\//, "$1/");
+	return value.replace(/\/+$/, "").replace(/\.git$/, "");
+}
+/** How far up from the install dir to look for the repository root. */
+const MAX_PARENT_DIRS = 64;
+/** Git's own files are small. Anything larger at these paths is not one. */
+const MAX_GIT_FILE_BYTES = 64 * 1024;
+/**
+* A git file's text, or null unless it is a regular file under the size cap.
+* The project controls these paths, and a FIFO or device there would block
+* the read.
+*/
+function readGitFile(file) {
+	try {
+		const stats = statSync(file);
+		if (!stats.isFile() || stats.size > MAX_GIT_FILE_BYTES) return null;
+		return readFileSync(file, "utf8");
+	} catch {
+		return null;
+	}
+}
+/** The real path of `target` when it is `realRoot` or inside it, else null. */
+function realPathWithin(target, realRoot) {
+	try {
+		const real = realpathSync(target);
+		const relative = path.relative(realRoot, real);
+		return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative) ? real : null;
+	} catch {
+		return null;
+	}
+}
+function isDirectory(target) {
+	try {
+		return statSync(target).isDirectory();
+	} catch {
+		return false;
+	}
+}
+/**
+* The repository root above `installDir` and the git directory holding its
+* config, found by walking up. A `.git` file (worktree or submodule) points at
+* the real git directory, and a worktree's `commondir` points at the shared one.
+*
+* The project chooses what those pointers say, so one is followed only to a
+* place inside the install dir. Otherwise there is no repository to read, and
+* the fingerprint falls back to the install dir's path.
+*/
+function findGitConfigDir(installDir) {
+	let realInstallDir;
+	try {
+		realInstallDir = realpathSync(installDir);
+	} catch {
+		return null;
+	}
+	let dir = path.resolve(installDir);
+	for (let depth = 0; depth < MAX_PARENT_DIRS; depth += 1) {
+		const dotGit = path.join(dir, ".git");
+		let gitDir = null;
+		if (isDirectory(dotGit)) gitDir = dotGit;
+		else {
+			const pointer = /^gitdir:\s*(.+)$/m.exec(readGitFile(dotGit) ?? "");
+			if (pointer) {
+				gitDir = realPathWithin(path.resolve(dir, pointer[1].trim()), realInstallDir);
+				if (!gitDir) return null;
+			}
 		}
-	},
-	{
-		kind: "Typeform",
-		label: "Typeform",
-		mode: "in-cli",
-		signals: {
-			npm: ["@typeform/api-client"],
-			envKeys: [/^TYPEFORM_/]
+		if (gitDir) {
+			const common = readGitFile(path.join(gitDir, "commondir"))?.trim();
+			if (!common) return {
+				root: dir,
+				gitDir
+			};
+			const commonDir = realPathWithin(path.resolve(gitDir, common), realInstallDir);
+			return commonDir ? {
+				root: dir,
+				gitDir: commonDir
+			} : null;
 		}
-	},
-	{
-		kind: "Sentry",
-		label: "Sentry",
-		mode: "in-cli",
-		signals: {
-			npm: [
-				"@sentry/node",
-				"@sentry/browser",
-				"@sentry/react",
-				"@sentry/nextjs"
-			],
-			python: ["sentry-sdk"],
-			ruby: ["sentry-ruby"]
+		const parent = path.dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+	return null;
+}
+/**
+* The repository's root and `origin` URL, read from its config file. Read
+* directly rather than through `git`: on Windows, running a bare `git` from
+* the project directory can launch a `git.exe` committed to the repository.
+*/
+function readRepository(installDir) {
+	const found = findGitConfigDir(installDir);
+	if (!found) return null;
+	const config = readGitFile(path.join(found.gitDir, "config"));
+	if (!config) return null;
+	let inOrigin = false;
+	for (const raw of config.split("\n")) {
+		const line = raw.trim();
+		const section = /^\[([^\]]+)\]$/.exec(line);
+		if (section) {
+			inOrigin = /^remote\s+"origin"$/.test(section[1].trim());
+			continue;
 		}
-	},
-	{
-		kind: "Plaid",
-		label: "Plaid",
-		mode: "in-cli",
-		signals: {
-			npm: ["plaid"],
-			python: ["plaid-python", "plaid"],
-			ruby: ["plaid"],
-			envKeys: [/^PLAID_/]
+		if (!inOrigin) continue;
+		const remote = /^url\s*=\s*(.+)$/.exec(line)?.[1].trim();
+		if (remote) return {
+			remote,
+			root: found.root
+		};
+	}
+	return null;
+}
+/**
+* Identifies the scanned codebase within a project, so two repos, or two apps
+* in one monorepo, sending scans to one project don't mark each other's tools
+* as removed. Salted with the project ID so the hash can't be matched to a
+* public repo name across projects.
+*/
+function workspaceFingerprint(projectId, installDir, findRepository = readRepository) {
+	const absolute = path.resolve(installDir);
+	const repository = findRepository(absolute);
+	const workspace = repository ? `${normalizeGitRemote(repository.remote)}:${repositoryPath(repository.root, absolute)}` : absolute;
+	return createHash("sha256").update(`${projectId}:${workspace}`).digest("hex");
+}
+/** The install dir's path from the repository root, with POSIX separators; `.` for the root. */
+function repositoryPath(root, installDir) {
+	const relative = path.relative(root, installDir);
+	return relative ? relative.split(path.sep).join("/") : ".";
+}
+//#endregion
+//#region src/programs/warehouse-sources/manifests.ts
+/**
+* Dependency-name parsers for the manifests of every ecosystem the wizard
+* installs into. Each returns package names in the form the PostHog tool
+* catalog lists them for that ecosystem. Regex-based on purpose: a manifest is
+* read for names only, so a full parser per language buys nothing, and a
+* malformed file yields fewer names instead of an error.
+*/
+/**
+* Crate names from `Cargo.toml` dependency tables: `[dependencies]`,
+* `[dev-dependencies]`, `[build-dependencies]`, `[workspace.dependencies]`,
+* target-specific tables, and the `[dependencies.<name>]` form. Dotted keys
+* (`sentry.workspace = true`) name their crate. A renamed dependency
+* (`alias = { package = "real" }`, `alias.package = "real"`, or a
+* `[dependencies.alias]` table with `package = "real"`) reports the real crate.
+*/
+function parseCargoToml(content) {
+	const crates = /* @__PURE__ */ new Map();
+	const add = (key, crate) => {
+		if (crate !== void 0) crates.set(key, crate);
+		else if (!crates.has(key)) crates.set(key, key);
+	};
+	let inDeps = false;
+	let tableDep = null;
+	for (const raw of content.split("\n")) {
+		const line = raw.trim();
+		const header = /^\[\[?([^\]]+)\]\]?\s*(?:#.*)?$/.exec(line);
+		if (header) {
+			const table = header[1].trim();
+			const named = /(?:^|\.)(?:dev-|build-)?dependencies\.([A-Za-z0-9_-]+)$/.exec(table);
+			tableDep = named ? named[1] : null;
+			if (tableDep) add(tableDep);
+			inDeps = /(?:^|\.)(?:dev-|build-)?dependencies$/.test(table);
+			continue;
 		}
-	},
-	{
-		kind: "Braintree",
-		label: "Braintree",
-		mode: "in-cli",
-		signals: {
-			npm: ["braintree"],
-			python: ["braintree"],
-			ruby: ["braintree"],
-			envKeys: [/^BRAINTREE_/]
+		if (tableDep) {
+			const renamed = /^package\s*=\s*"([^"]+)"/.exec(line);
+			if (renamed) add(tableDep, renamed[1]);
+			continue;
 		}
-	},
-	{
-		kind: "Square",
-		label: "Square",
-		mode: "in-cli",
-		signals: {
-			npm: ["square"],
-			python: ["squareup"],
-			ruby: ["square"],
-			envKeys: [/^SQUARE_/]
+		if (!inDeps) continue;
+		const entry = /^([A-Za-z0-9_-]+)(\.[A-Za-z0-9_-]+)?\s*=(.*)$/.exec(line);
+		if (!entry) continue;
+		const [, key, subkey, value] = entry;
+		let renamed = null;
+		if (subkey === ".package") renamed = /^\s*"([^"]+)"/.exec(value);
+		else if (!subkey) renamed = /\bpackage\s*=\s*"([^"]+)"/.exec(value);
+		add(key, renamed?.[1]);
+	}
+	return [...new Set(crates.values())];
+}
+/** Pod names from a `Podfile`; a subspec (`Firebase/Analytics`) reports its pod. */
+function parsePodfile(content) {
+	return [...content.matchAll(/^\s*pod\s+['"]([^'"/]+)/gm)].map((m) => m[1]);
+}
+/** `composer.json` `require` and `require-dev` keys, minus PHP itself and extensions. */
+function parseComposerJson(content) {
+	let manifest;
+	try {
+		manifest = JSON.parse(content);
+	} catch {
+		return [];
+	}
+	if (typeof manifest !== "object" || manifest === null) return [];
+	const names = [];
+	for (const section of ["require", "require-dev"]) {
+		const deps = manifest[section];
+		if (typeof deps !== "object" || deps === null) continue;
+		for (const name of Object.keys(deps)) {
+			if (name === "php" || name.startsWith("ext-")) continue;
+			names.push(name.toLowerCase());
+		}
+	}
+	return names;
+}
+/**
+* Module paths from `go.mod` `require` lines and blocks, without `// indirect`
+* requirements (a dependency of a dependency says little about the project).
+* A final `/vN` major-version element is dropped, so `stripe-go/v82` matches
+* the catalog's `stripe-go`. Case is kept: Go module paths are case-sensitive.
+*/
+function parseGoMod(content) {
+	const names = [];
+	let inBlock = false;
+	for (const raw of content.split("\n")) {
+		const line = raw.trim();
+		if (inBlock) {
+			if (line.startsWith(")")) {
+				inBlock = false;
+				continue;
+			}
+			addGoRequirement(line, names);
+		} else if (/^require\s*\(\s*(?:\/\/.*)?$/.test(line)) inBlock = true;
+		else if (line.startsWith("require ")) addGoRequirement(line.slice(8).trim(), names);
+	}
+	return names;
+}
+function addGoRequirement(line, names) {
+	if (!line || line.startsWith("//") || /\/\/\s*indirect\b/.test(line)) return;
+	const modulePath = line.split(/\s+/)[0];
+	names.push(modulePath.replace(/\/v\d+$/, ""));
+}
+/** Hex package names from `mix.exs` dependency tuples, e.g. `{:sentry, "~> 10.0"}`. */
+function parseMixExs(content) {
+	return [...content.matchAll(/\{\s*:([a-z][a-z0-9_]*)\s*,/g)].map((m) => m[1]);
+}
+const MAVEN_COORDINATE = /['"]([A-Za-z0-9_.-]+):([A-Za-z0-9_.-]+)(?::[^'"\s]*)?['"]/g;
+const GRADLE_MAP_NOTATION = /group\s*[:=]\s*['"]([^'"]+)['"]\s*,\s*name\s*[:=]\s*['"]([^'"]+)['"]/g;
+/** `group:artifact` coordinates from `build.gradle` or `build.gradle.kts`. */
+function parseGradleBuild(content) {
+	const names = [];
+	for (const m of content.matchAll(MAVEN_COORDINATE)) names.push(`${m[1]}:${m[2]}`);
+	for (const m of content.matchAll(GRADLE_MAP_NOTATION)) names.push(`${m[1]}:${m[2]}`);
+	return names;
+}
+/** `group:artifact` coordinates from a Gradle version catalog (`libs.versions.toml`). */
+function parseGradleVersionCatalog(content) {
+	const names = [];
+	for (const m of content.matchAll(/\bmodule\s*=\s*"([^":]+):([^":]+)"/g)) names.push(`${m[1]}:${m[2]}`);
+	for (const m of content.matchAll(GRADLE_MAP_NOTATION)) names.push(`${m[1]}:${m[2]}`);
+	for (const m of content.matchAll(/^\s*[A-Za-z0-9_.-]+\s*=\s*"([^":\s]+):([^":\s]+):[^"]*"/gm)) names.push(`${m[1]}:${m[2]}`);
+	return names;
+}
+/**
+* `groupId:artifactId` for each `<dependency>` in a `pom.xml`. Split on the
+* opening tag rather than matched lazily, which would rescan the rest of the
+* file for every unclosed `<dependency>`.
+*/
+function parsePomXml(content) {
+	const names = [];
+	for (const piece of content.split("<dependency>").slice(1)) {
+		const close = piece.indexOf("</dependency>");
+		if (close === -1) continue;
+		const block = piece.slice(0, close);
+		const group = /<groupId>\s*([^<\s]+)\s*<\/groupId>/.exec(block);
+		const artifact = /<artifactId>\s*([^<\s]+)\s*<\/artifactId>/.exec(block);
+		if (group && artifact) names.push(`${group[1]}:${artifact[1]}`);
+	}
+	return names;
+}
+/** Package names under the top-level `dependencies` and `dev_dependencies` of a `pubspec.yaml`. */
+function parsePubspecYaml(content) {
+	const names = [];
+	let inDeps = false;
+	let entryIndent = null;
+	for (const raw of content.split("\n")) {
+		if (!raw.trim() || raw.trim().startsWith("#")) continue;
+		const indent = raw.length - raw.trimStart().length;
+		if (indent === 0) {
+			inDeps = /^(dev_)?dependencies:\s*(?:#.*)?$/.test(raw.trim());
+			entryIndent = null;
+			continue;
 		}
-	},
-	{
-		kind: "GoCardless",
-		label: "GoCardless",
-		mode: "in-cli",
-		signals: {
-			npm: ["gocardless-nodejs"],
-			python: ["gocardless-pro"],
-			ruby: ["gocardless_pro"],
-			envKeys: [/^GOCARDLESS_/]
+		if (!inDeps) continue;
+		entryIndent ??= indent;
+		if (indent !== entryIndent) continue;
+		const key = /^([A-Za-z0-9_]+)\s*:/.exec(raw.trim());
+		if (key) names.push(key[1]);
+	}
+	return names;
+}
+/**
+* Package URLs from `Package.swift`, as `host/owner/repo`: lowercased, with no
+* scheme and no `.git`, e.g. `github.com/getsentry/sentry-cocoa`.
+*/
+function parsePackageSwift(content) {
+	return [...content.matchAll(/\burl\s*:\s*"([^"]+)"/g)].map((m) => normalizeGitRemote(m[1]));
+}
+//#endregion
+//#region src/programs/warehouse-sources/detect.ts
+/**
+* Data warehouse source detection.
+*
+* Scans a project for codebase signals (package manifests, `.env` key
+* names, third-party script hosts in templates) and matches them against the
+* detectors the caller passes in, from `loadSourceDetectors`. Pure function:
+* no store mutations, no UI calls. Reads files locally — only the wizard
+* process does this; the agent never sees secret values.
+*
+* Note we only read `.env` KEY NAMES, never values.
+*/
+const MAX_DEPTH = 3;
+const MAX_SIGNAL_SET = MAX_ENV_KEY_SET;
+const MAX_SIGNALS_PER_TOOL = 50;
+function addPackage(signals, ecosystem, name, file) {
+	let names = signals.packages.get(ecosystem);
+	if (!names) {
+		names = /* @__PURE__ */ new Map();
+		signals.packages.set(ecosystem, names);
+	}
+	if (names.size < MAX_SIGNAL_SET && !names.has(name)) names.set(name, file);
+}
+/** Where `matchedSignal` says a package was found, per ecosystem. */
+const PACKAGE_SIGNAL_LOCATIONS = {
+	npm: "package.json",
+	pypi: "Python dependencies",
+	rubygems: "Gemfile"
+};
+/**
+* Detect every catalog tool the project at `installDir` appears to use,
+* including tools the wizard never offers as a warehouse source. Each carries
+* the signals that matched it, for reporting.
+*/
+function detectTools(installDir, detectors) {
+	const signals = collectSignals(installDir, catalogScriptHosts(detectors));
+	const detected = [];
+	for (const detector of detectors) {
+		const matched = matchDetector(detector, signals);
+		if (matched.length === 0) continue;
+		detected.push({
+			kind: detector.kind,
+			label: detector.label,
+			warehouseSourceType: detector.warehouseSourceType,
+			mode: detector.mode,
+			matchedSignal: describeSignal(matched[0]),
+			signals: matched
+		});
+	}
+	return {
+		tools: detected,
+		complete: signals.complete
+	};
+}
+/**
+* The detected tools a user can import as warehouse sources, minus the ones a
+* more specific match supersedes. Kinds are unique, so the result is deduped.
+*/
+function toWarehouseSources(tools, detectors) {
+	const kinds = new Set(tools.map((tool) => tool.kind));
+	const supersededBy = new Map(detectors.map((detector) => [detector.kind, detector.supersededBy ?? []]));
+	const sources = [];
+	for (const tool of tools) {
+		const { mode, warehouseSourceType } = tool;
+		if (mode === null || warehouseSourceType === null) continue;
+		if (isSuperseded(supersededBy.get(tool.kind) ?? [], kinds)) continue;
+		sources.push({
+			kind: warehouseSourceType,
+			label: tool.label,
+			mode,
+			matchedSignal: tool.matchedSignal
+		});
+	}
+	return sources;
+}
+/**
+* Whether a more specific match covers this detector's data. Every consumer
+* treats a detected kind as a source to create, so a project whose Postgres
+* lives on Neon or Supabase would otherwise be offered both and end up with
+* the same tables imported twice.
+*/
+function isSuperseded(supersededBy, detectedKinds) {
+	return supersededBy.some((other) => detectedKinds.has(other));
+}
+/**
+* Every signal that matches the detector, capped per tool. Packages and script
+* hosts come before `.env` keys: they show the code uses the tool, while a key
+* can outlive it.
+*/
+function matchDetector(detector, signals) {
+	const { envKeys, scriptHosts, packages } = detector.signals;
+	const matched = [];
+	for (const [ecosystem, names] of Object.entries(packages)) {
+		const found = signals.packages.get(ecosystem);
+		if (!found) continue;
+		for (const name of names) {
+			const file = found.get(name);
+			if (file !== void 0) matched.push({
+				source: ecosystem,
+				name,
+				file
+			});
 		}
+	}
+	for (const host of scriptHosts) {
+		const file = signals.scriptHosts.get(host);
+		if (file !== void 0) matched.push({
+			source: SCRIPT_HOST_SIGNAL_SOURCE,
+			name: host,
+			file
+		});
+	}
+	if (envKeys.length > 0) {
+		for (const [key, file] of signals.envKeys) if (envKeys.some((re) => re.test(key))) matched.push({
+			source: ENV_KEY_SIGNAL_SOURCE,
+			name: key,
+			file
+		});
+	}
+	return matched.slice(0, MAX_SIGNALS_PER_TOOL);
+}
+/** Signal source for a `.env` key name. */
+const ENV_KEY_SIGNAL_SOURCE = "env_key";
+/** Signal source for a third-party script hostname found in a template. */
+const SCRIPT_HOST_SIGNAL_SOURCE = "script_host";
+/**
+* The human-readable form of a signal, shown on screens and given to the agent.
+*
+* For an env key, name the file that actually matched. The agent acts on this
+* string, so pointing it at `.env` when the key lives in `apps/api/.env.local`
+* sends it to look in the wrong place and conclude the credential is absent.
+*
+* Both interpolated parts are repository-derived, so both are quoted as code
+* and both are constrained. `parseEnvKeyNames` limits the key to
+* `[A-Za-z_][A-Za-z0-9_]*`. The path is the unconstrained part: the repository
+* names its own directories, so it arrives already sanitised from
+* `toPromptSafeRelativePath` and cannot break out of the code span.
+*/
+function describeSignal(signal) {
+	if (signal.source === ENV_KEY_SIGNAL_SOURCE) return `found \`${signal.name}\` in \`${signal.file ?? ".env"}\``;
+	if (signal.source === SCRIPT_HOST_SIGNAL_SOURCE) return `found a \`${signal.name}\` script in \`${signal.file ?? "a template"}\``;
+	const location = PACKAGE_SIGNAL_LOCATIONS[signal.source] ?? `${signal.source} dependencies`;
+	return `found \`${signal.name}\` in ${location}`;
+}
+function collectSignals(installDir, catalogScriptHosts) {
+	const signals = {
+		catalogScriptHosts,
+		envKeys: /* @__PURE__ */ new Map(),
+		scriptHosts: /* @__PURE__ */ new Map(),
+		templatesRead: 0,
+		packages: /* @__PURE__ */ new Map(),
+		complete: true
+	};
+	signals.complete = walkProjectFiles(installDir, (name, fullPath) => ingestFile(installDir, name, fullPath, signals), MAX_DEPTH, { followSymlinks: false });
+	return signals;
+}
+/**
+* Route a file to the right parser BY NAME, reading its contents only when the
+* name matches a manifest, an env file or a template we read. Checking the
+* name first avoids slurping every file in the tree (lockfiles, binaries,
+* assets) into memory just to discard it.
+*/
+function ingestFile(installDir, name, fullPath, signals) {
+	const ingest = ingestorFor(name, signals.catalogScriptHosts.length > 0);
+	if (!ingest) return;
+	if (ingest === addScriptHosts && signals.templatesRead >= MAX_TEMPLATE_FILES) return;
+	const content = safeReadFile(fullPath);
+	if (content === null) return;
+	ingest(content, signals, toPromptSafeRelativePath(installDir, fullPath));
+}
+/** Pick the parser for a manifest filename, or null if it's not one we read. */
+function ingestorFor(name, readTemplates) {
+	if (isEnvFileName(name)) return (c, s, relativePath) => addEnvKeys(c, s, relativePath);
+	if (readTemplates && isTemplateFileName(name)) return addScriptHosts;
+	if (name === "package.json") return addNpmDeps;
+	if (name === "requirements.txt") return (c, s, file) => parseRequirementsTxt(c).forEach((d) => addPackage(s, "pypi", d, file));
+	if (name === "pyproject.toml") return (c, s, file) => parsePyprojectToml(c).forEach((d) => addPackage(s, "pypi", d, file));
+	if (name === "Pipfile") return (c, s, file) => parsePipfile(c).forEach((d) => addPackage(s, "pypi", d, file));
+	const manifest = MANIFEST_PARSERS[name];
+	if (manifest) return (c, s, file) => manifest.parse(c).forEach((d) => addPackage(s, manifest.ecosystem, d, file));
+	return null;
+}
+/** Manifests of every ecosystem after npm and pypi, by file name, in ecosystem order. */
+const MANIFEST_PARSERS = {
+	"Cargo.toml": {
+		ecosystem: "cargo",
+		parse: parseCargoToml
 	},
-	{
-		kind: "Mollie",
-		label: "Mollie",
-		mode: "in-cli",
-		signals: {
-			npm: ["@mollie/api-client"],
-			python: ["mollie-api-python"],
-			envKeys: [/^MOLLIE_/]
-		}
+	Podfile: {
+		ecosystem: "cocoapods",
+		parse: parsePodfile
 	},
-	{
-		kind: "CheckoutCom",
-		label: "Checkout.com",
-		mode: "in-cli",
-		signals: {
-			npm: ["checkout-sdk-node"],
-			python: ["checkout-sdk"],
-			envKeys: [/^CKO_/, /^CHECKOUT_COM_/]
-		}
+	"composer.json": {
+		ecosystem: "composer",
+		parse: parseComposerJson
 	},
-	{
-		kind: "Recurly",
-		label: "Recurly",
-		mode: "in-cli",
-		signals: {
-			npm: ["recurly"],
-			python: ["recurly"],
-			ruby: ["recurly"],
-			envKeys: [/^RECURLY_/]
-		}
+	"go.mod": {
+		ecosystem: "go",
+		parse: parseGoMod
 	},
-	{
-		kind: "RevenueCat",
-		label: "RevenueCat",
-		mode: "in-cli",
-		signals: {
-			npm: [
-				"@revenuecat/purchases-js",
-				"react-native-purchases",
-				"@revenuecat/purchases-capacitor"
-			],
-			envKeys: [/^REVENUE_?CAT_/]
-		}
+	"mix.exs": {
+		ecosystem: "hex",
+		parse: parseMixExs
 	},
-	{
-		kind: "Twilio",
-		label: "Twilio",
-		mode: "in-cli",
-		signals: {
-			npm: ["twilio"],
-			python: ["twilio"],
-			ruby: ["twilio-ruby"],
-			envKeys: [/^TWILIO_/]
-		}
+	"build.gradle": {
+		ecosystem: "maven",
+		parse: parseGradleBuild
 	},
-	{
-		kind: "SendGrid",
-		label: "SendGrid",
-		mode: "in-cli",
-		signals: {
-			npm: ["@sendgrid/mail", "@sendgrid/client"],
-			python: ["sendgrid"],
-			ruby: ["sendgrid-ruby"],
-			envKeys: [/^SENDGRID_/]
-		}
+	"build.gradle.kts": {
+		ecosystem: "maven",
+		parse: parseGradleBuild
 	},
-	{
-		kind: "Mailgun",
-		label: "Mailgun",
-		mode: "in-cli",
-		signals: {
-			npm: ["mailgun.js", "mailgun-js"],
-			python: ["mailgun"],
-			ruby: ["mailgun-ruby"],
-			envKeys: [/^MAILGUN_/]
-		}
+	"libs.versions.toml": {
+		ecosystem: "maven",
+		parse: parseGradleVersionCatalog
 	},
-	{
-		kind: "Postmark",
-		label: "Postmark",
-		mode: "in-cli",
-		signals: {
-			npm: ["postmark"],
-			python: ["postmarker"],
-			ruby: ["postmark"],
-			envKeys: [/^POSTMARK_/]
-		}
+	"pom.xml": {
+		ecosystem: "maven",
+		parse: parsePomXml
 	},
-	{
-		kind: "Brevo",
-		label: "Brevo",
-		mode: "in-cli",
-		signals: {
-			npm: ["@getbrevo/brevo", "sib-api-v3-sdk"],
-			python: ["sib-api-v3-sdk"],
-			envKeys: [/^BREVO_/]
-		}
+	"pubspec.yaml": {
+		ecosystem: "pub",
+		parse: parsePubspecYaml
 	},
-	{
-		kind: "MailerLite",
-		label: "MailerLite",
-		mode: "in-cli",
-		signals: {
-			npm: ["@mailerlite/mailerlite-nodejs"],
-			python: ["mailerlite"],
-			envKeys: [/^MAILERLITE_/]
-		}
+	Gemfile: {
+		ecosystem: "rubygems",
+		parse: parseGemfile
 	},
-	{
-		kind: "Mailjet",
-		label: "Mailjet",
-		mode: "in-cli",
-		signals: {
-			npm: ["node-mailjet"],
-			python: ["mailjet-rest"],
-			envKeys: [/^MAILJET_/, /^MJ_APIKEY_/]
+	"Package.swift": {
+		ecosystem: "swiftpm",
+		parse: parsePackageSwift
+	}
+};
+function catalogScriptHosts(detectors) {
+	return [...new Set(detectors.flatMap((d) => d.signals.scriptHosts))];
+}
+/**
+* A scan matches script hosts in at most this many templates with a `<script`
+* tag, and skips any larger than {@link MAX_TEMPLATE_BYTES}.
+*/
+const MAX_TEMPLATE_FILES = 300;
+const MAX_TEMPLATE_BYTES = 512 * 1024;
+const TEMPLATE_SUFFIXES = [
+	".html",
+	".htm",
+	".erb",
+	".ejs",
+	".hbs",
+	".jinja",
+	".j2",
+	".twig",
+	".blade.php",
+	".heex",
+	".liquid",
+	".vue",
+	".svelte",
+	".astro",
+	".jsx",
+	".tsx"
+];
+function isTemplateFileName(name) {
+	return TEMPLATE_SUFFIXES.some((suffix) => name.endsWith(suffix));
+}
+function hostMatches(host, catalogHost) {
+	return host === catalogHost || host.endsWith(`.${catalogHost}`);
+}
+const URL_HOST = /(?:https?:)?\/\/([a-z0-9-]+(?:\.[a-z0-9-]+)+)/gi;
+/**
+* The text of each `<script>` element in a template: its attributes and its
+* inline body. Case-insensitive, so a Next.js `<Script>` counts. A plain
+* scan with `indexOf`, so a template full of unclosed tags stays linear.
+*/
+function scriptElements(content) {
+	const lower = content.toLowerCase();
+	const elements = [];
+	let from = 0;
+	for (;;) {
+		const start = lower.indexOf("<script", from);
+		if (start === -1) return elements;
+		const after = lower.charAt(start + 7);
+		if (after !== "" && !/[\s>/]/.test(after)) {
+			from = start + 1;
+			continue;
 		}
-	},
-	{
-		kind: "LaunchDarkly",
-		label: "LaunchDarkly",
-		mode: "in-cli",
-		signals: {
-			npm: [
-				"launchdarkly-node-server-sdk",
-				"@launchdarkly/node-server-sdk",
-				"launchdarkly-js-client-sdk",
-				"launchdarkly-react-client-sdk"
-			],
-			python: ["launchdarkly-server-sdk"],
-			ruby: ["launchdarkly-server-sdk"],
-			envKeys: [/^LAUNCHDARKLY_/, /^LD_SDK_KEY$/]
-		}
-	},
-	{
-		kind: "Optimizely",
-		label: "Optimizely",
-		mode: "in-cli",
-		signals: {
-			npm: ["@optimizely/optimizely-sdk"],
-			python: ["optimizely-sdk"],
-			envKeys: [/^OPTIMIZELY_/]
-		}
-	},
-	{
-		kind: "Braze",
-		label: "Braze",
-		mode: "in-cli",
-		signals: {
-			npm: ["@braze/web-sdk", "@braze/react-native-sdk"],
-			python: ["braze-client"],
-			envKeys: [/^BRAZE_/]
-		}
-	},
-	{
-		kind: "Rollbar",
-		label: "Rollbar",
-		mode: "in-cli",
-		signals: {
-			npm: ["rollbar"],
-			python: ["rollbar", "pyrollbar"],
-			ruby: ["rollbar"],
-			envKeys: [/^ROLLBAR_/]
-		}
-	},
-	{
-		kind: "Okta",
-		label: "Okta",
-		mode: "in-cli",
-		signals: {
-			npm: [
-				"@okta/okta-sdk-nodejs",
-				"@okta/okta-auth-js",
-				"@okta/okta-react"
-			],
-			python: ["okta"],
-			envKeys: [/^OKTA_/]
-		}
-	},
-	{
-		kind: "WorkOS",
-		label: "WorkOS",
-		mode: "in-cli",
-		signals: {
-			npm: ["@workos-inc/node"],
-			python: ["workos"],
-			envKeys: [/^WORKOS_/]
-		}
-	},
-	{
-		kind: "Notion",
-		label: "Notion",
-		mode: "in-cli",
-		signals: {
-			npm: ["@notionhq/client"],
-			python: ["notion-client"],
-			envKeys: [/^NOTION_/]
-		}
-	},
-	{
-		kind: "FullStory",
-		label: "FullStory",
-		mode: "in-cli",
-		signals: {
-			npm: ["@fullstory/browser", "@fullstory/react-native"],
-			envKeys: [/^FULLSTORY_/]
-		}
-	},
-	{
-		kind: "Amplitude",
-		label: "Amplitude",
-		mode: "in-cli",
-		signals: {
-			npm: [
-				"@amplitude/analytics-browser",
-				"@amplitude/analytics-node",
-				"@amplitude/analytics-react-native",
-				"amplitude-js"
-			],
-			python: ["amplitude-analytics"],
-			envKeys: [/^AMPLITUDE_/]
-		}
-	},
-	{
-		kind: "Mixpanel",
-		label: "Mixpanel",
-		mode: "in-cli",
-		signals: {
-			npm: ["mixpanel", "mixpanel-browser"],
-			python: ["mixpanel"],
-			ruby: ["mixpanel-ruby"],
-			envKeys: [/^MIXPANEL_/]
-		}
-	},
-	{
-		kind: "Pendo",
-		label: "Pendo",
-		mode: "in-cli",
-		signals: {
-			npm: ["@pendo/agent"],
-			envKeys: [/^PENDO_/]
-		}
-	},
-	{
-		kind: "Salesforce",
-		label: "Salesforce",
-		mode: "deep-link",
-		signals: {
-			npm: ["jsforce"],
-			python: ["simple-salesforce"],
-			envKeys: [/^SALESFORCE_/]
-		}
-	},
-	{
-		kind: "Hubspot",
-		label: "HubSpot",
-		mode: "deep-link",
-		signals: {
-			npm: ["@hubspot/api-client"],
-			python: ["hubspot-api-client"],
-			envKeys: [/^HUBSPOT_/]
-		}
-	},
-	{
-		kind: "Zendesk",
-		label: "Zendesk",
-		mode: "deep-link",
-		signals: {
-			npm: ["node-zendesk"],
-			python: ["zenpy"],
-			envKeys: [/^ZENDESK_/]
-		}
-	},
-	{
-		kind: "Intercom",
-		label: "Intercom",
-		mode: "deep-link",
-		signals: {
-			npm: ["intercom-client", "@intercom/messenger-js-sdk"],
-			python: ["python-intercom"],
-			envKeys: [/^INTERCOM_/]
-		}
-	},
-	{
-		kind: "Linear",
-		label: "Linear",
-		mode: "deep-link",
-		signals: {
-			npm: ["@linear/sdk"],
-			envKeys: [/^LINEAR_API_KEY$/]
-		}
-	},
-	{
-		kind: "Slack",
-		label: "Slack",
-		mode: "deep-link",
-		signals: {
-			npm: ["@slack/web-api", "@slack/bolt"],
-			python: ["slack-sdk", "slack-bolt"],
-			envKeys: [/^SLACK_(BOT|APP|SIGNING|CLIENT)_/]
-		}
-	},
-	{
-		kind: "Github",
-		label: "GitHub",
-		mode: "deep-link",
-		signals: {
-			npm: [
-				"@octokit/rest",
-				"@octokit/core",
-				"@octokit/graphql",
-				"octokit"
-			],
-			python: ["pygithub"],
-			ruby: ["octokit"]
-		}
-	}
-];
-const LLM_SOURCE_DETECTORS = [
-	{
-		kind: "OpenAI",
-		label: "OpenAI",
-		mode: "in-cli",
-		signals: {
-			npm: ["openai"],
-			python: ["openai"],
-			envKeys: [/^OPENAI_/]
-		}
-	},
-	{
-		kind: "Anthropic",
-		label: "Anthropic",
-		mode: "in-cli",
-		signals: {
-			npm: ["@anthropic-ai/sdk"],
-			python: ["anthropic"],
-			envKeys: [/^ANTHROPIC_/]
-		}
-	},
-	{
-		kind: "Cohere",
-		label: "Cohere",
-		mode: "in-cli",
-		signals: {
-			npm: ["cohere-ai"],
-			python: ["cohere"],
-			envKeys: [/^COHERE_/]
-		}
-	},
-	{
-		kind: "MistralAI",
-		label: "Mistral AI",
-		mode: "in-cli",
-		signals: {
-			npm: ["@mistralai/mistralai"],
-			python: ["mistralai"],
-			envKeys: [/^MISTRAL_/]
-		}
-	},
-	{
-		kind: "Groq",
-		label: "Groq",
-		mode: "in-cli",
-		signals: {
-			npm: ["groq-sdk"],
-			python: ["groq"],
-			envKeys: [/^GROQ_/]
-		}
-	},
-	{
-		kind: "TogetherAI",
-		label: "Together AI",
-		mode: "in-cli",
-		signals: {
-			npm: ["together-ai"],
-			python: ["together"],
-			envKeys: [/^TOGETHER_/]
-		}
-	},
-	{
-		kind: "FireworksAI",
-		label: "Fireworks AI",
-		mode: "in-cli",
-		signals: {
-			python: ["fireworks-ai"],
-			envKeys: [/^FIREWORKS_/]
-		}
-	},
-	{
-		kind: "Replicate",
-		label: "Replicate",
-		mode: "in-cli",
-		signals: {
-			npm: ["replicate"],
-			python: ["replicate"],
-			envKeys: [/^REPLICATE_/]
-		}
-	},
-	{
-		kind: "HuggingFace",
-		label: "Hugging Face",
-		mode: "in-cli",
-		signals: {
-			npm: ["@huggingface/inference"],
-			python: ["huggingface-hub"],
-			envKeys: [/^HUGGINGFACE_/, /^HF_TOKEN$/]
-		}
-	},
-	{
-		kind: "ElevenLabs",
-		label: "ElevenLabs",
-		mode: "in-cli",
-		signals: {
-			npm: ["@elevenlabs/elevenlabs-js", "elevenlabs"],
-			python: ["elevenlabs"],
-			envKeys: [/^ELEVENLABS_/, /^ELEVEN_LABS_/]
-		}
-	},
-	{
-		kind: "Deepgram",
-		label: "Deepgram",
-		mode: "in-cli",
-		signals: {
-			npm: ["@deepgram/sdk"],
-			python: ["deepgram-sdk"],
-			envKeys: [/^DEEPGRAM_/]
-		}
-	},
-	{
-		kind: "AssemblyAI",
-		label: "AssemblyAI",
-		mode: "in-cli",
-		signals: {
-			npm: ["assemblyai"],
-			python: ["assemblyai"],
-			envKeys: [/^ASSEMBLYAI_/]
-		}
-	},
-	{
-		kind: "Langfuse",
-		label: "Langfuse",
-		mode: "in-cli",
-		signals: {
-			npm: ["langfuse"],
-			python: ["langfuse"],
-			envKeys: [/^LANGFUSE_/]
-		}
-	},
-	{
-		kind: "LangSmith",
-		label: "LangSmith",
-		mode: "in-cli",
-		signals: {
-			npm: ["langsmith"],
-			python: ["langsmith"],
-			envKeys: [/^LANGSMITH_/, /^LANGCHAIN_API_KEY$/]
-		}
-	},
-	{
-		kind: "Firecrawl",
-		label: "Firecrawl",
-		mode: "in-cli",
-		signals: {
-			npm: ["@mendable/firecrawl-js"],
-			python: ["firecrawl-py"],
-			envKeys: [/^FIRECRAWL_/]
-		}
-	},
-	{
-		kind: "Mem0",
-		label: "Mem0",
-		mode: "in-cli",
-		signals: {
-			npm: ["mem0ai"],
-			python: ["mem0ai"],
-			envKeys: [/^MEM0_/]
-		}
-	},
-	{
-		kind: "Vellum",
-		label: "Vellum",
-		mode: "in-cli",
-		signals: {
-			npm: ["vellum-ai"],
-			python: ["vellum-ai"],
-			envKeys: [/^VELLUM_/]
-		}
-	},
-	{
-		kind: "Helicone",
-		label: "Helicone",
-		mode: "in-cli",
-		signals: {
-			npm: ["@helicone/helpers"],
-			envKeys: [/^HELICONE_/]
-		}
-	},
-	{
-		kind: "OpenRouter",
-		label: "OpenRouter",
-		mode: "in-cli",
-		signals: {
-			npm: ["@openrouter/ai-sdk-provider"],
-			envKeys: [/^OPENROUTER_/]
-		}
-	},
-	{
-		kind: "Browserbase",
-		label: "Browserbase",
-		mode: "in-cli",
-		signals: {
-			npm: ["@browserbasehq/sdk", "@browserbasehq/stagehand"],
-			python: ["browserbase"],
-			envKeys: [/^BROWSERBASE_/]
-		}
-	},
-	{
-		kind: "E2B",
-		label: "E2B",
-		mode: "in-cli",
-		signals: {
-			npm: ["e2b", "@e2b/code-interpreter"],
-			python: ["e2b", "e2b-code-interpreter"],
-			envKeys: [/^E2B_/]
-		}
-	},
-	{
-		kind: "WeightsAndBiases",
-		label: "Weights & Biases",
-		mode: "in-cli",
-		signals: {
-			python: ["wandb"],
-			envKeys: [/^WANDB_/]
-		}
-	},
-	{
-		kind: "LlamaCloud",
-		label: "LlamaCloud",
-		mode: "in-cli",
-		signals: {
-			npm: ["llama-cloud-services"],
-			python: ["llama-cloud-services"],
-			envKeys: [/^LLAMA_CLOUD_/]
-		}
-	},
-	{
-		kind: "Zep",
-		label: "Zep",
-		mode: "in-cli",
-		signals: {
-			npm: ["@getzep/zep-cloud"],
-			python: ["zep-cloud"],
-			envKeys: [/^ZEP_API_KEY$/]
-		}
-	}
-];
-const OTHER_SOURCE_DETECTORS = [
-	{
-		kind: "Paystack",
-		label: "Paystack",
-		mode: "in-cli",
-		signals: {
-			python: ["paystackapi"],
-			envKeys: [/^PAYSTACK_/]
-		}
-	},
-	{
-		kind: "Orb",
-		label: "Orb",
-		mode: "in-cli",
-		signals: {
-			npm: ["orb-billing"],
-			python: ["orb-billing"],
-			envKeys: [/^ORB_/]
-		}
-	},
-	{
-		kind: "Lago",
-		label: "Lago",
-		mode: "in-cli",
-		signals: {
-			npm: ["lago-javascript-client"],
-			python: ["lago-python-client"],
-			envKeys: [/^LAGO_/]
-		}
-	},
-	{
-		kind: "Zuora",
-		label: "Zuora",
-		mode: "in-cli",
-		signals: { envKeys: [/^ZUORA_/] }
-	},
-	{
-		kind: "Stigg",
-		label: "Stigg",
-		mode: "in-cli",
-		signals: {
-			npm: ["@stigg/node-server-sdk"],
-			envKeys: [/^STIGG_/]
-		}
-	},
-	{
-		kind: "Ramp",
-		label: "Ramp",
-		mode: "in-cli",
-		signals: { envKeys: [/^RAMP_/] }
-	},
-	{
-		kind: "Brex",
-		label: "Brex",
-		mode: "in-cli",
-		signals: { envKeys: [/^BREX_/] }
-	},
-	{
-		kind: "Tremendous",
-		label: "Tremendous",
-		mode: "in-cli",
-		signals: { envKeys: [/^TREMENDOUS_/] }
-	},
-	{
-		kind: "Maxio",
-		label: "Maxio",
-		mode: "in-cli",
-		signals: { envKeys: [/^MAXIO_/] }
-	},
-	{
-		kind: "Chargify",
-		label: "Chargify",
-		mode: "in-cli",
-		signals: { envKeys: [/^CHARGIFY_/] }
-	},
-	{
-		kind: "Invoiced",
-		label: "Invoiced",
-		mode: "in-cli",
-		signals: {
-			npm: ["invoiced"],
-			python: ["invoiced"],
-			envKeys: [/^INVOICED_/]
-		}
-	},
-	{
-		kind: "LemonSqueezy",
-		label: "Lemon Squeezy",
-		mode: "in-cli",
-		signals: {
-			npm: ["@lemonsqueezy/lemonsqueezy.js"],
-			envKeys: [/^LEMONSQUEEZY_/, /^LEMON_SQUEEZY_/]
-		}
-	},
-	{
-		kind: "Razorpay",
-		label: "Razorpay",
-		mode: "in-cli",
-		signals: {
-			npm: ["razorpay"],
-			python: ["razorpay"],
-			ruby: ["razorpay"],
-			envKeys: [/^RAZORPAY_/]
-		}
-	},
-	{
-		kind: "Adyen",
-		label: "Adyen",
-		mode: "in-cli",
-		signals: {
-			npm: ["@adyen/api-library"],
-			python: ["adyen"],
-			envKeys: [/^ADYEN_/]
-		}
-	},
-	{
-		kind: "ChartMogul",
-		label: "ChartMogul",
-		mode: "in-cli",
-		signals: {
-			npm: ["chartmogul-node"],
-			python: ["chartmogul"],
-			envKeys: [/^CHARTMOGUL_/]
-		}
-	},
-	{
-		kind: "Airwallex",
-		label: "Airwallex",
-		mode: "in-cli",
-		signals: {
-			npm: ["airwallex-payment-elements"],
-			envKeys: [/^AIRWALLEX_/]
-		}
-	},
-	{
-		kind: "Flutterwave",
-		label: "Flutterwave",
-		mode: "in-cli",
-		signals: {
-			npm: ["flutterwave-node-v3"],
-			python: ["flutterwave"],
-			envKeys: [/^FLUTTERWAVE_/, /^FLW_(PUBLIC|SECRET)_KEY$/]
-		}
-	},
-	{
-		kind: "DodoPayments",
-		label: "Dodo Payments",
-		mode: "in-cli",
-		signals: {
-			npm: ["dodopayments"],
-			python: ["dodopayments"],
-			envKeys: [/^DODO_PAYMENTS_/]
-		}
-	},
-	{
-		kind: "Whop",
-		label: "Whop",
-		mode: "in-cli",
-		signals: {
-			npm: ["@whop/api", "@whop-apps/sdk"],
-			envKeys: [/^WHOP_/]
-		}
-	},
-	{
-		kind: "SparkPost",
-		label: "SparkPost",
-		mode: "in-cli",
-		signals: {
-			npm: ["sparkpost"],
-			python: ["sparkpost"],
-			envKeys: [/^SPARKPOST_/]
-		}
-	},
-	{
-		kind: "MailerSend",
-		label: "MailerSend",
-		mode: "in-cli",
-		signals: {
-			npm: ["mailersend"],
-			python: ["mailersend"],
-			envKeys: [/^MAILERSEND_/]
-		}
-	},
-	{
-		kind: "Iterable",
-		label: "Iterable",
-		mode: "in-cli",
-		signals: { envKeys: [/^ITERABLE_/] }
-	},
-	{
-		kind: "ConvertKit",
-		label: "ConvertKit",
-		mode: "in-cli",
-		signals: { envKeys: [/^CONVERTKIT_/] }
-	},
-	{
-		kind: "Drip",
-		label: "Drip",
-		mode: "in-cli",
-		signals: {
-			npm: ["drip-nodejs"],
-			envKeys: [/^DRIP_/]
-		}
-	},
-	{
-		kind: "Omnisend",
-		label: "Omnisend",
-		mode: "in-cli",
-		signals: { envKeys: [/^OMNISEND_/] }
-	},
-	{
-		kind: "EmailOctopus",
-		label: "EmailOctopus",
-		mode: "in-cli",
-		signals: { envKeys: [/^EMAILOCTOPUS_/, /^EMAIL_OCTOPUS_/] }
-	},
-	{
-		kind: "Elasticemail",
-		label: "Elastic Email",
-		mode: "in-cli",
-		signals: { envKeys: [/^ELASTICEMAIL_/, /^ELASTIC_EMAIL_/] }
-	},
-	{
-		kind: "CampaignMonitor",
-		label: "Campaign Monitor",
-		mode: "in-cli",
-		signals: {
-			npm: ["createsend-node"],
-			envKeys: [/^CAMPAIGN_MONITOR_/, /^CREATESEND_/]
-		}
-	},
-	{
-		kind: "Lemlist",
-		label: "Lemlist",
-		mode: "in-cli",
-		signals: { envKeys: [/^LEMLIST_/] }
-	},
-	{
-		kind: "Loops",
-		label: "Loops",
-		mode: "in-cli",
-		signals: {
-			npm: ["loops"],
-			envKeys: [/^LOOPS_/]
-		}
-	},
-	{
-		kind: "Knock",
-		label: "Knock",
-		mode: "in-cli",
-		signals: {
-			npm: ["@knocklabs/node", "@knocklabs/client"],
-			python: ["knockapi"],
-			envKeys: [/^KNOCK_/]
-		}
-	},
-	{
-		kind: "AwsSes",
-		label: "Amazon SES",
-		mode: "in-cli",
-		signals: {
-			npm: ["@aws-sdk/client-ses", "@aws-sdk/client-sesv2"],
-			envKeys: [/^AWS_SES_/]
-		}
-	},
-	{
-		kind: "Beehiiv",
-		label: "beehiiv",
-		mode: "in-cli",
-		signals: { envKeys: [/^BEEHIIV_/] }
-	},
-	{
-		kind: "Mailtrap",
-		label: "Mailtrap",
-		mode: "in-cli",
-		signals: {
-			npm: ["mailtrap"],
-			python: ["mailtrap"],
-			envKeys: [/^MAILTRAP_/]
-		}
-	},
-	{
-		kind: "Plunk",
-		label: "Plunk",
-		mode: "in-cli",
-		signals: {
-			npm: ["@plunk/node"],
-			envKeys: [/^PLUNK_/]
-		}
-	},
-	{
-		kind: "Ortto",
-		label: "Ortto",
-		mode: "in-cli",
-		signals: { envKeys: [/^ORTTO_/] }
-	},
-	{
-		kind: "Postscript",
-		label: "Postscript",
-		mode: "in-cli",
-		signals: { envKeys: [/^POSTSCRIPT_/] }
-	},
-	{
-		kind: "Marketo",
-		label: "Marketo",
-		mode: "in-cli",
-		signals: {
-			python: ["marketorestpython"],
-			envKeys: [/^MARKETO_/]
-		}
-	},
-	{
-		kind: "Lob",
-		label: "Lob",
-		mode: "in-cli",
-		signals: {
-			npm: ["lob"],
-			python: ["lob"],
-			envKeys: [/^LOB_API_KEY$/]
-		}
-	},
-	{
-		kind: "Segment",
-		label: "Segment",
-		mode: "in-cli",
-		signals: {
-			npm: ["@segment/analytics-node", "analytics-node"],
-			python: ["segment-analytics-python", "analytics-python"],
-			envKeys: [/^SEGMENT_/]
-		}
-	},
-	{
-		kind: "Snowplow",
-		label: "Snowplow Analytics",
-		mode: "in-cli",
-		signals: {
-			npm: ["@snowplow/node-tracker"],
-			python: ["snowplow-tracker"],
-			envKeys: [/^SNOWPLOW_/]
-		}
-	},
-	{
-		kind: "Matomo",
-		label: "Matomo",
-		mode: "in-cli",
-		signals: {
-			npm: ["matomo-tracker"],
-			envKeys: [/^MATOMO_/]
-		}
-	},
-	{
-		kind: "Plausible",
-		label: "Plausible",
-		mode: "in-cli",
-		signals: {
-			npm: ["plausible-tracker"],
-			envKeys: [/^PLAUSIBLE_/]
-		}
-	},
-	{
-		kind: "ConfigCat",
-		label: "ConfigCat",
-		mode: "in-cli",
-		signals: {
-			npm: ["configcat-node", "configcat-js"],
-			python: ["configcat-client"],
-			envKeys: [/^CONFIGCAT_/]
-		}
-	},
-	{
-		kind: "Flagsmith",
-		label: "Flagsmith",
-		mode: "in-cli",
-		signals: {
-			npm: ["flagsmith-nodejs", "flagsmith"],
-			python: ["flagsmith"],
-			envKeys: [/^FLAGSMITH_/]
-		}
-	},
-	{
-		kind: "Unleash",
-		label: "Unleash",
-		mode: "in-cli",
-		signals: {
-			npm: ["unleash-client"],
-			python: ["unleashclient"],
-			envKeys: [/^UNLEASH_/]
-		}
-	},
-	{
-		kind: "SplitIo",
-		label: "Split.io",
-		mode: "in-cli",
-		signals: {
-			npm: ["@splitsoftware/splitio"],
-			python: ["splitio-client"],
-			envKeys: [/^SPLITIO_/, /^SPLIT_IO_/]
-		}
-	},
-	{
-		kind: "Stytch",
-		label: "Stytch",
-		mode: "in-cli",
-		signals: {
-			npm: ["stytch"],
-			python: ["stytch"],
-			envKeys: [/^STYTCH_/]
-		}
-	},
-	{
-		kind: "Doppler",
-		label: "Doppler",
-		mode: "in-cli",
-		signals: {
-			npm: ["@dopplerhq/node-sdk"],
-			envKeys: [/^DOPPLER_/]
-		}
-	},
-	{
-		kind: "Infisical",
-		label: "Infisical",
-		mode: "in-cli",
-		signals: {
-			npm: ["@infisical/sdk"],
-			python: ["infisicalsdk"],
-			envKeys: [/^INFISICAL_/]
-		}
-	},
-	{
-		kind: "OnePassword",
-		label: "1Password",
-		mode: "in-cli",
-		signals: {
-			npm: ["@1password/sdk"],
-			python: ["onepassword-sdk"],
-			envKeys: [/^ONEPASSWORD_/, /^OP_SERVICE_ACCOUNT_TOKEN$/]
-		}
-	},
-	{
-		kind: "Persona",
-		label: "Persona",
-		mode: "in-cli",
-		signals: { envKeys: [/^PERSONA_/] }
-	},
-	{
-		kind: "Svix",
-		label: "Svix",
-		mode: "in-cli",
-		signals: {
-			npm: ["svix"],
-			python: ["svix"],
-			envKeys: [/^SVIX_/]
-		}
-	},
-	{
-		kind: "Mux",
-		label: "Mux",
-		mode: "in-cli",
-		signals: {
-			npm: ["@mux/mux-node"],
-			python: ["mux-python"],
-			envKeys: [/^MUX_/]
-		}
-	},
-	{
-		kind: "Vapi",
-		label: "Vapi",
-		mode: "in-cli",
-		signals: {
-			npm: ["@vapi-ai/server-sdk"],
-			python: ["vapi-server-sdk"],
-			envKeys: [/^VAPI_/]
-		}
-	},
-	{
-		kind: "Aircall",
-		label: "Aircall",
-		mode: "in-cli",
-		signals: { envKeys: [/^AIRCALL_/] }
-	},
-	{
-		kind: "JustCall",
-		label: "JustCall",
-		mode: "in-cli",
-		signals: { envKeys: [/^JUSTCALL_/] }
-	},
-	{
-		kind: "Telnyx",
-		label: "Telnyx",
-		mode: "in-cli",
-		signals: {
-			npm: ["telnyx"],
-			python: ["telnyx"],
-			envKeys: [/^TELNYX_/]
-		}
-	},
-	{
-		kind: "Plivo",
-		label: "Plivo",
-		mode: "in-cli",
-		signals: {
-			npm: ["plivo"],
-			python: ["plivo"],
-			envKeys: [/^PLIVO_/]
-		}
-	},
-	{
-		kind: "Courier",
-		label: "Courier",
-		mode: "in-cli",
-		signals: {
-			npm: ["@trycourier/courier"],
-			python: ["trycourier"],
-			envKeys: [/^COURIER_AUTH_TOKEN$/]
-		}
-	},
-	{
-		kind: "WooCommerce",
-		label: "WooCommerce",
-		mode: "in-cli",
-		signals: {
-			npm: ["@woocommerce/woocommerce-rest-api"],
-			python: ["woocommerce"],
-			envKeys: [/^WOOCOMMERCE_/]
-		}
-	},
-	{
-		kind: "Recharge",
-		label: "Recharge",
-		mode: "in-cli",
-		signals: { envKeys: [/^RECHARGE_/] }
-	},
-	{
-		kind: "Commercetools",
-		label: "commercetools",
-		mode: "in-cli",
-		signals: {
-			npm: ["@commercetools/platform-sdk"],
-			python: ["commercetools"],
-			envKeys: [/^CTP_/, /^COMMERCETOOLS_/]
-		}
-	},
-	{
-		kind: "Webflow",
-		label: "Webflow",
-		mode: "in-cli",
-		signals: {
-			npm: ["webflow-api"],
-			envKeys: [/^WEBFLOW_/]
-		}
-	},
-	{
-		kind: "Easypost",
-		label: "EasyPost",
-		mode: "in-cli",
-		signals: {
-			npm: ["@easypost/api"],
-			python: ["easypost"],
-			envKeys: [/^EASYPOST_/]
-		}
-	},
-	{
-		kind: "Shippo",
-		label: "Shippo",
-		mode: "in-cli",
-		signals: {
-			npm: ["shippo"],
-			python: ["shippo"],
-			envKeys: [/^SHIPPO_/]
-		}
-	},
-	{
-		kind: "ShipStation",
-		label: "ShipStation",
-		mode: "in-cli",
-		signals: { envKeys: [/^SHIPSTATION_/] }
-	},
-	{
-		kind: "Squarespace",
-		label: "Squarespace",
-		mode: "in-cli",
-		signals: { envKeys: [/^SQUARESPACE_/] }
-	},
-	{
-		kind: "Printify",
-		label: "Printify",
-		mode: "in-cli",
-		signals: { envKeys: [/^PRINTIFY_/] }
-	},
-	{
-		kind: "BigCommerce",
-		label: "BigCommerce",
-		mode: "in-cli",
-		signals: {
-			npm: ["node-bigcommerce"],
-			envKeys: [/^BIGCOMMERCE_/]
-		}
-	},
-	{
-		kind: "Freshdesk",
-		label: "Freshdesk",
-		mode: "in-cli",
-		signals: {
-			python: ["python-freshdesk"],
-			envKeys: [/^FRESHDESK_/]
-		}
-	},
-	{
-		kind: "Front",
-		label: "Front",
-		mode: "in-cli",
-		signals: { envKeys: [/^FRONTAPP_/, /^FRONT_API_/] }
-	},
-	{
-		kind: "Gorgias",
-		label: "Gorgias",
-		mode: "in-cli",
-		signals: { envKeys: [/^GORGIAS_/] }
-	},
-	{
-		kind: "Chatwoot",
-		label: "Chatwoot",
-		mode: "in-cli",
-		signals: { envKeys: [/^CHATWOOT_/] }
-	},
-	{
-		kind: "Kustomer",
-		label: "Kustomer",
-		mode: "in-cli",
-		signals: { envKeys: [/^KUSTOMER_/] }
-	},
-	{
-		kind: "Plain",
-		label: "Plain",
-		mode: "in-cli",
-		signals: {
-			npm: ["@team-plain/typescript-sdk"],
-			envKeys: [/^PLAIN_/]
-		}
-	},
-	{
-		kind: "Canny",
-		label: "Canny",
-		mode: "in-cli",
-		signals: { envKeys: [/^CANNY_/] }
-	},
-	{
-		kind: "Pylon",
-		label: "Pylon",
-		mode: "in-cli",
-		signals: { envKeys: [/^PYLON_/] }
-	},
-	{
-		kind: "GitLab",
-		label: "GitLab",
-		mode: "in-cli",
-		signals: {
-			npm: ["@gitbeaker/rest"],
-			python: ["python-gitlab"],
-			ruby: ["gitlab"],
-			envKeys: [/^GITLAB_/]
-		}
-	},
-	{
-		kind: "Bitbucket",
-		label: "Atlassian Bitbucket Cloud",
-		mode: "in-cli",
-		signals: {
-			npm: ["bitbucket"],
-			envKeys: [/^BITBUCKET_/]
-		}
-	},
-	{
-		kind: "Gitea",
-		label: "Gitea",
-		mode: "in-cli",
-		signals: {
-			npm: ["gitea-js"],
-			envKeys: [/^GITEA_/]
-		}
-	},
-	{
-		kind: "Datadog",
-		label: "Datadog",
-		mode: "in-cli",
-		signals: {
-			npm: ["@datadog/datadog-api-client", "dd-trace"],
-			python: ["datadog", "datadog-api-client"],
-			ruby: ["dogapi"],
-			envKeys: [
-				/^DATADOG_/,
-				/^DD_API_KEY$/,
-				/^DD_APP_KEY$/
-			]
-		}
-	},
-	{
-		kind: "NewRelic",
-		label: "New Relic",
-		mode: "in-cli",
-		signals: {
-			npm: ["newrelic"],
-			python: ["newrelic"],
-			ruby: ["newrelic_rpm"],
-			envKeys: [/^NEW_RELIC_/, /^NEWRELIC_/]
-		}
-	},
-	{
-		kind: "Cloudflare",
-		label: "Cloudflare",
-		mode: "in-cli",
-		signals: {
-			npm: ["cloudflare"],
-			python: ["cloudflare"],
-			envKeys: [/^CLOUDFLARE_/, /^CF_API_TOKEN$/]
-		}
-	},
-	{
-		kind: "Elasticsearch",
-		label: "Elasticsearch",
-		mode: "in-cli",
-		signals: {
-			npm: ["@elastic/elasticsearch"],
-			python: ["elasticsearch"],
-			ruby: ["elasticsearch"],
-			envKeys: [/^ELASTICSEARCH_/]
-		}
-	},
-	{
-		kind: "Snyk",
-		label: "Snyk",
-		mode: "in-cli",
-		signals: {
-			npm: ["snyk"],
-			python: ["pysnyk"],
-			envKeys: [/^SNYK_/]
-		}
-	},
-	{
-		kind: "PagerDuty",
-		label: "PagerDuty",
-		mode: "in-cli",
-		signals: {
-			npm: ["@pagerduty/pdjs"],
-			python: ["pdpyras"],
-			envKeys: [/^PAGERDUTY_/, /^PD_API_KEY$/]
-		}
-	},
-	{
-		kind: "Opsgenie",
-		label: "Opsgenie",
-		mode: "in-cli",
-		signals: { envKeys: [/^OPSGENIE_/] }
-	},
-	{
-		kind: "IncidentIo",
-		label: "incident.io",
-		mode: "in-cli",
-		signals: { envKeys: [/^INCIDENT_IO_/, /^INCIDENTIO_/] }
-	},
-	{
-		kind: "Bugsnag",
-		label: "Bugsnag",
-		mode: "in-cli",
-		signals: {
-			npm: ["@bugsnag/js"],
-			python: ["bugsnag"],
-			ruby: ["bugsnag"],
-			envKeys: [/^BUGSNAG_/]
-		}
-	},
-	{
-		kind: "Honeybadger",
-		label: "Honeybadger",
-		mode: "in-cli",
-		signals: {
-			npm: ["@honeybadger-io/js"],
-			python: ["honeybadger"],
-			ruby: ["honeybadger"],
-			envKeys: [/^HONEYBADGER_/]
-		}
-	},
-	{
-		kind: "Raygun",
-		label: "Raygun",
-		mode: "in-cli",
-		signals: {
-			npm: ["raygun"],
-			python: ["raygun4py"],
-			ruby: ["raygun4ruby"],
-			envKeys: [/^RAYGUN_/]
-		}
-	},
-	{
-		kind: "CircleCI",
-		label: "CircleCI",
-		mode: "in-cli",
-		signals: { envKeys: [/^CIRCLECI_/, /^CIRCLE_TOKEN$/] }
-	},
-	{
-		kind: "Upstash",
-		label: "Upstash",
-		mode: "in-cli",
-		signals: {
-			npm: ["@upstash/redis"],
-			python: ["upstash-redis"],
-			envKeys: [/^UPSTASH_/]
-		}
-	},
-	{
-		kind: "Vercel",
-		label: "Vercel",
-		mode: "in-cli",
-		signals: {
-			npm: ["@vercel/sdk"],
-			envKeys: [/^VERCEL_API_TOKEN$/]
-		}
-	},
-	{
-		kind: "Algolia",
-		label: "Algolia",
-		mode: "in-cli",
-		signals: {
-			npm: ["algoliasearch"],
-			python: ["algoliasearch"],
-			ruby: ["algolia"],
-			envKeys: [/^ALGOLIA_/]
-		}
-	},
-	{
-		kind: "Inngest",
-		label: "Inngest",
-		mode: "in-cli",
-		signals: {
-			npm: ["inngest"],
-			python: ["inngest"],
-			envKeys: [/^INNGEST_/]
-		}
-	},
-	{
-		kind: "TriggerDev",
-		label: "Trigger.dev",
-		mode: "in-cli",
-		signals: {
-			npm: ["@trigger.dev/sdk"],
-			envKeys: [/^TRIGGER_(SECRET_KEY|API_KEY|PROJECT_ID)$/]
-		}
-	},
-	{
-		kind: "Ably",
-		label: "Ably",
-		mode: "in-cli",
-		signals: {
-			npm: ["ably"],
-			python: ["ably"],
-			envKeys: [/^ABLY_/]
-		}
-	},
-	{
-		kind: "Netlify",
-		label: "Netlify",
-		mode: "in-cli",
-		signals: {
-			npm: ["@netlify/functions"],
-			envKeys: [/^NETLIFY_/]
-		}
-	},
-	{
-		kind: "Railway",
-		label: "Railway",
-		mode: "in-cli",
-		signals: { envKeys: [/^RAILWAY_/] }
-	},
-	{
-		kind: "Render",
-		label: "Render",
-		mode: "in-cli",
-		signals: { envKeys: [/^RENDER_API_KEY$/] }
-	},
-	{
-		kind: "FlyIo",
-		label: "Fly.io",
-		mode: "in-cli",
-		signals: { envKeys: [/^FLY_API_TOKEN$/, /^FLY_APP_NAME$/] }
-	},
-	{
-		kind: "Heroku",
-		label: "Heroku",
-		mode: "in-cli",
-		signals: { envKeys: [/^HEROKU_/] }
-	},
-	{
-		kind: "DigitalOcean",
-		label: "DigitalOcean",
-		mode: "in-cli",
-		signals: { envKeys: [/^DIGITALOCEAN_/] }
-	},
-	{
-		kind: "Grafana",
-		label: "Grafana",
-		mode: "in-cli",
-		signals: {
-			python: ["grafana-client"],
-			envKeys: [/^GRAFANA_/]
-		}
-	},
-	{
-		kind: "BetterStack",
-		label: "Better Stack",
-		mode: "in-cli",
-		signals: {
-			npm: ["@logtail/node", "@logtail/js"],
-			envKeys: [
-				/^BETTERSTACK_/,
-				/^BETTER_STACK_/,
-				/^LOGTAIL_/
-			]
-		}
-	},
-	{
-		kind: "Honeycomb",
-		label: "Honeycomb",
-		mode: "in-cli",
-		signals: {
-			npm: ["@honeycombio/opentelemetry-node", "honeycomb-beeline"],
-			python: ["honeycomb-beeline", "libhoney"],
-			envKeys: [/^HONEYCOMB_/]
-		}
-	},
-	{
-		kind: "Descope",
-		label: "Descope",
-		mode: "in-cli",
-		signals: {
-			npm: [
-				"@descope/node-sdk",
-				"@descope/nextjs-sdk",
-				"@descope/react-sdk"
-			],
-			python: ["descope"],
-			envKeys: [/^DESCOPE_/]
-		}
-	},
-	{
-		kind: "FusionAuth",
-		label: "FusionAuth",
-		mode: "in-cli",
-		signals: {
-			npm: ["@fusionauth/typescript-client"],
-			python: ["fusionauth-client"],
-			envKeys: [/^FUSIONAUTH_/, /^FUSION_AUTH_/]
-		}
-	},
-	{
-		kind: "Hookdeck",
-		label: "Hookdeck",
-		mode: "in-cli",
-		signals: {
-			npm: ["@hookdeck/sdk"],
-			envKeys: [/^HOOKDECK_/]
-		}
-	},
-	{
-		kind: "N8n",
-		label: "n8n",
-		mode: "in-cli",
-		signals: {
-			npm: ["n8n"],
-			envKeys: [/^N8N_/]
-		}
-	},
-	{
-		kind: "Dbt",
-		label: "dbt",
-		mode: "in-cli",
-		signals: {
-			python: [
-				"dbt-core",
-				"dbt-snowflake",
-				"dbt-postgres",
-				"dbt-bigquery",
-				"dbt-redshift",
-				"dbt-databricks"
-			],
-			envKeys: [/^DBT_/]
-		}
-	},
-	{
-		kind: "Fastly",
-		label: "Fastly",
-		mode: "in-cli",
-		signals: {
-			npm: ["fastly"],
-			python: ["fastly"],
-			envKeys: [/^FASTLY_/]
-		}
-	},
-	{
-		kind: "Bunny",
-		label: "Bunny.net",
-		mode: "in-cli",
-		signals: { envKeys: [/^BUNNY_/] }
-	},
-	{
-		kind: "Codecov",
-		label: "Codecov",
-		mode: "in-cli",
-		signals: {
-			npm: ["codecov"],
-			envKeys: [/^CODECOV_/]
-		}
-	},
-	{
-		kind: "Sourcegraph",
-		label: "Sourcegraph",
-		mode: "in-cli",
-		signals: { envKeys: [/^SOURCEGRAPH_/, /^SRC_ACCESS_TOKEN$/] }
-	},
-	{
-		kind: "TemporalIO",
-		label: "Temporal.io",
-		mode: "in-cli",
-		signals: {
-			npm: ["@temporalio/client", "@temporalio/worker"],
-			python: ["temporalio"],
-			envKeys: [/^TEMPORAL_/]
-		}
-	},
-	{
-		kind: "Hatchet",
-		label: "Hatchet",
-		mode: "in-cli",
-		signals: {
-			npm: ["@hatchet-dev/typescript-sdk"],
-			python: ["hatchet-sdk"],
-			envKeys: [/^HATCHET_/]
-		}
-	},
-	{
-		kind: "Pipedrive",
-		label: "Pipedrive",
-		mode: "in-cli",
-		signals: {
-			npm: ["pipedrive"],
-			envKeys: [/^PIPEDRIVE_/]
-		}
-	},
-	{
-		kind: "Close",
-		label: "Close",
-		mode: "in-cli",
-		signals: {
-			python: ["closeio"],
-			envKeys: [/^CLOSE_API_KEY$/]
-		}
-	},
-	{
-		kind: "Copper",
-		label: "Copper",
-		mode: "in-cli",
-		signals: { envKeys: [/^COPPER_/] }
-	},
-	{
-		kind: "Insightly",
-		label: "Insightly",
-		mode: "in-cli",
-		signals: { envKeys: [/^INSIGHTLY_/] }
-	},
-	{
-		kind: "Salesflare",
-		label: "Salesflare",
-		mode: "in-cli",
-		signals: { envKeys: [/^SALESFLARE_/] }
-	},
-	{
-		kind: "SalesLoft",
-		label: "Salesloft",
-		mode: "in-cli",
-		signals: { envKeys: [/^SALESLOFT_/] }
-	},
-	{
-		kind: "Attio",
-		label: "Attio",
-		mode: "in-cli",
-		signals: {
-			npm: ["attio"],
-			envKeys: [/^ATTIO_/]
-		}
-	},
-	{
-		kind: "ActiveCampaign",
-		label: "ActiveCampaign",
-		mode: "in-cli",
-		signals: { envKeys: [/^ACTIVECAMPAIGN_/, /^ACTIVE_CAMPAIGN_/] }
-	},
-	{
-		kind: "Vitally",
-		label: "Vitally",
-		mode: "in-cli",
-		signals: { envKeys: [/^VITALLY_/] }
-	},
-	{
-		kind: "Docusign",
-		label: "DocuSign",
-		mode: "in-cli",
-		signals: {
-			npm: ["docusign-esign"],
-			python: ["docusign-esign"],
-			envKeys: [/^DOCUSIGN_/]
-		}
-	},
-	{
-		kind: "PandaDoc",
-		label: "PandaDoc",
-		mode: "in-cli",
-		signals: { envKeys: [/^PANDADOC_/] }
-	},
-	{
-		kind: "Gong",
-		label: "Gong",
-		mode: "in-cli",
-		signals: { envKeys: [/^GONG_/] }
-	},
-	{
-		kind: "Asana",
-		label: "Asana",
-		mode: "in-cli",
-		signals: {
-			npm: ["asana"],
-			python: ["asana"],
-			envKeys: [/^ASANA_/]
-		}
-	},
-	{
-		kind: "Trello",
-		label: "Trello",
-		mode: "in-cli",
-		signals: {
-			npm: ["trello"],
-			envKeys: [/^TRELLO_/]
-		}
-	},
-	{
-		kind: "Todoist",
-		label: "Todoist",
-		mode: "in-cli",
-		signals: {
-			npm: ["@doist/todoist-api-typescript"],
-			python: ["todoist-api-python"],
-			envKeys: [/^TODOIST_/]
-		}
-	},
-	{
-		kind: "Monday",
-		label: "monday.com",
-		mode: "in-cli",
-		signals: {
-			npm: ["@mondaydotcomorg/api"],
-			envKeys: [/^MONDAY_/]
-		}
-	},
-	{
-		kind: "ClickUp",
-		label: "ClickUp",
-		mode: "in-cli",
-		signals: { envKeys: [/^CLICKUP_/] }
-	},
-	{
-		kind: "Height",
-		label: "Height",
-		mode: "in-cli",
-		signals: { envKeys: [/^HEIGHT_API_KEY$/] }
-	},
-	{
-		kind: "Shortcut",
-		label: "Shortcut",
-		mode: "in-cli",
-		signals: {
-			npm: ["@shortcut/client"],
-			envKeys: [/^SHORTCUT_/]
-		}
-	},
-	{
-		kind: "Jira",
-		label: "Jira",
-		mode: "in-cli",
-		signals: {
-			npm: ["jira-client"],
-			python: ["jira", "atlassian-python-api"],
-			envKeys: [/^JIRA_/]
-		}
-	},
-	{
-		kind: "Confluence",
-		label: "Confluence",
-		mode: "in-cli",
-		signals: { envKeys: [/^CONFLUENCE_/] }
-	},
-	{
-		kind: "Airtable",
-		label: "Airtable",
-		mode: "in-cli",
-		signals: {
-			npm: ["airtable"],
-			python: ["pyairtable"],
-			envKeys: [/^AIRTABLE_/]
-		}
-	},
-	{
-		kind: "Smartsheet",
-		label: "Smartsheet",
-		mode: "in-cli",
-		signals: {
-			npm: ["smartsheet"],
-			python: ["smartsheet-python-sdk"],
-			envKeys: [/^SMARTSHEET_/]
-		}
-	},
-	{
-		kind: "Coda",
-		label: "Coda",
-		mode: "in-cli",
-		signals: { envKeys: [/^CODA_API_/] }
-	},
-	{
-		kind: "Productboard",
-		label: "Productboard",
-		mode: "in-cli",
-		signals: { envKeys: [/^PRODUCTBOARD_/] }
-	},
-	{
-		kind: "GoogleSheets",
-		label: "Google Sheets",
-		mode: "in-cli",
-		signals: {
-			npm: ["google-spreadsheet"],
-			python: ["gspread"],
-			envKeys: [/^GOOGLE_SHEETS_/]
-		}
-	},
-	{
-		kind: "Formbricks",
-		label: "Formbricks",
-		mode: "in-cli",
-		signals: {
-			npm: ["@formbricks/js"],
-			envKeys: [/^FORMBRICKS_/]
-		}
-	},
-	{
-		kind: "Tally",
-		label: "Tally",
-		mode: "in-cli",
-		signals: { envKeys: [/^TALLY_API_KEY$/] }
-	},
-	{
-		kind: "Jotform",
-		label: "Jotform",
-		mode: "in-cli",
-		signals: {
-			python: ["jotform"],
-			envKeys: [/^JOTFORM_/]
-		}
-	},
-	{
-		kind: "GitBook",
-		label: "GitBook",
-		mode: "in-cli",
-		signals: {
-			npm: ["@gitbook/api"],
-			envKeys: [/^GITBOOK_/]
-		}
-	},
-	{
-		kind: "Wordpress",
-		label: "WordPress",
-		mode: "in-cli",
-		signals: {
-			npm: ["wpapi"],
-			envKeys: [/^WORDPRESS_/]
-		}
-	},
-	{
-		kind: "Clockify",
-		label: "Clockify",
-		mode: "in-cli",
-		signals: { envKeys: [/^CLOCKIFY_/] }
-	},
-	{
-		kind: "Calendly",
-		label: "Calendly",
-		mode: "in-cli",
-		signals: { envKeys: [/^CALENDLY_/] }
-	},
-	{
-		kind: "CalCom",
-		label: "Cal.com",
-		mode: "in-cli",
-		signals: { envKeys: [/^CALCOM_/, /^CAL_API_KEY$/] }
-	},
-	{
-		kind: "Eventbrite",
-		label: "Eventbrite",
-		mode: "in-cli",
-		signals: {
-			python: ["eventbrite"],
-			envKeys: [/^EVENTBRITE_/]
-		}
-	},
-	{
-		kind: "BambooHR",
-		label: "BambooHR",
-		mode: "in-cli",
-		signals: {
-			python: ["pybamboohr"],
-			envKeys: [/^BAMBOOHR_/, /^BAMBOO_HR_/]
-		}
-	},
-	{
-		kind: "Personio",
-		label: "Personio",
-		mode: "in-cli",
-		signals: { envKeys: [/^PERSONIO_/] }
-	},
-	{
-		kind: "Rippling",
-		label: "Rippling",
-		mode: "in-cli",
-		signals: { envKeys: [/^RIPPLING_/] }
-	},
-	{
-		kind: "Greenhouse",
-		label: "Greenhouse",
-		mode: "in-cli",
-		signals: { envKeys: [/^GREENHOUSE_/] }
-	},
-	{
-		kind: "Ashby",
-		label: "Ashby",
-		mode: "in-cli",
-		signals: { envKeys: [/^ASHBY_/] }
-	},
-	{
-		kind: "Workable",
-		label: "Workable",
-		mode: "in-cli",
-		signals: { envKeys: [/^WORKABLE_/] }
-	},
-	{
-		kind: "GoogleAds",
-		label: "Google Ads",
-		mode: "deep-link",
-		signals: {
-			npm: ["google-ads-api"],
-			python: ["google-ads"],
-			envKeys: [/^GOOGLE_ADS_/]
-		}
-	},
-	{
-		kind: "MetaAds",
-		label: "Meta Ads",
-		mode: "deep-link",
-		signals: {
-			npm: ["facebook-nodejs-business-sdk"],
-			python: ["facebook-business"],
-			envKeys: [/^META_ADS_/, /^FACEBOOK_ADS_/]
-		}
-	},
-	{
-		kind: "LinkedinAds",
-		label: "LinkedIn Ads",
-		mode: "deep-link",
-		signals: { envKeys: [/^LINKEDIN_ADS_/] }
-	},
-	{
-		kind: "TikTokAds",
-		label: "TikTok Ads",
-		mode: "deep-link",
-		signals: { envKeys: [/^TIKTOK_ADS_/] }
-	},
-	{
-		kind: "RedditAds",
-		label: "Reddit Ads",
-		mode: "deep-link",
-		signals: { envKeys: [/^REDDIT_ADS_/] }
-	},
-	{
-		kind: "PinterestAds",
-		label: "Pinterest Ads",
-		mode: "deep-link",
-		signals: { envKeys: [/^PINTEREST_ADS_/] }
-	},
-	{
-		kind: "BingAds",
-		label: "Bing Ads",
-		mode: "deep-link",
-		signals: {
-			python: ["bingads"],
-			envKeys: [/^BING_ADS_/, /^MICROSOFT_ADS_/]
-		}
-	},
-	{
-		kind: "AmazonAds",
-		label: "Amazon Ads",
-		mode: "deep-link",
-		signals: { envKeys: [/^AMAZON_ADS_/] }
-	},
-	{
-		kind: "GoogleAnalytics",
-		label: "Google Analytics",
-		mode: "deep-link",
-		signals: {
-			npm: ["react-ga4"],
-			python: ["google-analytics-data"],
-			envKeys: [/^GOOGLE_ANALYTICS_/, /^GA4_/]
-		}
-	},
-	{
-		kind: "GoogleSearchConsole",
-		label: "Google Search Console",
-		mode: "deep-link",
-		signals: { envKeys: [/^SEARCH_CONSOLE_/, /^GSC_/] }
-	},
-	{
-		kind: "AppsFlyer",
-		label: "AppsFlyer",
-		mode: "in-cli",
-		signals: {
-			npm: ["react-native-appsflyer"],
-			envKeys: [/^APPSFLYER_/]
-		}
-	},
-	{
-		kind: "Dub",
-		label: "Dub",
-		mode: "in-cli",
-		signals: {
-			npm: ["dub"],
-			python: ["dub"],
-			envKeys: [/^DUB_API_KEY$/]
+		const tagEnd = endOfTag(content, start);
+		let end = tagEnd;
+		if (content.charAt(tagEnd - 1) !== "/") {
+			const close = lower.indexOf("<\/script", tagEnd);
+			end = close === -1 ? content.length : close;
 		}
+		elements.push(content.slice(start, end));
+		if (end >= content.length) return elements;
+		from = end + 1;
 	}
-];
-const SOURCE_DETECTORS = [
-	...CORE_SOURCE_DETECTORS,
-	...LLM_SOURCE_DETECTORS,
-	...OTHER_SOURCE_DETECTORS
-];
-/** Kinds from the LLM / AI section above — the only ones that may set `wizard_ai_sdk_detected`. */
-const AI_SOURCE_KINDS = new Set(LLM_SOURCE_DETECTORS.map((detector) => detector.kind));
-//#endregion
-//#region src/programs/warehouse-sources/detect.ts
-/**
-* Data warehouse source detection.
-*
-* Scans a project for codebase signals (npm/python/ruby deps, `.env` key
-* names) and matches them against the `SOURCE_DETECTORS` registry. Pure
-* function: no store mutations, no UI calls. Reads files locally — only the
-* wizard process does this; the agent never sees secret values.
-*
-* Note we only read `.env` KEY NAMES, never values.
-*/
-const MAX_DEPTH = 3;
-const MAX_SIGNAL_SET = MAX_ENV_KEY_SET;
-function addCapped(set, value) {
-	if (set.size < MAX_SIGNAL_SET) set.add(value);
 }
 /**
-* Detect which warehouse sources the project at `installDir` appears to use.
-* Returns one `DetectedSource` per matched registry entry (kinds are unique,
-* so the result is naturally deduped), minus the entries a more specific
-* match supersedes.
+* The index of the `>` that closes the tag opened at `start`, or the end of
+* the content. Skips a `>` inside a quoted value or a JSX `{...}` expression,
+* such as an arrow function in a `<Script onLoad={() => ...}>` prop.
 */
-function detectWarehouseSources(installDir) {
-	const signals = collectSignals(installDir);
-	const matched = [];
-	for (const detector of SOURCE_DETECTORS) {
-		const signal = matchDetector(detector, signals);
-		if (signal) matched.push({
-			detector,
-			signal
-		});
+function endOfTag(content, start) {
+	let quote = null;
+	let braces = 0;
+	for (let i = start; i < content.length; i += 1) {
+		const char = content[i];
+		if (quote) {
+			if (char === quote) quote = null;
+		} else if (char === "\"" || char === "'" || char === "`") quote = char;
+		else if (char === "{") braces += 1;
+		else if (char === "}") braces = Math.max(0, braces - 1);
+		else if (char === ">" && braces === 0) return i;
 	}
-	const kinds = new Set(matched.map((m) => m.detector.kind));
-	return matched.filter(({ detector }) => !isSuperseded(detector, kinds)).map(({ detector, signal }) => ({
-		kind: detector.kind,
-		label: detector.label,
-		mode: detector.mode,
-		matchedSignal: signal
-	}));
+	return content.length;
 }
 /**
-* Whether a more specific match covers this detector's data. Every consumer
-* treats a detected kind as a source to create, so a project whose Postgres
-* lives on Neon or Supabase would otherwise be offered both and end up with
-* the same tables imported twice.
+* Record the catalog script hosts a template loads from. Only `<script>`
+* elements count: a URL in a link or in text loads nothing. A hostname is kept
+* as the catalog host it matched, never as written, so a customer subdomain
+* such as `acme.zendesk.com` never leaves the machine. Every other hostname
+* is dropped as soon as it is read.
 */
-function isSuperseded(detector, detectedKinds) {
-	return (detector.supersededBy ?? []).some((kind) => detectedKinds.has(kind));
-}
-/** Returns a human-readable description of the first matching signal, or null. */
-function matchDetector(detector, signals) {
-	const { npm, python, ruby, envKeys } = detector.signals;
-	const npmHit = npm?.find((dep) => signals.npm.has(dep));
-	if (npmHit) return `found \`${npmHit}\` in package.json`;
-	const pyHit = python?.find((dep) => signals.python.has(dep));
-	if (pyHit) return `found \`${pyHit}\` in Python dependencies`;
-	const rubyHit = ruby?.find((gem) => signals.ruby.has(gem));
-	if (rubyHit) return `found \`${rubyHit}\` in Gemfile`;
-	if (envKeys) {
-		for (const [key, file] of signals.envKeys) if (envKeys.some((re) => re.test(key))) return `found \`${key}\` in \`${file}\``;
+function addScriptHosts(content, signals, file) {
+	if (signals.templatesRead >= MAX_TEMPLATE_FILES) return;
+	if (content.length > MAX_TEMPLATE_BYTES) return;
+	if (!/<script\b/i.test(content)) return;
+	signals.templatesRead += 1;
+	for (const element of scriptElements(content)) for (const match of element.matchAll(URL_HOST)) {
+		const host = match[1].toLowerCase();
+		for (const catalogHost of signals.catalogScriptHosts) if (hostMatches(host, catalogHost) && !signals.scriptHosts.has(catalogHost)) signals.scriptHosts.set(catalogHost, file);
 	}
-	return null;
-}
-function collectSignals(installDir) {
-	const signals = {
-		npm: /* @__PURE__ */ new Set(),
-		python: /* @__PURE__ */ new Set(),
-		ruby: /* @__PURE__ */ new Set(),
-		envKeys: /* @__PURE__ */ new Map()
-	};
-	walkProjectFiles(installDir, (name, fullPath) => ingestFile(installDir, name, fullPath, signals), MAX_DEPTH);
-	return signals;
-}
-/**
-* Route a file to the right parser BY NAME, reading its contents only when the
-* name matches one of the ~6 manifests we care about. Checking the name first
-* avoids slurping every file in the tree (lockfiles, binaries, assets) into
-* memory just to discard it.
-*/
-function ingestFile(installDir, name, fullPath, signals) {
-	const ingest = ingestorFor(name);
-	if (!ingest) return;
-	const content = safeReadFile(fullPath);
-	if (content === null) return;
-	ingest(content, signals, toPromptSafeRelativePath(installDir, fullPath));
-}
-/** Pick the parser for a manifest filename, or null if it's not one we read. */
-function ingestorFor(name) {
-	if (name === "package.json") return addNpmDeps;
-	if (name === "requirements.txt") return (c, s) => parseRequirementsTxt(c).forEach((d) => addCapped(s.python, d));
-	if (name === "pyproject.toml") return (c, s) => parsePyprojectToml(c).forEach((d) => addCapped(s.python, d));
-	if (name === "Pipfile") return (c, s) => parsePipfile(c).forEach((d) => addCapped(s.python, d));
-	if (name === "Gemfile") return (c, s) => parseGemfile(c).forEach((g) => addCapped(s.ruby, g));
-	if (isEnvFileName(name)) return (c, s, relativePath) => addEnvKeys(c, s, relativePath);
-	return null;
 }
 /**
 * Record each key NAME against the file that defined it. The first file wins,
@@ -9773,13 +7988,13 @@ function addEnvKeys(content, signals, relativePath) {
 		signals.envKeys.set(key, relativePath);
 	}
 }
-function addNpmDeps(content, signals) {
+function addNpmDeps(content, signals, file) {
 	try {
 		const pkg = JSON.parse(content);
 		for (const dep of Object.keys({
 			...pkg.dependencies,
 			...pkg.devDependencies
-		})) addCapped(signals.npm, dep);
+		})) addPackage(signals, "npm", dep, file);
 	} catch (error) {
 		analytics.captureException(error instanceof Error ? error : new Error(String(error)), { step: "detectWarehouseSources.parsePackageJson" });
 	}
@@ -9800,6 +8015,169 @@ function getDetectedWarehouseSources(session) {
 	return session.frameworkContext["detectedWarehouseSources"] ?? [];
 }
 //#endregion
+//#region src/programs/warehouse-sources/registry.ts
+/**
+* Registry of data warehouse source detectors, built from PostHog's tool
+* catalog. The wizard downloads the catalog at runtime, so a tool added in
+* PostHog reaches every installed wizard without a release. Edit the catalog
+* in PostHog, not here.
+*/
+const CATALOG_API_PATH = "/api/wizard/tool_catalog/";
+/** Tried in order after a pinned PostHog host. Both regions serve the same catalog. */
+const PUBLIC_CATALOG_SOURCES = [{
+	name: "us",
+	url: `https://us.posthog.com${CATALOG_API_PATH}`
+}, {
+	name: "eu",
+	url: `https://eu.posthog.com${CATALOG_API_PATH}`
+}];
+const FETCH_TIMEOUT_MS = 5e3;
+const KIND = /^[A-Za-z0-9]{1,64}$/;
+const catalogToolSchema = z.object({
+	kind: z.string().regex(KIND),
+	label: z.string().regex(/^[\w .,&()+/'!-]{1,80}$/),
+	warehouse_source_type: z.string().regex(KIND).nullable(),
+	wizard_setup_mode: z.enum(["in-cli", "deep-link"]).nullable(),
+	superseded_by: z.array(z.string().regex(KIND)),
+	signals: z.object({
+		env_key_patterns: z.array(z.string().regex(/^\^(?:(?:[A-Za-z0-9_]|\((?:[A-Za-z0-9_]+\|)*[A-Za-z0-9_]+\))\??)+\$?$/)),
+		script_hosts: z.array(z.string().regex(/^[a-z0-9.-]{1,253}$/)),
+		packages: z.record(z.string(), z.array(z.string().regex(/^[A-Za-z0-9@/._:+~-]{1,214}$/)))
+	})
+});
+const catalogEnvelopeSchema = z.object({
+	schema_version: z.literal(1),
+	tools: z.array(z.unknown())
+});
+function toDetector(tool) {
+	return {
+		kind: tool.kind,
+		label: tool.label,
+		warehouseSourceType: tool.warehouse_source_type,
+		mode: tool.wizard_setup_mode,
+		signals: {
+			envKeys: tool.signals.env_key_patterns.map((pattern) => new RegExp(pattern)),
+			scriptHosts: tool.signals.script_hosts,
+			packages: tool.signals.packages
+		},
+		supersededBy: tool.superseded_by
+	};
+}
+/**
+* Reads a downloaded catalog body. Throws when the body is not a version 1
+* catalog. Skips a tool entry that fails validation, and logs it.
+*/
+function toSourceDetectors(body) {
+	const catalog = catalogEnvelopeSchema.safeParse(body);
+	if (!catalog.success) throw new Error(`unreadable catalog: ${catalog.error.message}`);
+	const detectors = [];
+	catalog.data.tools.forEach((entry, index) => {
+		const tool = catalogToolSchema.safeParse(entry);
+		if (tool.success) detectors.push(toDetector(tool.data));
+		else logToFile(`[tool-catalog] skipped tool ${index}: ${tool.error.message.slice(0, 500)}`);
+	});
+	return detectors;
+}
+function catalogSources(baseUrl) {
+	const pinned = resolveBaseUrl(baseUrl);
+	if (!pinned) return [...PUBLIC_CATALOG_SOURCES];
+	return [{
+		name: "pinned",
+		url: `${pinned.replace(/\/+$/, "")}${CATALOG_API_PATH}`
+	}, ...PUBLIC_CATALOG_SOURCES];
+}
+async function fetchDetectors(url) {
+	const response = await fetch(url, {
+		headers: { "User-Agent": WIZARD_USER_AGENT },
+		signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+	});
+	if (!response.ok) throw new Error(`HTTP ${response.status}`);
+	return toSourceDetectors(await response.json());
+}
+async function downloadDetectors(baseUrl) {
+	const failures = {};
+	for (const { name, url } of catalogSources(baseUrl)) try {
+		const detectors = await fetchDetectors(url);
+		logToFile(`[tool-catalog] loaded ${detectors.length} tools from ${url}`);
+		return detectors;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		logToFile(`[tool-catalog] ${url} failed: ${message}`);
+		failures[name] = message.slice(0, 200);
+	}
+	analytics.wizardCapture("tool catalog unavailable", { failures });
+	return [];
+}
+let loading = null;
+/**
+* The detectors from PostHog's tool catalog. Tries a pinned PostHog host
+* (`--base-url`, `--local-posthog`, dev builds) first, then US and EU.
+* Resolves to an empty list when every source fails, and never rejects, so
+* the run goes on without codebase detection.
+*
+* Every caller in the process shares the first call's download. The base URL
+* is fixed for a run, so the first caller's `baseUrl` is everyone's.
+*/
+function loadSourceDetectors(baseUrl) {
+	loading ??= downloadDetectors(baseUrl);
+	return loading;
+}
+//#endregion
+//#region src/programs/codebase-scan/scan.ts
+/**
+* The run's one codebase scan. Every program that sets `scansCodebase` reads
+* this result instead of scanning on its own, so local suggestions, the
+* warehouse flow, the self-driving prompt and the report all agree. Each
+* program derives its own view from it in `onReady`; the scan writes no
+* program's keys, so a composed run sees only what its own program chose.
+*
+* Scanning always runs; consent only gates reporting (see `report.ts`).
+*/
+/** frameworkContext key holding the full scan, every detected tool included. */
+const CODEBASE_SCAN_KEY = "codebaseScan";
+/** Scan once per run, for a program that sets `scansCodebase`. Best-effort: never throws. */
+async function scanCodebaseFor(config, ctx) {
+	if (!config.scansCodebase) return;
+	if (getCodebaseScan(ctx.session)) return;
+	const detectors = await loadSourceDetectors(ctx.session.baseUrl);
+	const scannedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const scannedDir = ctx.session.installDir;
+	const failed = {
+		program: config.id,
+		scannedAt,
+		scannedDir,
+		tools: [],
+		complete: false,
+		failed: true
+	};
+	if (detectors.length === 0) {
+		ctx.setFrameworkContext(CODEBASE_SCAN_KEY, failed);
+		return;
+	}
+	try {
+		const { tools, complete } = detectTools(scannedDir, detectors);
+		ctx.setFrameworkContext(CODEBASE_SCAN_KEY, {
+			program: config.id,
+			scannedAt,
+			scannedDir,
+			tools,
+			complete
+		});
+	} catch (error) {
+		ctx.setFrameworkContext(CODEBASE_SCAN_KEY, failed);
+		analytics.captureException(error instanceof Error ? error : new Error(String(error)), { step: "scanCodebase" });
+	}
+}
+/** The warehouse sources the scan found, for a program that offers them. */
+async function scannedWarehouseSources(session) {
+	const scan = getCodebaseScan(session);
+	if (!scan) return [];
+	return toWarehouseSources(scan.tools, await loadSourceDetectors(session.baseUrl));
+}
+function getCodebaseScan(session) {
+	return session.frameworkContext[CODEBASE_SCAN_KEY];
+}
+//#endregion
 //#region src/programs/shared/package-scanning.ts
 const POSTHOG_SDKS = new Set([
 	"posthog-js",
@@ -9840,22 +8218,6 @@ function findPackageJsons(installDir, maxDepth = 3) {
 	return matches;
 }
 //#endregion
-//#region src/programs/detection/ai-sdk-stamp.ts
-function hasAiSdkEvidence(evidence) {
-	return evidence.warehouseSources.some((s) => AI_SOURCE_KINDS.has(s.kind)) || evidence.discoveredFeatures.includes("llm");
-}
-/**
-* Boolean only, on the org, never the list of kinds or any non-AI tool: a
-* decline must not leak even the shape of what local detection saw.
-*/
-function stampAiSdkDetected(evidence) {
-	if (!evidence.mayReportScanResults) return;
-	const organizationId = evidence.apiUser?.organization?.id;
-	if (!organizationId) return;
-	if (!hasAiSdkEvidence(evidence)) return;
-	analytics.groupIdentify("organization", organizationId, { wizard_ai_sdk_detected: true });
-}
-//#endregion
 //#region src/programs/detection/integration.ts
 async function detectPostHogIntegration(ctx) {
 	const session = ctx.session;
@@ -9882,7 +8244,7 @@ async function detectPostHogIntegration(ctx) {
 		if (versionResult.supported !== true) ctx.setUnsupportedVersion(versionResult.supported);
 	}
 	for (const feature of discoverFeatures(installDir)) ctx.addDiscoveredFeature(feature);
-	detectWarehouseSourcesForSuggestion(ctx, installDir);
+	await offerScannedWarehouseSources(ctx);
 	detectExistingPostHog(ctx, installDir);
 	ctx.setDetectionComplete();
 }
@@ -9894,40 +8256,35 @@ async function detectPostHogIntegration(ctx) {
 *            scan below, but every program's intro screen resolves consent
 *            through the same store method, so the reporter is reached on runs
 *            where no scan ever happened.
-*   'failed' the scan threw. A zero-count row would read as "scanned, found
-*            nothing", which is a different fact.
+*   'failed' the scan threw, or had no tool catalog to match against. A
+*            zero-count row would read as "scanned, found nothing", which is
+*            a different fact.
 *   'ok'     the scan ran. Zero sources is a real result and gets reported.
 */
 const WAREHOUSE_SCAN_STATE_KEY = "warehouseScanState";
 /**
-* Scan for data warehouse source signals (Postgres, Stripe, Hubspot, …) and,
-* when found, stash them for a `wizard warehouse` suggestion on the outro.
-* Runs unconditionally during `detect`, before the intro screen has asked
-* about sharing. Reporting what this finds is a separate, later concern.
-* See `reportWarehouseSourcesDetected` below.
+* Stash the run's scanned warehouse sources (Postgres, Stripe, Hubspot, …)
+* for a `wizard warehouse` suggestion on the outro. The scan itself runs
+* unconditionally before `onReady`, before the intro screen has asked about
+* sharing. Reporting what it found is a separate, later concern. See
+* `reportWarehouseSourcesDetected` below.
 *
 * Deliberately a suggestion, not an inline agent run: a second credential-
 * collecting agent run before the outro could end the run on any of its
 * failure paths and cost the user the success outro on a run where PostHog
 * installed fine.
-*
-* Calls `detectWarehouseSources` (a pure scan) rather than the warehouse
-* program's `detectWarehousePrerequisites`, which writes a `detectError` when
-* it finds nothing — that's right for `wizard warehouse` but here would show a
-* spurious error and trip the CI prerequisites abort. No sources is a no-op.
-*
-* Best-effort: never let a scan failure break the wizard flow.
 */
-function detectWarehouseSourcesForSuggestion(ctx, installDir) {
-	try {
-		const sources = detectWarehouseSources(installDir);
-		ctx.setFrameworkContext(WAREHOUSE_SCAN_STATE_KEY, "ok");
-		if (sources.length === 0) return;
-		ctx.setFrameworkContext(DETECTED_WAREHOUSE_SOURCES_KEY, sources);
-	} catch (error) {
+async function offerScannedWarehouseSources(ctx) {
+	const scan = getCodebaseScan(ctx.session);
+	if (!scan) return;
+	if (scan.failed) {
 		ctx.setFrameworkContext(WAREHOUSE_SCAN_STATE_KEY, "failed");
-		analytics.captureException(error instanceof Error ? error : new Error(String(error)), { step: "detectWarehouseSourcesForSuggestion" });
+		return;
 	}
+	ctx.setFrameworkContext(WAREHOUSE_SCAN_STATE_KEY, "ok");
+	const sources = await scannedWarehouseSources(ctx.session);
+	if (sources.length === 0) return;
+	ctx.setFrameworkContext(DETECTED_WAREHOUSE_SOURCES_KEY, sources);
 }
 /**
 * The single place scan results become telemetry. Called from
@@ -9947,10 +8304,12 @@ function reportWarehouseSourcesDetected(session) {
 	if (mayReportScanResults(session)) {
 		const sources = getDetectedWarehouseSources(session);
 		if (session.frameworkContext[WAREHOUSE_SCAN_STATE_KEY] !== "ok") return true;
+		const discoveredFeatures = reportableDiscoveredFeatures(session);
 		analytics.wizardCapture("warehouse sources detected", {
 			warehouse_source_count: sources.length,
 			warehouse_source_kinds: sources.map((s) => s.kind),
-			warehouse_source_modes: sources.map((s) => s.mode)
+			warehouse_source_modes: sources.map((s) => s.mode),
+			...discoveredFeatures ? { discovered_features: discoveredFeatures } : {}
 		});
 		if (sources.length > 0) {
 			analytics.setTag("warehouse_source_kinds", sources.map((s) => s.kind).join(","));
@@ -10196,14 +8555,25 @@ const config = {
 	agentFlow: "integration-v2",
 	handoffNotebook: true,
 	eventPlanFile: EVENT_PLAN_FILE,
+	scansCodebase: true,
 	onReady: (ctx) => detectPostHogIntegration(ctx),
 	disallowedTools: [WIZARD_TOOL_NAMES.wizardAsk],
 	oauthScopeAdditions: [...WAREHOUSE_SOURCE_SCOPE_ADDITIONS],
 	seedTasks: warehouseSeedTasks,
+	decisions: [
+		"framework",
+		"is_monorepo",
+		"product_category",
+		"calls_llm_api",
+		"structured_logging",
+		"otel_exporter",
+		"server_runtime",
+		"observability_stack"
+	],
 	excludedTaskTypes: (flags) => flags["wizard-default-aio-logs"] === "false" ? ["ai-observability", "logs"] : [],
 	ciPreRun: async (session, runner) => {
 		await scopeInstallDirToProject(session, runner);
-		const integration = await detectFramework(session.installDir);
+		const integration = await detectFramework(session.installDir) ?? void 0;
 		if (!integration) abortNoFrameworkDetected();
 		session.integration = integration;
 		analytics.setTag("integration", integration);
@@ -10231,7 +8601,7 @@ const config = {
 		if (usesPackageJson) {
 			const packageJson = await tryGetPackageJson({ installDir: session.installDir });
 			if (packageJson) {
-				const { hasDeclaredDependency } = await import("./package-json-Dblip2_X.js");
+				const { hasDeclaredDependency } = await import("./package-json-BAtJRHSq.js");
 				if (!hasDeclaredDependency(config.detection.packageName, packageJson)) runner.log.warn(`${config.detection.packageDisplayName} does not seem to be installed. Continuing anyway — the agent will handle it.`);
 				frameworkVersion = config.detection.getVersion(packageJson);
 			} else runner.log.warn("Could not find package.json. Continuing anyway — the agent will handle it.");
@@ -10300,7 +8670,7 @@ ${warehouseReportInstruction(session)}
 			postRun: async (sess, credentials) => {
 				const envVars = config.environment.getEnvVars(credentials.projectApiKey, credentials.host.apiHost);
 				if (config.environment.uploadToHosting) {
-					const { uploadEnvironmentVariablesStep } = await import("./upload-step-CFoxwd5t.js");
+					const { uploadEnvironmentVariablesStep } = await import("./upload-step-DrYXnpzI.js");
 					const uploadedEnvVars = await uploadEnvironmentVariablesStep(envVars, {
 						integration: config.metadata.integration,
 						installDir: sess.installDir,
@@ -10342,6 +8712,6 @@ ${warehouseReportInstruction(session)}
 	}
 };
 //#endregion
-export { formatCostUsd as A, FRAMEWORK_REGISTRY as C, runAgent as D, streamMcpPrompt as E, DEFAULT_BINDING as O, detectFramework as S, scanInstalledSkill as T, detectProjectsWithAgent as _, detectPostHogIntegration as a, noteDetectedFramework as b, POSTHOG_SDKS as c, DETECTED_WAREHOUSE_SOURCES_KEY as d, detectWarehouseSources as f, toIntegrationCandidates as g, scopeInstallDirToProject as h, ProgramAbort as i, formatTokenCount as j, computeTokenCostUsd as k, STRIPE_SDKS as l, detectIntegrationProjects as m, WAREHOUSE_SOURCE_SCOPE_ADDITIONS as n, reportWarehouseSourcesDetected as o, getDetectedWarehouseSources as p, abortNoFrameworkDetected as r, stampAiSdkDetected as s, config as t, findPackageJsons as u, resolveProjectDir as v, SPINNER_MESSAGE as w, gatherFrameworkContext as x, loadWizardFlags as y };
+export { streamMcpPrompt as A, loadWizardFlags as C, FRAMEWORK_REGISTRY as D, detectFramework as E, formatTokenCount as F, DEFAULT_BINDING as M, computeTokenCostUsd as N, SPINNER_MESSAGE as O, formatCostUsd as P, tagScanResults as S, gatherFrameworkContext as T, scopeInstallDirToProject as _, detectPostHogIntegration as a, resolveProjectDir as b, STRIPE_SDKS as c, scanCodebaseFor as d, scannedWarehouseSources as f, detectIntegrationProjects as g, workspaceFingerprint as h, ProgramAbort as i, runAgent as j, scanInstalledSkill as k, findPackageJsons as l, getDetectedWarehouseSources as m, WAREHOUSE_SOURCE_SCOPE_ADDITIONS as n, reportWarehouseSourcesDetected as o, DETECTED_WAREHOUSE_SOURCES_KEY as p, abortNoFrameworkDetected as r, POSTHOG_SDKS as s, config as t, getCodebaseScan as u, toIntegrationCandidates as v, noteDetectedFramework as w, applyScanTags as x, detectProjectsWithAgent as y };
 
-//# sourceMappingURL=posthog-integration-DxRkw5DI.js.map
+//# sourceMappingURL=posthog-integration-mIQGBc1f.js.map