@planu/cli 4.13.0 → 4.14.1

package/dist/config/technology-registry.json

@@ -0,0 +1,120 @@
+{
+  "schemaVersion": 1,
+  "frameworkCatalog": "framework-registry/index.json",
+  "detectionCatalog": "detection-signals.json",
+  "symbols": {
+    "technology-activerecord-97a448": "activerecord",
+    "technology-actix-d99b7a": "actix",
+    "technology-actix-web-ab3e35": "actix-web",
+    "technology-alembic-8249d2": "alembic",
+    "technology-angular-a39f89": "angular",
+    "technology-angular-e79052": "Angular",
+    "technology-aspnet-cc66fa": "aspnet",
+    "technology-astro-23661e": "astro",
+    "technology-astro-c490cc": "Astro",
+    "technology-aws-cdk-0145c3": "aws-cdk",
+    "technology-axum-af7119": "axum",
+    "technology-celery-ddc517": "celery",
+    "technology-celery-17d78b": "Celery",
+    "technology-chrome-9390ef": "chrome",
+    "technology-cloudflare-738e22": "cloudflare",
+    "technology-datadog-4d8bd9": "datadog",
+    "technology-diesel-f83cff": "diesel",
+    "technology-django-7d8a08": "django",
+    "technology-django-4445d9": "Django",
+    "technology-docker-d548c5": "docker",
+    "technology-docker-e6169e": "Docker",
+    "technology-docker-compose-b0a828": "docker-compose",
+    "technology-drizzle-424f22": "drizzle",
+    "technology-echo-092c79": "echo",
+    "technology-electron-88b1de": "electron",
+    "technology-electron-61a62a": "Electron",
+    "technology-eloquent-b89f45": "eloquent",
+    "technology-express-008231": "express",
+    "technology-express-572a14": "Express",
+    "technology-fastapi-6aee0e": "fastapi",
+    "technology-fastapi-2dd9eb": "FastAPI",
+    "technology-fastify-cbe57e": "fastify",
+    "technology-fastify-ed8050": "Fastify",
+    "technology-fiber-77c3e6": "fiber",
+    "technology-figma-5b79d0": "figma",
+    "technology-flask-b87aa5": "flask",
+    "technology-flask-c08622": "Flask",
+    "technology-flutter-be1396": "flutter",
+    "technology-fly-f4debd": "fly",
+    "technology-gin-985adc": "gin",
+    "technology-gorm-7f6614": "gorm",
+    "technology-gorm-9c68e4": "GORM",
+    "technology-graphql-aed31c": "graphql",
+    "technology-jest-35e99f": "jest",
+    "technology-jest-1f30f0": "Jest",
+    "technology-kubernetes-94abcb": "kubernetes",
+    "technology-kubernetes-a37d07": "Kubernetes",
+    "technology-laravel-c34cfa": "laravel",
+    "technology-laravel-ab5d68": "Laravel",
+    "technology-mongoose-4e1812": "mongoose",
+    "technology-nestjs-2d0087": "nestjs",
+    "technology-nestjs-58b822": "NestJS",
+    "technology-netlify-58465a": "netlify",
+    "technology-netlify-55c13c": "Netlify",
+    "technology-next-js-0d857f": "next.js",
+    "technology-next-js-30b7f8": "Next.js",
+    "technology-nextjs-c93379": "nextjs",
+    "technology-nuxt-22c407": "nuxt",
+    "technology-nuxt-e88c87": "Nuxt",
+    "technology-opentelemetry-15646c": "opentelemetry",
+    "technology-playwright-7827e8": "playwright",
+    "technology-playwright-9b7555": "Playwright",
+    "technology-prisma-99497c": "prisma",
+    "technology-prisma-e4b88d": "Prisma",
+    "technology-puppeteer-c83c91": "puppeteer",
+    "technology-pydantic-636623": "pydantic",
+    "technology-pytest-2b0121": "pytest",
+    "technology-rails-2e1d59": "rails",
+    "technology-railway-e34d1c": "railway",
+    "technology-railway-3e12c4": "Railway",
+    "technology-react-275976": "react",
+    "technology-redis-34fb46": "redis",
+    "technology-redis-a7f641": "Redis",
+    "technology-redis-1fa82e": "REDIS",
+    "technology-remix-0c5d96": "remix",
+    "technology-remix-f84ed4": "Remix",
+    "technology-sentry-0cf685": "sentry",
+    "technology-sentry-0acb12": "SENTRY",
+    "technology-sequelize-d18291": "sequelize",
+    "technology-serde-8b917c": "serde",
+    "technology-shadcn-d27663": "shadcn",
+    "technology-shadcn-ui-542509": "shadcn/ui",
+    "technology-spring-boot-9c3c05": "spring boot",
+    "technology-spring-boot-8d9a80": "Spring Boot",
+    "technology-springboot-7e901d": "springboot",
+    "technology-sqlalchemy-37f268": "sqlalchemy",
+    "technology-sqlx-28225b": "sqlx",
+    "technology-stripe-2bed20": "stripe",
+    "technology-stripe-961a60": "Stripe",
+    "technology-stripe-59c349": "STRIPE",
+    "technology-supabase-4d7594": "supabase",
+    "technology-supabase-fe7ceb": "Supabase",
+    "technology-supabase-1dedb8": "SUPABASE",
+    "technology-svelte-c190ac": "svelte",
+    "technology-sveltekit-eefb03": "sveltekit",
+    "technology-sveltekit-b62200": "SvelteKit",
+    "technology-swiftui-b63400": "swiftui",
+    "technology-swiftui-2d05f5": "SwiftUI",
+    "technology-tailwind-44c8cf": "tailwind",
+    "technology-terraform-94dc3e": "terraform",
+    "technology-terraform-05b073": "Terraform",
+    "technology-tokio-434de5": "tokio",
+    "technology-trpc-7a75ed": "trpc",
+    "technology-turbopack-1a3487": "turbopack",
+    "technology-typeorm-527d4d": "typeorm",
+    "technology-typescript-969545": "typescript",
+    "technology-typescript-ed0504": "TypeScript",
+    "technology-vercel-9d3508": "vercel",
+    "technology-vercel-68edc7": "Vercel",
+    "technology-vitest-a9127f": "vitest",
+    "technology-vitest-7fc39e": "Vitest",
+    "technology-vue-564382": "vue",
+    "technology-zod-4f63cf": "zod"
+  }
+}

