@planu/cli 4.12.3 → 4.14.1

package/dist/engine/spec-migrator/strict-planu-cleanup.js

@@ -17,16 +17,21 @@ async function pathIsDirectory(path) {
         return false;
     }
 }
+async function readDirectory(path) {
+    try {
+        return await readdir(path);
+    }
+    catch {
+        return [];
+    }
+}
 async function gitRmCached(projectPath, relPath) {
     if (!existsSync(join(projectPath, '.git'))) {
         return;
     }
     try {
-        const args = ['rm', '--cached', '--quiet', '--ignore-unmatch'];
-        if (await pathIsDirectory(join(projectPath, relPath))) {
-            args.push('-r');
-        }
-        args.push(relPath);
+        // This helper is only called for directories from removePath.
+        const args = ['rm', '--cached', '--quiet', '--ignore-unmatch', '-r', relPath];
         await execFileAsync('git', args, {
             cwd: projectPath,
             timeout: 5_000,
@@ -48,9 +53,6 @@ function appendSectionIfMissing(specContent, heading, body) {
 async function mergeLegacySpecFile(projectPath, specDir, fileName) {
     const specPath = join(specDir, 'spec.md');
     const legacyPath = join(specDir, fileName);
-    if (!existsSync(legacyPath) || !existsSync(specPath)) {
-        return false;
-    }
     const [specContent, legacyContent] = await Promise.all([
         readFile(specPath, 'utf-8'),
         readFile(legacyPath, 'utf-8'),
@@ -70,7 +72,6 @@ async function mergeLegacySpecFile(projectPath, specDir, fileName) {
         });
     }
     await safeUnlink(projectPath, legacyPath);
-    return true;
 }
 async function removePath(projectPath, absolutePath) {
     const rel = relative(projectPath, absolutePath);
@@ -116,13 +117,12 @@ async function updateGitignore(projectPath) {
     return true;
 }
 async function walkSpecDirectory(projectPath, specDir, result) {
-    const entries = await readdir(specDir).catch(() => []);
+    const entries = await readDirectory(specDir);
     for (const entry of entries) {
         const full = join(specDir, entry);
         if (mustMergeBeforeDeleteSpecFile(entry)) {
-            if (await mergeLegacySpecFile(projectPath, specDir, entry)) {
-                result.merged.push(relative(projectPath, full));
-            }
+            await mergeLegacySpecFile(projectPath, specDir, entry);
+            result.merged.push(relative(projectPath, full));
             continue;
         }
         const isDir = await pathIsDirectory(full);
@@ -134,11 +134,10 @@ async function walkSpecDirectory(projectPath, specDir, result) {
     }
 }
 async function shouldDeleteOrphanSpecDir(specDir) {
-    const entries = await readdir(specDir).catch(() => []);
-    if (entries.includes('spec.md')) {
-        return false;
-    }
-    return !entries.some((entry) => mustMergeBeforeDeleteSpecFile(entry));
+    const entries = await readDirectory(specDir);
+    // Legacy split files are only mergeable when the canonical destination exists.
+    // Keeping them without spec.md leaves a permanently non-canonical orphan behind.
+    return !entries.includes('spec.md');
 }
 export async function runStrictPlanuCleanup(projectPath) {
     const result = { deleted: [], merged: [], gitignoreUpdated: false };
@@ -146,7 +145,7 @@ export async function runStrictPlanuCleanup(projectPath) {
     if (!existsSync(planuDir)) {
         return result;
     }
-    const entries = await readdir(planuDir).catch(() => []);
+    const entries = await readDirectory(planuDir);
     for (const entry of entries) {
         const full = join(planuDir, entry);
         const isDir = await pathIsDirectory(full);
@@ -161,7 +160,7 @@ export async function runStrictPlanuCleanup(projectPath) {
         }
     }
     const releasesDir = join(planuDir, 'releases');
-    for (const entry of await readdir(releasesDir).catch(() => [])) {
+    for (const entry of await readDirectory(releasesDir)) {
         const rel = `releases/${entry}`;
         if (!isCanonicalReleaseFile(rel)) {
             const full = join(releasesDir, entry);
@@ -170,7 +169,7 @@ export async function runStrictPlanuCleanup(projectPath) {
         }
     }
     const specsDir = join(planuDir, 'specs');
-    for (const entry of await readdir(specsDir).catch(() => [])) {
+    for (const entry of await readDirectory(specsDir)) {
         const full = join(specsDir, entry);
         if (!(await pathIsDirectory(full)) || entry === 'data') {
             await removePath(projectPath, full);
@@ -198,7 +197,7 @@ export async function validateStrictPlanuLayout(projectPath, options = {}) {
     const offenders = [];
     const planuDir = join(projectPath, 'planu');
     if (options.includeRoot !== false) {
-        const entries = await readdir(planuDir).catch(() => []);
+        const entries = await readDirectory(planuDir);
         for (const entry of entries) {
             const full = join(planuDir, entry);
             const isDir = await pathIsDirectory(full);
@@ -207,7 +206,7 @@ export async function validateStrictPlanuLayout(projectPath, options = {}) {
                 offenders.push(relative(projectPath, full));
             }
         }
-        for (const entry of await readdir(join(planuDir, 'releases')).catch(() => [])) {
+        for (const entry of await readDirectory(join(planuDir, 'releases'))) {
             const rel = `releases/${entry}`;
             if (!isCanonicalReleaseFile(rel)) {
                 offenders.push(`planu/${rel}`);
@@ -215,7 +214,7 @@ export async function validateStrictPlanuLayout(projectPath, options = {}) {
         }
     }
     const scopedSpecDirs = resolveSpecDirsForValidation(projectPath, options.specPath) ??
-        (await readdir(join(planuDir, 'specs')).catch(() => [])).map((specDir) => join(planuDir, 'specs', specDir));
+        (await readDirectory(join(planuDir, 'specs'))).map((specDir) => join(planuDir, 'specs', specDir));
     for (const full of scopedSpecDirs) {
         const specDir = relative(join(planuDir, 'specs'), full);
         if (!(await pathIsDirectory(full)) || specDir === 'data') {
@@ -226,7 +225,7 @@ export async function validateStrictPlanuLayout(projectPath, options = {}) {
             offenders.push(relative(projectPath, full));
             continue;
         }
-        for (const entry of await readdir(full).catch(() => [])) {
+        for (const entry of await readDirectory(full)) {
             const entryPath = join(full, entry);
             const isDir = await pathIsDirectory(entryPath);
             if (isDir ? !isCanonicalSpecDir(entry) : !isCanonicalSpecFile(entry)) {

package/dist/engine/spec-registry/adapter.d.ts

@@ -1,8 +1,3 @@
-/**
- * Stack detection and spec adaptation for registry specs.
- * Detects project technology stack from config files and applies
- * framework-specific substitutions to spec content.
- */
 import type { StackDetectionResult, StackAdaptation } from '../../types/index.js';
 export declare function detectStack(projectPath: string): Promise<StackDetectionResult>;
 export declare function adaptSpec(specDir: string, projectStack: StackDetectionResult, adaptableMap?: Record<string, Record<string, string>>): Promise<StackAdaptation[]>;

package/dist/engine/spec-registry/adapter.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';
 /**
  * Stack detection and spec adaptation for registry specs.
  * Detects project technology stack from config files and applies
@@ -59,49 +58,49 @@ function textContains(text, keyword) {
 // ---------------------------------------------------------------------------
 function detectNodeFramework(pkg) {
     if (hasDep(pkg, 'next')) {
-        return 'nextjs';
+        return technologyValue('technology-nextjs-c93379');
     }
-    if (hasDep(pkg, 'nuxt')) {
-        return 'nuxt';
+    if (hasDep(pkg, technologyValue('technology-nuxt-22c407'))) {
+        return technologyValue('technology-nuxt-22c407');
     }
-    if (hasDep(pkg, '@sveltejs/kit') || hasDep(pkg, 'svelte')) {
-        return 'sveltekit';
+    if (hasDep(pkg, '@sveltejs/kit') || hasDep(pkg, technologyValue('technology-svelte-c190ac'))) {
+        return technologyValue('technology-sveltekit-eefb03');
     }
-    if (hasDep(pkg, '@remix-run/node') || hasDep(pkg, 'remix')) {
-        return 'remix';
+    if (hasDep(pkg, '@remix-run/node') || hasDep(pkg, technologyValue('technology-remix-0c5d96'))) {
+        return technologyValue('technology-remix-0c5d96');
     }
-    if (hasDep(pkg, 'astro')) {
-        return 'astro';
+    if (hasDep(pkg, technologyValue('technology-astro-23661e'))) {
+        return technologyValue('technology-astro-23661e');
     }
-    if (hasDep(pkg, 'fastify')) {
-        return 'fastify';
+    if (hasDep(pkg, technologyValue('technology-fastify-cbe57e'))) {
+        return technologyValue('technology-fastify-cbe57e');
     }
-    if (hasDep(pkg, 'express')) {
-        return 'express';
+    if (hasDep(pkg, technologyValue('technology-express-008231'))) {
+        return technologyValue('technology-express-008231');
     }
     return 'unknown';
 }
 function detectNodeOrm(pkg) {
-    if (hasDep(pkg, '@prisma/client') || hasDep(pkg, 'prisma')) {
-        return 'prisma';
+    if (hasDep(pkg, '@prisma/client') || hasDep(pkg, technologyValue('technology-prisma-99497c'))) {
+        return technologyValue('technology-prisma-99497c');
     }
     if (hasDep(pkg, 'drizzle-orm')) {
-        return 'drizzle';
+        return technologyValue('technology-drizzle-424f22');
     }
-    if (hasDep(pkg, 'sequelize')) {
-        return 'sequelize';
+    if (hasDep(pkg, technologyValue('technology-sequelize-d18291'))) {
+        return technologyValue('technology-sequelize-d18291');
     }
-    if (hasDep(pkg, 'typeorm')) {
-        return 'typeorm';
+    if (hasDep(pkg, technologyValue('technology-typeorm-527d4d'))) {
+        return technologyValue('technology-typeorm-527d4d');
     }
     return undefined;
 }
 function detectNodeTestRunner(pkg) {
-    if (hasDevDep(pkg, 'vitest')) {
-        return 'vitest';
+    if (hasDevDep(pkg, technologyValue('technology-vitest-a9127f'))) {
+        return technologyValue('technology-vitest-a9127f');
     }
-    if (hasDevDep(pkg, 'jest')) {
-        return 'jest';
+    if (hasDevDep(pkg, technologyValue('technology-jest-35e99f'))) {
+        return technologyValue('technology-jest-35e99f');
     }
     if (hasDevDep(pkg, 'mocha')) {
         return 'mocha';
@@ -140,7 +139,7 @@ async function detectNodePackageManager(projectPath) {
 async function detectNodeStack(projectPath, pkg) {
     const result = { language: 'javascript', framework: 'unknown' };
     if (await fileExists(join(projectPath, 'tsconfig.json'))) {
-        result.language = 'typescript';
+        result.language = technologyValue('technology-typescript-969545');
     }
     result.framework = detectNodeFramework(pkg);
     result.orm = detectNodeOrm(pkg);
@@ -158,20 +157,20 @@ async function detectPythonStack(projectPath) {
     const requirements = await readTextSafe(join(projectPath, 'requirements.txt'));
     const combined = [pyproject, requirements].filter(Boolean).join('\n');
     /* v8 ignore start -- Python framework detection branches */
-    if (textContains(combined, 'fastapi')) {
-        result.framework = 'fastapi';
+    if (textContains(combined, technologyValue('technology-fastapi-6aee0e'))) {
+        result.framework = technologyValue('technology-fastapi-6aee0e');
     }
-    else if (textContains(combined, 'django')) {
-        result.framework = 'django';
+    else if (textContains(combined, technologyValue('technology-django-7d8a08'))) {
+        result.framework = technologyValue('technology-django-7d8a08');
     }
-    else if (textContains(combined, 'flask')) {
-        result.framework = 'flask';
+    else if (textContains(combined, technologyValue('technology-flask-b87aa5'))) {
+        result.framework = technologyValue('technology-flask-b87aa5');
     }
-    if (textContains(combined, 'sqlalchemy')) {
-        result.orm = 'sqlalchemy';
+    if (textContains(combined, technologyValue('technology-sqlalchemy-37f268'))) {
+        result.orm = technologyValue('technology-sqlalchemy-37f268');
     }
-    if (textContains(combined, 'pytest')) {
-        result.testRunner = 'pytest';
+    if (textContains(combined, technologyValue('technology-pytest-2b0121'))) {
+        result.testRunner = technologyValue('technology-pytest-2b0121');
     }
     if (await fileExists(join(projectPath, 'poetry.lock'))) {
         result.packageManager = 'poetry';
@@ -193,13 +192,13 @@ async function detectGoStack(projectPath) {
         return result;
     }
     if (goMod.includes('github.com/gin-gonic/gin')) {
-        result.framework = 'gin';
+        result.framework = technologyValue('technology-gin-985adc');
     }
     else if (goMod.includes('github.com/gofiber/fiber')) {
-        result.framework = 'fiber';
+        result.framework = technologyValue('technology-fiber-77c3e6');
     }
     if (goMod.includes('gorm.io/gorm')) {
-        result.orm = 'gorm';
+        result.orm = technologyValue('technology-gorm-7f6614');
     }
     return result;
 }
@@ -209,14 +208,14 @@ async function detectRustStack(projectPath) {
     if (!cargo) {
         return result;
     }
-    if (textContains(cargo, 'actix-web')) {
-        result.framework = 'actix-web';
+    if (textContains(cargo, technologyValue('technology-actix-web-ab3e35'))) {
+        result.framework = technologyValue('technology-actix-web-ab3e35');
     }
-    else if (textContains(cargo, 'axum')) {
-        result.framework = 'axum';
+    else if (textContains(cargo, technologyValue('technology-axum-af7119'))) {
+        result.framework = technologyValue('technology-axum-af7119');
     }
-    if (textContains(cargo, 'diesel')) {
-        result.orm = 'diesel';
+    if (textContains(cargo, technologyValue('technology-diesel-f83cff'))) {
+        result.orm = technologyValue('technology-diesel-f83cff');
     }
     return result;
 }

package/dist/engine/spec-registry/client.js

@@ -2,6 +2,7 @@
 // HTTP client for the Planu spec registry. Uses node:https/http only (no external deps).
 import * as https from 'node:https';
 import * as http from 'node:http';
+import { assertNetworkAllowed } from '../network-policy.js';
 const DEFAULT_BASE_URL = 'https://registry.planu.dev/api/v1';
 const MAX_RETRIES = 3;
 const BASE_DELAY_MS = 1000;
@@ -71,6 +72,7 @@ async function request(url, options, body) {
 }
 /** Execute a single HTTP request. */
 function executeRequest(url, options, body) {
+    assertNetworkAllowed(url);
     return new Promise((resolve, reject) => {
         const transport = getTransport(url);
         const req = transport.request(url, options, (res) => {

package/dist/engine/spec-source-sync.js

@@ -1,3 +1,4 @@
+import { technologyValue } from './technology-registry.js';
 // engine/spec-source-sync.ts — Spec-as-Source sync logic (SPEC-349)
 import { readFile } from 'node:fs/promises';
 // ---------------------------------------------------------------------------
@@ -26,9 +27,9 @@ export function detectMarkers(content) {
 export function detectLanguage(filePath) {
     const ext = filePath.split('.').pop()?.toLowerCase() ?? '';
     const MAP = {
-        ts: 'typescript',
+        ts: technologyValue('technology-typescript-969545'),
         js: 'javascript',
-        tsx: 'typescript',
+        tsx: technologyValue('technology-typescript-969545'),
         jsx: 'javascript',
         py: 'python',
         rb: 'ruby',

package/dist/engine/spec-templates/custom-loader.js

@@ -4,6 +4,7 @@
 import { readdir, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { z } from 'zod';
+import { resolvedStorageArtifactPath } from '../../storage/storage-catalog.js';
 /** Zod schema for validating custom template JSON files. */
 const templateVariableSchema = z.object({
     key: z.string().min(1),
@@ -53,14 +54,12 @@ const customTemplateSchema = z.object({
     fichaTecnicaTemplate: z.string().min(1),
     progressTemplate: z.string().min(1),
 });
-/** Default directory for custom user templates. */
-const CUSTOM_TEMPLATES_DIR = 'data/global/spec-templates/custom';
 /**
  * Loads custom templates from a directory. Each .json file is validated.
  * Malformed files generate warnings but do not block loading of other templates.
  */
 export async function loadCustomTemplates(baseDir) {
-    const dir = baseDir ?? CUSTOM_TEMPLATES_DIR;
+    const dir = baseDir ?? resolvedStorageArtifactPath('custom-spec-templates');
     const templates = [];
     const warnings = [];
     let files;

package/dist/engine/spec-templates/templates-domain-specific.js

@@ -1,7 +1,4 @@
-// engine/spec-templates/templates-domain-specific.ts — Domain-specific spec templates A (SPEC-513).
-// Auth login, auth OAuth, Stripe payment, and CRUD resource templates.
-// Templates 5-8 (REST API integration, webhook, file upload, background job) are in
-// templates-domain-specific-b.ts.
+import { technologyValue } from '../technology-registry.js';
 import { REST_API_INTEGRATION_TEMPLATE, WEBHOOK_CONSUMER_TEMPLATE, FILE_UPLOAD_TEMPLATE, BACKGROUND_JOB_TEMPLATE, } from './templates-domain-specific-b.js';
 export { REST_API_INTEGRATION_TEMPLATE, WEBHOOK_CONSUMER_TEMPLATE, FILE_UPLOAD_TEMPLATE, BACKGROUND_JOB_TEMPLATE, };
 /** Auth Login spec template — credential validation, session, rate limiting, lockout. */
@@ -223,7 +220,13 @@ export const STRIPE_PAYMENT_TEMPLATE = {
     name: 'Stripe Payment',
     category: 'integration',
     description: 'Stripe checkout sessions, webhook signature verification, refunds, and failed payment retry.',
-    tags: ['payments', 'stripe', 'webhook', 'idempotency', 'backend'],
+    tags: [
+        'payments',
+        technologyValue('technology-stripe-2bed20'),
+        'webhook',
+        'idempotency',
+        'backend',
+    ],
     complexityScore: 'M',
     estimationBase: {
         hoursMin: 20,

package/dist/engine/spec-templates/templates-perf-integration.js

@@ -1,5 +1,4 @@
-// engine/spec-templates/templates-perf-integration.ts — Performance + third-party integration templates.
-// Extracted from catalog-extra.ts to keep file sizes within limits.
+import { technologyValue } from '../technology-registry.js';
 /** Performance optimization spec template. */
 export const PERFORMANCE_OPTIMIZATION_TEMPLATE = {
     id: 'performance-optimization',
@@ -139,7 +138,7 @@ export const THIRD_PARTY_INTEGRATION_TEMPLATE = {
             key: 'ServiceName',
             label: 'Service name',
             description: 'Name of the external service to integrate',
-            example: 'Stripe',
+            example: technologyValue('technology-stripe-961a60'),
             required: true,
         },
         {

package/dist/engine/stack-auditor/manifest-reader.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.
 // manifest-reader.ts — Reads project manifest files (SPEC-041)
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';

package/dist/engine/staleness/stale-implementing.js

@@ -5,7 +5,7 @@
 import { readFile, access, readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { constants } from 'node:fs';
-import { hashProjectPath } from '../../storage/base-store.js';
+import { hashProjectPath, projectDataDir } from '../../storage/base-store.js';
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -18,8 +18,8 @@ async function fileExists(p) {
         return false;
     }
 }
-async function getLastTransitionForSpec(projectPath, projectId, specId) {
-    const logPath = join(projectPath, 'planu', 'data', 'projects', projectId, 'transition-log.jsonl');
+async function getLastTransitionForSpec(projectId, specId) {
+    const logPath = join(projectDataDir(projectId), 'transition-log.jsonl');
     try {
         const raw = await readFile(logPath, 'utf-8');
         const lines = raw.trim().split('\n').filter(Boolean);
@@ -47,8 +47,8 @@ async function getLastTransitionForSpec(projectPath, projectId, specId) {
         return null;
     }
 }
-async function getDaysInImplementing(projectPath, projectId, specId) {
-    const logPath = join(projectPath, 'planu', 'data', 'projects', projectId, 'transition-log.jsonl');
+async function getDaysInImplementing(projectId, specId) {
+    const logPath = join(projectDataDir(projectId), 'transition-log.jsonl');
     try {
         const raw = await readFile(logPath, 'utf-8');
         const lines = raw.trim().split('\n').filter(Boolean);
@@ -120,8 +120,8 @@ export async function findStaleImplementing(params) {
             // No specs dir
         }
         const hasProgress = specDir !== null && (await fileExists(join(specDir, 'progress.md')));
-        const daysInStatus = await getDaysInImplementing(projectPath, projectId, spec.id);
-        const lastTransition = await getLastTransitionForSpec(projectPath, projectId, spec.id);
+        const daysInStatus = await getDaysInImplementing(projectId, spec.id);
+        const lastTransition = await getLastTransitionForSpec(projectId, spec.id);
         if (daysInStatus >= daysThreshold || daysInStatus === -1) {
             results.push({
                 specId: spec.id,

package/dist/engine/tdd-scaffold-generator.js

@@ -1,3 +1,4 @@
+import { technologyValue } from './technology-registry.js';
 // engine/tdd-scaffold-generator.ts — SPEC-323
 // Generates TDD scaffold (failing test stubs + impl skeleton) from spec ACs.
 import { readFile } from 'node:fs/promises';
@@ -41,11 +42,11 @@ async function detectFramework(projectPath) {
             ...(pkg.dependencies ?? {}),
             ...(pkg.devDependencies ?? {}),
         };
-        if ('vitest' in deps) {
-            return 'vitest';
+        if (technologyValue('technology-vitest-a9127f') in deps) {
+            return technologyValue('technology-vitest-a9127f');
         }
-        if ('jest' in deps) {
-            return 'jest';
+        if (technologyValue('technology-jest-35e99f') in deps) {
+            return technologyValue('technology-jest-35e99f');
         }
         if ('mocha' in deps) {
             return 'mocha';
@@ -56,7 +57,7 @@ async function detectFramework(projectPath) {
         // Check for Python or Java markers
         const setup = await readFile(join(projectPath, 'setup.py'), 'utf8').catch(() => null);
         if (setup !== null) {
-            return 'pytest';
+            return technologyValue('technology-pytest-2b0121');
         }
         const pom = await readFile(join(projectPath, 'pom.xml'), 'utf8').catch(() => null);
         if (pom !== null) {
@@ -174,13 +175,13 @@ function buildJunitContent(stubs) {
 }
 function buildTestContent(stubs, framework) {
     switch (framework) {
-        case 'vitest':
+        case technologyValue('technology-vitest-a9127f'):
             return buildVitestContent(stubs);
-        case 'jest':
+        case technologyValue('technology-jest-35e99f'):
             return buildJestContent(stubs);
         case 'mocha':
             return buildMochaContent(stubs);
-        case 'pytest':
+        case technologyValue('technology-pytest-2b0121'):
             return buildPytestContent(stubs);
         case 'junit':
             return buildJunitContent(stubs);
@@ -223,9 +224,21 @@ export async function generateTddScaffold(specPath, projectPath) {
         testName: criterionToTestName(criterion),
         framework,
     }));
-    const ext = framework === 'pytest' ? 'py' : framework === 'junit' ? 'java' : 'ts';
-    const testExt = framework === 'pytest' ? '_test.py' : framework === 'junit' ? 'Test.java' : '.test.ts';
-    const testDir = framework === 'pytest' ? 'tests' : framework === 'junit' ? 'src/test' : 'tests';
+    const ext = framework === technologyValue('technology-pytest-2b0121')
+        ? 'py'
+        : framework === 'junit'
+            ? 'java'
+            : 'ts';
+    const testExt = framework === technologyValue('technology-pytest-2b0121')
+        ? '_test.py'
+        : framework === 'junit'
+            ? 'Test.java'
+            : '.test.ts';
+    const testDir = framework === technologyValue('technology-pytest-2b0121')
+        ? 'tests'
+        : framework === 'junit'
+            ? 'src/test'
+            : 'tests';
     const testFilePath = join(projectPath, testDir, `${slug}${testExt}`);
     const implFilePath = join(projectPath, 'src', `${slug}.${ext}`);
     const testContent = buildTestContent(stubs, framework);

package/dist/engine/teammate-router/green-phase-verifier.js

@@ -1,3 +1,4 @@
+import { technologyValue } from '../technology-registry.js';
 // engine/teammate-router/green-phase-verifier.ts — SPEC-750
 // Verifies green phase: tests pass AND none of the red tests were deleted.
 import { execFile as execFileCb } from 'node:child_process';
@@ -24,7 +25,7 @@ export async function verifyGreenPhase(redHandoff, projectRoot) {
     // Step 2: Run the tests and expect them to pass now
     try {
         const testArgs = ['--pool=forks', ...redHandoff.testFiles];
-        await execFile('npx', ['vitest', 'run', ...testArgs], {
+        await execFile('npx', [technologyValue('technology-vitest-a9127f'), 'run', ...testArgs], {
             cwd: projectRoot,
             timeout: 120_000,
         });

package/dist/engine/teammate-router/red-phase-verifier.js

@@ -1,3 +1,4 @@
+import { technologyValue } from '../technology-registry.js';
 // engine/teammate-router/red-phase-verifier.ts — SPEC-750
 // Runs the test suite and confirms that all expected tests are failing (RED phase).
 import { execFile as execFileCb } from 'node:child_process';
@@ -12,7 +13,7 @@ export async function verifyRedPhase(handoff, projectRoot) {
     try {
         // Run just the test files from the handoff
         const testArgs = ['--pool=forks', ...handoff.testFiles];
-        await execFile('npx', ['vitest', 'run', ...testArgs], {
+        await execFile('npx', [technologyValue('technology-vitest-a9127f'), 'run', ...testArgs], {
             cwd: projectRoot,
             timeout: 120_000,
         });

package/dist/engine/technology-registry.d.ts

@@ -0,0 +1,11 @@
+import type { TechnologyRegistry } from '../types/technology-registry.js';
+import type { TechnologySymbolMap } from '../types/technology-symbols.generated.js';
+export declare function parseTechnologyRegistry(input: {
+    authority: unknown;
+    frameworkCatalog: unknown;
+    detectionCatalog: unknown;
+}): TechnologyRegistry;
+export declare function technologyValue<K extends keyof TechnologySymbolMap>(symbol: K): TechnologySymbolMap[K];
+export declare function loadTechnologyRegistry(directory?: string): TechnologyRegistry;
+export declare function resetTechnologyRegistryCache(): void;
+//# sourceMappingURL=technology-registry.d.ts.map