@planu/cli 4.13.0 → 4.14.1

package/dist/tools/schemas/validate-output-schema.js

@@ -0,0 +1,212 @@
+import { z } from 'zod';
+const checklistItem = z.object({
+    id: z.string(),
+    description: z.string().optional(),
+    category: z.string().optional(),
+    status: z.string(),
+    required: z.boolean().optional(),
+});
+const qualityIssue = z.object({
+    file: z.string(),
+    line: z.number().optional(),
+    severity: z.string(),
+    rule: z.string(),
+    message: z.string(),
+    suggestion: z.string().optional(),
+});
+const conventionViolation = z.object({
+    category: z.string(),
+    file: z.string(),
+    line: z.number().optional(),
+    message: z.string(),
+    severity: z.string(),
+});
+const validationGate = z.object({
+    name: z.string(),
+    passed: z.boolean(),
+    reason: z.string().optional(),
+});
+/** Exact public structured-output contract for the validate MCP tool. */
+export const ValidateCompletionOutputSchema = {
+    specId: z.string(),
+    title: z.string().optional(),
+    ready: z.boolean(),
+    status: z.enum(['passing', 'failing']),
+    score: z.number().nullable(),
+    summary: z.object({
+        specId: z.string(),
+        score: z.number().nullable(),
+        passed: z.number(),
+        failed: z.number(),
+        total: z.number(),
+        status: z.enum(['passing', 'failing']),
+    }),
+    counts: z.object({
+        matches: z.number(),
+        missing: z.number(),
+        extra: z.number(),
+        indeterminate: z.number(),
+        qualityIssues: z.number(),
+        conventionViolations: z.number(),
+        graphGaps: z.number(),
+        failedGates: z.number(),
+    }),
+    fieldsImplemented: z.number(),
+    fieldsTotal: z.number(),
+    matches: z.array(z.string()),
+    missing: z.array(z.string()),
+    extra: z.array(z.string()),
+    qualityIssues: z.array(qualityIssue),
+    missingTop5: z.array(z.string()),
+    extraTop5: z.array(z.string()),
+    indeterminateTop5: z.array(z.string()),
+    qualityIssuesTop5: z.array(qualityIssue),
+    blockersCount: z.number(),
+    blockersTop3: z.array(z.string()),
+    risksTop5: z.array(z.string()),
+    autofixable: z.boolean(),
+    nextAction: z.string(),
+    artifactRefs: z
+        .object({
+        validationReport: z.string().optional(),
+        validationReportSha: z.string().optional(),
+    })
+        .optional(),
+    validationReport: z.object({
+        written: z.boolean(),
+        path: z.string().optional(),
+        sha: z.string().optional(),
+        passed: z.boolean(),
+        reviewer: z.object({
+            kind: z.enum(['implementation-review-agent', 'human', 'automation']),
+            agent: z.string(),
+            verdict: z.enum(['approved', 'changes-requested']),
+        }),
+        gatesCount: z.number(),
+        failedGatesTop5: z.array(validationGate),
+    }),
+    implementationQualityScore: z.object({
+        overall: z.number(),
+        gradeLetter: z.string(),
+        filesAudited: z.number(),
+        categories: z.array(z.object({
+            category: z.string(),
+            score: z.number(),
+            weight: z.number(),
+            issueCount: z.number(),
+            worstSeverity: z.string(),
+        })),
+    }),
+    definitionOfReady: z.object({
+        isReady: z.boolean(),
+        passed: z.number(),
+        required: z.number(),
+        items: z.array(checklistItem),
+        failedItemsTop5: z.array(checklistItem),
+    }),
+    definitionOfDone: z.object({
+        isDone: z.boolean(),
+        passed: z.number(),
+        required: z.number(),
+        failedItems: z.array(checklistItem),
+        failedItemsTop5: z.array(checklistItem),
+    }),
+    conventionCompliance: z.object({
+        totalViolations: z.number(),
+        regressionDetected: z.boolean(),
+        violations: z.array(conventionViolation),
+        violationsTop5: z.array(conventionViolation),
+    }),
+    lintCheck: z.object({
+        passed: z.boolean(),
+        command: z.string().nullable().optional(),
+        issueCount: z.number().optional(),
+        output: z.string(),
+        outputPreview: z.string().optional(),
+    }),
+    assuranceGates: z.object({
+        newCode: z.object({
+            passed: z.boolean(),
+            findingsCount: z.number(),
+            findingsTop5: z.array(z.object({
+                rule: z.string(),
+                file: z.string(),
+                line: z.number(),
+                message: z.string(),
+                evidence: z.string(),
+            })),
+        }),
+    }),
+    qualityGateSummary: z.object({
+        passed: z.boolean(),
+        effectiveScore: z.number().nullable(),
+        failures: z.array(z.string()),
+        conventionRegression: z.boolean(),
+        blockingConventionViolations: z.number(),
+        lintPassed: z.boolean(),
+        assurancePassed: z.boolean(),
+        minimalityPassed: z.boolean(),
+    }),
+    minimalityReport: z
+        .object({
+        enabled: z.boolean(),
+        blocked: z.boolean(),
+        findingCount: z.number(),
+        blockingFindingCount: z.number(),
+        blockingFindingsTop5: z.array(z.object({
+            ruleId: z.string(),
+            target: z.string(),
+            evidence: z.string(),
+            blocksDone: z.boolean(),
+        })),
+    })
+        .optional(),
+    graphCoverage: z.object({
+        gapsCount: z.number(),
+        gapsTop5: z.array(z.string()),
+        freshness: z
+            .object({
+            exists: z.boolean(),
+            stale: z.boolean(),
+            reason: z.enum(['missing', 'fresh', 'expired', 'source_changed', 'corrupt']),
+            graphPath: z.string(),
+            generatedAt: z.string().optional(),
+            changedSources: z.array(z.string()),
+        })
+            .optional(),
+    }),
+    suggestionsTop5: z.array(z.string()),
+    suggestions: z.array(z.string()).optional(),
+    interactiveQuestions: z
+        .array(z.object({
+        question: z.string(),
+        header: z.string(),
+        options: z.array(z.object({ label: z.string(), description: z.string() })),
+        multiSelect: z.boolean(),
+    }))
+        .optional(),
+    elicitedAction: z.enum(['re-implement', 'ignore', 'mark-manual']).optional(),
+};
+export const ValidateOutputSchema = {
+    schemaVersion: z.literal(1),
+    operationId: z.string().min(1).max(128),
+    projectId: z.string().min(1).max(128),
+    workspaceId: z.string().min(1).max(128),
+    state: z.enum(['accepted', 'running', 'checkpointed']),
+    submittedAt: z.iso.datetime(),
+    cursor: z.string().regex(/^[a-f0-9]{64}$/),
+    terminalStates: z.tuple([
+        z.literal('completed'),
+        z.literal('failed'),
+        z.literal('cancelled'),
+        z.literal('dead-letter'),
+    ]),
+    resultSchema: z.literal('validate-completion/v1'),
+    observation: z.object({
+        get: z.literal('get_job'),
+        watch: z.literal('watch_job'),
+        cancel: z.literal('cancel_job'),
+        restart: z.literal('restart_job'),
+    }),
+};
+//# sourceMappingURL=validate-output-schema.js.map

