@planu/cli 4.12.3 → 4.14.1

package/dist/engine/technology-registry.js

@@ -0,0 +1,142 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { z } from 'zod';
+import bundledAuthority from '../config/technology-registry.json' with { type: 'json' };
+import bundledFrameworkCatalog from '../config/framework-registry/index.json' with { type: 'json' };
+import bundledDetectionCatalog from '../config/detection-signals.json' with { type: 'json' };
+const nonBlank = z.string().trim().min(1);
+const relativeJsonFile = nonBlank.regex(/^(?!\/)(?!.*\/\/)(?!.*(?:^|\/)\.{1,2}(?:\/|$))[A-Za-z0-9_-]+(?:\/[A-Za-z0-9_.-]+)*\.json$/u);
+const authoritySchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    frameworkCatalog: relativeJsonFile,
+    detectionCatalog: relativeJsonFile,
+    symbols: z.record(nonBlank, nonBlank),
+})
+    .strict();
+const frameworkSchema = z
+    .object({
+    id: nonBlank,
+    displayName: nonBlank,
+    ecosystem: nonBlank,
+    frameworkVersion: nonBlank,
+    lastUpdated: nonBlank,
+    file: relativeJsonFile,
+})
+    .strict();
+const signalSchema = z
+    .object({
+    frameworkId: nonBlank,
+    ecosystem: nonBlank,
+    type: z.enum(['dependency', 'file', 'env']),
+    pattern: nonBlank,
+    manager: nonBlank.optional(),
+})
+    .strict();
+const targetSchema = z
+    .object({
+    id: nonBlank,
+    type: z.enum(['dependency', 'file', 'env']),
+    pattern: nonBlank,
+    manager: nonBlank.optional(),
+    additionalMatch: nonBlank.optional(),
+})
+    .strict();
+const frameworkCatalogSchema = z.object({ frameworks: z.array(frameworkSchema) }).strict();
+const detectionCatalogSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    description: nonBlank.optional(),
+    signals: z.array(signalSchema),
+    deployTargets: z.array(targetSchema),
+    databases: z.array(targetSchema),
+    aliases: z.array(z.object({ alias: nonBlank, canonical: nonBlank }).strict()).default([]),
+})
+    .strict();
+let cache;
+function readJsonSource(path) {
+    try {
+        const source = readFileSync(path, 'utf8');
+        return { identity: source, value: JSON.parse(source) };
+    }
+    catch (error) {
+        throw new Error(`TECHNOLOGY_REGISTRY_INVALID: cannot read ${path}`, { cause: error });
+    }
+}
+export function parseTechnologyRegistry(input) {
+    const authority = authoritySchema.parse(input.authority);
+    const frameworks = frameworkCatalogSchema.parse(input.frameworkCatalog).frameworks;
+    const detection = detectionCatalogSchema.parse(input.detectionCatalog);
+    const duplicates = frameworks.filter((entry, index) => frameworks.slice(0, index).some((candidate) => candidate.id === entry.id));
+    if (duplicates.length > 0) {
+        throw new Error(`TECHNOLOGY_REGISTRY_INVALID: duplicate framework ${duplicates[0]?.id ?? ''}`);
+    }
+    const canonicalTerms = new Set([
+        ...frameworks.flatMap((entry) => [entry.id, entry.displayName]),
+        ...detection.signals.map((entry) => entry.frameworkId),
+        ...detection.deployTargets.map((entry) => entry.id),
+        ...detection.databases.map((entry) => entry.id),
+        ...detection.aliases.flatMap((entry) => [entry.alias, entry.canonical]),
+    ].map((term) => term.toLowerCase()));
+    for (const [symbol, value] of Object.entries(authority.symbols)) {
+        if (!/^technology-[a-z0-9-]+-[a-f0-9]{6}$/u.test(symbol) ||
+            !canonicalTerms.has(value.toLowerCase())) {
+            throw new Error(`TECHNOLOGY_REGISTRY_INVALID: invalid symbol ${symbol}`);
+        }
+    }
+    return {
+        schemaVersion: 1,
+        frameworks,
+        signals: detection.signals,
+        deployTargets: detection.deployTargets,
+        databases: detection.databases,
+        aliases: detection.aliases,
+        symbols: authority.symbols,
+    };
+}
+export function technologyValue(symbol) {
+    const registry = cache?.registry ?? loadTechnologyRegistry();
+    const value = registry.symbols[symbol];
+    if (value === undefined) {
+        throw new Error(`TECHNOLOGY_REGISTRY_INVALID: unknown symbol ${symbol}`);
+    }
+    return value;
+}
+export function loadTechnologyRegistry(directory) {
+    if (directory === undefined) {
+        const identity = JSON.stringify([
+            bundledAuthority,
+            bundledFrameworkCatalog,
+            bundledDetectionCatalog,
+        ]);
+        if (cache?.identity === identity) {
+            return cache.registry;
+        }
+        const registry = parseTechnologyRegistry({
+            authority: bundledAuthority,
+            frameworkCatalog: bundledFrameworkCatalog,
+            detectionCatalog: bundledDetectionCatalog,
+        });
+        cache = { identity, registry };
+        return registry;
+    }
+    const authoritySource = readJsonSource(join(directory, 'technology-registry.json'));
+    const authority = authoritySchema.parse(authoritySource.value);
+    const frameworkSource = readJsonSource(join(directory, authority.frameworkCatalog));
+    const detectionSource = readJsonSource(join(directory, authority.detectionCatalog));
+    const identity = `${authoritySource.identity}\0${frameworkSource.identity}\0${detectionSource.identity}`;
+    if (cache?.identity === identity) {
+        return cache.registry;
+    }
+    const registry = parseTechnologyRegistry({
+        authority,
+        frameworkCatalog: frameworkSource.value,
+        detectionCatalog: detectionSource.value,
+    });
+    cache = { identity, registry };
+    return registry;
+}
+export function resetTechnologyRegistryCache() {
+    cache = undefined;
+}
+//# sourceMappingURL=technology-registry.js.map

