@planu/cli 4.13.0 → 5.0.0

package/dist/engine/execution/validate-job-payload.d.ts

@@ -0,0 +1,5 @@
+import type { ValidateDurableJobPayload } from '../../types/durable-job.js';
+export declare function isValidateJob(value: unknown): boolean;
+export declare function parseValidatePayload(value: unknown): ValidateDurableJobPayload | undefined;
+export declare function rehydrateValidationPayload(payload: ValidateDurableJobPayload): Promise<ValidateDurableJobPayload>;
+//# sourceMappingURL=validate-job-payload.d.ts.map

package/dist/engine/execution/validate-job-payload.js

@@ -0,0 +1,144 @@
+import { mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { projectDataDir } from '../../storage/base-store.js';
+import { reportClassifiedDegradation } from '../../errors/classified-degradation.js';
+import { computeDurableValidationBindings, toValidationReceiptBindings, } from '../validation/durable-validation.js';
+import { assertValidationFreshnessBarrier, beginValidationFreshnessBarrier, bindValidationFreshnessLease, closeValidationFreshnessLease, } from '../validation/validation-freshness.js';
+import { PROJECT_ID as CANONICAL_PROJECT_ID, SPEC_ID as CANONICAL_SPEC_ID, } from '../validation/validation-receipt-codec.js';
+import { isValidationRootId, revalidateValidationWorktree, ValidationWorktreeError, } from '../validation/validation-worktree.js';
+export function isValidateJob(value) {
+    return Boolean(value && typeof value === 'object' && value.kind === 'validate');
+}
+async function closeFreshnessLeaseWithoutMasking(lease) {
+    try {
+        await closeValidationFreshnessLease(lease);
+    }
+    catch (error) {
+        reportClassifiedDegradation('VALIDATION_FRESHNESS_CHECK_FAILED', error);
+    }
+}
+function hasValidBindingIdentity(payload) {
+    return (payload.bindings === undefined ||
+        (payload.bindings.projectId === payload.input?.projectId &&
+            CANONICAL_PROJECT_ID.test(payload.bindings.projectId)));
+}
+function hasValidPayloadShape(payload) {
+    return Boolean(payload.kind === 'validate' &&
+        payload.schemaVersion === 2 &&
+        payload.input &&
+        typeof payload.input.specId === 'string' &&
+        CANONICAL_SPEC_ID.test(payload.input.specId) &&
+        typeof payload.input.projectId === 'string' &&
+        CANONICAL_PROJECT_ID.test(payload.input.projectId) &&
+        typeof payload.input.projectPath === 'string' &&
+        typeof payload.specPath === 'string' &&
+        hasValidBindingIdentity(payload));
+}
+export function parseValidatePayload(value) {
+    if (!value || typeof value !== 'object') {
+        return undefined;
+    }
+    const payload = value;
+    const schemaVersion = value.schemaVersion;
+    const rawSpecId = payload.input?.specId;
+    const inputSpecId = typeof rawSpecId === 'string' && CANONICAL_SPEC_ID.test(rawSpecId) ? rawSpecId : 'SPEC-unknown';
+    if (schemaVersion !== 2) {
+        throw new ValidationWorktreeError('VALIDATION_PAYLOAD_VERSION_UNSUPPORTED', inputSpecId);
+    }
+    if (!isValidationRootId(payload.validationRootId)) {
+        throw new ValidationWorktreeError('VALIDATION_ROOT_ID_MALFORMED', inputSpecId);
+    }
+    if (typeof rawSpecId !== 'string' || !CANONICAL_SPEC_ID.test(rawSpecId)) {
+        throw new ValidationWorktreeError('VALIDATION_SPEC_ID_MISMATCH', 'SPEC-unknown');
+    }
+    if (!hasValidPayloadShape(payload)) {
+        return undefined;
+    }
+    return payload;
+}
+async function computeFreshSnapshot(input) {
+    const handoffPath = join(projectDataDir(input.projectId), 'handoffs', input.specId);
+    await mkdir(handoffPath, { recursive: true });
+    const freshnessLease = await beginValidationFreshnessBarrier({
+        projectId: input.projectId,
+        specId: input.specId,
+        projectPath: input.projectPath,
+        handoffPath,
+    });
+    try {
+        const observed = await computeDurableValidationBindings({
+            canonicalProjectId: input.projectId,
+            specId: input.specId,
+            projectPath: input.projectPath,
+            specPath: input.specPath,
+        });
+        return { freshnessLease, observed };
+    }
+    catch (error) {
+        await closeFreshnessLeaseWithoutMasking(freshnessLease);
+        throw error;
+    }
+}
+export async function rehydrateValidationPayload(payload) {
+    const resolved = await revalidateValidationWorktree({
+        projectPath: payload.input.projectPath ?? '',
+        specPath: payload.specPath,
+        specId: payload.input.specId,
+        validationRootId: payload.validationRootId,
+    });
+    const projectPath = resolved.projectPath;
+    const specPath = resolved.specPath;
+    const normalizedPayload = {
+        ...payload,
+        input: { ...payload.input, projectPath },
+        specPath,
+    };
+    if (!payload.bindings || !payload.artifactDigests) {
+        const { freshnessLease, observed } = await computeFreshSnapshot({
+            projectId: payload.input.projectId,
+            specId: payload.input.specId,
+            projectPath,
+            specPath,
+        });
+        try {
+            const observedReceiptBindings = toValidationReceiptBindings(observed.bindings, observed.artifactDigests);
+            if (!(await bindValidationFreshnessLease(freshnessLease, observedReceiptBindings))) {
+                throw new Error('[Planu] Validation inputs changed while the snapshot was computed');
+            }
+            return {
+                ...normalizedPayload,
+                bindings: observed.bindings,
+                artifactDigests: observed.artifactDigests,
+                freshnessLease,
+            };
+        }
+        catch (error) {
+            await closeFreshnessLeaseWithoutMasking(freshnessLease);
+            throw error;
+        }
+    }
+    const expected = toValidationReceiptBindings(payload.bindings, payload.artifactDigests);
+    if (payload.freshnessLease &&
+        (await assertValidationFreshnessBarrier(payload.freshnessLease, expected))) {
+        return normalizedPayload;
+    }
+    const { freshnessLease, observed } = await computeFreshSnapshot({
+        projectId: payload.bindings.projectId,
+        specId: payload.bindings.specId,
+        projectPath,
+        specPath,
+    });
+    try {
+        const observedReceiptBindings = toValidationReceiptBindings(observed.bindings, observed.artifactDigests);
+        if (JSON.stringify(expected) !== JSON.stringify(observedReceiptBindings) ||
+            !(await bindValidationFreshnessLease(freshnessLease, observedReceiptBindings))) {
+            throw new Error('[Planu] Durable validation bindings became stale; submit a new validation');
+        }
+        return { ...normalizedPayload, freshnessLease };
+    }
+    catch (error) {
+        await closeFreshnessLeaseWithoutMasking(freshnessLease);
+        throw error;
+    }
+}
+//# sourceMappingURL=validate-job-payload.js.map

package/dist/engine/execution/validate-job-recovery.d.ts

@@ -0,0 +1,4 @@
+import type { ValidateJobRecoveryOptions } from '../../types/durable-validation.js';
+/** Recover runnable validation work and program one global sweep for the earliest live lease. */
+export declare function recoverValidateJobs(defaultSchedule: (projectId: string, workspaceId: string) => void, options?: ValidateJobRecoveryOptions): void;
+//# sourceMappingURL=validate-job-recovery.d.ts.map

package/dist/engine/execution/validate-job-recovery.js

@@ -0,0 +1,47 @@
+import { DurableJobRuntime } from './job-runtime.js';
+function isValidatePayload(value) {
+    return Boolean(value &&
+        typeof value === 'object' &&
+        value.kind === 'validate' &&
+        value.schemaVersion === 2);
+}
+/** Recover runnable validation work and program one global sweep for the earliest live lease. */
+export function recoverValidateJobs(defaultSchedule, options = {}) {
+    const runtime = options.runtimeFactory?.() ?? new DurableJobRuntime();
+    const schedule = options.schedule ?? defaultSchedule;
+    const now = options.now ?? Date.now;
+    const scheduleLater = options.scheduleLater ??
+        ((callback, delayMs) => {
+            const timer = setTimeout(callback, delayMs);
+            timer.unref();
+        });
+    try {
+        let earliestRunningLeaseExpiry;
+        for (const scope of runtime.listRunnableScopes()) {
+            const jobs = runtime
+                .list(scope.projectId, scope.workspaceId)
+                .filter((job) => isValidatePayload(job.payload));
+            if (jobs.some((job) => job.state === 'accepted' || job.state === 'checkpointed')) {
+                schedule(scope.projectId, scope.workspaceId);
+            }
+            for (const job of jobs) {
+                if (job.state !== 'running' || !job.leaseExpiresAt) {
+                    continue;
+                }
+                const expiry = Date.parse(job.leaseExpiresAt);
+                if (Number.isFinite(expiry)) {
+                    earliestRunningLeaseExpiry = Math.min(earliestRunningLeaseExpiry ?? expiry, expiry);
+                }
+            }
+        }
+        if (earliestRunningLeaseExpiry !== undefined) {
+            scheduleLater(() => {
+                recoverValidateJobs(defaultSchedule, options);
+            }, Math.max(1, earliestRunningLeaseExpiry - now() + 1));
+        }
+    }
+    finally {
+        runtime.close();
+    }
+}
+//# sourceMappingURL=validate-job-recovery.js.map

package/dist/engine/execution/validate-worker-runtime.d.ts

@@ -0,0 +1,10 @@
+import type { ValidateWorkerCall } from '../../types/validate-worker.js';
+import type { ToolResult } from '../../types/index.js';
+export declare class ValidationWorkerStalledError extends Error {
+    readonly code: 'VALIDATION_STALLED';
+    readonly lastPhase: string;
+    constructor(lastPhase: string);
+}
+/** Execute validation in a supervised OS worker thread, isolated from the MCP event loop. */
+export declare function runValidateWorker(call: ValidateWorkerCall): Promise<ToolResult>;
+//# sourceMappingURL=validate-worker-runtime.d.ts.map

package/dist/engine/execution/validate-worker-runtime.js

@@ -0,0 +1,188 @@
+import { randomBytes } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { Worker } from 'node:worker_threads';
+import { reportClassifiedDegradation } from '../../errors/classified-degradation.js';
+import { getRuntimePolicy } from '../runtime-policy.js';
+export class ValidationWorkerStalledError extends Error {
+    code = 'VALIDATION_STALLED';
+    lastPhase;
+    constructor(lastPhase) {
+        const phase = safePhase(lastPhase);
+        super(`[Planu] VALIDATION_STALLED: no semantic progress during ${phase}`);
+        this.name = 'ValidationWorkerStalledError';
+        this.lastPhase = phase;
+    }
+}
+function safePhase(phase) {
+    const normalized = phase.trim();
+    return /^[a-z][a-z0-9_-]{0,79}$/iu.test(normalized) ? normalized : 'redacted';
+}
+function semanticProgressAdvanced(previous, current) {
+    if (previous === undefined) {
+        return true;
+    }
+    if (current.completedGates < previous.completedGates ||
+        current.lastProgressAt < previous.lastProgressAt) {
+        return false;
+    }
+    return (current.phase !== previous.phase ||
+        current.status !== previous.status ||
+        current.completedGates > previous.completedGates);
+}
+class SemanticProgressWatchdog {
+    timeoutMs;
+    onStalled;
+    timer;
+    previous;
+    phase = 'startup';
+    constructor(timeoutMs, onStalled) {
+        this.timeoutMs = timeoutMs;
+        this.onStalled = onStalled;
+    }
+    start() {
+        this.arm();
+    }
+    observe(progress) {
+        if (!semanticProgressAdvanced(this.previous, progress)) {
+            return;
+        }
+        this.phase = progress.phase;
+        this.previous = progress;
+        this.arm();
+    }
+    dispose() {
+        if (this.timer !== undefined) {
+            clearTimeout(this.timer);
+            this.timer = undefined;
+        }
+    }
+    arm() {
+        this.dispose();
+        this.timer = setTimeout(() => {
+            this.onStalled(this.phase);
+        }, this.timeoutMs);
+        this.timer.unref();
+    }
+}
+function workerUrl() {
+    const sibling = new URL('./validate-worker-thread.js', import.meta.url);
+    if (existsSync(sibling)) {
+        return sibling;
+    }
+    const built = resolve(process.cwd(), 'dist/engine/execution/validate-worker-thread.js');
+    if (existsSync(built)) {
+        return pathToFileURL(built);
+    }
+    throw new Error('[Planu] Validate worker artifact is missing; run the production build');
+}
+/** Execute validation in a supervised OS worker thread, isolated from the MCP event loop. */
+// eslint-disable-next-line max-lines-per-function -- lifecycle handlers stay co-located around one worker instance.
+export function runValidateWorker(call) {
+    if (call.signal?.aborted) {
+        return Promise.reject(abortError(call.signal));
+    }
+    if (!Number.isSafeInteger(call.deadlineAt) || call.deadlineAt <= Date.now()) {
+        return Promise.reject(new Error('[Planu] Validate worker requires a future deadline'));
+    }
+    const secret = randomBytes(32).toString('hex');
+    const worker = new Worker(workerUrl(), { workerData: { secret }, execArgv: [] });
+    // eslint-disable-next-line max-lines-per-function -- watchdog and authenticated worker share one settlement boundary
+    return new Promise((resolveCall, reject) => {
+        let settled = false;
+        let sent = false;
+        const watchdog = new SemanticProgressWatchdog(getRuntimePolicy().validation.noProgressTimeoutMs, (phase) => {
+            if (call.signal?.aborted) {
+                abort();
+            }
+            else if (Date.now() >= call.deadlineAt) {
+                finish(new Error('[Planu] Validate worker deadline exceeded'));
+            }
+            else {
+                finish(new ValidationWorkerStalledError(phase));
+            }
+        });
+        const finish = (error, result) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            watchdog.dispose();
+            call.signal?.removeEventListener('abort', abort);
+            void worker.terminate();
+            if (error) {
+                reject(error);
+            }
+            else if (result) {
+                resolveCall(result);
+            }
+            else {
+                reject(new Error('[Planu] Validate worker returned no result'));
+            }
+        };
+        const abort = () => {
+            finish(abortError(call.signal));
+        };
+        const timer = setTimeout(() => {
+            finish(new Error('[Planu] Validate worker deadline exceeded'));
+        }, Math.max(1, call.deadlineAt - Date.now()));
+        timer.unref();
+        watchdog.start();
+        call.signal?.addEventListener('abort', abort, { once: true });
+        worker.once('error', (error) => {
+            finish(error instanceof Error ? error : new Error(String(error)));
+        });
+        worker.once('exit', (code) => {
+            if (!settled && code !== 0) {
+                finish(new Error(`[Planu] Validate worker exited ${String(code)}`));
+            }
+        });
+        worker.on('message', (value) => {
+            if (settled) {
+                return;
+            }
+            const response = value;
+            if (response.kind === 'ready' && response.schemaVersion === 1 && !sent) {
+                const request = {
+                    kind: 'validate-request',
+                    schemaVersion: 1,
+                    secret,
+                    requestId: call.requestId,
+                    deadlineAt: call.deadlineAt,
+                    input: call.input,
+                };
+                sent = true;
+                worker.postMessage(request);
+                return;
+            }
+            const responseRequestId = 'requestId' in response ? response.requestId : undefined;
+            if (!sent || responseRequestId !== call.requestId || response.schemaVersion !== 1) {
+                finish(new Error('[Planu] Validate worker response identity mismatch'));
+            }
+            else if (response.kind === 'validate-progress' && response.progress !== undefined) {
+                watchdog.observe(response.progress);
+                try {
+                    call.onProgress?.(response.progress);
+                }
+                catch (error) {
+                    reportClassifiedDegradation('VALIDATE_WORKER_PROGRESS_CALLBACK_FAILURE', error);
+                    finish(error instanceof Error ? error : new Error(String(error)));
+                }
+            }
+            else if (response.kind === 'validate-error') {
+                finish(new Error(response.message));
+            }
+            else if (response.kind === 'validate-result') {
+                finish(undefined, response.result);
+            }
+        });
+    });
+}
+function abortError(signal) {
+    return signal?.reason instanceof Error
+        ? signal.reason
+        : new Error('[Planu] Validate worker cancelled');
+}
+//# sourceMappingURL=validate-worker-runtime.js.map

