@planu/cli 4.13.0 → 4.14.1

package/dist/engine/core-bridge.js

@@ -1,59 +1,28 @@
 import { createRequire } from 'node:module';
-import * as nodeFs from 'node:fs';
-import { existsSync, readFileSync, statSync, readdirSync } from 'node:fs';
-import { join, extname, basename, dirname, sep } from 'node:path';
+import { isMainThread } from 'node:worker_threads';
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { join, extname, basename } from 'node:path';
 import { createHash, createHmac } from 'node:crypto';
 import { tsExtractTsRelations, tsQueryAffectedNodes, tsQueryShortestPath, resolveProjectGraphLimits, tsScanProjectGraphSources, tsSelectCompactGraphSlice, } from './core-bridge-project-graph.js';
+import { PLANU_VERSION } from '../config/version.js';
+import { negotiateNativeRuntime, inspectNativeArtifact, NATIVE_CAPABILITY_ABI, NATIVE_NODE_API_ABI, NATIVE_PROTOCOL_ABI, RUNTIME_STORAGE_SCHEMA, } from './native-runtime-handshake.js';
+import { createMacOSKeychainNativePort } from './macos-keychain-native-port.js';
+import { NATIVE_CAPABILITY_POLICIES } from './native-capability-policy.js';
+import { detectMusl } from './native-platform.js';
+import { findDuplicateBlocks } from './core-bridge-duplicate-blocks.js';
+import { appendGapEntry, verifyGapsChain } from './core-bridge-gaps.js';
+import { reportClassifiedDegradation } from '../errors/classified-degradation.js';
+export { negotiateNativeRuntime, NATIVE_CAPABILITY_ABI, NATIVE_NODE_API_ABI, NATIVE_PROTOCOL_ABI, RUNTIME_STORAGE_SCHEMA, };
 const require = createRequire(import.meta.url);