package/dist/config/version.js

@@ -3,15 +3,14 @@ import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 const pkgPath = join(dirname(fileURLToPath(import.meta.url)), '../../package.json');
-let version = '0.0.0';
-try {
+function loadVersion() {
     const raw = JSON.parse(readFileSync(pkgPath, 'utf8'));
-    if (typeof raw === 'object' && raw !== null && 'version' in raw) {
-        version = String(raw.version);
+    const version = typeof raw === 'object' && raw !== null && 'version' in raw ? raw.version : undefined;
+    if (typeof version !== 'string' ||
+        !/^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)$/u.test(version)) {
+        throw new Error('[Planu] package.json contains an invalid release version');
     }
+    return version;
 }
-catch {
-    // Fallback to unknown version on parse error
-}
-export const PLANU_VERSION = version;
+export const PLANU_VERSION = loadVersion();
 //# sourceMappingURL=version.js.map

package/dist/config/version.ts

@@ -5,14 +5,17 @@ import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const pkgPath = join(dirname(fileURLToPath(import.meta.url)), '../../package.json');
-let version = '0.0.0';
-try {
+function loadVersion(): string {
   const raw: unknown = JSON.parse(readFileSync(pkgPath, 'utf8'));
-  if (typeof raw === 'object' && raw !== null && 'version' in raw) {
-    version = String(raw.version);
+  const version =
+    typeof raw === 'object' && raw !== null && 'version' in raw ? raw.version : undefined;
+  if (
+    typeof version !== 'string' ||
+    !/^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)$/u.test(version)
+  ) {
+    throw new Error('[Planu] package.json contains an invalid release version');
   }
-} catch {
-  // Fallback to unknown version on parse error
+  return version;
 }
 
-export const PLANU_VERSION = version;
+export const PLANU_VERSION = loadVersion();

package/dist/engine/abortable-process-runner.js

@@ -1,4 +1,16 @@
 import { execFileSync, spawn } from 'node:child_process';
+import { getExecutionSignal, remainingExecutionMs } from './execution/context.js';
+const TERM_GRACE_MS = 75;
+function operationSignal(signal) {
+    const parentSignal = getExecutionSignal();
+    if (signal === undefined) {
+        return parentSignal;
+    }
+    if (parentSignal === undefined || parentSignal === signal) {
+        return signal;
+    }
+    return AbortSignal.any([signal, parentSignal]);
+}
 /**
  * Runs a validation command in its own process group. Cancellation and timeouts
  * terminate the complete group and settle only after the child has closed, so a
@@ -6,13 +18,14 @@ import { execFileSync, spawn } from 'node:child_process';
  */
 export function runAbortableProcess(command, args, options) {
     return new Promise((resolve) => {
-        if (options.signal?.aborted === true) {
+        const signal = operationSignal(options.signal);
+        if (signal?.aborted === true) {
             resolve({
                 stdout: '',
                 stderr: '',
                 status: null,
                 signal: null,
-                error: abortError(options.signal.reason),
+                error: abortError(signal.reason),
                 timedOut: false,
                 aborted: true,
             });
@@ -30,6 +43,9 @@ export function runAbortableProcess(command, args, options) {
         let aborted = false;
         let processError;
         let hardStop;
+        let deferredClose;
+        const parentRemainingMs = remainingExecutionMs();
+        const timeoutMs = Math.max(0, Math.min(options.timeoutMs, parentRemainingMs));
         const append = (current, chunk) => `${current}${chunk.toString('utf8')}`.slice(-options.maxBufferBytes);
         child.stdout.on('data', (chunk) => {
             stdout = append(stdout, chunk);
@@ -63,28 +79,43 @@ export function runAbortableProcess(command, args, options) {
                 catch {
                     child.kill('SIGKILL');
                 }
-            }, 250);
+                hardStop = undefined;
+                if (deferredClose !== undefined) {
+                    const [status, closeSignal] = deferredClose;
+                    deferredClose = undefined;
+                    finish(status, closeSignal);
+                }
+            }, TERM_GRACE_MS);
             hardStop.unref();
         };
         const onAbort = () => {
             aborted = true;
-            processError = abortError(options.signal?.reason);
+            processError = abortError(signal?.reason);
             terminateTree();
+            try {
+                options.onCancellationAcknowledged?.();
+            }
+            catch {
+                // A diagnostic callback must never interfere with process termination.
+            }
         };
-        options.signal?.addEventListener('abort', onAbort, { once: true });
+        signal?.addEventListener('abort', onAbort, { once: true });
         const timer = setTimeout(() => {
             timedOut = true;
-            processError = new Error(`Process timed out after ${String(options.timeoutMs)}ms`);
+            processError = new Error(`Process timed out after ${String(timeoutMs)}ms`);
             terminateTree();
-        }, options.timeoutMs);
+        }, timeoutMs);
         const finish = (status, closeSignal) => {
             if (settled) {
                 return;
             }
+            if (hardStop !== undefined && process.platform !== 'win32') {
+                deferredClose = [status, closeSignal];
+                return;
+            }
             settled = true;
             clearTimeout(timer);
-            clearTimeout(hardStop);
-            options.signal?.removeEventListener('abort', onAbort);
+            signal?.removeEventListener('abort', onAbort);
             resolve({
                 stdout,
                 stderr,

package/dist/engine/advanced-testing/accessibility-checker.js

@@ -1,7 +1,4 @@
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
-// engine/advanced-testing/accessibility-checker.ts — SPEC-049
-// Generates WCAG 2.1 Level AA criteria and axe-core test scaffolds.
+import { technologyValue } from '../technology-registry.js';
 /** WCAG 2.1 Level AA criteria list for create_spec. */
 export function buildA11yCriteria() {
     return [
@@ -112,10 +109,11 @@ urls:
 /** Map framework name to A11yFramework type. */
 function toA11yFramework(testFramework) {
     const fw = testFramework.toLowerCase();
-    if (fw.includes('playwright')) {
+    if (fw.includes(technologyValue('technology-playwright-7827e8'))) {
         return 'axe-core';
     }
-    if (fw.includes('jest') || fw.includes('react-testing-library')) {
+    if (fw.includes(technologyValue('technology-jest-35e99f')) ||
+        fw.includes('react-testing-library')) {
         return 'jest-axe';
     }
     if (fw.includes('pa11y')) {
@@ -151,20 +149,20 @@ export function generateA11yTests(testFramework) {
 /** Detect if the project is a web project based on stack signals. */
 export function isWebProject(stack) {
     const webSignals = [
-        'react',
-        'vue',
-        'angular',
-        'svelte',
+        technologyValue('technology-react-275976'),
+        technologyValue('technology-vue-564382'),
+        technologyValue('technology-angular-a39f89'),
+        technologyValue('technology-svelte-c190ac'),
         'next',
-        'nuxt',
-        'remix',
-        'astro',
+        technologyValue('technology-nuxt-22c407'),
+        technologyValue('technology-remix-0c5d96'),
+        technologyValue('technology-astro-23661e'),
         'html',
         'css',
         'browser',
         'frontend',
         'web',
-        'playwright',
+        technologyValue('technology-playwright-7827e8'),
         'cypress',
     ];
     const stackLower = stack.map((s) => s.toLowerCase()).join(' ');

package/dist/engine/advanced-testing/mutation-advisor.js

@@ -1,5 +1,4 @@
-// engine/advanced-testing/mutation-advisor.ts — SPEC-049
-// Recommends mutation testing configuration based on project language and coverage.
+import { technologyValue } from '../technology-registry.js';
 import { getJvmVersion } from '../../config/version-defaults.js';
 /** Minimum coverage required before recommending mutation testing. */
 const MIN_COVERAGE_FOR_MUTATION = 90;
@@ -13,7 +12,7 @@ export function shouldRecommendMutation(coverage) {
 /** Map a language to its primary mutation testing tool. */
 export function getMutationTool(language) {
     const lang = language.toLowerCase();
-    if (lang === 'typescript' || lang === 'javascript') {
+    if (lang === technologyValue('technology-typescript-969545') || lang === 'javascript') {
         return 'stryker';
     }
     if (lang === 'python') {
@@ -213,7 +212,7 @@ export function generateMutationConfig(tool, language) {
 /** Return sensible default exclude patterns for a language. */
 function getDefaultExcludePatterns(language) {
     const lang = language.toLowerCase();
-    if (lang === 'typescript' || lang === 'javascript') {
+    if (lang === technologyValue('technology-typescript-969545') || lang === 'javascript') {
         return ['**/*.test.ts', '**/*.spec.ts', '**/index.ts', 'src/config/**', 'src/types/**'];
     }
     if (lang === 'python') {

package/dist/engine/advanced-testing/property-based.js

@@ -1,5 +1,4 @@
-// engine/advanced-testing/property-based.ts — SPEC-049
-// Detects property-based testing needs and generates scaffold code.
+import { technologyValue } from '../technology-registry.js';
 /** Keywords (case-insensitive) that indicate a property-based testing need. */
 const PBT_KEYWORDS_ES = [
     'siempre',
@@ -34,7 +33,7 @@ export function detectPropertyBasedNeed(criteria) {
 /** Map a language identifier to its property test framework. */
 export function getPropertyTestFramework(language) {
     const lang = language.toLowerCase();
-    if (lang === 'typescript' || lang === 'javascript') {
+    if (lang === technologyValue('technology-typescript-969545') || lang === 'javascript') {
         return 'fast-check';
     }
     if (lang === 'python') {

package/dist/engine/advanced-testing/test-data-advisor.js

@@ -1,5 +1,4 @@
-// engine/advanced-testing/test-data-advisor.ts — SPEC-049
-// Provides test data management criteria and synthetic data tooling recommendations.
+import { technologyValue } from '../technology-registry.js';
 /** PII/PHI signals in stack or project descriptions. */
 const PII_SIGNALS = [
     'pii',
@@ -90,7 +89,7 @@ function pythonTestDataTools() {
  */
 export function getTestDataTooling(language) {
     const lang = language.toLowerCase();
-    if (lang === 'typescript' || lang === 'javascript') {
+    if (lang === technologyValue('technology-typescript-969545') || lang === 'javascript') {
         return jsTestDataTools();
     }
     if (lang === 'python') {

package/dist/engine/agent-generator.js

@@ -1,3 +1,4 @@
+import { technologyValue } from './technology-registry.js';
 // @crash-shield-ignore-file — config/cache reader for Planu-controlled JSON; writer is this codebase, shape guaranteed by build/seed.
 // Planu — Agent Generator Engine
 // Generates sub-agent definitions for various multi-agent frameworks.
@@ -73,7 +74,7 @@ export async function getFrameworkConfig(framework) {
     const platforms = await loadFrameworks();
     return (platforms.subAgentFrameworks[framework] ?? {
         name: framework,
-        languages: ['typescript'],
+        languages: [technologyValue('technology-typescript-969545')],
         docsUrl: '',
         supportsHandoffs: false,
         supportsMcp: false,

package/dist/engine/agent-handoff-store.js

@@ -1,8 +1,9 @@
 // engine/agent-handoff-store.ts — SPEC-639: handoff.json protocol for agent teams
 import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
+import { hashProjectPath, projectDataDir } from '../storage/base-store.js';
 function handoffPath(projectPath, specId) {
-    return join(projectPath, '.planu', 'team', specId, 'handoff.json');
+    return join(projectDataDir(hashProjectPath(projectPath)), 'team', specId, 'handoff.json');
 }
 /**
  * SPEC-639: Initialize handoff.json for a spec team.

package/dist/engine/agent-prompt-generator.js

@@ -1,3 +1,4 @@
+import { technologyValue } from './technology-registry.js';
 // ── Layer path mappings ────────────────────────────────────────────────────
 const LAYER_PATHS = {
     frontend: ['src/components/', 'src/pages/', 'src/app/', 'src/views/', 'src/ui/', 'src/screens/'],
@@ -37,24 +38,25 @@ function stackInstructions(knowledge, layer) {
     const lines = [];
     const { framework, language } = knowledge;
     if (layer === 'frontend') {
-        if (framework === 'react' || framework === 'next') {
+        if (framework === technologyValue('technology-react-275976') || framework === 'next') {
             lines.push('Use functional components with hooks (no class components).');
             lines.push('JSX files must use .tsx extension. Props typed with interfaces.');
         }
-        if (framework === 'vue') {
+        if (framework === technologyValue('technology-vue-564382')) {
             lines.push('Use Composition API with <script setup> syntax.');
             lines.push('Props defined with defineProps<T>(). Emits with defineEmits<T>().');
         }
-        if (framework === 'svelte') {
+        if (framework === technologyValue('technology-svelte-c190ac')) {
             lines.push('Use Svelte 5 runes ($state, $derived, $effect) when available.');
         }
     }
     if (layer === 'backend' || layer === 'engine') {
-        if (language === 'typescript') {
+        if (language === technologyValue('technology-typescript-969545')) {
             lines.push('Strict TypeScript — no `any`, no non-null assertions without comment.');
             lines.push('Return types must be explicit on all exported functions.');
         }
-        if (framework === 'express' || framework === 'fastify') {
+        if (framework === technologyValue('technology-express-008231') ||
+            framework === technologyValue('technology-fastify-cbe57e')) {
             lines.push('Validate all request inputs with Zod before business logic.');
         }
     }

package/dist/engine/agent-telemetry.js

@@ -3,11 +3,12 @@ import { appendFile, stat, readFile, writeFile, mkdir } from 'node:fs/promises';
 import { createReadStream } from 'node:fs';
 import { createInterface } from 'node:readline';
 import { join } from 'node:path';
+import { hashProjectPath, projectDataDir } from '../storage/base-store.js';
 const MAX_FILE_BYTES = 1024 * 1024; // 1 MB
 const PRUNE_AGE_MS = 30 * 24 * 60 * 60 * 1000; // 30 days
 const EVICT_RATIO = 0.2; // drop oldest 20%
 function telemetryPath(projectPath, specId) {
-    return join(projectPath, '.planu', 'team', specId, 'telemetry.jsonl');
+    return join(projectDataDir(hashProjectPath(projectPath)), 'team', specId, 'telemetry.jsonl');
 }
 async function pruneIfNeeded(file) {
     let size;

package/dist/engine/ai-integration/gemini/extensions-advisor.js

@@ -1,12 +1,14 @@
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
-// engine/ai-integration/gemini/extensions-advisor.ts — Gemini extensions advisor (SPEC-267)
+import { technologyValue } from '../../technology-registry.js';
 const EXTENSION_CATALOG = [
     {
         name: 'Conductor',
         url: 'https://geminicli.com/extensions/conductor',
         reason: 'Feature specification and planning',
-        stackSignals: ['python', 'django', 'fastapi'],
+        stackSignals: [
+            'python',
+            technologyValue('technology-django-7d8a08'),
+            technologyValue('technology-fastapi-6aee0e'),
+        ],
     },
     {
         name: 'BigQuery Extension',
@@ -24,31 +26,61 @@ const EXTENSION_CATALOG = [
         name: 'Figma Extension',
         url: 'https://geminicli.com/extensions/figma',
         reason: 'Figma design file access',
-        stackSignals: ['figma', 'design', 'frontend', 'react', 'vue'],
+        stackSignals: [
+            technologyValue('technology-figma-5b79d0'),
+            'design',
+            'frontend',
+            technologyValue('technology-react-275976'),
+            technologyValue('technology-vue-564382'),
+        ],
     },
     {
         name: 'GitHub Extension',
         url: 'https://geminicli.com/extensions/github',
         reason: 'GitHub issues, PRs, and repo management',
-        stackSignals: ['github', 'git', 'typescript', 'javascript', 'node'],
+        stackSignals: [
+            'github',
+            'git',
+            technologyValue('technology-typescript-969545'),
+            'javascript',
+            'node',
+        ],
     },
     {
         name: 'Firebase Extension',
         url: 'https://geminicli.com/extensions/firebase',
         reason: 'Firebase project management and Firestore queries',
-        stackSignals: ['firebase', 'firestore', 'gcp', 'react-native', 'flutter'],
+        stackSignals: [
+            'firebase',
+            'firestore',
+            'gcp',
+            'react-native',
+            technologyValue('technology-flutter-be1396'),
+        ],
     },
     {
         name: 'Kubernetes Extension',
         url: 'https://geminicli.com/extensions/kubernetes',
         reason: 'Kubernetes cluster inspection and deployment management',
-        stackSignals: ['kubernetes', 'k8s', 'docker', 'helm', 'gcp'],
+        stackSignals: [
+            technologyValue('technology-kubernetes-94abcb'),
+            'k8s',
+            technologyValue('technology-docker-d548c5'),
+            'helm',
+            'gcp',
+        ],
     },
     {
         name: 'Terraform Extension',
         url: 'https://geminicli.com/extensions/terraform',
         reason: 'Terraform plan inspection and infrastructure management',
-        stackSignals: ['terraform', 'aws', 'azure', 'gcp', 'infrastructure'],
+        stackSignals: [
+            technologyValue('technology-terraform-94dc3e'),
+            'aws',
+            'azure',
+            'gcp',
+            'infrastructure',
+        ],
     },
 ];
 export function getRecommendedExtensions(stack) {

package/dist/engine/ambiguity-detector.js

@@ -1,3 +1,4 @@
+import { technologyValue } from './technology-registry.js';
 import { matchAnyKeyword } from './keyword-matcher/index.js';
 // ---------------------------------------------------------------------------
 // Per-tool ambiguity thresholds (0–100). Higher = more tolerant.
@@ -69,18 +70,18 @@ const OBJECTIVE_SIGNALS = [
 ];
 /** Keywords that suggest stack information. */
 const STACK_SIGNALS = [
-    'react',
-    'vue',
-    'angular',
+    technologyValue('technology-react-275976'),
+    technologyValue('technology-vue-564382'),
+    technologyValue('technology-angular-a39f89'),
     'next',
     'node',
-    'express',
-    'fastapi',
-    'django',
-    'rails',
+    technologyValue('technology-express-008231'),
+    technologyValue('technology-fastapi-6aee0e'),
+    technologyValue('technology-django-7d8a08'),
+    technologyValue('technology-rails-2e1d59'),
     'spring',
-    'laravel',
-    'typescript',
+    technologyValue('technology-laravel-c34cfa'),
+    technologyValue('technology-typescript-969545'),
     'python',
     'java',
     'rust',
@@ -89,9 +90,9 @@ const STACK_SIGNALS = [
     'mysql',
     'mongodb',
     'sqlite',
-    'redis',
+    technologyValue('technology-redis-34fb46'),
     'firebase',
-    'supabase',
+    technologyValue('technology-supabase-4d7594'),
 ];
 /** Keywords that indicate business context. */
 const CONTEXT_SIGNALS = [

package/dist/engine/analyzer/db-engine.js

@@ -1,5 +1,4 @@
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
+import { technologyValue } from '../technology-registry.js';
 // Planu — DB Engine Detection (SPEC-025)
 // Detects database engine from project dependencies and generates adapted SQL syntax
 import { readFile } from 'node:fs/promises';
@@ -57,7 +56,7 @@ export function getSQLSyntaxForEngine(engine) {
         autoIncrement: 'GENERATED ALWAYS AS IDENTITY',
     };
     switch (engine) {
-        case 'supabase':
+        case technologyValue('technology-supabase-4d7594'):
         case 'postgresql':
             return {
                 createTable: 'CREATE TABLE IF NOT EXISTS',