package/dist/engine/execution/validate-worker-thread.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=validate-worker-thread.d.ts.map

package/dist/engine/execution/validate-worker-thread.js

@@ -0,0 +1,64 @@
+import { parentPort, workerData } from 'node:worker_threads';
+import { redactFailureMessage, reportClassifiedDegradation, } from '../../errors/classified-degradation.js';
+import { createExecutionScope } from './context.js';
+const bootstrap = workerData;
+if (!parentPort || typeof bootstrap?.secret !== 'string' || bootstrap.secret.length < 32) {
+    throw new Error('[Planu] Validate worker bootstrap authentication failed');
+}
+const port = parentPort;
+const secret = bootstrap.secret;
+port.postMessage({ kind: 'ready', schemaVersion: 1 });
+port.once('message', (value) => {
+    void execute(value);
+});
+async function execute(value) {
+    const request = value;
+    const requestId = typeof request.requestId === 'string' ? request.requestId : 'invalid';
+    try {
+        if (request.kind !== 'validate-request' ||
+            request.schemaVersion !== 1 ||
+            request.secret !== secret ||
+            typeof request.requestId !== 'string' ||
+            !request.input ||
+            typeof request.input.specId !== 'string' ||
+            typeof request.input.projectId !== 'string' ||
+            typeof request.deadlineAt !== 'number' ||
+            Date.now() >= request.deadlineAt) {
+            throw new Error('[Planu] Validate worker rejected malformed or expired work');
+        }
+        const { executeValidate } = await import('../../tools/validate.js');
+        const input = request.input;
+        const scope = createExecutionScope({ requestId, deadlineAt: request.deadlineAt });
+        let result;
+        try {
+            result = await scope.run(() => executeValidate(input, undefined, (progress) => {
+                port.postMessage({
+                    kind: 'validate-progress',
+                    schemaVersion: 1,
+                    requestId,
+                    progress,
+                });
+            }));
+        }
+        finally {
+            scope.dispose();
+        }
+        port.postMessage({
+            kind: 'validate-result',
+            schemaVersion: 1,
+            requestId,
+            result,
+        });
+    }
+    catch (error) {
+        /* reliability-optional: VALIDATE_WORKER_FAILURE — typed error response is emitted */
+        reportClassifiedDegradation('VALIDATE_WORKER_FAILURE', error);
+        port.postMessage({
+            kind: 'validate-error',
+            schemaVersion: 1,
+            requestId,
+            message: redactFailureMessage(error),
+        });
+    }
+}
+//# sourceMappingURL=validate-worker-thread.js.map