package/dist/tools/sentry-handler.js

@@ -1,3 +1,4 @@
+import { technologyValue } from '../engine/technology-registry.js';
 import { getSentryConfig, saveSentryConfig } from '../storage/sentry-store.js';
 import { fetchSentryIssues, fetchSentryIssue, fetchIssueStacktrace, } from '../engine/sentry/sentry-client.js';
 import { mapIssueToSpecTitle, mapIssueToDescription, mapIssueToAcceptanceCriteria, mapIssuePriority, } from '../engine/sentry/sentry-spec-mapper.js';
@@ -123,7 +124,11 @@ export async function handleSentryErrorToSpec(input) {
         type: 'bugfix',
         scope: 'feature',
         target: 'fullstack',
-        tags: ['sentry', `sentry-issue:${issue.id}`, `priority:${priority}`],
+        tags: [
+            technologyValue('technology-sentry-0cf685'),
+            `sentry-issue:${issue.id}`,
+            `priority:${priority}`,
+        ],
     });
     if (createResult.isError === true) {
         return createResult;

package/dist/tools/skill-bootstrap-handler.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 '../engine/technology-registry.js';
 // tools/skill-bootstrap-handler.ts — SPEC-439: Multi-Source Skill Auto-Bootstrap handlers
 // SPEC-607: Adds project-aware skill generation via Agent Skills spec + multi-agent writer.
 import { z } from 'zod';
@@ -160,8 +159,12 @@ async function generateProjectSkills(projectPath, detectedStack) {
     const supportedTypes = listSupportedSkillTypes();
     const stackInfo = {
         frameworks: detectedStack,
-        language: detectedStack.includes('typescript') ? 'typescript' : 'javascript',
-        testRunner: detectedStack.find((t) => t === 'vitest' || t === 'jest' || t === 'pytest') ?? null,
+        language: detectedStack.includes(technologyValue('technology-typescript-969545'))
+            ? technologyValue('technology-typescript-969545')
+            : 'javascript',
+        testRunner: detectedStack.find((t) => t === technologyValue('technology-vitest-a9127f') ||
+            t === technologyValue('technology-jest-35e99f') ||
+            t === technologyValue('technology-pytest-2b0121')) ?? null,
         bundler: detectedStack.find((t) => t === 'vite' || t === 'webpack' || t === 'esbuild') ?? null,
     };
     const writtenPaths = [];

package/dist/tools/status-handler.js

@@ -15,6 +15,7 @@ import { readPlanuConfig } from '../engine/planu-config-writer.js';
 import { computePlanuDriftScore } from '../engine/dashboard/drift-score.js';
 import { loadTokenWastePolicy } from '../engine/token-optimizer/index.js';
 import { getProjectGraphFreshnessHint } from '../engine/project-graph/index.js';
+import { hasGitMetadata } from '../engine/git/repository-probe.js';
 import { getToolExecutionSignal } from './safe-handler.js';
 const execFile = promisify(execFileCb);
 const STATUS_READ_TIMEOUT_MS = 1_500;
@@ -22,6 +23,9 @@ const STATUS_READ_TIMEOUT_MS = 1_500;
 // Git helpers
 // ---------------------------------------------------------------------------
 async function getGitState(projectPath, signal) {
+    if (!(await hasGitMetadata(projectPath))) {
+        return null;
+    }
     try {
         const [stagedResult, modifiedResult, branchResult] = await Promise.all([
             execFile('git', ['diff', '--cached', '--name-only'], {

package/dist/tools/storage-bundle-handler.d.ts

@@ -0,0 +1,9 @@
+import type { ToolResult } from '../types/index.js';
+export declare function handleStorageExport(input: {
+    projectId: string;
+    outputPath: string;
+}): Promise<ToolResult>;
+export declare function handleStorageImport(input: {
+    inputPath: string;
+}): Promise<ToolResult>;
+//# sourceMappingURL=storage-bundle-handler.d.ts.map

package/dist/tools/storage-bundle-handler.js

@@ -0,0 +1,29 @@
+import { exportStorageBundle, importStorageBundle } from '../storage/storage-bundle.js';
+export async function handleStorageExport(input) {
+    const bundle = await exportStorageBundle(input.projectId, input.outputPath);
+    const payload = {
+        schemaVersion: 1,
+        exported: true,
+        projectId: bundle.projectId,
+        outputPath: input.outputPath,
+        checksum: bundle.checksum,
+    };
+    return {
+        content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }],
+        structuredContent: payload,
+    };
+}
+export async function handleStorageImport(input) {
+    const bundle = await importStorageBundle(input.inputPath);
+    const payload = {
+        schemaVersion: 1,
+        imported: true,
+        projectId: bundle.projectId,
+        inputPath: input.inputPath,
+    };
+    return {
+        content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }],
+        structuredContent: payload,
+    };
+}
+//# sourceMappingURL=storage-bundle-handler.js.map

package/dist/tools/storage-paths-handler.d.ts

@@ -0,0 +1,9 @@
+import type { ToolResult } from '../types/index.js';
+export interface StoragePathsInput {
+    projectPath?: string;
+    logicalProjectId?: string;
+    workspaceKeyHash?: string;
+}
+/** Read-only MCP view over the same catalog used by the CLI. */
+export declare function handleStoragePaths(input: StoragePathsInput): ToolResult;
+//# sourceMappingURL=storage-paths-handler.d.ts.map

package/dist/tools/storage-paths-handler.js

@@ -0,0 +1,17 @@
+import { createStorageCatalog } from '../storage/storage-catalog.js';
+import { resolveStorageLayout } from '../storage/storage-layout.js';
+/** Read-only MCP view over the same catalog used by the CLI. */
+export function handleStoragePaths(input) {
+    const artifacts = createStorageCatalog({
+        layout: resolveStorageLayout(),
+        projectPath: input.projectPath,
+        logicalProjectId: input.logicalProjectId,
+        workspaceKeyHash: input.workspaceKeyHash,
+    });
+    const payload = { schemaVersion: 1, artifacts };
+    return {
+        content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }],
+        structuredContent: payload,
+    };
+}
+//# sourceMappingURL=storage-paths-handler.js.map

package/dist/tools/suggest-mcp-server.js

@@ -1,7 +1,4 @@
-// @crash-shield-ignore-file — config/cache reader for Planu-controlled JSON; writer is this codebase, shape guaranteed by build/seed.
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
-// tools/suggest-mcp-server.ts — MCP tool handler that generates a full MCP server recommendation.
+import { technologyValue } from '../engine/technology-registry.js';
 import { knowledgeStore } from '../storage/index.js';
 import { scoreMcpCandidate, detectAppDomains } from '../engine/detectors/mcp-candidate-detector.js';
 import { t } from '../i18n/index.js';
@@ -54,7 +51,16 @@ export async function handleSuggestMcpServer(args) {
     const suggestedResources = matchingArchetypes.flatMap((a) => a.resources);
     // Determine transport suggestion
     const stack = knowledge.stack;
-    const suggestedTransport = stack.some((s) => ['express', 'fastify', 'nestjs', 'koa', 'hapi', 'django', 'flask', 'fastapi'].includes(s.toLowerCase()))
+    const suggestedTransport = stack.some((s) => [
+        technologyValue('technology-express-008231'),
+        technologyValue('technology-fastify-cbe57e'),
+        technologyValue('technology-nestjs-2d0087'),
+        'koa',
+        'hapi',
+        technologyValue('technology-django-7d8a08'),
+        technologyValue('technology-flask-b87aa5'),
+        technologyValue('technology-fastapi-6aee0e'),
+    ].includes(s.toLowerCase()))
         ? 'http-streamable'
         : 'stdio';
     // Estimate effort

package/dist/tools/suggest-mcps.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 '../engine/technology-registry.js';
 // tools/suggest-mcps.ts — Recommend relevant third-party MCPs
 // Uses config/mcp-catalog.json + project knowledge
 // SPEC-027: generates install instructions per MCP and supports catalog auto-extension
@@ -121,13 +120,33 @@ export async function handleSuggestMcps(args) {
         }
         // Check type relevance
         const typeRelevance = {
-            database: ['postgresql', 'supabase', 'mysql', 'sqlite', 'mongodb', 'firebase'],
-            deployment: ['vercel', 'railway', 'docker', 'fly.io', 'netlify'],
+            database: [
+                'postgresql',
+                technologyValue('technology-supabase-4d7594'),
+                'mysql',
+                'sqlite',
+                'mongodb',
+                'firebase',
+            ],
+            deployment: [
+                technologyValue('technology-vercel-9d3508'),
+                technologyValue('technology-railway-e34d1c'),
+                technologyValue('technology-docker-d548c5'),
+                'fly.io',
+                technologyValue('technology-netlify-58465a'),
+            ],
             'project-management': ['linear', 'jira', 'github'],
-            monitoring: ['sentry', 'datadog'],
-            payments: ['stripe', 'paddle'],
-            design: ['figma'],
-            testing: ['playwright', 'puppeteer', 'cypress'],
+            monitoring: [
+                technologyValue('technology-sentry-0cf685'),
+                technologyValue('technology-datadog-4d8bd9'),
+            ],
+            payments: [technologyValue('technology-stripe-2bed20'), 'paddle'],
+            design: [technologyValue('technology-figma-5b79d0')],
+            testing: [
+                technologyValue('technology-playwright-7827e8'),
+                technologyValue('technology-puppeteer-c83c91'),
+                'cypress',
+            ],
             communication: ['slack'],
         };
         const typeMatches = typeRelevance[entry.type] ?? [];
@@ -149,7 +168,8 @@ export async function handleSuggestMcps(args) {
             score += 2;
             reasons.push('GitHub integration benefits most projects');
         }
-        if (key === 'puppeteer' && knowledge.apps.some((a) => a.type === 'frontend')) {
+        if (key === technologyValue('technology-puppeteer-c83c91') &&
+            knowledge.apps.some((a) => a.type === 'frontend')) {
             score += 1;
             reasons.push('Browser automation for frontend testing');
         }

package/dist/tools/suggest-tooling/advanced-testing-catalog.js

@@ -1,5 +1,4 @@
-// tools/suggest-tooling/advanced-testing-catalog.ts — SPEC-049
-// Builds advanced testing pattern tooling recommendation lines for suggest_tooling.
+import { technologyValue } from '../../engine/technology-registry.js';
 import { isWebProject, isKubernetesProject, hasPiiSignals, } from '../../engine/advanced-testing/index.js';
 import { getJvmVersion, getCdnUrl } from '../../config/version-defaults.js';
 /**
@@ -15,7 +14,7 @@ export function buildAdvancedTestingToolingLines(knowledge) {
     lines.push('', '## Advanced Testing Patterns', '');
     // S1 — Property-Based Testing
     lines.push('### Property-Based Testing (PBT)', '');
-    if (lang === 'typescript' || lang === 'javascript') {
+    if (lang === technologyValue('technology-typescript-969545') || lang === 'javascript') {
         lines.push('**fast-check** — Property-based testing for JS/TS (60K npm/week)');
         lines.push('- Install: `pnpm add -D fast-check`');
         lines.push('- Docs: https://fast-check.dev');
@@ -52,7 +51,7 @@ export function buildAdvancedTestingToolingLines(knowledge) {
         lines.push('### Mutation Testing', '');
         lines.push('> Recommended when line/branch coverage is already ≥90%.');
         lines.push('');
-        if (lang === 'typescript' || lang === 'javascript') {
+        if (lang === technologyValue('technology-typescript-969545') || lang === 'javascript') {
             lines.push('**Stryker Mutator** — JS/TS mutation testing (5K+ GitHub stars)');
             lines.push('- Install: `pnpm add -D @stryker-mutator/core @stryker-mutator/vitest-runner`');
             lines.push('- Config: `testRunner: "vitest"` in stryker.config.mjs');
@@ -123,7 +122,7 @@ export function buildAdvancedTestingToolingLines(knowledge) {
     else {
         lines.push('### Test Data Management', '');
     }
-    if (lang === 'typescript' || lang === 'javascript') {
+    if (lang === technologyValue('technology-typescript-969545') || lang === 'javascript') {
         lines.push('**@faker-js/faker** — Fake data generation for JS/TS');
         lines.push('- Install: `pnpm add -D @faker-js/faker`');
         lines.push('- Docs: https://fakerjs.dev');

package/dist/tools/suggest-tooling/build-tool-catalog.js

@@ -1,3 +1,4 @@
+import { technologyValue } from '../../engine/technology-registry.js';
 // tools/suggest-tooling/build-tool-catalog.ts — SPEC-050 S2
 // Build tool recommendations for suggest_tooling based on detected build tool.
 // C4: new JS/TS project → recommend Vite 7
@@ -72,7 +73,7 @@ async function loadBuildToolsCatalog() {
 // ---------------------------------------------------------------------------
 function isJsTsProject(knowledge) {
     const lang = knowledge.language.toLowerCase();
-    return lang === 'typescript' || lang === 'javascript';
+    return lang === technologyValue('technology-typescript-969545') || lang === 'javascript';
 }
 function parseVersionMajor(version) {
     if (!version) {

package/dist/tools/suggest-tooling/css-framework-catalog.js

@@ -1,14 +1,19 @@
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
-// tools/suggest-tooling/css-framework-catalog.ts — CSS framework detection and recommendations
-// SPEC-017a: CSS framework recommendation for frontend/fullstack web stacks
+import { technologyValue } from '../../engine/technology-registry.js';
 /**
  * Build CSS framework recommendation lines based on detected or missing framework.
  * Only recommends for frontend/fullstack web stacks.
  */
 export function buildCSSFrameworkLines(knowledge, detectedFramework) {
     // Only recommend for frontend/fullstack web stacks
-    const webFrameworks = ['react', 'next', 'vue', 'nuxt', 'svelte', 'sveltekit', 'angular'];
+    const webFrameworks = [
+        technologyValue('technology-react-275976'),
+        'next',
+        technologyValue('technology-vue-564382'),
+        technologyValue('technology-nuxt-22c407'),
+        technologyValue('technology-svelte-c190ac'),
+        technologyValue('technology-sveltekit-eefb03'),
+        technologyValue('technology-angular-a39f89'),
+    ];
     const stackLower = knowledge.stack.map((s) => s.toLowerCase());
     const hasWebFramework = webFrameworks.some((f) => stackLower.some((s) => s.includes(f))) ||
         webFrameworks.some((f) => (knowledge.framework ?? '').toLowerCase().includes(f));
@@ -28,13 +33,14 @@ export function buildCSSFrameworkLines(knowledge, detectedFramework) {
     let recommended = 'Tailwind CSS';
     let installCmd = 'npm install -D tailwindcss postcss autoprefixer && npx tailwindcss init -p';
     let reason = 'Tailwind CSS is framework-agnostic, highly customizable, and has excellent DX.';
-    if (fw.includes('next') || fw.includes('react')) {
+    if (fw.includes('next') || fw.includes(technologyValue('technology-react-275976'))) {
         recommended = 'Tailwind CSS or shadcn/ui';
         installCmd = 'npm install -D tailwindcss && npx shadcn@latest init';
         reason =
             'Tailwind + shadcn/ui provides accessible components with full control for React/Next.js.';
     }
-    else if (fw.includes('vue') || fw.includes('nuxt')) {
+    else if (fw.includes(technologyValue('technology-vue-564382')) ||
+        fw.includes(technologyValue('technology-nuxt-22c407'))) {
         recommended = 'Tailwind CSS';
         reason = 'Tailwind CSS integrates seamlessly with Vue/Nuxt via @nuxtjs/tailwindcss module.';
     }

package/dist/tools/suggest-tooling/framework-catalog.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.
-// tools/suggest-tooling/framework-catalog.ts — Desktop and AI agent tooling line builders
-// Extracted from suggest-tooling.ts to stay within the 400-line file budget.
+import { technologyValue } from '../../engine/technology-registry.js';
 // === SPEC-016a: AI agent tooling ===
 export function buildAgentToolingLines(knowledge) {
     const stack = knowledge.stack.map((s) => s.toLowerCase());
@@ -66,7 +63,8 @@ export function buildDesktopToolingLines(knowledge) {
         return [];
     }
     const lines = ['## Desktop Distribution Tooling', ''];
-    const isElectron = framework === 'electron' || stack.some((s) => s.includes('electron'));
+    const isElectron = framework === technologyValue('technology-electron-88b1de') ||
+        stack.some((s) => s.includes(technologyValue('technology-electron-88b1de')));
     const isTauri = framework === 'tauri' || stack.some((s) => s.includes('tauri'));
     const isDotNet = framework === 'dotnet' || stack.some((s) => s.includes('dotnet') || s.includes('.net'));
     const isLinuxNative = stack.some((s) => s.includes('gtk') || s.includes('qt') || s.includes('gnome'));

package/dist/tools/suggest-tooling/frontend-perf-catalog.js

@@ -1,14 +1,10 @@
-// tools/suggest-tooling/frontend-perf-catalog.ts — SPEC-057
-// Generates tooling recommendations for frontend performance, MFE management,
-// design systems, and E2E testing.
-// Criteria: S3 (Lighthouse CI), S7 (Bit.dev/Nx Cloud), S11 (Storybook/Ladle),
-//           S13 (Playwright/Cypress), S15 (Chromatic)
+import { technologyValue } from '../../engine/technology-registry.js';
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 function isJsTsProject(knowledge) {
     const lang = knowledge.language.toLowerCase();
-    return lang === 'typescript' || lang === 'javascript';
+    return lang === technologyValue('technology-typescript-969545') || lang === 'javascript';
 }
 function hasMfeDetected(knowledge) {
     const mfe = knowledge.mfeDetection;

package/dist/tools/suggest-tooling/handler.js

@@ -1,8 +1,9 @@
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
+import { technologyValue } from '../../engine/technology-registry.js';
 // tools/suggest-tooling/handler.ts — MCP tool handler for suggest_tooling
+import { dirname } from 'node:path';
 import { t, ti } from '../../i18n/index.js';
 import { knowledgeStore } from '../../storage/index.js';
+import { resolvedStorageArtifactPath } from '../../storage/storage-catalog.js';
 import { discoverTools } from '../../engine/discovery/tech-discovery.js';
 import { detectCSSFramework } from '../../engine/detectors/css-framework-detector.js';
 import { fetchRecommendedSkills } from './skills-fetcher.js';
@@ -261,7 +262,12 @@ export async function handleSuggestTooling(args) {
     if (knowledge.otelDetection?.isInstalled) {
         detectedPatterns.push('observability');
     }
-    if (knowledge.externalServices.some((s) => ['vercel', 'netlify', 'lambda', 'cloudflare'].some((p) => s.toLowerCase().includes(p)))) {
+    if (knowledge.externalServices.some((s) => [
+        technologyValue('technology-vercel-9d3508'),
+        technologyValue('technology-netlify-58465a'),
+        'lambda',
+        technologyValue('technology-cloudflare-738e22'),
+    ].some((p) => s.toLowerCase().includes(p)))) {
         detectedPatterns.push('serverless');
     }
     if (knowledge.architecture.primary === 'microservices') {
@@ -273,7 +279,7 @@ export async function handleSuggestTooling(args) {
     let discoverySection = [];
     if (detectedPatterns.length > 0) {
         try {
-            const dataDir = `data/global`;
+            const dataDir = dirname(resolvedStorageArtifactPath('tool-discovery-cache'));
             const discovered = await discoverTools(detectedPatterns, knowledge.language, dataDir);
             if (discovered.length > 0) {
                 const discLines = [

package/dist/tools/suggest-tooling/hypermedia-catalog.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 '../../engine/technology-registry.js';
 // tools/suggest-tooling/hypermedia-catalog.ts — SPEC-043
 // Loads and formats hypermedia tooling recommendations from the config catalog.
 import { readFile } from 'node:fs/promises';
@@ -26,7 +25,16 @@ async function loadHypermediaCatalog() {
         return {};
     }
 }
-const SPA_FRAMEWORKS = ['react', 'vue', 'angular', 'svelte', 'solid', 'qwik', 'next', 'nuxt'];
+const SPA_FRAMEWORKS = [
+    technologyValue('technology-react-275976'),
+    technologyValue('technology-vue-564382'),
+    technologyValue('technology-angular-a39f89'),
+    technologyValue('technology-svelte-c190ac'),
+    'solid',
+    'qwik',
+    'next',
+    technologyValue('technology-nuxt-22c407'),
+];
 const BUNDLER_TOOLS = ['webpack', 'vite', 'esbuild', 'parcel', 'rollup'];
 /**
  * Build tooling recommendation lines for hypermedia/backend-first projects.

package/dist/tools/suggest-tooling/linting-catalog.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.
-// Planu — Linting & Formatting tooling recommendations (SPEC-025)
-// Barrel: merges core languages + extended languages, builds recommendation lines
+import { technologyValue } from '../../engine/technology-registry.js';
 import { LINTING_CORE } from './linting-catalog-core.js';
 import { LINTING_EXTENDED } from './linting-catalog-extended.js';
 const LINTING_BY_LANGUAGE = {
@@ -10,8 +7,8 @@ const LINTING_BY_LANGUAGE = {
 };
 /** Map raw language strings to registry keys */
 function resolveLangKey(lang) {
-    if (lang.includes('typescript') || lang.includes(' ts')) {
-        return 'typescript';
+    if (lang.includes(technologyValue('technology-typescript-969545')) || lang.includes(' ts')) {
+        return technologyValue('technology-typescript-969545');
     }
     if (lang.includes('python') || lang.includes('py')) {
         return 'python';
@@ -40,7 +37,7 @@ function resolveLangKey(lang) {
     if (lang.includes('csharp') || lang.includes('c#') || lang.includes('.net')) {
         return 'csharp';
     }
-    if (lang.includes('dart') || lang.includes('flutter')) {
+    if (lang.includes('dart') || lang.includes(technologyValue('technology-flutter-be1396'))) {
         return 'dart';
     }
     if (lang.includes('elixir')) {