-function detectMusl() {
-    if (process.platform !== 'linux') {
-        return false;
-    }
-    // Layered detection — any positive signal wins. Order is cheapest first.
-    // 1) Distro marker (Alpine and other musl distros) — covers distroless/scratch
-    //    images where /usr/bin/ldd is absent.
-    try {
-        if (existsSync('/etc/alpine-release')) {
-            return true;
-        }
+const reportedDegradations = new Set();
+const FALLBACK_ERROR = new Error('Native fallback operation degraded');
+function reportOnce(code, report) {
+    if (!reportedDegradations.has(code)) {
+        reportedDegradations.add(code);
+        report();
     }
-    catch {
-        /* ignore */
-    }
-    // 2) Node header report (Node 18+) — reports the libc family.
-    try {
-        const reportApi = process.report;
-        if (reportApi) {
-            const report = reportApi.getReport();
-            if (typeof report === 'string' && /musl/i.test(report)) {
-                return true;
-            }
-        }
-    }
-    catch {
-        /* ignore */
-    }
-    // 3) /usr/bin/ldd shell script (musl-utils on full Alpine).
-    try {
-        if (existsSync('/usr/bin/ldd')) {
-            const ldd = readFileSync('/usr/bin/ldd', 'utf8');
-            return /musl/i.test(ldd);
-        }
-    }
-    catch {
-        /* ignore */
-    }
-    // 4) ld-musl-* dynamic linker present in /lib (final fallback for distroless).
-    try {
-        const libEntries = readdirSync('/lib');
-        if (libEntries.some((e) => e.startsWith('ld-musl-'))) {
-            return true;
-        }
-    }
-    catch {
-        /* ignore */
-    }
-    return false;
+}
+class InvalidFallbackPatternError extends Error {
 }
 function getPlatformInfo() {
     return {
@@ -90,6 +59,9 @@ function platformPackageName(info) {
     }
     return null;
 }
+export function currentNativePackageName() {
+    return platformPackageName(getPlatformInfo());
+}
 function localBinaryName(info) {
     const { platform, arch, libc } = info;
     if (platform === 'linux') {
@@ -101,6 +73,10 @@ function localBinaryName(info) {
     }
     return `planu-core.${platform}-${arch}.node`;
 }
+// Native loader --------------------------------------------------------------
+function nativeTarget(info) {
+    return [info.platform, info.arch, info.libc].filter(Boolean).join('-');
+}
 let nativeModule = null;
 let loadDiagnostic = { attempted: [], errors: [] };
 let loaded = false;
@@ -114,79 +90,146 @@ function loadNative() {
         return nativeModule;
     }
     loaded = true;
+    const rejectedOverrides = ['PLANU_NATIVE_PATH', 'NAPI_RS_NATIVE_LIBRARY_PATH'].filter((name) => process.env[name] !== undefined);
+    if (rejectedOverrides.length > 0) {
+        loadDiagnostic = {
+            attempted: [],
+            errors: ['Untrusted native path overrides are forbidden'],
+            rejectedOverrides,
+        };
+        return null;
+    }
     const info = getPlatformInfo();
     const attempts = [];
     const errors = [];
-    const tryRequire = (id) => {
-        attempts.push(id);
+    const target = nativeTarget(info);
+    const tryRequire = (originLabel, id, artifactPath) => {
+        attempts.push(originLabel);
         try {
-            return require(id);
-        }
-        catch (err) {
-            errors.push(`${id}: ${err.message.split('\n')[0]}`);
+            const resolvedPath = artifactPath ?? require.resolve(id);
+            const { artifactSha256, manifest } = inspectNativeArtifact(resolvedPath);
+            if (!manifest) {
+                errors.push(`${originLabel}: native artifact manifest is missing, unsafe or invalid`);
+                return null;
+            }
+            const candidate = require(resolvedPath);
+            let handshake = null;
+            try {
+                handshake = candidate.planuRuntimeHandshake?.() ?? null;
+            }
+            catch (error) {
+                void error;
+                /* reliability-optional: NATIVE_HANDSHAKE_FAILED */
+                reportOnce('NATIVE_HANDSHAKE_FAILED', () => {
+                    reportClassifiedDegradation('NATIVE_HANDSHAKE_FAILED', FALLBACK_ERROR);
+                });
+                errors.push(`${originLabel}: native handshake failed`);
+                return null;
+            }
+            const compatibility = negotiateNativeRuntime(handshake, manifest, {
+                cliVersion: PLANU_VERSION,
+                target,
+                artifactSha256,
+            });
+            if (!compatibility.compatible) {
+                errors.push(`${originLabel}: incompatible native runtime`);
+                loadDiagnostic = { attempted: attempts, errors, compatibility };
+                return null;
+            }
+            loadDiagnostic = { attempted: attempts, errors, compatibility };
+            loadDiagnostic.artifactSha256 = artifactSha256;
+            return candidate;
+        }
+        catch (error) {
+            void error;
+            /* reliability-optional: NATIVE_ARTIFACT_LOAD_FAILED */
+            reportOnce('NATIVE_ARTIFACT_LOAD_FAILED', () => {
+                reportClassifiedDegradation('NATIVE_ARTIFACT_LOAD_FAILED', FALLBACK_ERROR);
+            });
+            errors.push(`${originLabel}: native artifact load failed`);
             return null;
         }
     };
-    // 1) Honour an explicit override.
-    const override = process.env.PLANU_NATIVE_PATH;
-    if (override) {
-        const mod = tryRequire(override);
-        if (mod) {
-            loadDiagnostic = { attempted: attempts, errors, loaded: override };
-            nativeModule = mod;
-            return mod;
-        }
-    }
-    // 2) Local platform-tagged binary in the same dir (dev builds + bundled tarball).
+    // 1) Local platform-tagged binary in the same dir (dev builds + bundled tarball).
     const localName = localBinaryName(info);
     const localPath = join(import.meta.dirname, localName);
     if (existsSync(localPath)) {
-        const mod = tryRequire(localPath);
+        const mod = tryRequire(`local:${localName}`, localPath, localPath);
         if (mod) {
-            loadDiagnostic = { attempted: attempts, errors, loaded: localPath };
-            nativeModule = mod;
-            return mod;
-        }
-    }
-    // 3) Legacy untagged binary shipped in older tarballs.
-    const legacyPath = join(import.meta.dirname, 'planu-core.node');
-    if (existsSync(legacyPath)) {
-        const mod = tryRequire(legacyPath);
-        if (mod) {
-            loadDiagnostic = { attempted: attempts, errors, loaded: legacyPath };
+            loadDiagnostic = {
+                ...loadDiagnostic,
+                attempted: attempts,
+                errors,
+                loaded: localName,
+                origin: 'local',
+            };
             nativeModule = mod;
+            console.error(`[Planu-RS] Verified native core loaded (${localName}).`);
             return mod;
         }
     }
-    // 4) Optional dependency subpackage installed by npm.
+    // 2) Optional dependency subpackage installed by npm. Untagged legacy
+    // binaries are intentionally rejected: they cannot prove target/ABI/schema.
     const pkg = platformPackageName(info);
     if (pkg) {
-        const mod = tryRequire(pkg);
+        const mod = tryRequire(`package:${pkg}`, pkg);
         if (mod) {
-            loadDiagnostic = { attempted: attempts, errors, loaded: pkg };
+            loadDiagnostic = {
+                ...loadDiagnostic,
+                attempted: attempts,
+                errors,
+                loaded: pkg,
+                origin: 'package',
+            };
             nativeModule = mod;
+            console.error(`[Planu-RS] Verified native core loaded (${pkg}).`);
             return mod;
         }
     }
     loadDiagnostic = { attempted: attempts, errors };
     return null;
 }
-const native = loadNative();
-if (native) {
-    console.error(`[Planu-RS] Native core loaded (${loadDiagnostic.loaded}).`);
-}
-else if (process.env.PLANU_DEBUG_NATIVE === '1') {
-    console.warn(`[Planu-RS] Native core unavailable on ${process.platform}-${process.arch}. ` +
-        `Falling back to TypeScript implementation. Attempts: ${loadDiagnostic.attempted.join(', ')}`);
+function refreshNativeCapabilityDiagnostic() {
+    const rejectedOverrides = ['PLANU_NATIVE_PATH', 'NAPI_RS_NATIVE_LIBRARY_PATH'].filter((name) => process.env[name] !== undefined);
+    if (!loaded && rejectedOverrides.length > 0) {
+        loadDiagnostic = {
+            attempted: [],
+            errors: ['Untrusted native path overrides are forbidden'],
+            rejectedOverrides,
+        };
+    }
+    const runtimeCapabilities = loadDiagnostic.compatibility?.compatible === true
+        ? loadDiagnostic.compatibility.handshake?.capabilities
+        : undefined;
+    loadDiagnostic.capabilities = NATIVE_CAPABILITY_POLICIES.map((policy) => ({
+        capability: policy.capability,
+        state: runtimeCapabilities?.includes(policy.capability)
+            ? 'available'
+            : policy.fallback === 'fail-closed'
+                ? 'unavailable'
+                : 'degraded',
+        fallback: policy.fallback,
+    }));
+    loadDiagnostic.executionScope = 'isolated-worker-and-keychain-port';
+}
+refreshNativeCapabilityDiagnostic();
+// Synchronous bindings are deliberately confined to the durable native worker.
+// Main-thread callers use parity-tested TypeScript paths and can observe that
+// degradation through nativeLoadDiagnostic()/`planu inspect`.
+const getNative = () => process.env.DISABLE_NATIVE_CORE === '1' || isMainThread ? null : loadNative();
+/** Main-thread port for async Keychain calls; never accepts override or unverified native code. */
+export function requireMacOSKeychainNativePort() {
+    const keychainNative = loadNative();
+    refreshNativeCapabilityDiagnostic();
+    return createMacOSKeychainNativePort(process.platform, process.env.PLANU_NATIVE_PATH !== undefined ||
+        process.env.NAPI_RS_NATIVE_LIBRARY_PATH !== undefined, process.env.DISABLE_NATIVE_CORE === '1', keychainNative, loadDiagnostic.origin, loadDiagnostic.compatibility?.handshake?.capabilities);
 }
-const getNative = () => process.env.DISABLE_NATIVE_CORE === '1' ? null : nativeModule;
 // TypeScript fallbacks -------------------------------------------------------
 // These keep the surface area working when the native binary is unavailable
 // (unsupported platform, sandboxed install, dev environment without build).
 const PROJECT_ID_RE = /^[a-f0-9]{16,64}$/;
 const SPEC_ANNOTATION_RE = /@spec\s+(SPEC-\d+)(?:\s+AC:([\d,]+))?(?:\s+(.*))?/;
 const SCANNABLE_EXTS = new Set(['.ts', '.js', '.tsx', '.jsx', '.rs', '.py', '.go']);
-const MAX_TS_WATCHERS = 128;
 const IGNORED_DIRS = new Set([
     'node_modules',
     '.git',
@@ -201,7 +244,12 @@ function* walkFiles(root) {
     try {
         entries = readdirSync(root, { withFileTypes: true });
     }
-    catch {
+    catch (error) {
+        void error;
+        /* reliability-optional: CORE_BRIDGE_DIRECTORY_READ_FAILED */
+        reportOnce('CORE_BRIDGE_DIRECTORY_READ_FAILED', () => {
+            reportClassifiedDegradation('CORE_BRIDGE_DIRECTORY_READ_FAILED', FALLBACK_ERROR);
+        });
         return;
     }
     for (const entry of entries) {
@@ -226,8 +274,12 @@ function tsScanAndHashFiles(root) {
             const content = readFileSync(path);
             out.push({ path, hash: createHash('sha256').update(content).digest('hex') });
         }
-        catch {
-            /* skip unreadable */
+        catch (error) {
+            void error;
+            /* reliability-optional: CORE_BRIDGE_FILE_HASH_FAILED */
+            reportOnce('CORE_BRIDGE_FILE_HASH_FAILED', () => {
+                reportClassifiedDegradation('CORE_BRIDGE_FILE_HASH_FAILED', FALLBACK_ERROR);
+            });
         }
     }
     return out;
@@ -239,8 +291,12 @@ function tsScanProjectMetadata(root) {
             const stat = statSync(path);
             out.push({ path, mtime: stat.mtimeMs, size: stat.size });
         }
-        catch {
-            /* skip */
+        catch (error) {
+            void error;
+            /* reliability-optional: CORE_BRIDGE_METADATA_READ_FAILED */
+            reportOnce('CORE_BRIDGE_METADATA_READ_FAILED', () => {
+                reportClassifiedDegradation('CORE_BRIDGE_METADATA_READ_FAILED', FALLBACK_ERROR);
+            });
         }
     }
     return out;
@@ -280,8 +336,12 @@ function tsScanSpecAnnotations(root) {
                 });
             });
         }
-        catch {
-            /* skip */
+        catch (error) {
+            void error;
+            /* reliability-optional: CORE_BRIDGE_ANNOTATION_READ_FAILED */
+            reportOnce('CORE_BRIDGE_ANNOTATION_READ_FAILED', () => {
+                reportClassifiedDegradation('CORE_BRIDGE_ANNOTATION_READ_FAILED', FALLBACK_ERROR);
+            });
         }
     }
     return out;
@@ -295,8 +355,12 @@ function tsCheckAcCoverage(filePaths, keywords) {
         try {
             combined += readFileSync(p, 'utf8').toLowerCase() + '\n';
         }
-        catch {
-            /* skip */
+        catch (error) {
+            void error;
+            /* reliability-optional: CORE_BRIDGE_COVERAGE_READ_FAILED */
+            reportOnce('CORE_BRIDGE_COVERAGE_READ_FAILED', () => {
+                reportClassifiedDegradation('CORE_BRIDGE_COVERAGE_READ_FAILED', FALLBACK_ERROR);
+            });
         }
     }
     return keywords.filter((kw) => combined.includes(kw.toLowerCase()));
@@ -327,7 +391,12 @@ function tsReadFiles(paths) {
         try {
             return { path: p, content: readFileSync(p, 'utf8') };
         }
-        catch {
+        catch (error) {
+            void error;
+            /* reliability-optional: CORE_BRIDGE_FILE_READ_FAILED */
+            reportOnce('CORE_BRIDGE_FILE_READ_FAILED', () => {
+                reportClassifiedDegradation('CORE_BRIDGE_FILE_READ_FAILED', FALLBACK_ERROR);
+            });
             return null;
         }
     })
@@ -376,19 +445,15 @@ function tsFindPatterns(root, patterns, extensions, exclude) {
     if (patterns.length === 0) {
         return [];
     }
-    const regexes = patterns
-        .map((p) => {
+    const regexes = patterns.map((p) => {
         try {
             return { p, re: new RegExp(p) };
         }
-        catch {
-            return null;
+        catch (error) {
+            void error;
+            throw new InvalidFallbackPatternError('[Planu] Invalid fallback search pattern');
         }
-    })
-        .filter((x) => x !== null);
-    if (regexes.length === 0) {
-        return [];
-    }
+    });
     const extSet = new Set(extensions.map((e) => (e.startsWith('.') ? e : `.${e}`)));
     const excludeSet = new Set(exclude);
     const matches = [];
@@ -403,7 +468,12 @@ function tsFindPatterns(root, patterns, extensions, exclude) {
         try {
             lines = readFileSync(path, 'utf8').split('\n');
         }
-        catch {
+        catch (error) {
+            void error;
+            /* reliability-optional: CORE_BRIDGE_PATTERN_FILE_READ_FAILED */
+            reportOnce('CORE_BRIDGE_PATTERN_FILE_READ_FAILED', () => {
+                reportClassifiedDegradation('CORE_BRIDGE_PATTERN_FILE_READ_FAILED', FALLBACK_ERROR);
+            });
             continue;
         }
         lines.forEach((line, idx) => {
@@ -473,7 +543,12 @@ export function fastDetectDriftParallel(rootPath, keywords) {
         try {
             content = readFileSync(file, 'utf8').toLowerCase();
         }
-        catch {
+        catch (error) {
+            void error;
+            /* reliability-optional: CORE_BRIDGE_DRIFT_READ_FAILED */
+            reportOnce('CORE_BRIDGE_DRIFT_READ_FAILED', () => {
+                reportClassifiedDegradation('CORE_BRIDGE_DRIFT_READ_FAILED', FALLBACK_ERROR);
+            });
             continue;
         }
         keywords.forEach((kw, i) => {
@@ -490,65 +565,7 @@ export function fastFindDuplicateBlocks(paths, minLines) {
     if (n) {
         return n.fastFindDuplicateBlocks(paths, minLines);
     }
-    // TS fallback: hash sliding windows of normalized lines.
-    if (paths.length === 0 || minLines <= 0) {
-        return [];
-    }
-    const map = new Map();
-    for (const path of paths) {
-        let raw;
-        try {
-            raw = readFileSync(path, 'utf8')
-                .replace(/\/\*[\s\S]*?\*\//g, '')
-                .split('\n');
-        }
-        catch {
-            continue;
-        }
-        const norm = [];
-        raw.forEach((line, i) => {
-            const stripped = line
-                .replace(/\/\/.*$/, '')
-                .trim()
-                .toLowerCase();
-            if (stripped) {
-                norm.push({ text: stripped, idx: i + 1 });
-            }
-        });
-        if (norm.length < minLines) {
-            continue;
-        }
-        for (let i = 0; i <= norm.length - minLines; i++) {
-            const window = norm.slice(i, i + minLines);
-            const lines = window.map((w) => w.text);
-            const hash = createHash('sha256').update(lines.join('\n')).digest('hex').slice(0, 16);
-            const first = window[0];
-            const last = window[window.length - 1];
-            if (!first || !last) {
-                continue;
-            }
-            const loc = {
-                path,
-                startLine: first.idx,
-                endLine: last.idx,
-                lines,
-            };
-            const arr = map.get(hash);
-            if (arr) {
-                arr.push(loc);
-            }
-            else {
-                map.set(hash, [loc]);
-            }
-        }
-    }
-    const out = [];
-    for (const [hash, locations] of map) {
-        if (locations.length >= 2) {
-            out.push({ hash, locations });
-        }
-    }
-    return out;
+    return findDuplicateBlocks(paths, minLines);
 }
 export function fastFindPatterns(rootPath, patterns, extensions = [], exclude = []) {
     const n = getNative();
@@ -582,79 +599,14 @@ export function fastVerifyGapsChain(filePath) {
     if (n) {
         return n.fastVerifyGapsChain(filePath);
     }
-    // TS fallback: linear walk validating prevSha + sha pair.
-    if (!existsSync(filePath)) {
-        return { valid: true, totalEntries: 0, brokenAt: null };
-    }
-    let prevSha = '';
-    let count = 0;
-    let lines;
-    try {
-        lines = readFileSync(filePath, 'utf8').split('\n');
-    }
-    catch {
-        return { valid: false, totalEntries: 0, brokenAt: 0 };
-    }
-    for (let i = 0; i < lines.length; i++) {
-        const rawLine = lines[i];
-        if (!rawLine) {
-            continue;
-        }
-        const line = rawLine.trim();
-        if (!line) {
-            continue;
-        }
-        let entry;
-        try {
-            entry = JSON.parse(line);
-        }
-        catch {
-            return { valid: false, totalEntries: count, brokenAt: i };
-        }
-        const actualPrev = typeof entry.prevSha === 'string' ? entry.prevSha : '';
-        if (actualPrev !== prevSha) {
-            return { valid: false, totalEntries: count, brokenAt: i };
-        }
-        const sha = typeof entry.sha === 'string' ? entry.sha : '';
-        const { sha: _, ...rest } = entry;
-        void _;
-        const expected = createHash('sha256').update(JSON.stringify(rest)).digest('hex');
-        if (sha !== expected) {
-            return { valid: false, totalEntries: count, brokenAt: i };
-        }
-        prevSha = sha;
-        count++;
-    }
-    return { valid: true, totalEntries: count, brokenAt: null };
+    return verifyGapsChain(filePath);
 }
 export function fastAppendGapEntry(filePath, id, timestamp, specId, description, severity, affectedSpecs) {
     const n = getNative();
     if (n) {
         return n.fastAppendGapEntry(filePath, id, timestamp, specId, description, severity, affectedSpecs);
     }
-    // TS fallback: read prev sha, append new entry.
-    const fs = nodeFs;
-    let prevSha = '';
-    if (existsSync(filePath)) {
-        const lines = readFileSync(filePath, 'utf8').trim().split('\n');
-        const last = lines[lines.length - 1];
-        if (last) {
-            try {
-                const v = JSON.parse(last);
-                prevSha = v.sha ?? '';
-            }
-            catch {
-                /* ignore */
-            }
-        }
-    }
-    else {
-        fs.mkdirSync(dirname(filePath).split(sep).join(sep), { recursive: true });
-    }
-    const entry = { id, timestamp, specId, description, severity, affectedSpecs, prevSha };
-    const sha = createHash('sha256').update(JSON.stringify(entry)).digest('hex');
-    fs.appendFileSync(filePath, JSON.stringify({ ...entry, sha }) + '\n');
-    return sha;
+    return appendGapEntry(filePath, id, timestamp, specId, description, severity, affectedSpecs);
 }
 export function fastCosineSimilarity(v1, v2) {
     const n = getNative();
@@ -726,48 +678,9 @@ export function fastSelectCompactGraphSlice(seeds, nodes, edges, policy, overrid
     }
     return tsSelectCompactGraphSlice(seeds, nodes, edges, limits);
 }
-export function startNativeWatcher(rootPath, callback) {
-    const n = getNative();
-    if (n && typeof n.startProjectWatcher === 'function') {
-        n.startProjectWatcher(rootPath, callback);
-        return;
-    }
-    // TS fallback: watch each existing directory. Node's `recursive: true` is not
-    // portable across all OS/libc combinations, and unsupported platforms must not
-    // crash the MCP server when the native watcher is unavailable.
-    const fs = nodeFs;
-    let watcherCount = 0;
-    const watchDir = (absDir, relDir) => {
-        if (watcherCount >= MAX_TS_WATCHERS) {
-            return;
-        }
-        const watcher = fs.watch(absDir, {}, (event, filename) => {
-            callback(null, `${event}:${join(relDir, filename?.toString() ?? '')}`);
-        });
-        watcherCount++;
-        watcher.on('error', (err) => {
-            callback(err, '');
-        });
-    };
-    const walkDirs = (absDir, relDir) => {
-        watchDir(absDir, relDir);
-        let entries;
-        try {
-            entries = readdirSync(absDir, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            if (!entry.isDirectory() || IGNORED_DIRS.has(entry.name)) {
-                continue;
-            }
-            const childRel = join(relDir, entry.name);
-            walkDirs(join(absDir, entry.name), childRel);
-        }
-    };
-    walkDirs(rootPath, '');
-}
-export const isNativeActive = () => nativeModule !== null && process.env.DISABLE_NATIVE_CORE !== '1';
-export const nativeLoadDiagnostic = () => loadDiagnostic;
+export const isNativeActive = () => getNative() !== null;
+export const nativeLoadDiagnostic = () => {
+    refreshNativeCapabilityDiagnostic();
+    return loadDiagnostic;
+};
 //# sourceMappingURL=core-bridge.js.map

package/dist/engine/cost-tracking/ledger.js

@@ -1,7 +1,7 @@
 // engine/cost-tracking/ledger.ts — Per-operation cost ledger (SPEC-475)
 import { appendFile, readFile, mkdir } from 'node:fs/promises';
 import { join, dirname } from 'node:path';
-import { hashProjectPath } from '../../storage/base-store.js';
+import { hashProjectPath, projectDataDir } from '../../storage/base-store.js';
 // ---------------------------------------------------------------------------
 // Model pricing (USD per token)
 // ---------------------------------------------------------------------------
@@ -14,12 +14,9 @@ const PRICING = {
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
-function getDataDir() {
-    return join(process.cwd(), 'data');
-}
 function getLedgerPath(projectPath) {
     const projectId = hashProjectPath(projectPath);
-    return join(getDataDir(), projectId, 'cost-ledger.jsonl');
+    return join(projectDataDir(projectId), 'cost-ledger.jsonl');
 }
 function isPeriodMatch(ts, period) {
     if (period === 'all') {

package/dist/engine/coverage-gap-analyzer.js

@@ -1,3 +1,4 @@
+import { technologyValue } from './technology-registry.js';
 // engine/coverage-gap-analyzer.ts — SPEC-323
 // Maps spec acceptance criteria to existing test files and surfaces untested ACs.
 import { readFile } from 'node:fs/promises';
@@ -14,7 +15,15 @@ const RISK_DOMAIN_MAP = [
         level: 'high',
     },
     {
-        keywords: ['payment', 'billing', 'charge', 'invoice', 'stripe', 'refund', 'subscription'],
+        keywords: [
+            'payment',
+            'billing',
+            'charge',
+            'invoice',
+            technologyValue('technology-stripe-2bed20'),
+            'refund',
+            'subscription',
+        ],
         domain: 'payment',
         level: 'high',
     },

package/dist/engine/crash-shield/detectors/framework-detector.d.ts

@@ -1,3 +1,5 @@
 import type { CrashDetector } from '../../../types/safety-scanner.js';
+import type { CrashShieldFrameworkRule } from '../../../types/crash-shield-framework-rules.js';
+export declare function parseFrameworkRules(value: unknown): CrashShieldFrameworkRule[];
 export declare const frameworkDetector: CrashDetector;
 //# sourceMappingURL=framework-detector.d.ts.map