package/dist/engine/telemetry/error-reporter.d.ts

@@ -1,6 +1,5 @@
 /**
- * Returns true when remote error reporting is active (default: on).
- * Disabled by setting env var PLANU_TELEMETRY=off.
+ * Environment-only fast check. The client also enforces persisted versioned opt-in.
  */
 export declare function isErrorReportingEnabled(): boolean;
 /**

package/dist/engine/telemetry/error-reporter.js

@@ -5,23 +5,21 @@
 // No PII: only tool name, sanitized error message, version, and Node version are sent.
 import { sendTelemetryEvent } from './telemetry-client.js';
 import { PLANU_VERSION } from '../../config/version.js';
+import { redactText } from '../../security/redactor.js';
+import { TELEMETRY_CONSENT_VERSION } from './telemetry-store.js';
 /**
- * Returns true when remote error reporting is active (default: on).
- * Disabled by setting env var PLANU_TELEMETRY=off.
+ * Environment-only fast check. The client also enforces persisted versioned opt-in.
  */
 export function isErrorReportingEnabled() {
-    return process.env.PLANU_TELEMETRY !== 'off';
+    return (process.env.PLANU_TELEMETRY === 'on' &&
+        process.env.PLANU_TELEMETRY_CONSENT_VERSION === String(TELEMETRY_CONSENT_VERSION));
 }
 /**
  * Sanitizes an error message by removing filesystem paths and home-dir fragments
  * so no user-specific data is transmitted.
  */
 export function sanitizeErrorMessage(message) {
-    return message
-        .replace(/\/Users\/[^\s/]+/g, '/[user]')
-        .replace(/\/home\/[^\s/]+/g, '/[user]')
-        .replace(/C:\\Users\\[^\s\\]+/g, 'C:\\[user]')
-        .slice(0, 300);
+    return redactText(message).slice(0, 300);
 }
 /** Patterns in error messages that indicate a gate/policy block (not an exception). */
 const BLOCKED_PATTERNS = [
@@ -51,21 +49,19 @@ export function classifyToolEvent(errorMessage, errorType) {
  * Call this from safe-handler catch blocks after returning isError:true to the user.
  */
 export function reportToolError(toolName, error) {
-    if (!isErrorReportingEnabled()) {
+    if (process.env.PLANU_TELEMETRY === 'off') {
         return;
     }
-    const rawMessage = error instanceof Error ? error.message : String(error);
-    const message = sanitizeErrorMessage(rawMessage);
+    const errorClass = error instanceof Error ? error.name : typeof error;
     sendTelemetryEvent({
         event: 'tool_error',
         properties: {
             tool: toolName,
-            message,
             errorType: 'exception',
+            errorClass,
             planVersion: PLANU_VERSION,
             nodeVersion: process.version,
         },
-        installationId: 'anonymous',
     });
 }
 /**
@@ -75,21 +71,18 @@ export function reportToolError(toolName, error) {
  * Fire-and-forget — never throws.
  */
 export function reportToolValidationError(toolName, message) {
-    if (!isErrorReportingEnabled()) {
+    if (process.env.PLANU_TELEMETRY === 'off') {
         return;
     }
-    const sanitized = sanitizeErrorMessage(message);
-    const event = classifyToolEvent(sanitized, 'validation');
+    const event = classifyToolEvent(message, 'validation');
     sendTelemetryEvent({
         event,
         properties: {
             tool: toolName,
-            message: sanitized,
             errorType: 'validation',
             planVersion: PLANU_VERSION,
             nodeVersion: process.version,
         },
-        installationId: 'anonymous',
     });
 }
 //# sourceMappingURL=error-reporter.js.map

package/dist/engine/telemetry/health-checker.js

@@ -4,6 +4,7 @@ import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { readTelemetryConfig } from './telemetry-store.js';
 import { sendTelemetryEvent } from './telemetry-client.js';
+import { hashProjectPath, projectDataDir } from '../../storage/base-store.js';
 const NETWORK_TIMEOUT_MS = 5_000;
 const RECENT_EVENT_THRESHOLD_DAYS = 7;
 // ---------------------------------------------------------------------------
@@ -80,11 +81,7 @@ async function checkNetworkReachable(endpoint) {
     }
 }
 async function checkLastEvent(projectPath) {
-    const candidates = [
-        join(projectPath, 'data', 'telemetry-events.json'),
-        join(projectPath, '.planu', 'telemetry-events.json'),
-        join(projectPath, 'data', 'telemetry.json'),
-    ];
+    const candidates = [join(projectDataDir(hashProjectPath(projectPath)), 'telemetry-events.json')];
     for (const candidate of candidates) {
         try {
             const raw = await readFile(candidate, 'utf-8');
@@ -126,10 +123,7 @@ async function checkLastEvent(projectPath) {
     };
 }
 async function checkErrorLog(projectPath) {
-    const candidates = [
-        join(projectPath, 'data', 'telemetry-errors.json'),
-        join(projectPath, '.planu', 'telemetry-errors.json'),
-    ];
+    const candidates = [join(projectDataDir(hashProjectPath(projectPath)), 'telemetry-errors.json')];
     for (const candidate of candidates) {
         try {
             const raw = await readFile(candidate, 'utf-8');
@@ -196,7 +190,7 @@ async function checkClientVersion(projectPath) {
 // ---------------------------------------------------------------------------
 // Test event
 // ---------------------------------------------------------------------------
-function sendTestDiagnosticEvent(installationId) {
+function sendTestDiagnosticEvent() {
     sendTelemetryEvent({
         event: 'tool_used',
         properties: {
@@ -204,7 +198,6 @@ function sendTestDiagnosticEvent(installationId) {
             diagnostic: true,
             timestamp: new Date().toISOString(),
         },
-        installationId,
     });
 }
 // ---------------------------------------------------------------------------
@@ -284,9 +277,7 @@ export async function checkTelemetryHealth(projectPath, options) {
     ];
     const status = computeStatus(enabled, checks);
     if (options?.sendTestEvent === true) {
-        const config = await readTelemetryConfig();
-        const installationId = config?.installationId ?? 'anonymous';
-        sendTestDiagnosticEvent(installationId);
+        sendTestDiagnosticEvent();
     }
     return {
         status,

package/dist/engine/telemetry/index.d.ts

@@ -1,5 +1,4 @@
 export * from './telemetry-store.js';
 export * from './telemetry-client.js';
 export * from './health-checker.js';
-export { resolveGeo, resetGeoCache } from './geo-resolver.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/engine/telemetry/index.js

@@ -2,5 +2,4 @@
 export * from './telemetry-store.js';
 export * from './telemetry-client.js';
 export * from './health-checker.js';
-export { resolveGeo, resetGeoCache } from './geo-resolver.js';
 //# sourceMappingURL=index.js.map

package/dist/engine/telemetry/stance.js

@@ -1,6 +1,7 @@
 // engine/telemetry/stance.ts — Telemetry opt-in stance reader (SPEC-741)
 import { readFileSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
+import { TELEMETRY_CONSENT_VERSION } from './telemetry-store.js';
 /**
  * Returns true if telemetry is enabled for the given project root.
  * Reads conventions.json synchronously.
@@ -11,7 +12,7 @@ export function isTelemetryEnabled(projectRoot) {
         return false;
     }
     if (process.env.PLANU_TELEMETRY === 'on') {
-        return true;
+        return process.env.PLANU_TELEMETRY_CONSENT_VERSION === String(TELEMETRY_CONSENT_VERSION);
     }
     try {
         const conventionsPath = join(projectRoot, 'planu', 'conventions.json');
@@ -21,7 +22,7 @@ export function isTelemetryEnabled(projectRoot) {
         const raw = readFileSync(conventionsPath, 'utf-8');
         const parsed = JSON.parse(raw);
         const telemetry = parsed.telemetry;
-        return telemetry?.enabled === true;
+        return telemetry?.enabled === true && telemetry.consentVersion === TELEMETRY_CONSENT_VERSION;
     }
     catch {
         return false;

package/dist/engine/telemetry/telemetry-client.d.ts

@@ -1,8 +1,4 @@
 import type { TelemetryEvent } from '../../types/index.js';
-/**
- * Send a telemetry event to Supabase. Fire-and-forget — never awaited by callers.
- * Enriches events with geo data (country/timezone) from a cached IP lookup.
- * No PII: properties must not contain paths, emails, or user identifiers.
- */
+/** Fire-and-forget; absence or staleness of opt-in prevents any network access. */
 export declare function sendTelemetryEvent(event: TelemetryEvent): void;
 //# sourceMappingURL=telemetry-client.d.ts.map

package/dist/engine/telemetry/telemetry-client.js

@@ -1,31 +1,46 @@
-// engine/telemetry/telemetry-client.ts — SPEC-200: Fire-and-forget telemetry POST to Supabase.
-// Never throws — all errors are silently swallowed to avoid blocking tool responses.
-import { resolveGeo } from './geo-resolver.js';
+// Remote telemetry is disabled by default and always crosses consent + redaction boundaries.
+import { networkFetch, withNetworkConsent } from '../network-policy.js';
+import { redactSensitiveValue } from '../../security/redactor.js';
+import { isTelemetryEnabled } from './telemetry-store.js';
 const SUPABASE_URL = 'https://canusqigtzldstnjddio.supabase.co';
 const SUPABASE_ANON_KEY = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImNhbnVzcWlndHpsZHN0bmpkZGlvIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzI3NTk2MjgsImV4cCI6MjA4ODMzNTYyOH0.Thw1Xgf9_iabOD75J00u35d2k5NsIpUBU9PrqOShxMU';
 const TELEMETRY_ENDPOINT = `${SUPABASE_URL}/rest/v1/telemetry_events`;
-/**
- * Send a telemetry event to Supabase. Fire-and-forget — never awaited by callers.
- * Enriches events with geo data (country/timezone) from a cached IP lookup.
- * No PII: properties must not contain paths, emails, or user identifiers.
- */
+const ALLOWED_PROPERTIES = new Set([
+    'allowed',
+    'context',
+    'diagnostic',
+    'duplicateCount',
+    'durationMs',
+    'errorClass',
+    'errorType',
+    'framework',
+    'freeGBObserved',
+    'language',
+    'nodeVersion',
+    'planVersion',
+    'platform',
+    'pressureLevel',
+    'requested',
+    'specCount',
+    'stack',
+    'timestamp',
+    'tool',
+]);
+function safeProperties(properties) {
+    const allowlisted = Object.fromEntries(Object.entries(properties).filter(([key]) => ALLOWED_PROPERTIES.has(key)));
+    const redacted = redactSensitiveValue(allowlisted);
+    return redacted !== null && typeof redacted === 'object' && !Array.isArray(redacted)
+        ? redacted
+        : {};
+}
+/** Fire-and-forget; absence or staleness of opt-in prevents any network access. */
 export function sendTelemetryEvent(event) {
-    // Enrich with geo data asynchronously, then send
-    resolveGeo()
-        .then((geo) => {
-        const properties = geo
-            ? {
-                ...event.properties,
-                country: geo.countryCode,
-                timezone: geo.timezone,
-            }
-            : event.properties;
-        const payload = {
-            event_name: event.event,
-            properties,
-            installation_id: event.installationId,
-        };
-        return fetch(TELEMETRY_ENDPOINT, {
+    void isTelemetryEnabled()
+        .then((enabled) => {
+        if (!enabled) {
+            return undefined;
+        }
+        return withNetworkConsent('telemetry', (receipt) => networkFetch(receipt, TELEMETRY_ENDPOINT, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
@@ -33,12 +48,13 @@ export function sendTelemetryEvent(event) {
                 Authorization: `Bearer ${SUPABASE_ANON_KEY}`,
                 Prefer: 'return=minimal',
             },
-            body: JSON.stringify(payload),
+            body: JSON.stringify({
+                event_name: event.event,
+                properties: safeProperties(event.properties),
+            }),
             signal: AbortSignal.timeout(5_000),
-        });
+        }));
     })
-        .catch(() => {
-        // Silently swallow all errors — telemetry must never break the tool
-    });
+        .catch(() => undefined);
 }
 //# sourceMappingURL=telemetry-client.js.map

package/dist/engine/telemetry/telemetry-store.d.ts

@@ -1,11 +1,11 @@
 import type { TelemetryConfig } from '../../types/index.js';
+export declare const TELEMETRY_CONSENT_VERSION: 1;
 export declare function readTelemetryConfig(): Promise<TelemetryConfig | null>;
 export declare function writeTelemetryConfig(config: TelemetryConfig): Promise<void>;
-export declare function getOrCreateInstallationId(): Promise<string>;
 /**
  * Returns true if telemetry is enabled.
- * Default: ENABLED (opt-out model). Disable by setting PLANU_TELEMETRY=off
- * or by explicitly calling configure_telemetry with enabled=false.
+ * Default: disabled. Both environment and stored opt-ins are versioned so a
+ * changed privacy contract requires renewed consent.
  */
 export declare function isTelemetryEnabled(): Promise<boolean>;
 /** Returns true if the user has never been shown the opt-in prompt. */

package/dist/engine/telemetry/telemetry-store.js

@@ -3,14 +3,25 @@
 // Stores opt-in preference and installation ID outside the project directory.
 import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
-import { homedir } from 'node:os';
-import { randomUUID } from 'node:crypto';
-const PLANU_DIR = join(homedir(), '.planu');
+import { resolveStorageLayout } from '../../storage/storage-layout.js';
+const PLANU_DIR = resolveStorageLayout().config;
 const TELEMETRY_FILE = join(PLANU_DIR, 'telemetry.json');
+export const TELEMETRY_CONSENT_VERSION = 1;
 export async function readTelemetryConfig() {
     try {
         const raw = await readFile(TELEMETRY_FILE, 'utf-8');
-        return JSON.parse(raw);
+        const parsed = JSON.parse(raw);
+        const config = {
+            enabled: parsed.enabled === true,
+            promptedAt: typeof parsed.promptedAt === 'string' ? parsed.promptedAt : '',
+        };
+        if (typeof parsed.consentVersion === 'number') {
+            config.consentVersion = parsed.consentVersion;
+        }
+        if (parsed.enableObservatory === true) {
+            config.enableObservatory = true;
+        }
+        return config;
     }
     catch {
         return null;
@@ -18,32 +29,28 @@ export async function readTelemetryConfig() {
 }
 export async function writeTelemetryConfig(config) {
     await mkdir(PLANU_DIR, { recursive: true });
-    await writeFile(TELEMETRY_FILE, JSON.stringify(config, null, 2) + '\n', 'utf-8');
-}
-export async function getOrCreateInstallationId() {
-    const config = await readTelemetryConfig();
-    if (config?.installationId) {
-        return config.installationId;
-    }
-    const id = randomUUID();
-    await writeTelemetryConfig({
-        enabled: false,
-        installationId: id,
-        promptedAt: '',
-    });
-    return id;
+    const safeConfig = {
+        enabled: config.enabled,
+        promptedAt: config.promptedAt,
+        consentVersion: config.consentVersion,
+        enableObservatory: config.enableObservatory,
+    };
+    await writeFile(TELEMETRY_FILE, JSON.stringify(safeConfig, null, 2) + '\n', 'utf-8');
 }
 /**
  * Returns true if telemetry is enabled.
- * Default: ENABLED (opt-out model). Disable by setting PLANU_TELEMETRY=off
- * or by explicitly calling configure_telemetry with enabled=false.
+ * Default: disabled. Both environment and stored opt-ins are versioned so a
+ * changed privacy contract requires renewed consent.
  */
 export async function isTelemetryEnabled() {
     if (process.env.PLANU_TELEMETRY === 'off') {
         return false;
     }
+    if (process.env.PLANU_TELEMETRY === 'on') {
+        return process.env.PLANU_TELEMETRY_CONSENT_VERSION === String(TELEMETRY_CONSENT_VERSION);
+    }
     const config = await readTelemetryConfig();
-    return config?.enabled !== false; // default true unless explicitly disabled
+    return config?.enabled === true && config.consentVersion === TELEMETRY_CONSENT_VERSION;
 }
 /** Returns true if the user has never been shown the opt-in prompt. */
 export async function hasNeverBeenPrompted() {
@@ -53,11 +60,11 @@ export async function hasNeverBeenPrompted() {
 /** Mark that the user was shown the opt-in prompt (so we don't show it again). */
 export async function markAsPrompted() {
     const existing = await readTelemetryConfig();
-    const id = existing?.installationId ?? randomUUID();
     await writeTelemetryConfig({
         enabled: existing?.enabled ?? false,
-        installationId: id,
         promptedAt: new Date().toISOString(),
+        consentVersion: existing?.consentVersion,
+        enableObservatory: existing?.enableObservatory,
     });
 }
 //# sourceMappingURL=telemetry-store.js.map

package/dist/engine/test-framework-detector/detectors.js

@@ -1,11 +1,10 @@
-// engine/test-framework-detector/detectors.ts — SPEC-018
-// Individual testing framework detectors. Pure functions — no I/O.
+import { technologyValue } from '../technology-registry.js';
 // === Unit test framework detection ===
 const TESTING_FRAMEWORK_DEPS = [
-    ['vitest', 'vitest'],
-    ['jest', 'jest'],
+    [technologyValue('technology-vitest-a9127f'), technologyValue('technology-vitest-a9127f')],
+    [technologyValue('technology-jest-35e99f'), technologyValue('technology-jest-35e99f')],
     ['mocha', 'mocha'],
-    ['pytest', 'pytest'],
+    [technologyValue('technology-pytest-2b0121'), technologyValue('technology-pytest-2b0121')],
     ['junit', 'junit'],
     ['xunit', 'xunit'],
     ['rspec', 'rspec'],
@@ -207,7 +206,8 @@ export function detectVisualRegFramework(deps, files) {
         }
     }
     // Playwright with toMatchSnapshot is detected by playwright presence + snapshot usage
-    if (depSet.has('@playwright/test') || depSet.has('playwright')) {
+    if (depSet.has('@playwright/test') ||
+        depSet.has(technologyValue('technology-playwright-7827e8'))) {
         return 'playwright-snapshot';
     }
     return null;
@@ -215,8 +215,8 @@ export function detectVisualRegFramework(deps, files) {
 // === Test double pattern detection ===
 const TEST_DOUBLE_DEP_MAP = [
     ['sinon', 'sinon-stub'],
-    ['vitest', 'vitest-mock'],
-    ['jest', 'jest-mock'],
+    [technologyValue('technology-vitest-a9127f'), 'vitest-mock'],
+    [technologyValue('technology-jest-35e99f'), 'jest-mock'],
 ];
 export function detectTestDoublePattern(deps, fileContents) {
     const depSet = new Set(deps.map((d) => d.toLowerCase()));

package/dist/engine/test-framework-detector/strategy.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/test-framework-detector/strategy.ts — SPEC-018
-// Test strategy selection and full ecosystem detection.
+import { technologyValue } from '../technology-registry.js';
 import { detectTestingFramework, detectBDDFramework, detectPropertyTestFramework, detectLoadTestFramework, detectChaosFramework, detectVisualRegFramework, detectMutationFramework, detectTestDoublePattern, } from './detectors.js';
 /**
  * Select the appropriate test strategy based on project type and stack.
@@ -9,14 +6,16 @@ import { detectTestingFramework, detectBDDFramework, detectPropertyTestFramework
 export function selectTestStrategy(projectType, stack) {
     const stackSet = new Set(stack.map((s) => s.toLowerCase()));
     // Microservices → Honeycomb (more integration, minimal unit and E2E)
-    if (projectType === 'microservices' || stackSet.has('kubernetes') || stackSet.has('docker')) {
+    if (projectType === 'microservices' ||
+        stackSet.has(technologyValue('technology-kubernetes-94abcb')) ||
+        stackSet.has(technologyValue('technology-docker-d548c5'))) {
         return 'honeycomb';
     }
     // Frontend frameworks → Testing Trophy (more integration than unit)
-    if (stackSet.has('react') ||
-        stackSet.has('vue') ||
-        stackSet.has('angular') ||
-        stackSet.has('svelte') ||
+    if (stackSet.has(technologyValue('technology-react-275976')) ||
+        stackSet.has(technologyValue('technology-vue-564382')) ||
+        stackSet.has(technologyValue('technology-angular-a39f89')) ||
+        stackSet.has(technologyValue('technology-svelte-c190ac')) ||
         projectType === 'frontend') {
         return 'testing-trophy';
     }

package/dist/engine/test-generators/agent-test-templates.js

@@ -1,5 +1,4 @@
-// Planu — Agent Test Templates
-// SPEC-016a criteria 6 and 20: AI agent test scaffolds.
+import { technologyValue } from '../technology-registry.js';
 import { generatePytestAgentContent } from './agent-test-pytest.js';
 // === Test Definitions (criterion 6) ===
 /**
@@ -82,7 +81,7 @@ export function generateAgentTestDefs(title, testDir) {
  */
 export function generateAgentTestContent(title, testFramework) {
     const slug = title.toLowerCase().replace(/[^a-z0-9]/g, '-');
-    if (testFramework === 'pytest') {
+    if (testFramework === technologyValue('technology-pytest-2b0121')) {
         return generatePytestAgentContent(title, slug);
     }
     return generateVitestAgentContent(title, slug);

package/dist/engine/test-generators/contract-test-generator.d.ts

@@ -13,7 +13,7 @@ export declare function buildSampleEndpoints(_specTitle: string): ContractSpecEn
  * Generate a contract spec for the given spec title and knowledge.
  * Format is auto-detected from project stack.
  */
-export declare function generateContractSpec(specTitle: string, knowledge: ProjectKnowledge): ContractSpec;
+export declare function generateContractSpec(_specTitle: string, knowledge: ProjectKnowledge): ContractSpec;
 /**
  * Get the file extension for a given contract format.
  */