@planu/cli 4.12.3 → 4.14.1

package/dist/engine/platform-detector/desktop.js

@@ -1,5 +1,11 @@
+import { technologyValue } from '../technology-registry.js';
 import { fileExists, hasAnyFile } from '../detection-utils.js';
-const DESKTOP_FW_SET = new Set(['electron', 'tauri', 'dotnet', 'qt']);
+const DESKTOP_FW_SET = new Set([
+    technologyValue('technology-electron-88b1de'),
+    'tauri',
+    'dotnet',
+    'qt',
+]);
 /**
  * Returns true if the framework string matches a known desktop framework.
  */
@@ -37,7 +43,14 @@ export async function detectDesktopFramework(projectPath, framework) {
  */
 export function getEmbeddedWebFramework(knowledge) {
     const stack = knowledge.stack;
-    const webFrameworks = ['react', 'vue', 'angular', 'svelte', 'next.js', 'nuxt'];
+    const webFrameworks = [
+        technologyValue('technology-react-275976'),
+        technologyValue('technology-vue-564382'),
+        technologyValue('technology-angular-a39f89'),
+        technologyValue('technology-svelte-c190ac'),
+        technologyValue('technology-next-js-0d857f'),
+        technologyValue('technology-nuxt-22c407'),
+    ];
     for (const fw of webFrameworks) {
         if (stack.includes(fw)) {
             return fw;

package/dist/engine/platform-detector/extensions.js

@@ -1,3 +1,4 @@
+import { technologyValue } from '../technology-registry.js';
 import { fileExists, hasAnyFile } from '../detection-utils.js';
 /**
  * Returns the extension platform if the project is a browser or IDE extension.
@@ -67,7 +68,7 @@ async function detectBrowserExtension(projectPath) {
         if (bss?.gecko !== undefined) {
             return 'firefox';
         }
-        return 'chrome';
+        return technologyValue('technology-chrome-9390ef');
     }
     catch {
         return null;

package/dist/engine/platform-detector/games.js

@@ -1,3 +1,4 @@
+import { technologyValue } from '../technology-registry.js';
 import { fileExists, hasAnyFile } from '../detection-utils.js';
 const GAME_FW_SET = new Set(['unity', 'godot', 'unreal', 'bevy', 'phaser', 'pygame']);
 /**
@@ -48,7 +49,7 @@ export function getGameEngineLanguage(engine) {
         godot: 'gdscript',
         unreal: 'cpp',
         bevy: 'rust',
-        phaser: 'typescript',
+        phaser: technologyValue('technology-typescript-969545'),
         pygame: 'python',
     };
     return languageMap[engine];

package/dist/engine/platform-detector.js

@@ -1,3 +1,4 @@
+import { technologyValue } from './technology-registry.js';
 import { isDesktopFramework, detectDesktopFramework, getEmbeddedWebFramework, } from './platform-detector/desktop.js';
 import { isGameFramework, detectGameEngine, getGameEngineLanguage, } from './platform-detector/games.js';
 import { detectExtensionPlatform, getBrowserExtensionManifestVersion, } from './platform-detector/extensions.js';
@@ -6,9 +7,9 @@ export { isDesktopFramework, detectDesktopFramework, getEmbeddedWebFramework };
 export { isGameFramework, detectGameEngine, getGameEngineLanguage };
 export { detectExtensionPlatform, getBrowserExtensionManifestVersion };
 const MOBILE_FRAMEWORKS = new Set([
-    'swiftui',
+    technologyValue('technology-swiftui-b63400'),
     'uikit',
-    'flutter',
+    technologyValue('technology-flutter-be1396'),
     'react-native',
     'compose',
     'xml-views',

package/dist/engine/platform-engineering/idp-detector.js

@@ -1,3 +1,4 @@
+import { technologyValue } from '../technology-registry.js';
 // engine/platform-engineering/idp-detector.ts — SPEC-048
 // Detects signals of Internal Developer Platform need and calculates DX score.
 import { access, readFile } from 'node:fs/promises';
@@ -80,7 +81,7 @@ async function detectIaCFiles(projectPath) {
         }
     }
     // Check for terraform directory
-    if (await fileExists(join(projectPath, 'terraform'))) {
+    if (await fileExists(join(projectPath, technologyValue('technology-terraform-94dc3e')))) {
         return true;
     }
     if (await fileExists(join(projectPath, 'infra'))) {

package/dist/engine/plugin-installer/stack-matcher.js

@@ -1,21 +1,16 @@
 // @crash-shield-ignore-file — config/cache reader for Planu-controlled JSON; writer is this codebase, shape guaranteed by build/seed.
 // engine/plugin-installer/stack-matcher.ts — Registry-driven stack signal normalization (SPEC-596 + SPEC-597 + SPEC-605)
 //
-// Reads src/config/framework-registry/index.json and src/config/detection-signals.json
+// Reads the validated src/config/technology-registry.json authority.
 // at first use (synchronously, once per process), builds an alias → canonical-name map
 // dynamically, and normalizes raw stack strings from scan_project / ProjectKnowledge / user hints.
 //
 // ZERO HARDCODE: adding a new framework or deploy target = edit the JSON registries,
 // never touch this file.
-import { readFileSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
-import { fileURLToPath } from 'node:url';
-import { dirname, join, resolve as pathResolve } from 'node:path';
+import { join } from 'node:path';
+import { loadTechnologyRegistry } from '../technology-registry.js';
 let aliasMapCache = null;
-function registryDir() {
-    const here = fileURLToPath(import.meta.url);
-    return pathResolve(dirname(here), '..', '..', 'config');
-}
 function addAliasTo(entries, seen, alias, canonical) {
     const key = alias.toLowerCase().trim();
     if (key.length === 0 || seen.has(key)) {
@@ -38,24 +33,21 @@ function buildAliasMap() {
     if (aliasMapCache) {
         return aliasMapCache;
     }
-    const fwRaw = readFileSync(join(registryDir(), 'framework-registry', 'index.json'), 'utf-8');
-    const fw = JSON.parse(fwRaw);
-    const sigRaw = readFileSync(join(registryDir(), 'detection-signals.json'), 'utf-8');
-    const signals = JSON.parse(sigRaw);
+    const registry = loadTechnologyRegistry();
     const entries = [];
     const seen = new Set();
-    for (const f of fw.frameworks) {
+    for (const f of registry.frameworks) {
         addAliasTo(entries, seen, f.id, f.id);
         addAliasTo(entries, seen, f.displayName, f.id);
         addAliasTo(entries, seen, f.displayName.replace(/[.\s]/g, ''), f.id);
     }
-    for (const target of signals.deployTargets) {
+    for (const target of registry.deployTargets) {
         addAliasTo(entries, seen, target.id, target.id);
     }
-    for (const db of signals.databases) {
+    for (const db of registry.databases) {
         addAliasTo(entries, seen, db.id, db.id);
     }
-    for (const sig of signals.signals) {
+    for (const sig of registry.signals) {
         if (sig.type !== 'dependency') {
             continue;
         }
@@ -65,7 +57,7 @@ function buildAliasMap() {
         addAliasTo(entries, seen, sig.pattern, sig.frameworkId);
     }
     // Explicit aliases from the registry (e.g. "otel" → "opentelemetry", "shadcn/ui" → "shadcn").
-    for (const entry of signals.aliases ?? []) {
+    for (const entry of registry.aliases) {
         addAliasTo(entries, seen, entry.alias, entry.canonical);
     }
     aliasMapCache = Object.fromEntries(entries);

package/dist/engine/plugins/lifecycle.js

@@ -1,6 +1,6 @@
 // engine/plugins/lifecycle.ts — Plugin lifecycle management (SPEC-085 AC-03)
 import { cp, rm, readFile, mkdir } from 'node:fs/promises';
-import { join } from 'node:path';
+import { isAbsolute, join } from 'node:path';
 import { writeJsonSafe } from '../safety/atomic-writer.js';
 import { getPluginsDir, loadPluginModule } from './loader.js';
 import { validateManifestStructure } from './validator.js';
@@ -11,14 +11,18 @@ import { registerPluginAnalyzers, unregisterPluginAnalyzers, } from './extension
 import { registerPluginTemplates, unregisterPluginTemplates, } from './extensions/template-extension.js';
 const STATE_FILE = 'plugins-state.json';
 function stateFilePath(dataDir) {
+    if (!isAbsolute(dataDir)) {
+        throw new Error('[Planu] Plugin state data root must be absolute');
+    }
     return join(dataDir, 'global', STATE_FILE);
 }
 /**
  * Reads plugin state from disk.
  */
 export async function readPluginState(dataDir) {
+    const filePath = stateFilePath(dataDir);
     try {
-        const raw = await readFile(stateFilePath(dataDir), 'utf8');
+        const raw = await readFile(filePath, 'utf8');
         return JSON.parse(raw);
     }
     catch {

package/dist/engine/prior-decisions/contradiction-detector.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.
-// Planu — Contradiction Detector (SPEC-615)
-// Detects when a new spec criterion contradicts a prior decision
-// using keyword-category heuristics.
+import { technologyValue } from '../technology-registry.js';
 // ---------------------------------------------------------------------------
 // Category buckets — words that belong to the same "technology slot"
 // When a decision says "use X" and a criterion says "use Y" (different X/Y in
@@ -18,10 +14,10 @@ const TECH_CATEGORIES = [
         'mysql',
         'sqlite',
         'mongodb',
-        'redis',
+        technologyValue('technology-redis-34fb46'),
         'dynamodb',
         'firestore',
-        'supabase',
+        technologyValue('technology-supabase-4d7594'),
         'planetscale',
         'cockroachdb',
         'neo4j',
@@ -29,46 +25,80 @@ const TECH_CATEGORIES = [
     ],
     // Frontend frameworks
     [
-        'react',
-        'vue',
-        'angular',
-        'svelte',
+        technologyValue('technology-react-275976'),
+        technologyValue('technology-vue-564382'),
+        technologyValue('technology-angular-a39f89'),
+        technologyValue('technology-svelte-c190ac'),
         'solid',
         'qwik',
-        'remix',
-        'nextjs',
-        'nuxt',
-        'astro',
+        technologyValue('technology-remix-0c5d96'),
+        technologyValue('technology-nextjs-c93379'),
+        technologyValue('technology-nuxt-22c407'),
+        technologyValue('technology-astro-23661e'),
         'gatsby',
     ],
     // Backend frameworks
     [
-        'express',
-        'fastify',
+        technologyValue('technology-express-008231'),
+        technologyValue('technology-fastify-cbe57e'),
         'koa',
         'hapi',
-        'nestjs',
-        'django',
-        'flask',
-        'fastapi',
-        'rails',
-        'laravel',
+        technologyValue('technology-nestjs-2d0087'),
+        technologyValue('technology-django-7d8a08'),
+        technologyValue('technology-flask-b87aa5'),
+        technologyValue('technology-fastapi-6aee0e'),
+        technologyValue('technology-rails-2e1d59'),
+        technologyValue('technology-laravel-c34cfa'),
         'spring',
-        'gin',
-        'fiber',
+        technologyValue('technology-gin-985adc'),
+        technologyValue('technology-fiber-77c3e6'),
     ],
     // Testing
-    ['jest', 'vitest', 'mocha', 'jasmine', 'pytest', 'rspec', 'junit'],
+    [
+        technologyValue('technology-jest-35e99f'),
+        technologyValue('technology-vitest-a9127f'),
+        'mocha',
+        'jasmine',
+        technologyValue('technology-pytest-2b0121'),
+        'rspec',
+        'junit',
+    ],
     // Styling
-    ['tailwind', 'css-modules', 'styled-components', 'emotion', 'sass', 'scss', 'less'],
+    [
+        technologyValue('technology-tailwind-44c8cf'),
+        'css-modules',
+        'styled-components',
+        'emotion',
+        'sass',
+        'scss',
+        'less',
+    ],
     // State management
     ['redux', 'zustand', 'mobx', 'pinia', 'jotai', 'recoil', 'xstate'],
     // ORMs
-    ['prisma', 'drizzle', 'typeorm', 'sequelize', 'sqlalchemy', 'ecto', 'hibernate'],
+    [
+        technologyValue('technology-prisma-99497c'),
+        technologyValue('technology-drizzle-424f22'),
+        technologyValue('technology-typeorm-527d4d'),
+        technologyValue('technology-sequelize-d18291'),
+        technologyValue('technology-sqlalchemy-37f268'),
+        'ecto',
+        'hibernate',
+    ],
     // Message brokers
-    ['kafka', 'rabbitmq', 'sqs', 'pubsub', 'nats', 'redis'],
+    ['kafka', 'rabbitmq', 'sqs', 'pubsub', 'nats', technologyValue('technology-redis-34fb46')],
     // Container / infra
-    ['docker', 'kubernetes', 'k8s', 'nomad', 'heroku', 'railway', 'fly', 'vercel', 'netlify'],
+    [
+        technologyValue('technology-docker-d548c5'),
+        technologyValue('technology-kubernetes-94abcb'),
+        'k8s',
+        'nomad',
+        'heroku',
+        technologyValue('technology-railway-e34d1c'),
+        technologyValue('technology-fly-f4debd'),
+        technologyValue('technology-vercel-9d3508'),
+        technologyValue('technology-netlify-58465a'),
+    ],
 ];
 /** Returns the category bucket index for a token, or -1 if none. */
 function categoryOf(token) {

package/dist/engine/project-dna/stack-detector.js

@@ -1,12 +1,9 @@
 // @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.
 // Planu — project-dna/stack-detector.ts
 // Detects project stack by reading manifest files.
 import { readFile, access } from 'node:fs/promises';
-import { readFileSync } from 'node:fs';
-import { join, dirname, resolve as pathResolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { join } from 'node:path';
+import { loadTechnologyRegistry, technologyValue } from '../technology-registry.js';
 // ---------------------------------------------------------------------------
 // Registry loader (readFileSync — not intercepted by test mocks of fs/promises)
 // ---------------------------------------------------------------------------
@@ -15,10 +12,7 @@ function loadSignals() {
     if (signalsCache) {
         return signalsCache;
     }
-    const here = fileURLToPath(import.meta.url);
-    const configDir = pathResolve(dirname(here), '..', '..', 'config');
-    const raw = readFileSync(join(configDir, 'detection-signals.json'), 'utf-8');
-    signalsCache = JSON.parse(raw);
+    signalsCache = loadTechnologyRegistry();
     return signalsCache;
 }
 // ---------------------------------------------------------------------------
@@ -209,14 +203,14 @@ export async function detectPackageManager(projectPath) {
  * Detects the primary testing framework based on stack tokens and config files.
  */
 export async function detectTestingFramework(projectPath, stack) {
-    if (stack.includes('vitest')) {
-        return 'vitest';
+    if (stack.includes(technologyValue('technology-vitest-a9127f'))) {
+        return technologyValue('technology-vitest-a9127f');
     }
-    if (stack.includes('jest')) {
-        return 'jest';
+    if (stack.includes(technologyValue('technology-jest-35e99f'))) {
+        return technologyValue('technology-jest-35e99f');
     }
-    if (stack.includes('pytest')) {
-        return 'pytest';
+    if (stack.includes(technologyValue('technology-pytest-2b0121'))) {
+        return technologyValue('technology-pytest-2b0121');
     }
     // Go test is always available if go.mod exists
     if (await fileExists(join(projectPath, 'go.mod'))) {
@@ -245,7 +239,9 @@ export async function detectLinter(projectPath, stack) {
             return 'eslint';
         }
     }
-    if (stack.includes('fastapi') || stack.includes('django') || stack.includes('flask')) {
+    if (stack.includes(technologyValue('technology-fastapi-6aee0e')) ||
+        stack.includes(technologyValue('technology-django-7d8a08')) ||
+        stack.includes(technologyValue('technology-flask-b87aa5'))) {
         if (await fileExists(join(projectPath, 'pyproject.toml'))) {
             const content = await readFileIfExists(join(projectPath, 'pyproject.toml'));
             if (content?.includes('ruff') === true) {
@@ -282,7 +278,9 @@ export async function detectFormatter(projectPath, stack) {
             return 'prettier';
         }
     }
-    if (stack.includes('fastapi') || stack.includes('django') || stack.includes('flask')) {
+    if (stack.includes(technologyValue('technology-fastapi-6aee0e')) ||
+        stack.includes(technologyValue('technology-django-7d8a08')) ||
+        stack.includes(technologyValue('technology-flask-b87aa5'))) {
         return 'black';
     }
     if (await fileExists(join(projectPath, 'go.mod'))) {

package/dist/engine/project-graph/builder.js

@@ -6,6 +6,7 @@ import { extractDecisionStoreGraph } from './extractors/decision-store-extractor
 import { extractSpecGraph } from './extractors/spec-extractor.js';
 import { extractValidationGraph } from './extractors/validation-extractor.js';
 import { createNativeProjectGraphRuntime } from './native.js';
+import { publishFreshProjectGraphProjection } from './freshness-projection.js';
 const NATIVE_PROJECT_GRAPH_IMPLEMENTATION_VERSION = 'native-project-graph-v2';
 function uniqueNodes(nodes) {
     return [...new Map(nodes.map((node) => [node.id, node])).values()];
@@ -207,6 +208,11 @@ async function buildProjectKnowledgeGraphUnlocked(args) {
         Array.isArray(existingGraph.nodes) &&
         Array.isArray(existingGraph.edges);
     if (hasConsistentExistingGraph && diff.changed.length === 0 && diff.removed.length === 0) {
+        publishFreshProjectGraphProjection({
+            projectId: args.projectId,
+            generatedAt: existingGraph.generatedAt,
+            generation: existingGraph.generation,
+        });
         return {
             graph: existingGraph,
             generation: existingGraph.generation,
@@ -279,6 +285,11 @@ async function buildProjectKnowledgeGraphUnlocked(args) {
         graph,
         cache,
     });
+    publishFreshProjectGraphProjection({
+        projectId: args.projectId,
+        generatedAt: graph.generatedAt,
+        generation,
+    });
     return {
         graph,
         generation,

package/dist/engine/project-graph/cache.js

@@ -234,7 +234,7 @@ export async function withProjectGraphBuildLock(projectId, policy, task) {
         const startedAt = Date.now();
         for (;;) {
             try {
-                return await withSpecLock(key, 'PROJECT-GRAPH-BUILD', async () => task(), {
+                return await withSpecLock(projectId, 'PROJECT-GRAPH-BUILD', async () => task(), {
                     reason: `project graph build for ${projectId}`,
                 });
             }

package/dist/engine/project-graph/freshness-projection.d.ts

@@ -0,0 +1,16 @@
+import type { ProjectGraphFreshnessProjection } from '../../types/project-knowledge-graph.js';
+/** Read the canonical O(1) freshness projection. Invalid records are unavailable, never trusted. */
+export declare function readProjectGraphFreshnessProjection(projectId: string): ProjectGraphFreshnessProjection | undefined;
+/** Publish a successful graph generation as the new canonical freshness projection. */
+export declare function publishFreshProjectGraphProjection(args: {
+    readonly projectId: string;
+    readonly generatedAt: string;
+    readonly generation: string;
+}): void;
+/** Explicitly invalidate freshness without retaining an old value as a fresh fallback. */
+export declare function invalidateProjectGraphFreshnessProjection(args: {
+    readonly projectId: string;
+    readonly reason?: 'source_changed' | 'corrupt';
+    readonly changedSourceCount?: number;
+}): void;
+//# sourceMappingURL=freshness-projection.d.ts.map

package/dist/engine/project-graph/freshness-projection.js

@@ -0,0 +1,95 @@
+import { join } from 'node:path';
+import { projectDataDir } from '../../storage/base-store.js';
+import { RuntimeDatabase } from '../../storage/runtime-db.js';
+import { resolveStorageLayout } from '../../storage/storage-layout.js';
+const PROJECTION_WORKSPACE = 'project-graph';
+const PROJECTION_KEY = 'freshness-v1';
+const projectionCache = new Map();
+function runtimeDatabasePath(projectId) {
+    // PLANU_PROJECT_DATA_DIR is the established isolated test/CI project-data root.
+    // Production uses the single canonical runtime database from the storage layout.
+    return process.env.PLANU_PROJECT_DATA_DIR
+        ? join(projectDataDir(projectId), 'runtime', 'planu.sqlite3')
+        : resolveStorageLayout().runtimeDatabase;
+}
+function withDatabase(projectId, operation) {
+    const database = new RuntimeDatabase({
+        path: runtimeDatabasePath(projectId),
+        checkIntegrity: false,
+    });
+    try {
+        return operation(database);
+    }
+    finally {
+        database.close();
+    }
+}
+function isProjection(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const candidate = value;
+    return (candidate.schemaVersion === 1 &&
+        (candidate.state === 'fresh' || candidate.state === 'invalidated') &&
+        Number.isSafeInteger(candidate.changedSourceCount) &&
+        Number(candidate.changedSourceCount) >= 0 &&
+        (candidate.generatedAt === undefined || typeof candidate.generatedAt === 'string') &&
+        (candidate.reason === undefined ||
+            candidate.reason === 'source_changed' ||
+            candidate.reason === 'corrupt'));
+}
+/** Read the canonical O(1) freshness projection. Invalid records are unavailable, never trusted. */
+export function readProjectGraphFreshnessProjection(projectId) {
+    const cached = projectionCache.get(projectId);
+    if (cached !== undefined) {
+        return cached ?? undefined;
+    }
+    const value = withDatabase(projectId, (database) => database.getRecord(projectId, PROJECTION_WORKSPACE, 'index', PROJECTION_KEY)?.value);
+    const projection = isProjection(value) ? value : undefined;
+    projectionCache.set(projectId, projection ?? null);
+    return projection;
+}
+/** Publish a successful graph generation as the new canonical freshness projection. */
+export function publishFreshProjectGraphProjection(args) {
+    const projection = {
+        schemaVersion: 1,
+        state: 'fresh',
+        generatedAt: args.generatedAt,
+        changedSourceCount: 0,
+    };
+    withDatabase(args.projectId, (database) => {
+        database.putRecord({
+            projectId: args.projectId,
+            workspaceId: PROJECTION_WORKSPACE,
+            kind: 'index',
+            key: PROJECTION_KEY,
+            sourceDigest: args.generation,
+            value: projection,
+        });
+    });
+    projectionCache.set(args.projectId, projection);
+}
+/** Explicitly invalidate freshness without retaining an old value as a fresh fallback. */
+export function invalidateProjectGraphFreshnessProjection(args) {
+    const changedSourceCount = args.changedSourceCount ?? 0;
+    if (!Number.isSafeInteger(changedSourceCount) || changedSourceCount < 0) {
+        throw new Error('[Planu] changedSourceCount must be a non-negative safe integer');
+    }
+    const projection = {
+        schemaVersion: 1,
+        state: 'invalidated',
+        reason: args.reason ?? 'source_changed',
+        changedSourceCount,
+    };
+    withDatabase(args.projectId, (database) => {
+        database.putRecord({
+            projectId: args.projectId,
+            workspaceId: PROJECTION_WORKSPACE,
+            kind: 'index',
+            key: PROJECTION_KEY,
+            value: projection,
+        });
+    });
+    projectionCache.set(args.projectId, projection);
+}
+//# sourceMappingURL=freshness-projection.js.map

package/dist/engine/project-graph/index.d.ts

@@ -2,5 +2,6 @@ export { buildProjectKnowledgeGraph } from './builder.js';
 export { queryProjectGraphSlice, formatProjectGraphContext, getProjectGraphFreshnessHint, } from './query.js';
 export { redactGraphText } from './redaction.js';
 export { createNativeProjectGraphRuntime } from './native.js';
+export { invalidateProjectGraphFreshnessProjection, publishFreshProjectGraphProjection, readProjectGraphFreshnessProjection, } from './freshness-projection.js';
 export { getProjectGraphFreshness, loadProjectGraphPolicy, projectGraphPath, projectGraphCachePath, } from './cache.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/engine/project-graph/index.js

@@ -2,5 +2,6 @@ export { buildProjectKnowledgeGraph } from './builder.js';
 export { queryProjectGraphSlice, formatProjectGraphContext, getProjectGraphFreshnessHint, } from './query.js';
 export { redactGraphText } from './redaction.js';
 export { createNativeProjectGraphRuntime } from './native.js';
+export { invalidateProjectGraphFreshnessProjection, publishFreshProjectGraphProjection, readProjectGraphFreshnessProjection, } from './freshness-projection.js';
 export { getProjectGraphFreshness, loadProjectGraphPolicy, projectGraphPath, projectGraphCachePath, } from './cache.js';
 //# sourceMappingURL=index.js.map

package/dist/engine/project-graph/query.js

@@ -1,6 +1,7 @@
 import { hashProjectPath } from '../../storage/base-store.js';
 import { buildProjectKnowledgeGraph } from './builder.js';
 import { getProjectGraphFreshness, loadProjectGraphPolicy, readProjectGraph } from './cache.js';
+import { readProjectGraphFreshnessProjection } from './freshness-projection.js';
 import { createNativeProjectGraphRuntime } from './native.js';
 import { escapeInert, redactGraphText } from './redaction.js';
 function sanitizeLabel(label, policy) {
@@ -168,32 +169,21 @@ export async function getProjectGraphFreshnessHint(args) {
     if (!policy.enabled) {
         return undefined;
     }
-    let freshness = await getProjectGraphFreshness({
-        projectId,
-        projectPath: args.projectPath,
-        policy,
-    });
-    if (!freshness.exists ||
-        freshness.reason === 'source_changed' ||
-        freshness.reason === 'corrupt') {
-        try {
-            await buildProjectKnowledgeGraph({ projectId, projectPath: args.projectPath, policy });
-            freshness = await getProjectGraphFreshness({
-                projectId,
-                projectPath: args.projectPath,
-                policy,
-            });
-        }
-        catch {
-            // status must stay non-blocking; fall back to the stale hint below.
-        }
-    }
-    if (!freshness.stale) {
+    const projection = readProjectGraphFreshnessProjection(projectId);
+    if (projection === undefined) {
         return undefined;
     }
-    const suffix = freshness.changedSources.length > 0
-        ? `; ${String(freshness.changedSources.length)} changed source(s)`
-        : '';
-    return `project graph ${freshness.reason}${suffix}`;
+    if (projection.state === 'invalidated') {
+        const suffix = projection.changedSourceCount > 0
+            ? `; ${String(projection.changedSourceCount)} changed source(s)`
+            : '';
+        return `project graph ${projection.reason ?? 'source_changed'}${suffix}`;
+    }
+    const generatedAtMs = Date.parse(projection.generatedAt ?? '');
+    const ageMinutes = (Date.now() - generatedAtMs) / 60_000;
+    if (!Number.isFinite(ageMinutes) || ageMinutes > policy.freshness.staleAfterMinutes) {
+        return 'project graph expired';
+    }
+    return undefined;
 }
 //# sourceMappingURL=query.js.map

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

@@ -1,6 +1,5 @@
+import { technologyValue } from './technology-registry.js';
 // @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.
 // engine/project-health-checker.ts — SPEC-180 + SPEC-192 + SPEC-177: Project health check with convention scanning
 import { execSync } from 'node:child_process';
 import { readFile, access } from 'node:fs/promises';
@@ -25,8 +24,8 @@ function daysSince(iso) {
 }
 // ── helpers: serverless detection (SPEC-177) ──────────────────────────────
 const SERVERLESS_PLATFORM_KEYWORDS = [
-    'vercel',
-    'netlify',
+    technologyValue('technology-vercel-9d3508'),
+    technologyValue('technology-netlify-58465a'),
     'lambda',
     'cloudflare-workers',
     'deno-deploy',