@planu/cli 4.13.0 → 5.0.0

package/dist/engine/readiness-checker.js

@@ -1,6 +1,6 @@
 // engine/readiness-checker.ts — Spec readiness evaluation for implementation gate (SPEC-039)
 import { readFile } from 'node:fs/promises';
-import { readSpecTechnicalSection } from './spec-format/read-technical-section.js';
+import { extractSectionBody, readSpecTechnicalSection, } from './spec-format/read-technical-section.js';
 import { stripFrontmatter } from './frontmatter-parser.js';
 import { loadReadinessConfig } from './readiness-config-loader.js';
 import { runEarsGate } from './ears-gate.js';
@@ -233,7 +233,7 @@ export function detectTechnicalPlaceholder(body) {
 /**
  * SPEC-784: Returns true when the ## Technical body is too shallow:
  * fewer than TECHNICAL_MIN_CHARS characters AND contains zero file
- * paths under src/ or tests/.
+ * safe repository-relative file paths.
  */
 export function detectTechnicalTooShallow(body) {
     const section = extractTechnicalSection(body);
@@ -244,9 +244,7 @@ export function detectTechnicalTooShallow(body) {
     if (section.length >= TECHNICAL_MIN_CHARS) {
         return false;
     }
-    // Has at least one file path under src/ or tests/ → not too shallow
-    const hasFilePaths = /\b(?:src|tests)\/[a-zA-Z0-9/_.-]+\.[a-z]+\b/.test(section);
-    return !hasFilePaths;
+    return extractFilePaths(section).size === 0;
 }
 // ── SPEC-629 / SPEC-777: Specificity gate helpers ────────────────────────────
 /**
@@ -260,18 +258,27 @@ export function detectTechnicalTooShallow(body) {
  */
 export function extractFilePaths(text) {
     const found = new Set();
-    // Match paths that look like <dir>/<rest>.<ext> where dir is a valid identifier
-    // Works inside backticks, after commas/spaces, after FILES: markers
-    const RE = /(?:[`\s,]|^|FILES:\s*)([a-zA-Z][a-zA-Z0-9_-]*(?:\/[a-zA-Z0-9_.-]+)+\.[a-zA-Z]{1,6})(?=[`\s,\n)]|$)/g;
+    const RE = /(?<![a-zA-Z0-9_./\\-])([a-zA-Z0-9_.-]+(?:\/[a-zA-Z0-9_.-]+)*\.[a-zA-Z][a-zA-Z0-9]*)(?=[`"'\s,):;.!?]|$)/g;
     let m;
     while ((m = RE.exec(text)) !== null) {
         const p = m[1];
-        if (p !== undefined) {
+        if (p !== undefined && isSafeRepositoryFilePath(p)) {
             found.add(p);
         }
     }
     return found;
 }
+function isSafeRepositoryFilePath(path) {
+    const segments = path.split('/');
+    const filename = segments.at(-1) ?? '';
+    const extensionIndex = filename.lastIndexOf('.');
+    return (path.length > 0 &&
+        !path.startsWith('/') &&
+        !/^[a-zA-Z]:/u.test(path) &&
+        segments.every((segment) => segment.length > 0 && segment !== '.' && segment !== '..') &&
+        extensionIndex > 0 &&
+        extensionIndex < filename.length - 1);
+}
 /**
  * Extract function/method names from text.
  * Recognises:
@@ -294,27 +301,21 @@ export function extractFunctionNames(text) {
 // ── SPEC-629: Specificity gate (difficulty >= 3) ────────────────────────────
 /**
  * For specs with difficulty >= 3, enforces that criteria contain:
- * - 3+ concrete file paths (src/ or tests/)
+ * - 3+ concrete repository-relative file paths
  * - 1+ criterion with exact function/type name
  * - 1+ anticipated test break (file + line number)
  * Returns blocker strings; empty array = gate passed.
  */
-function checkSpecificityGate(spec, criteriaLines, fichaContent) {
+function checkSpecificityGate(spec, criteriaLines, fichaContent, anticipatedTestBreaksContent) {
     if (spec.difficulty < 3) {
         return [];
     }
     const allText = [...criteriaLines, fichaContent].join('\n');
     const blockers = [];
-    // Count distinct file paths in src/ or tests/ — use enhanced extractor (SPEC-777)
     const uniquePaths = extractFilePaths(allText);
-    // Also keep the legacy word-boundary regex for backward compat with bare paths not in backticks
-    const legacyMatches = allText.match(/\b(?:src|tests)\/[a-zA-Z0-9/_.-]+\.[a-z]+\b/g) ?? [];
-    for (const p of legacyMatches) {
-        uniquePaths.add(p);
-    }
     if (uniquePaths.size < 3) {
-        blockers.push(`Difficulty ${String(spec.difficulty)} spec requires 3+ concrete file paths in criteria (src/ or tests/) — found ${String(uniquePaths.size)}. ` +
-            `Add exact paths like 'src/engine/foo/bar.ts'.`);
+        blockers.push(`Difficulty ${String(spec.difficulty)} spec requires 3+ concrete repository-relative file paths in criteria — found ${String(uniquePaths.size)}. ` +
+            `Add exact paths like 'scripts/check-contract.mjs'.`);
     }
     // Detect function calls via enhanced extractor + legacy regex (SPEC-777)
     const functionNames = extractFunctionNames(allText);
@@ -325,7 +326,8 @@ function checkSpecificityGate(spec, criteriaLines, fichaContent) {
     }
     // Detect anticipated test breaks: a test file path + "line N" (with optional ~) or "change ... from ... to"
     const hasTestBreak = /\btests?\/[a-zA-Z0-9/_.-]+\.test\.[a-z]+.*\bline\s+~?\d+/i.test(allText) ||
-        /\bchange\b.*\bfrom\b.*\bto\b/i.test(allText);
+        /\bchange\b.*\bfrom\b.*\bto\b/i.test(allText) ||
+        /\btests\/[a-zA-Z0-9/_.-]+\.test\.[a-z0-9]+(?![a-zA-Z0-9_.\\/-])[^\n]*\bline\s+~?\d+/i.test(anticipatedTestBreaksContent);
     if (!hasTestBreak) {
         blockers.push(`Difficulty ${String(spec.difficulty)} spec requires at least 1 anticipated test break ` +
             `(e.g. 'tests/api/foo.test.ts line 47: change count from 477 to 478').`);
@@ -333,76 +335,12 @@ function checkSpecificityGate(spec, criteriaLines, fichaContent) {
     return blockers;
 }
 // ── Public API ───────────────────────────────────────────────────────────────
-/**
- * SPEC-769: Pure in-memory readiness check — no file I/O.
- * Accepts the raw spec.md content (including frontmatter) and returns a quick
- * score + warnings without loading technical.md or any additional file.
- *
- * Scoring (max 100):
- *  - Base (title/metadata present): 20
- *  - Criteria: 0 | 20 | 35 | 50  (0 / 1-2 / 3-4 / 5+)
- *  - Technical files (src/*.ts paths found in body): 30
- */
-export function checkReadinessInternal(body) {
-    const bodyContent = stripFrontmatter(body);
-    const normalizedCriteria = extractNormalizedAcceptanceCriteria(body);
-    const criteriaLines = normalizedCriteria.map((criterion) => criterion.text);
-    const scenarioCount = criteriaLines.length === 0 ? countFrontmatterScenarios(body) : 0;
-    const criteriaCount = criteriaLines.length > 0 ? criteriaLines.length : scenarioCount;
-    const config = loadReadinessConfig();
-    const vagueWords = config.vagueWords.map((v) => v.word);
-    const warnings = [];
-    // Score based on criteria count
-    let criteriaScore;
-    if (criteriaCount === 0) {
-        criteriaScore = 0;
-        warnings.push('No acceptance criteria found — add at least 3 testable criteria');
-    }
-    else if (criteriaCount >= 5) {
-        criteriaScore = 50;
-    }
-    else if (criteriaCount >= 3) {
-        criteriaScore = 35;
-    }
-    else {
-        criteriaScore = 20;
-        warnings.push('Add more acceptance criteria (need at least 3 for adequate readiness)');
-    }
-    // Vague criteria detection (re-uses existing logic)
-    const criteriaResult = scoreCriteria(criteriaLines.length > 0 ? criteriaLines : [], vagueWords);
-    warnings.push(...criteriaResult.warnings);
-    // Technical files presence (proxy for inline ## Technical — check src/ paths in body)
-    const hasTechnicalFiles = /\bsrc\/[^\s]+\.[jt]s\b/.test(bodyContent);
-    const technicalScore = hasTechnicalFiles ? 30 : 0;
-    if (!hasTechnicalFiles && criteriaCount > 0) {
-        warnings.push('No source file paths (e.g. src/engine/foo.ts) found — add file entries in ## Technical section');
-    }
-    // SPEC-784: Technical section quality gates
-    // Run both detectors against the raw body (includes ## Technical heading)
-    if (detectTechnicalPlaceholder(bodyContent)) {
-        warnings.push('TECHNICAL_PLACEHOLDER_DETECTED: ## Technical section contains a placeholder pointer ' +
-            '(e.g. "See technical.md") — inline the content instead of deferring to another file');
-    }
-    if (detectTechnicalTooShallow(bodyContent)) {
-        warnings.push('TECHNICAL_TOO_SHALLOW: ## Technical section is too short (< 500 chars) and has no ' +
-            'src/ or tests/ file paths — add concrete file paths and implementation details');
-    }
-    // Base points (title present, valid structure)
-    const baseScore = 20;
-    // When any SPEC-784 technical blocker is present, cap the score at 0 so the
-    // approval gate hard-blocks (score < 70 with no-forceApprove path).
-    const technicalBlockerCount = warnings.filter((w) => w.startsWith('TECHNICAL_PLACEHOLDER_DETECTED') || w.startsWith('TECHNICAL_TOO_SHALLOW')).length;
-    if (technicalBlockerCount > 0) {
-        return { score: 0, warnings, criteriaCount };
-    }
-    const score = Math.min(100, baseScore + criteriaScore + technicalScore);
-    return { score, warnings, criteriaCount };
-}
 export async function checkSpecReadiness(spec, mode, projectHash) {
     const config = loadReadinessConfig(projectHash);
     const vagueWords = config.vagueWords.map((v) => v.word);
     const huRaw = await readHuRaw(spec);
     const huContent = stripFrontmatter(huRaw);
+    const anticipatedTestBreaksContent = extractSectionBody(huRaw, 'Anticipated Test Breaks');
     const fichaContent = await readFichaContent(spec);
     const normalizedCriteria = extractNormalizedAcceptanceCriteria(huRaw);
     const canonicalCriteriaLines = normalizedCriteria.map((criterion) => criterion.text);
@@ -414,6 +352,7 @@ export async function checkSpecReadiness(spec, mode, projectHash) {
     // evidence model so specificity gates still see exact test paths and line refs.
     const scenarioCriteria = usesFrontmatterAsCanonical ? frontmatterScenarioCriteria(huRaw) : [];
     const effectiveCriteriaLines = scenarioCriteria.length > 0 ? scenarioCriteria : canonicalCriteriaLines;
+    const specificityEvidenceLines = [...scenarioCriteria, ...extractCriteriaLines(huContent)];
     const hu = scoreHuCompleteness(spec);
     const criteria = scoreCriteria(effectiveCriteriaLines, vagueWords);
     const files = scoreFilesIdentified(spec, fichaContent);
@@ -450,11 +389,11 @@ export async function checkSpecReadiness(spec, mode, projectHash) {
     }
     if (detectTechnicalTooShallow(huContent)) {
         allBlockers.push('TECHNICAL_TOO_SHALLOW: ## Technical section is too short (< 500 chars) and has no ' +
-            'src/ or tests/ file paths — add concrete file paths and implementation details');
+            'repository-relative file paths — add concrete file paths and implementation details');
     }
     // SPEC-629: Specificity gate caps score at 60 for difficulty >= 3 specs that lack
     // concrete file paths, function names, or anticipated test breaks.
-    const specificityBlockers = checkSpecificityGate(spec, effectiveCriteriaLines, fichaContent);
+    const specificityBlockers = checkSpecificityGate(spec, specificityEvidenceLines, fichaContent, anticipatedTestBreaksContent);
     allBlockers.push(...specificityBlockers);
     const effectiveScore = specificityBlockers.length > 0 && spec.difficulty >= 3 ? Math.min(totalScore, 60) : totalScore;
     const breakdown = {
@@ -481,7 +420,7 @@ export async function checkSpecReadiness(spec, mode, projectHash) {
     const isReady = effectiveScore >= cautionThreshold && allBlockers.length === 0;
     const recommendations = buildRecommendations(effectiveScore, hu.points, criteria.points, files.points, deps.points);
     if (specificityBlockers.length > 0) {
-        recommendations.push('Add exact file paths (src/ or tests/), function names (e.g. createFoo()), and anticipated test breaks to unlock implementation for this difficulty spec.');
+        recommendations.push('Add exact repository-relative file paths, function names (e.g. createFoo()), and anticipated test breaks to unlock implementation for this difficulty spec.');
     }
     return {
         specId: spec.id,

package/dist/engine/registry/core.js

@@ -1,5 +1,3 @@
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
 // engine/registry/core.ts — Orchestrator for spec accuracy validation and doc enrichment
 // Composes loader → matcher → validator → reporter into two public functions.
 import { loadRegistry } from './loader.js';

package/dist/engine/registry/loader.js

@@ -2,12 +2,13 @@
 // engine/registry/loader.ts — Loads and merges framework registry entries
 // Base entries come from src/config/framework-registry/*.json
 // Custom entries come from data/global/registry-custom.json (user-added)
-import { readFile, readdir } from 'node:fs/promises';
+import { readFile } from 'node:fs/promises';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { readJson } from '../../storage/base-store.js';
+import { resolvedStorageArtifactPath } from '../../storage/storage-catalog.js';
+import { loadTechnologyRegistry } from '../technology-registry.js';
 const REGISTRY_DIR = join(dirname(fileURLToPath(import.meta.url)), '../../config/framework-registry');
-const CUSTOM_REGISTRY_PATH = 'data/global/registry-custom.json';
 /**
  * Load a single framework JSON file from the base registry directory.
  * Returns null if the file is missing or malformed.
@@ -43,23 +44,19 @@ async function loadFrameworkFile(fileName) {
  * Skips index.json and any file that fails to parse.
  */
 export async function loadBaseRegistry() {
-    let files;
-    try {
-        files = await readdir(REGISTRY_DIR);
-    }
-    catch {
-        return [];
+    const files = loadTechnologyRegistry().frameworks.map((entry) => entry.file);
+    const results = await Promise.all(files.map(loadFrameworkFile));
+    if (results.some((entry) => entry === null)) {
+        throw new Error('TECHNOLOGY_REGISTRY_INVALID: a registered framework file is unavailable');
     }
-    const jsonFiles = files.filter((f) => f.endsWith('.json') && f !== 'index.json');
-    const results = await Promise.all(jsonFiles.map(loadFrameworkFile));
-    return results.filter((e) => e !== null);
+    return results;
 }
 /**
  * Load user-defined custom registry entries from data/global/registry-custom.json.
  * Returns an empty array when the file does not exist.
  */
 export async function loadCustomRegistry() {
-    const store = await readJson(CUSTOM_REGISTRY_PATH, { entries: [] });
+    const store = await readJson(resolvedStorageArtifactPath('custom-framework-registry'), { entries: [] });
     return store.entries.map((e) => ({ ...e, customEntry: true }));
 }
 /**

package/dist/engine/registry/matcher.js

@@ -1,22 +1,92 @@
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
-// engine/registry/matcher.ts — Detects framework mentions and API references in spec text
-// Uses registry-aware keywords to avoid false positives on plain English words.
+import { technologyValue } from '../technology-registry.js';
 /** Mapping of framework ID → detection keywords (aliases / common spellings). */
 const FRAMEWORK_ALIASES = {
-    nextjs: ['next.js', 'nextjs', 'next js', 'next/navigation', 'next/router', 'app router'],
-    react: ['react', 'react dom', 'reactdom', 'jsx', 'useState', 'useEffect', 'useCallback'],
-    vue: ['vue', 'vue 3', 'vue.js', 'vuejs', 'composition api', 'script setup'],
-    nuxt: ['nuxt', 'nuxt 3', 'nuxt.js', 'usefetch', 'definepageeta'],
-    angular: ['angular', 'angular 17', '@angular', 'standalone component', 'angularjs'],
-    sveltekit: ['sveltekit', 'svelte kit', 'svelte', '+page.server.ts', 'use:enhance'],
-    astro: ['astro', 'astro.js', 'astro 4', 'client:load', 'getcollection'],
-    remix: ['remix', 'remix 2', '@remix-run', 'useloaderdata', 'useactiondata'],
-    express: ['express', 'express.js', 'expressjs', 'express.router', 'app.get(', 'app.use('],
-    nestjs: ['nestjs', 'nest.js', '@nestjs', '@injectable', '@controller', '@module'],
-    django: ['django', 'django 5', 'django orm', 'models.model', 'views.py', 'urls.py'],
+    nextjs: [
+        technologyValue('technology-next-js-0d857f'),
+        technologyValue('technology-nextjs-c93379'),
+        'next js',
+        'next/navigation',
+        'next/router',
+        'app router',
+    ],
+    react: [
+        technologyValue('technology-react-275976'),
+        'react dom',
+        'reactdom',
+        'jsx',
+        'useState',
+        'useEffect',
+        'useCallback',
+    ],
+    vue: [
+        technologyValue('technology-vue-564382'),
+        'vue 3',
+        'vue.js',
+        'vuejs',
+        'composition api',
+        'script setup',
+    ],
+    nuxt: [
+        technologyValue('technology-nuxt-22c407'),
+        'nuxt 3',
+        'nuxt.js',
+        'usefetch',
+        'definepageeta',
+    ],
+    angular: [
+        technologyValue('technology-angular-a39f89'),
+        'angular 17',
+        '@angular',
+        'standalone component',
+        'angularjs',
+    ],
+    sveltekit: [
+        technologyValue('technology-sveltekit-eefb03'),
+        'svelte kit',
+        technologyValue('technology-svelte-c190ac'),
+        '+page.server.ts',
+        'use:enhance',
+    ],
+    astro: [
+        technologyValue('technology-astro-23661e'),
+        'astro.js',
+        'astro 4',
+        'client:load',
+        'getcollection',
+    ],
+    remix: [
+        technologyValue('technology-remix-0c5d96'),
+        'remix 2',
+        '@remix-run',
+        'useloaderdata',
+        'useactiondata',
+    ],
+    express: [
+        technologyValue('technology-express-008231'),
+        'express.js',
+        'expressjs',
+        'express.router',
+        'app.get(',
+        'app.use(',
+    ],
+    nestjs: [
+        technologyValue('technology-nestjs-2d0087'),
+        'nest.js',
+        '@nestjs',
+        '@injectable',
+        '@controller',
+        '@module',
+    ],
+    django: [
+        technologyValue('technology-django-7d8a08'),
+        'django 5',
+        'django orm',
+        'models.model',
+        'views.py',
+        'urls.py',
+    ],
     fastapi: [
-        'fastapi',
+        technologyValue('technology-fastapi-6aee0e'),
         'fast api',
         'fastapi route',
         '@app.get',
@@ -25,26 +95,61 @@ const FRAMEWORK_ALIASES = {
         'basemodel',
     ],
     springboot: [
-        'spring boot',
-        'springboot',
+        technologyValue('technology-spring-boot-9c3c05'),
+        technologyValue('technology-springboot-7e901d'),
         '@springbootapplication',
         '@restcontroller',
         'jparepository',
     ],
-    rails: ['rails', 'ruby on rails', 'activerecord', 'activesupport', 'hotwire', 'turbo'],
-    laravel: ['laravel', 'laravel 11', 'eloquent', 'artisan', 'blade template'],
+    rails: [
+        technologyValue('technology-rails-2e1d59'),
+        'ruby on rails',
+        technologyValue('technology-activerecord-97a448'),
+        'activesupport',
+        'hotwire',
+        'turbo',
+    ],
+    laravel: [
+        technologyValue('technology-laravel-c34cfa'),
+        'laravel 11',
+        technologyValue('technology-eloquent-b89f45'),
+        'artisan',
+        'blade template',
+    ],
     gin: ['gin framework', 'gin.new()', 'gin.default()', 'c.json(', 'gin.h{', 'c.shouldbindjson'],
-    actix: ['actix-web', 'actix web', 'actix 4', 'web::data', 'httpresponse', 'web::path'],
-    aspnet: ['asp.net', 'aspnet', '.net core', 'dotnet', '@controller', 'iactionresult', 'blazor'],
+    actix: [
+        technologyValue('technology-actix-web-ab3e35'),
+        'actix web',
+        'actix 4',
+        'web::data',
+        'httpresponse',
+        'web::path',
+    ],
+    aspnet: [
+        'asp.net',
+        technologyValue('technology-aspnet-cc66fa'),
+        '.net core',
+        'dotnet',
+        '@controller',
+        'iactionresult',
+        'blazor',
+    ],
     flutter: [
-        'flutter',
+        technologyValue('technology-flutter-be1396'),
         'dart flutter',
         'statefulwidget',
         'statelesswidget',
         'buildcontext',
         'scaffold(',
     ],
-    swiftui: ['swiftui', 'swift ui', '@state', '@observedobject', '@stateobject', 'navigationstack'],
+    swiftui: [
+        technologyValue('technology-swiftui-b63400'),
+        'swift ui',
+        '@state',
+        '@observedobject',
+        '@stateobject',
+        'navigationstack',
+    ],
 };
 /** Regex patterns to detect API/pattern references in text. */
 const API_PATTERNS = [

package/dist/engine/resilience-detector/concurrency-detector.js

@@ -1,6 +1,4 @@
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
-// engine/resilience-detector/concurrency-detector.ts — Concurrency model & resilience detection (SPEC-034)
+import { technologyValue } from '../technology-registry.js';
 /**
  * Detects concurrency model based on language and runtime.
  */
@@ -28,7 +26,9 @@ export function detectConcurrencyModel(language, deps) {
         }
         return 'threads-locks';
     }
-    if (langLower === 'typescript' || langLower === 'javascript' || langLower === 'nodejs') {
+    if (langLower === technologyValue('technology-typescript-969545') ||
+        langLower === 'javascript' ||
+        langLower === 'nodejs') {
         if (depsLower.some((d) => d.includes('rxjs'))) {
             return 'reactive-streams';
         }

package/dist/engine/resilience-detector/middleware-detector.js

@@ -1,16 +1,14 @@
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
-// engine/resilience-detector/middleware-detector.ts — Middleware framework detection (SPEC-034)
+import { technologyValue } from '../technology-registry.js';
 const FRAMEWORK_SIGNALS = [
     {
-        name: 'express',
-        pattern: 'express',
+        name: technologyValue('technology-express-008231'),
+        pattern: technologyValue('technology-express-008231'),
         language: 'nodejs',
         chain: ['cors', 'body-parser', 'auth', 'rate-limit', 'validation', 'handler'],
     },
     {
-        name: 'fastify',
-        pattern: 'fastify',
+        name: technologyValue('technology-fastify-cbe57e'),
+        pattern: technologyValue('technology-fastify-cbe57e'),
         language: 'nodejs',
         chain: ['onRequest', 'preValidation', 'preHandler', 'handler', 'onSend'],
     },
@@ -21,7 +19,7 @@ const FRAMEWORK_SIGNALS = [
         chain: ['auth', 'rate-limit', 'handler'],
     },
     {
-        name: 'nestjs',
+        name: technologyValue('technology-nestjs-2d0087'),
         pattern: '@nestjs/core',
         language: 'nodejs',
         chain: ['Guards', 'Interceptors', 'Pipes', 'handler', 'Filters'],
@@ -33,14 +31,14 @@ const FRAMEWORK_SIGNALS = [
         chain: ['error-handler', 'auth', 'logger', 'handler'],
     },
     {
-        name: 'django',
-        pattern: 'django',
+        name: technologyValue('technology-django-7d8a08'),
+        pattern: technologyValue('technology-django-7d8a08'),
         language: 'python',
         chain: ['SecurityMiddleware', 'SessionMiddleware', 'AuthenticationMiddleware', 'handler'],
     },
     {
-        name: 'fastapi',
-        pattern: 'fastapi',
+        name: technologyValue('technology-fastapi-6aee0e'),
+        pattern: technologyValue('technology-fastapi-6aee0e'),
         language: 'python',
         chain: ['CORSMiddleware', 'auth-dependency', 'validation', 'handler'],
     },
@@ -57,7 +55,7 @@ const FRAMEWORK_SIGNALS = [
         chain: ['ExceptionHandler', 'HTTPS', 'Auth', 'RateLimiting', 'Endpoint'],
     },
     {
-        name: 'gin',
+        name: technologyValue('technology-gin-985adc'),
         pattern: 'gin-gonic/gin',
         language: 'go',
         chain: ['recovery', 'logger', 'auth', 'handler'],

package/dist/engine/resilience-detector/validation-detector.js

@@ -1,3 +1,4 @@
+import { technologyValue } from '../technology-registry.js';
 // engine/resilience-detector/validation-detector.ts — Validation library detection (SPEC-034)
 /**
  * Detects validation library in use for the given language and dependency set.
@@ -5,9 +6,21 @@
 export function detectValidationLibrary(deps, language) {
     const depsLower = deps.map((d) => d.toLowerCase());
     const patterns = {
-        typescript: ['zod', 'joi', 'yup', 'valibot', 'ajv', 'class-validator'],
-        javascript: ['zod', 'joi', 'yup', 'valibot', 'ajv'],
-        python: ['pydantic', 'marshmallow', 'cerberus', 'voluptuous'],
+        typescript: [
+            technologyValue('technology-zod-4f63cf'),
+            'joi',
+            'yup',
+            'valibot',
+            'ajv',
+            'class-validator',
+        ],
+        javascript: [technologyValue('technology-zod-4f63cf'), 'joi', 'yup', 'valibot', 'ajv'],
+        python: [
+            technologyValue('technology-pydantic-636623'),
+            'marshmallow',
+            'cerberus',
+            'voluptuous',
+        ],
         java: ['jakarta.validation', 'javax.validation', 'hibernate-validator', 'spring-validation'],
         go: ['go-playground/validator', 'go-ozzo/ozzo-validation', 'asaskevich/govalidator'],
         dotnet: ['FluentValidation', 'MiniValidation'],
@@ -20,7 +33,7 @@ export function detectValidationLibrary(deps, language) {
         const found = depsLower.some((d) => d.includes(patternLower));
         if (found) {
             const isPydanticMigration = language === 'python' &&
-                pattern === 'pydantic' &&
+                pattern === technologyValue('technology-pydantic-636623') &&
                 depsLower.some((d) => d.includes('pydantic.v1') || d.includes('pydantic-v1'));
             return { library: pattern, version: null, isPydanticMigration };
         }

package/dist/engine/reverse-engineer/config-analyzer.js

@@ -1,3 +1,4 @@
+import { technologyValue } from '../technology-registry.js';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 const ENV_VAR_PATTERNS = [
@@ -27,22 +28,22 @@ const FEATURE_FLAG_PATTERNS = [
     /flagsmith\.hasFeature\s*\(\s*['"]([^'"]+)['"]/g,
 ];
 const INFRA_INDICATORS = {
-    Dockerfile: 'Docker',
+    Dockerfile: technologyValue('technology-docker-e6169e'),
     'docker-compose.yml': 'Docker Compose',
     'docker-compose.yaml': 'Docker Compose',
-    kubernetes: 'Kubernetes',
-    k8s: 'Kubernetes',
+    kubernetes: technologyValue('technology-kubernetes-a37d07'),
+    k8s: technologyValue('technology-kubernetes-a37d07'),
     helm: 'Helm',
-    terraform: 'Terraform',
-    '.terraform': 'Terraform',
+    terraform: technologyValue('technology-terraform-05b073'),
+    '.terraform': technologyValue('technology-terraform-05b073'),
     pulumi: 'Pulumi',
     'serverless.yml': 'Serverless Framework',
     'serverless.yaml': 'Serverless Framework',
-    'vercel.json': 'Vercel',
-    'netlify.toml': 'Netlify',
+    'vercel.json': technologyValue('technology-vercel-68edc7'),
+    'netlify.toml': technologyValue('technology-netlify-55c13c'),
     'fly.toml': 'Fly.io',
     'render.yaml': 'Render',
-    'railway.json': 'Railway',
+    'railway.json': technologyValue('technology-railway-3e12c4'),
     Procfile: 'Heroku',
     'app.yaml': 'Google App Engine',
     '.github/workflows': 'GitHub Actions',

package/dist/engine/reverse-engineer/orchestrator.js

@@ -1,8 +1,4 @@
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
-// engine/reverse-engineer/orchestrator.ts — AC-7: Parallel analyzer orchestration
-// AC-9: Spec enrichment from analysis results
-// AC-10: Human-readable output summary
+import { technologyValue } from '../technology-registry.js';
 import { analyzeTestCoverage } from './test-analyzer.js';
 import { buildDependencyGraph } from './dependency-graph.js';
 import { detectApiRoutes } from './api-detector.js';
@@ -48,11 +44,11 @@ function detectTags(result) {
     const tagMap = {
         jest: 'vitest/jest',
         vitest: 'vitest/jest',
-        'next.config': 'nextjs',
+        'next.config': technologyValue('technology-nextjs-c93379'),
         'vite.config': 'vite',
-        tsconfig: 'typescript',
-        docker: 'docker',
-        Docker: 'docker',
+        tsconfig: technologyValue('technology-typescript-969545'),
+        docker: technologyValue('technology-docker-d548c5'),
+        Docker: technologyValue('technology-docker-d548c5'),
     };
     for (const cfg of result.configAnalysis.configFiles) {
         for (const [key, tag] of Object.entries(tagMap)) {

package/dist/engine/reverse-engineer/test-file-parser.js

@@ -1,3 +1,4 @@
+import { technologyValue } from '../technology-registry.js';
 // engine/reverse-engineer/test-file-parser.ts — Parse test files into spec ACs (SPEC-299)
 import { readFile } from 'node:fs/promises';
 import * as nodePath from 'node:path';
@@ -5,11 +6,13 @@ import * as nodePath from 'node:path';
  * Detect the test framework from file content.
  */
 export function detectFramework(content) {
-    const hasPlaywriterImport = content.toLowerCase().includes('playwright');
+    const hasPlaywriterImport = content
+        .toLowerCase()
+        .includes(technologyValue('technology-playwright-7827e8'));
     const hasTestDescribe = content.includes('test.describe');
     const hasPlaywright = hasPlaywriterImport || hasTestDescribe;
     if (hasPlaywright) {
-        return 'playwright';
+        return technologyValue('technology-playwright-7827e8');
     }
     const hasCyDot = content.includes('cy.');
     const hasCypress = hasCyDot;
@@ -21,7 +24,7 @@ export function detectFramework(content) {
     // hasCyDot and hasPlaywriterImport are already false here (early returns above)
     const hasJest = hasDescribe && hasItOrTest;
     if (hasJest) {
-        return 'jest';
+        return technologyValue('technology-jest-35e99f');
     }
     return 'unknown';
 }