package/dist/engine/execution-plan/desktop-distribution.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/execution-plan/desktop-distribution.ts — SPEC-014b
-// Distribution phase generator for desktop release specs (Electron, Tauri, .NET).
-// SRP: single responsibility — desktop app release pipeline steps.
+import { technologyValue } from '../technology-registry.js';
 /**
  * Returns true if the spec is a desktop release spec (based on tags, title, or type).
  */
@@ -11,7 +7,7 @@ export function isDesktopReleaseSpec(spec) {
     return (lower.includes('release') ||
         lower.includes('distribut') ||
         lower.includes('publish') ||
-        lower.includes('electron') ||
+        lower.includes(technologyValue('technology-electron-88b1de')) ||
         lower.includes('tauri') ||
         lower.includes('dotnet') ||
         spec.type === 'infra');
@@ -24,7 +20,7 @@ export function generateDesktopDistributionPhase(spec, startOrder) {
     const steps = [];
     let order = startOrder;
     const lower = `${spec.title} ${spec.tags.join(' ')}`.toLowerCase();
-    const isElectron = lower.includes('electron');
+    const isElectron = lower.includes(technologyValue('technology-electron-88b1de'));
     const isTauri = lower.includes('tauri');
     const isDotNet = lower.includes('dotnet') || lower.includes('.net');
     // Step 1: Platform-specific build

package/dist/engine/execution-plan/mobile-distribution.js

@@ -1,9 +1,4 @@
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
-// engine/execution-plan/mobile-distribution.ts — SPEC-013
-// Distribution phase orchestrator for iOS/Android/Flutter/ReactNative/Expo release specs.
-// SRP: detects platform + delegates step generation to platform-specific modules.
-// OCP: new platforms add a new file in mobile-dist/ — no changes to this file.
+import { technologyValue } from '../technology-registry.js';
 import { generateNativeDistributionPhase } from './mobile-dist/native-steps.js';
 import { generateFlutterDistributionPhase } from './mobile-dist/flutter-steps.js';
 import { generateExpoDistributionPhase } from './mobile-dist/expo-steps.js';
@@ -15,8 +10,8 @@ import { generateReactNativeDistributionPhase } from './mobile-dist/rn-steps.js'
  */
 export function detectCrossPlatformKind(spec) {
     const lower = `${spec.title} ${spec.tags.join(' ')}`.toLowerCase();
-    if (lower.includes('flutter')) {
-        return 'flutter';
+    if (lower.includes(technologyValue('technology-flutter-be1396'))) {
+        return technologyValue('technology-flutter-be1396');
     }
     if (lower.includes('expo')) {
         return 'expo';
@@ -43,7 +38,7 @@ export function isMobileDistributionSpec(spec) {
  */
 export function generateMobileDistributionPhase(spec, startOrder) {
     const crossPlatform = detectCrossPlatformKind(spec);
-    if (crossPlatform === 'flutter') {
+    if (crossPlatform === technologyValue('technology-flutter-be1396')) {
         return generateFlutterDistributionPhase(startOrder);
     }
     if (crossPlatform === 'expo') {

package/dist/engine/execution-plan/phases.js

@@ -1,6 +1,4 @@
-// engine/execution-plan/phases.ts — Execution phase generators
-// SRP: each function generates steps for one phase of the implementation plan.
-// OCP: new phases can be added without modifying the dispatcher in generate-execution-plan.ts.
+import { technologyValue } from '../technology-registry.js';
 import { inferDataLayerFiles, inferServiceFiles, inferApiFiles, inferPageFiles, inferComponentFiles, } from './plan-utils.js';
 export { generateTestingPhase, generateIntegrationPhase } from './phases-b.js';
 export function generateSetupPhase(spec, knowledge, startOrder) {
@@ -16,7 +14,8 @@ export function generateSetupPhase(spec, knowledge, startOrder) {
         estimatedMinutes: 2,
         canRollback: true,
     });
-    if (knowledge.language === 'typescript' || knowledge.language === 'javascript') {
+    if (knowledge.language === technologyValue('technology-typescript-969545') ||
+        knowledge.language === 'javascript') {
         steps.push({
             order: order++,
             title: 'Define types and interfaces',
@@ -156,7 +155,7 @@ export function generateUIPhase(spec, knowledge, content, startOrder) {
     const steps = [];
     let order = startOrder;
     const lower = content.toLowerCase();
-    const framework = knowledge.framework ?? 'react';
+    const framework = knowledge.framework ?? technologyValue('technology-react-275976');
     steps.push({
         order: order++,
         title: 'Create page layout and routing',

package/dist/engine/execution-plan/plan-utils.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';
 // engine/execution-plan/plan-utils.ts — Utilities for execution plan generation
 // Critical path analysis, parallelization detection, and file inference helpers.
 import { readFile } from 'node:fs/promises';
@@ -48,7 +47,7 @@ export function inferServiceFiles(spec, knowledge) {
 export function inferApiFiles(spec, knowledge) {
     const firstContract = knowledge.apiContracts[0];
     const apiType = firstContract ? firstContract.type : 'rest';
-    const base = apiType === 'trpc' ? 'src/server/routers' : 'src/routes';
+    const base = apiType === technologyValue('technology-trpc-7a75ed') ? 'src/server/routers' : 'src/routes';
     return [`${base}/${spec.slug}.ts`];
 }
 export function inferPageFiles(spec, knowledge) {
@@ -56,13 +55,17 @@ export function inferPageFiles(spec, knowledge) {
     if (framework.includes('next')) {
         return [`app/${spec.slug}/page.tsx`];
     }
-    if (framework.includes('nuxt')) {
+    if (framework.includes(technologyValue('technology-nuxt-22c407'))) {
         return [`pages/${spec.slug}.vue`];
     }
     return [`src/pages/${spec.slug}.tsx`];
 }
 export function inferComponentFiles(spec, knowledge) {
-    const ext = (knowledge.framework ?? '').toLowerCase().includes('vue') ? 'vue' : 'tsx';
+    const ext = (knowledge.framework ?? '')
+        .toLowerCase()
+        .includes(technologyValue('technology-vue-564382'))
+        ? technologyValue('technology-vue-564382')
+        : 'tsx';
     return [`src/components/${spec.slug}/${spec.slug}.${ext}`];
 }
 // --- Spec content reader ---

package/dist/engine/facilitate/context-loader.js

@@ -2,7 +2,7 @@
 // engine/facilitate/context-loader.ts — SPEC-264 Loads project context from disk
 import { readdir, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { createHash } from 'node:crypto';
+import { hashProjectPath, projectDataDir } from '../../storage/base-store.js';
 // ---------------------------------------------------------------------------
 // Internal helpers
 // ---------------------------------------------------------------------------
@@ -39,12 +39,6 @@ function parseFrontmatter(content) {
     }
     return result;
 }
-/**
- * Compute project hash the same way base-store does (SHA-256, first 16 chars).
- */
-function hashProjectPath(projectPath) {
-    return createHash('sha256').update(projectPath).digest('hex').slice(0, 16);
-}
 /**
  * Check if two sets of keywords overlap (case-insensitive).
  */
@@ -90,8 +84,8 @@ async function loadCheckpoint(checkpointFile) {
  */
 export async function loadContext(projectPath, keywords) {
     const projectId = hashProjectPath(projectPath);
-    const specsFile = join('data', 'projects', projectId, 'specs.json');
-    const checkpointFile = join('data', 'projects', projectId, 'session-state.json');
+    const specsFile = join(projectDataDir(projectId), 'specs.json');
+    const checkpointFile = join(projectDataDir(projectId), 'session-state.json');
     const specs = await loadSpecsFromFile(specsFile);
     const lastCheckpoint = await loadCheckpoint(checkpointFile);
     const activeSpecs = specs.filter((s) => ACTIVE_STATUSES.has(s.status));

package/dist/engine/figma/code-connect-fetcher.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';
 // engine/figma/code-connect-fetcher.ts — Figma Code Connect / Dev Resources (SPEC-426)
 const FIGMA_API_BASE = 'https://api.figma.com/v1';
 // ---------------------------------------------------------------------------
@@ -7,14 +6,16 @@ const FIGMA_API_BASE = 'https://api.figma.com/v1';
 // ---------------------------------------------------------------------------
 function inferFramework(url) {
     const lower = url.toLowerCase();
-    if (lower.includes('react') || lower.includes('jsx') || lower.includes('tsx')) {
-        return 'react';
+    if (lower.includes(technologyValue('technology-react-275976')) ||
+        lower.includes('jsx') ||
+        lower.includes('tsx')) {
+        return technologyValue('technology-react-275976');
     }
-    if (lower.includes('vue')) {
-        return 'vue';
+    if (lower.includes(technologyValue('technology-vue-564382'))) {
+        return technologyValue('technology-vue-564382');
     }
-    if (lower.includes('angular')) {
-        return 'angular';
+    if (lower.includes(technologyValue('technology-angular-a39f89'))) {
+        return technologyValue('technology-angular-a39f89');
     }
     if (lower.includes('swift') || lower.includes('ios')) {
         return 'ios';