@planu/cli 4.13.0 → 5.0.0

package/dist/engine/validator/validation-report-writer.js

@@ -1,7 +1,7 @@
 import { appendArtifact, readArtifact } from '../handoff-artifacts/io.js';
 import { runSpecCompliance, } from './spec-compliance-runner.js';
 export async function writeImplementationReviewReport(input) {
-    const specCompliance = await runSpecCompliance(input.spec, input.projectPath, input.signal);
+    const specCompliance = await runSpecCompliance(input.spec, input.projectPath, input.signal, input.projectId);
     const reportScore = resolveExecutableValidationScore(input.score, specCompliance);
     const gates = buildGates({
         score: reportScore,

package/dist/engine/validator.js

@@ -6,8 +6,9 @@ import { extractCriteria, extractVerifyBlocks } from './validator/extractors.js'
 import { scanCodeForSpec, checkCriterionEvidence, classifyDriftSeverity, quickQualityCheck, } from './validator/analyzer.js';
 import { resolveApplicableDimensions } from './validator/scope-resolver.js';
 import { buildHolisticReportFromFlatScore } from './validator/holistic-report.js';
-import { readEvidenceArtifacts } from './evidence-gates/artifact-reader.js';
-import { createCriterionIdentity } from './criterion-identity.js';
+import { readEvidenceArtifacts, traceabilityRowHasCurrentCommandEvidence, traceabilityRowHasCurrentTestEvidence, } from './evidence-gates/artifact-reader.js';
+import { createCriterionIdentity, hasExplicitCriterionId, normalizeCriterionText, } from './criterion-identity.js';
+import { hashProjectPath } from '../storage/base-store.js';
 // Re-export the full public API so external callers never need to know
 // about the sub-module layout.
 export { generateDoR, generateDoD } from './validator/dor-dod.js';
@@ -15,30 +16,39 @@ export { generateChecklist } from './validator/checklist.js';
 // SPEC-730: export scope-resolver and holistic-report for consumers
 export { resolveApplicableDimensions, normaliseScore } from './validator/scope-resolver.js';
 export { buildHolisticReportFromFlatScore } from './validator/holistic-report.js';
-function rowHasValidationEvidence(row) {
-    const hasImplementationEvidence = [
-        row.scenario?.trim(),
-        row.testEvidence?.length,
-        row.contractEvidence?.length,
-        row.manualEvidence?.trim(),
-    ].some((value) => Boolean(value));
-    return (row.changedFiles.length > 0 &&
-        hasImplementationEvidence &&
-        Boolean(row.validationEvidence?.trim()) &&
-        Boolean(row.reviewerEvidence?.trim()));
-}
 async function readTraceabilityEvidence(spec, projectPath) {
     try {
         const artifacts = await readEvidenceArtifacts({
             spec,
-            projectId: spec.projectId,
+            projectId: hashProjectPath(projectPath),
             specId: spec.id,
             projectPath,
         });
         const rows = artifacts.traceabilityMatrix?.rows ?? [];
-        return new Map(rows
-            .filter(rowHasValidationEvidence)
-            .flatMap((row, index) => createCriterionIdentity(row.acceptanceCriterion, { index }).aliases.map((alias) => [alias, row])));
+        const exactRows = new Map();
+        for (const [rowIndex, row] of rows.entries()) {
+            const evidenceArgs = { projectId: hashProjectPath(projectPath), projectPath };
+            if (!traceabilityRowHasCurrentCommandEvidence(row, evidenceArgs) &&
+                !traceabilityRowHasCurrentTestEvidence(row, evidenceArgs)) {
+                continue;
+            }
+            const identities = new Set(createCriterionIdentity(row.acceptanceCriterion, { index: rowIndex }).aliases);
+            if (row.scenario) {
+                const normalizedScenario = normalizeCriterionText(row.scenario);
+                if (normalizedScenario) {
+                    identities.add(normalizedScenario);
+                }
+            }
+            for (const identity of identities) {
+                if (!exactRows.has(identity)) {
+                    exactRows.set(identity, row);
+                }
+                else if (exactRows.get(identity) !== row) {
+                    exactRows.set(identity, undefined);
+                }
+            }
+        }
+        return new Map([...exactRows].filter((entry) => entry[1] !== undefined));
     }
     catch {
         return new Map();
@@ -93,12 +103,16 @@ export async function validateSpec(spec, projectPath) {
     const indeterminate = [];
     const extra = [];
     const qualityIssues = [];
-    for (let criterionIndex = 0; criterionIndex < criteria.length; criterionIndex += 1) {
-        const criterion = criteria[criterionIndex] ?? '';
+    for (const [criterionIndex, criterion] of criteria.entries()) {
         const verifyBlock = verifyBlockMap.get(criterion);
-        const evidenceRow = createCriterionIdentity(criterion, { index: criterionIndex })
-            .aliases.map((alias) => traceabilityEvidence.get(alias))
-            .find((row) => row !== undefined);
+        const criterionIdentity = createCriterionIdentity(criterion, { index: criterionIndex });
+        const aliases = hasExplicitCriterionId(criterion)
+            ? criterionIdentity.aliases
+            : [criterionIdentity.normalizedText];
+        const evidenceRows = new Set(aliases
+            .map((alias) => traceabilityEvidence.get(alias))
+            .filter((row) => row !== undefined));
+        const evidenceRow = evidenceRows.size === 1 ? [...evidenceRows][0] : undefined;
         if (evidenceRow !== undefined) {
             matches.push(criterion);
             continue;

package/dist/engine/verify-integrations/index.js

@@ -51,7 +51,7 @@ export async function verifyIntegrations(input) {
 // Internal helpers
 // ---------------------------------------------------------------------------
 async function loadConfig(projectPath) {
-    const configPath = join(projectPath, '.planu', 'integrations.json');
+    const configPath = join(projectPath, 'planu', 'integrations.json');
     try {
         const raw = await readFile(configPath, 'utf-8');
         const parsed = JSON.parse(raw);

package/dist/engine/version-resolver.js

@@ -5,6 +5,8 @@
 import { readFile, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { fetchLatestVersion } from './package-registry.js';
+import { getCachedVersions, saveCachedVersions, isExpired as isCachedVersionExpired, } from '../storage/version-cache-store.js';
 // -- Constants ---------------------------------------------------------------
 const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
 const CACHE_FILE = join(tmpdir(), 'planu-version-cache.json');
@@ -47,7 +49,6 @@ async function setInPersistentCache(key, entry) {
 // -- Registry fetch ----------------------------------------------------------
 async function fetchFromRegistry(packageName, registry) {
     try {
-        const { fetchLatestVersion } = await import('./package-registry.js');
         const result = await fetchLatestVersion(packageName, registry);
         if (!result) {
             return null;
@@ -201,20 +202,18 @@ export async function resolveSpecVersions(specText, projectId) {
     if (packages.length === 0) {
         return null;
     }
-    const { getCachedVersions, saveCachedVersions, isExpired: isCacheExpired, } = await import('../storage/version-cache-store.js');
     const cache = await getCachedVersions(projectId);
     const resolved = [];
     const updatedCache = { ...cache };
     await Promise.allSettled(packages.map(async (name) => {
         const cached = cache[name];
-        if (cached && !isCacheExpired(cached)) {
+        if (cached && !isCachedVersionExpired(cached)) {
             resolved.push(`${name}@${cached.version}`);
             return;
         }
         try {
-            const { fetchLatestVersion: fetchVersion } = await import('./package-registry.js');
             const result = await Promise.race([
-                fetchVersion(name, 'npm'),
+                fetchLatestVersion(name, 'npm'),
                 new Promise((resolve) => {
                     /* c8 ignore next */
                     setTimeout(() => {
@@ -235,7 +234,7 @@ export async function resolveSpecVersions(specText, projectId) {
             /* best-effort — skip unresolvable packages */
         }
     }));
-    if (Object.keys(updatedCache).length > Object.keys(cache).length) {
+    if (JSON.stringify(updatedCache) !== JSON.stringify(cache)) {
         await saveCachedVersions(projectId, updatedCache).catch(() => {
             /* best-effort */
         });

package/dist/engine/web-fetcher/stack-advisor.js

@@ -1,27 +1,25 @@
-// Planu — Web Fetcher: Stack recommendation logic
-// SPEC-597-EXEMPT: canonical name→npm-package mapping. Moving to JSON adds no
-// value because the consumer reads every key at once.
+import { technologyValue } from '../technology-registry.js';
 import { resolveFrameworkVersion } from '../version-resolver.js';
 const FRAMEWORK_PACKAGES = {
-    'next.js': 'next',
-    react: 'react',
-    vue: 'vue',
+    [technologyValue('technology-next-js-0d857f')]: 'next',
+    react: technologyValue('technology-react-275976'),
+    vue: technologyValue('technology-vue-564382'),
     angular: '@angular/core',
-    svelte: 'svelte',
-    astro: 'astro',
+    svelte: technologyValue('technology-svelte-c190ac'),
+    astro: technologyValue('technology-astro-23661e'),
     remix: '@remix-run/node',
     hono: 'hono',
-    express: 'express',
+    express: technologyValue('technology-express-008231'),
     expo: 'expo',
     commander: 'commander',
     tsup: 'tsup',
-    django: 'django',
-    fastapi: 'fastapi',
-    flask: 'flask',
-    gin: 'gin',
+    django: technologyValue('technology-django-7d8a08'),
+    fastapi: technologyValue('technology-fastapi-6aee0e'),
+    flask: technologyValue('technology-flask-b87aa5'),
+    gin: technologyValue('technology-gin-985adc'),
     cobra: 'cobra',
     cargo: 'cargo',
-    flutter: 'flutter',
+    flutter: technologyValue('technology-flutter-be1396'),
 };
 export async function verifyFrameworkVersion(framework) {
     const { fetchLatestVersion } = await import('../package-registry.js');
@@ -32,67 +30,114 @@ export async function verifyFrameworkVersion(framework) {
     const result = await fetchLatestVersion(packageName, 'npm');
     return result?.version ?? null;
 }
+function getBaseLibraryStack() {
+    return {
+        library: {
+            language: technologyValue('technology-typescript-969545'),
+            framework: 'tsup',
+            version: '8+',
+            database: 'none',
+            deployment: 'npm',
+            reasoning: 'tsup provides fast bundling with zero config for TypeScript libraries.',
+            ecosystem: ['tsup', technologyValue('technology-vitest-a9127f'), 'changesets'],
+        },
+    };
+}
 function getBaseRecommendations() {
     return {
         web: {
-            language: 'typescript',
-            framework: 'next.js',
+            language: technologyValue('technology-typescript-969545'),
+            framework: technologyValue('technology-next-js-0d857f'),
             version: '14+',
             database: 'postgresql',
-            orm: 'prisma',
+            orm: technologyValue('technology-prisma-99497c'),
             auth: 'next-auth',
-            deployment: 'vercel',
+            deployment: technologyValue('technology-vercel-9d3508'),
             reasoning: 'Next.js offers the best DX for web apps with SSR/SSG, API routes, and a mature ecosystem.',
-            ecosystem: ['react', 'tailwind', 'shadcn/ui', 'zod', 'tanstack-query'],
+            ecosystem: [
+                technologyValue('technology-react-275976'),
+                technologyValue('technology-tailwind-44c8cf'),
+                technologyValue('technology-shadcn-ui-542509'),
+                technologyValue('technology-zod-4f63cf'),
+                'tanstack-query',
+            ],
         },
         fullstack: {
-            language: 'typescript',
-            framework: 'next.js',
+            language: technologyValue('technology-typescript-969545'),
+            framework: technologyValue('technology-next-js-0d857f'),
             version: '14+',
             database: 'postgresql',
-            orm: 'drizzle',
+            orm: technologyValue('technology-drizzle-424f22'),
             auth: 'next-auth',
-            deployment: 'vercel',
+            deployment: technologyValue('technology-vercel-9d3508'),
             reasoning: 'Full-stack TypeScript with Next.js provides end-to-end type safety and excellent DX.',
-            ecosystem: ['react', 'tailwind', 'trpc', 'zod', 'drizzle'],
+            ecosystem: [
+                technologyValue('technology-react-275976'),
+                technologyValue('technology-tailwind-44c8cf'),
+                technologyValue('technology-trpc-7a75ed'),
+                technologyValue('technology-zod-4f63cf'),
+                technologyValue('technology-drizzle-424f22'),
+            ],
         },
         backend: {
-            language: 'typescript',
+            language: technologyValue('technology-typescript-969545'),
             framework: 'hono',
             version: '4+',
             database: 'postgresql',
-            orm: 'drizzle',
-            deployment: 'railway',
+            orm: technologyValue('technology-drizzle-424f22'),
+            deployment: technologyValue('technology-railway-e34d1c'),
             reasoning: 'Hono is lightweight, fast, and works across runtimes (Node, Bun, Cloudflare Workers).',
-            ecosystem: ['zod', 'drizzle', 'vitest'],
+            ecosystem: [
+                technologyValue('technology-zod-4f63cf'),
+                technologyValue('technology-drizzle-424f22'),
+                technologyValue('technology-vitest-a9127f'),
+            ],
         },
         mobile: {
-            language: 'typescript',
+            language: technologyValue('technology-typescript-969545'),
             framework: 'expo',
             version: '50+',
-            database: 'supabase',
+            database: technologyValue('technology-supabase-4d7594'),
             auth: 'supabase-auth',
             deployment: 'eas-build',
             reasoning: 'Expo simplifies React Native development with OTA updates and managed workflow.',
             ecosystem: ['react-native', 'expo-router', 'tamagui', 'zustand'],
         },
         cli: {
-            language: 'typescript',
+            language: technologyValue('technology-typescript-969545'),
             framework: 'commander',
             version: '12+',
             database: 'sqlite',
             deployment: 'npm',
             reasoning: 'TypeScript CLI tools with Commander provide type safety and excellent developer experience.',
-            ecosystem: ['commander', 'inquirer', 'chalk', 'zod'],
+            ecosystem: ['commander', 'inquirer', 'chalk', technologyValue('technology-zod-4f63cf')],
+        },
+        ...getBaseLibraryStack(),
+    };
+}
+function getAlternativeSystemStacks() {
+    return {
+        cli: {
+            language: 'go',
+            framework: 'cobra',
+            version: '1.22+',
+            database: 'sqlite',
+            deployment: 'goreleaser',
+            reasoning: 'Go CLI tools compile to a single binary with zero dependencies.',
+            ecosystem: ['cobra', 'viper', 'bubbletea'],
         },
         library: {
-            language: 'typescript',
-            framework: 'tsup',
-            version: '8+',
+            language: 'rust',
+            framework: 'cargo',
+            version: '2021+',
             database: 'none',
-            deployment: 'npm',
-            reasoning: 'tsup provides fast bundling with zero config for TypeScript libraries.',
-            ecosystem: ['tsup', 'vitest', 'changesets'],
+            deployment: 'crates.io',
+            reasoning: 'Rust provides memory safety and excellent performance for system-level libraries.',
+            ecosystem: [
+                'cargo',
+                technologyValue('technology-serde-8b917c'),
+                technologyValue('technology-tokio-434de5'),
+            ],
         },
     };
 }
@@ -105,11 +150,23 @@ function applyRequirementOverrides(rec, requirements, constraints) {
         result = {
             ...result,
             language: 'python',
-            framework: requestsApi ? 'fastapi' : 'django',
+            framework: requestsApi
+                ? technologyValue('technology-fastapi-6aee0e')
+                : technologyValue('technology-django-7d8a08'),
             version: requestsApi ? '0.100+' : '5+',
             ecosystem: requestsApi
-                ? ['fastapi', 'pydantic', 'sqlalchemy', 'alembic']
-                : ['django', 'django-rest-framework', 'celery', 'pytest'],
+                ? [
+                    technologyValue('technology-fastapi-6aee0e'),
+                    technologyValue('technology-pydantic-636623'),
+                    technologyValue('technology-sqlalchemy-37f268'),
+                    technologyValue('technology-alembic-8249d2'),
+                ]
+                : [
+                    technologyValue('technology-django-7d8a08'),
+                    'django-rest-framework',
+                    technologyValue('technology-celery-ddc517'),
+                    technologyValue('technology-pytest-2b0121'),
+                ],
         };
     }
     if (hasAffirmedTerm(requirements, /\bgo(?:lang)?\b/i) ||
@@ -117,15 +174,20 @@ function applyRequirementOverrides(rec, requirements, constraints) {
         result = {
             ...result,
             language: 'go',
-            framework: 'gin',
+            framework: technologyValue('technology-gin-985adc'),
             version: '1.22+',
-            ecosystem: ['gin', 'gorm', 'wire', 'testify'],
+            ecosystem: [
+                technologyValue('technology-gin-985adc'),
+                technologyValue('technology-gorm-7f6614'),
+                'wire',
+                'testify',
+            ],
         };
     }
     if (hasAffirmedTerm(requirements, /\bsupabase\b/i)) {
         result = {
             ...result,
-            database: 'supabase',
+            database: technologyValue('technology-supabase-4d7594'),
             orm: '@supabase/supabase-js',
             auth: 'supabase-auth',
         };
@@ -149,60 +211,53 @@ export function recommendStack(projectType, requirements, constraints) {
 export function recommendAlternativeStack(projectType, _requirements) {
     const alternatives = {
         web: {
-            language: 'typescript',
-            framework: 'astro',
+            language: technologyValue('technology-typescript-969545'),
+            framework: technologyValue('technology-astro-23661e'),
             version: '4+',
-            database: 'supabase',
-            deployment: 'vercel',
+            database: technologyValue('technology-supabase-4d7594'),
+            deployment: technologyValue('technology-vercel-9d3508'),
             reasoning: 'Astro provides excellent performance with islands architecture for content-heavy sites.',
-            ecosystem: ['astro', 'react', 'tailwind', 'supabase'],
+            ecosystem: [
+                technologyValue('technology-astro-23661e'),
+                technologyValue('technology-react-275976'),
+                technologyValue('technology-tailwind-44c8cf'),
+                technologyValue('technology-supabase-4d7594'),
+            ],
         },
         fullstack: {
-            language: 'typescript',
-            framework: 'remix',
+            language: technologyValue('technology-typescript-969545'),
+            framework: technologyValue('technology-remix-0c5d96'),
             version: '2+',
             database: 'postgresql',
-            orm: 'prisma',
+            orm: technologyValue('technology-prisma-99497c'),
             deployment: 'fly.io',
             reasoning: 'Remix embraces web standards with progressive enhancement and nested routing.',
-            ecosystem: ['react', 'tailwind', 'prisma', 'zod'],
+            ecosystem: [
+                technologyValue('technology-react-275976'),
+                technologyValue('technology-tailwind-44c8cf'),
+                technologyValue('technology-prisma-99497c'),
+                technologyValue('technology-zod-4f63cf'),
+            ],
         },
         backend: {
             language: 'go',
-            framework: 'gin',
+            framework: technologyValue('technology-gin-985adc'),
             version: '1.22+',
             database: 'postgresql',
-            deployment: 'docker',
+            deployment: technologyValue('technology-docker-d548c5'),
             reasoning: 'Go offers excellent performance and lower resource usage for high-throughput APIs.',
-            ecosystem: ['gin', 'pgx', 'testify'],
+            ecosystem: [technologyValue('technology-gin-985adc'), 'pgx', 'testify'],
         },
         mobile: {
             language: 'dart',
-            framework: 'flutter',
+            framework: technologyValue('technology-flutter-be1396'),
             version: '3+',
-            database: 'supabase',
+            database: technologyValue('technology-supabase-4d7594'),
             deployment: 'app-store',
             reasoning: 'Flutter provides true native performance with a single codebase and rich widget library.',
-            ecosystem: ['flutter', 'riverpod', 'freezed', 'go_router'],
-        },
-        cli: {
-            language: 'go',
-            framework: 'cobra',
-            version: '1.22+',
-            database: 'sqlite',
-            deployment: 'goreleaser',
-            reasoning: 'Go CLI tools compile to a single binary with zero dependencies.',
-            ecosystem: ['cobra', 'viper', 'bubbletea'],
-        },
-        library: {
-            language: 'rust',
-            framework: 'cargo',
-            version: '2021+',
-            database: 'none',
-            deployment: 'crates.io',
-            reasoning: 'Rust provides memory safety and excellent performance for system-level libraries.',
-            ecosystem: ['cargo', 'serde', 'tokio'],
+            ecosystem: [technologyValue('technology-flutter-be1396'), 'riverpod', 'freezed', 'go_router'],
         },
+        ...getAlternativeSystemStacks(),
     };
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- 'web' key always exists in object literal above
     return alternatives[projectType] ?? alternatives.web;
@@ -236,9 +291,9 @@ export function buildWhyNotOthers(_projectType, chosenFramework) {
 }
 export function buildMcpCompatibility(stack) {
     const results = [];
-    if (stack.database.includes('supabase')) {
+    if (stack.database.includes(technologyValue('technology-supabase-4d7594'))) {
         results.push({
-            mcp: 'supabase',
+            mcp: technologyValue('technology-supabase-4d7594'),
             compatible: true,
             notes: 'Full MCP support for SQL, migrations, auth.',
         });
@@ -246,22 +301,26 @@ export function buildMcpCompatibility(stack) {
     if (stack.database.includes('postgresql')) {
         results.push({ mcp: 'postgres', compatible: true, notes: 'Direct SQL access via MCP.' });
     }
-    if (stack.deployment.includes('vercel')) {
+    if (stack.deployment.includes(technologyValue('technology-vercel-9d3508'))) {
         results.push({
-            mcp: 'vercel',
+            mcp: technologyValue('technology-vercel-9d3508'),
             compatible: true,
             notes: 'Deploy previews and production via MCP.',
         });
     }
-    if (stack.deployment.includes('railway')) {
+    if (stack.deployment.includes(technologyValue('technology-railway-e34d1c'))) {
         results.push({
-            mcp: 'railway',
+            mcp: technologyValue('technology-railway-e34d1c'),
             compatible: true,
             notes: 'Full deployment management via MCP.',
         });
     }
     results.push({ mcp: 'github', compatible: true, notes: 'Issues, PRs, and code management.' });
-    results.push({ mcp: 'puppeteer', compatible: true, notes: 'Browser automation for testing.' });
+    results.push({
+        mcp: technologyValue('technology-puppeteer-c83c91'),
+        compatible: true,
+        notes: 'Browser automation for testing.',
+    });
     return results;
 }
 async function resolveVersionForFramework(framework, language) {
@@ -273,20 +332,21 @@ async function resolveVersionForFramework(framework, language) {
         }
     }
     // Try language-specific registries for non-npm frameworks
-    if (language === 'python' && framework === 'fastapi') {
-        const result = await resolveFrameworkVersion('fastapi', 'pypi');
+    if (language === 'python' && framework === technologyValue('technology-fastapi-6aee0e')) {
+        const result = await resolveFrameworkVersion(technologyValue('technology-fastapi-6aee0e'), 'pypi');
         return result.source !== 'fallback' ? result.version : null;
     }
-    if (language === 'python' && framework === 'django') {
-        const result = await resolveFrameworkVersion('django', 'pypi');
+    if (language === 'python' && framework === technologyValue('technology-django-7d8a08')) {
+        const result = await resolveFrameworkVersion(technologyValue('technology-django-7d8a08'), 'pypi');
         return result.source !== 'fallback' ? result.version : null;
     }
-    if (language === 'go' && framework === 'gin') {
+    if (language === 'go' && framework === technologyValue('technology-gin-985adc')) {
         const result = await resolveFrameworkVersion('gin-gonic/gin', 'go');
         return result.source !== 'fallback' ? result.version : null;
     }
-    if ((language === 'dart' || language === 'flutter') && framework === 'flutter') {
-        const result = await resolveFrameworkVersion('flutter', 'pub');
+    if ((language === 'dart' || language === technologyValue('technology-flutter-be1396')) &&
+        framework === technologyValue('technology-flutter-be1396')) {
+        const result = await resolveFrameworkVersion(technologyValue('technology-flutter-be1396'), 'pub');
         return result.source !== 'fallback' ? result.version : null;
     }
     return null;
@@ -369,7 +429,11 @@ function collectConfirmedChoices(requirements) {
     const choices = [
         ['language', 'python', /\b(?:must use|use|selected|confirmed|requires?)\s+python\b/i],
         ['language', 'go', /\b(?:must use|use|selected|confirmed|requires?)\s+go(?:lang)?\b/i],
-        ['database', 'supabase', /\b(?:must use|use|selected|confirmed|requires?)\s+supabase\b/i],
+        [
+            'database',
+            technologyValue('technology-supabase-4d7594'),
+            /\b(?:must use|use|selected|confirmed|requires?)\s+supabase\b/i,
+        ],
         ['database', 'firebase', /\b(?:must use|use|selected|confirmed|requires?)\s+firebase\b/i],
     ];
     return choices