@planu/cli 5.1.1 → 5.2.0

package/CHANGELOG.md

@@ -1,3 +1,30 @@
+## [5.2.0] - 2026-08-04
+
+### Features
+- feat(autopilot): refresh semantic index fire-and-forget on spec:created (SPEC-1345)
+- feat(i18n): auto-detect and persist user locale (SPEC-1347)
+- feat(spec-language): offer translation instead of rejecting non-English specs (SPEC-1342)
+- feat(semantic-search): persist index with incremental updates (SPEC-1345)
+
+### Bug Fixes
+- fix(storage): classify non-ENOENT failures in sync global-config read
+- fix(status): prefer implementing work over review work in compact status (SPEC-1228)
+- fix(challenge): stop handler names activating event scenarios across clauses (SPEC-1262)
+
+### Performance
+- perf(core-bridge): route main-thread hot paths through native dispatch (SPEC-1344)
+- perf(init-project): parallelize independent pipeline stages (SPEC-1343)
+
+### Chores
+- chore(website): regenerate deterministic product proof
+- chore(planu): close lifecycle for 8 specs done + SPEC-1368 bug spec + session checkpoint
+- chore(planu): file SPEC-1367 dogfood bug spec (validate false-negative on test-only criteria)
+- chore(planu): file SPEC-1366 dogfood bug spec and refresh session context
+- chore(doctor): remove commercial remnants and deepen diagnostics (SPEC-1346)
+- chore(planu): file SPEC-1365 dogfood bug spec (teamSuggestion recommends unregistered tools)
+- chore(planu): session checkpoint after v5.1.1 release
+
+
 ## [5.1.1] - 2026-08-04
 
 ### Bug Fixes

package/dist/cli/commands/doctor.d.ts

@@ -10,7 +10,29 @@ interface ToolCheck {
     paths: string[];
     format: 'standard' | 'zed';
 }
+interface DeepCheckResult {
+    name: string;
+    /** 'warn' is a degraded-but-working state (e.g. TS fallback active); 'fail' blocks usage. */
+    status: 'ok' | 'warn' | 'fail';
+    detail: string;
+}
 declare function checkTool(check: ToolCheck): ToolReport[];
+/** Check (1): the running Node version satisfies the `engines.node` field in package.json. */
+declare function checkNodeVersion(): DeepCheckResult;
+/**
+ * Check (2): the native Rust module loads, with a remediation hint when it doesn't.
+ * Missing native is a supported degraded mode (TypeScript fallback stays correct), so
+ * this reports 'warn' rather than 'fail' — it never blocks `planu doctor`'s exit code.
+ */
+declare function checkNativeModule(): DeepCheckResult;
+/** Check (3): PLANU_HOME / the resolved data directory is writable. */
+declare function checkDataDirWritable(): DeepCheckResult;
+/** Check (4): the runtime SQLite database opens without corruption. */
+declare function checkRuntimeDatabase(): DeepCheckResult;
+/** Check (5): the active locale resolves to a real translated message. */
+declare function checkLocaleResolution(): DeepCheckResult;
+declare function runDeepChecks(): DeepCheckResult[];
+export { checkNodeVersion, checkNativeModule, checkDataDirWritable, checkRuntimeDatabase, checkLocaleResolution, runDeepChecks, };
 export { checkTool };
 export declare const doctorCommand: CliCommand;
 //# sourceMappingURL=doctor.d.ts.map

package/dist/cli/commands/doctor.js

@@ -1,9 +1,16 @@
 // cli/commands/doctor.ts — planu doctor: verify MCP installations health (SPEC-236)
-import { existsSync } from 'node:fs';
+// Deep diagnostics (Node version, native engine, storage writability, runtime DB,
+// locale resolution) added by SPEC-1346 / SPEC-1344.
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { bold, cyan, green, yellow, red, dim } from '../colors.js';
 import { readJsonFile, hasPlanuEntry } from './install.js';
+import { resolveStorageLayout } from '../../storage/storage-layout.js';
+import { RuntimeDatabase } from '../../storage/runtime-db.js';
+import { probeNativeLoad } from '../../engine/core-bridge.js';
+import { getLocale, t } from '../../i18n/index.js';
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
@@ -86,6 +93,166 @@ function checkTool(check) {
     }
     return reports;
 }
+// ---------------------------------------------------------------------------
+// Deep diagnostics (SPEC-1346 / SPEC-1344)
+// ---------------------------------------------------------------------------
+/** Root of the package, resolved relative to this module so it works from src/ and dist/. */
+const PACKAGE_ROOT = join(dirname(fileURLToPath(import.meta.url)), '../../../package.json');
+function parseVersionTuple(version) {
+    const match = /(\d+)\.(\d+)\.(\d+)/.exec(version);
+    return [Number(match?.[1] ?? 0), Number(match?.[2] ?? 0), Number(match?.[3] ?? 0)];
+}
+function isVersionAtLeast(actual, required) {
+    for (let i = 0; i < 3; i++) {
+        const a = actual[i] ?? 0;
+        const r = required[i] ?? 0;
+        if (a !== r) {
+            return a > r;
+        }
+    }
+    return true;
+}
+/** Check (1): the running Node version satisfies the `engines.node` field in package.json. */
+function checkNodeVersion() {
+    let requiredRange;
+    try {
+        const pkg = JSON.parse(readFileSync(PACKAGE_ROOT, 'utf-8'));
+        requiredRange = pkg.engines?.node ?? '';
+    }
+    catch {
+        return {
+            name: 'Node version',
+            status: 'fail',
+            detail: 'Could not read package.json engines field',
+        };
+    }
+    if (!requiredRange) {
+        return { name: 'Node version', status: 'ok', detail: `Running Node ${process.version}` };
+    }
+    const required = parseVersionTuple(requiredRange);
+    const actual = parseVersionTuple(process.version);
+    if (isVersionAtLeast(actual, required)) {
+        return {
+            name: 'Node version',
+            status: 'ok',
+            detail: `${process.version} satisfies ${requiredRange}`,
+        };
+    }
+    return {
+        name: 'Node version',
+        status: 'fail',
+        detail: `${process.version} does not satisfy required range ${requiredRange}. Upgrade Node to continue.`,
+    };
+}
+/**
+ * Check (2): the native Rust module loads, with a remediation hint when it doesn't.
+ * Missing native is a supported degraded mode (TypeScript fallback stays correct), so
+ * this reports 'warn' rather than 'fail' — it never blocks `planu doctor`'s exit code.
+ */
+function checkNativeModule() {
+    if (process.env.DISABLE_NATIVE_CORE === '1') {
+        return {
+            name: 'Native engine',
+            status: 'ok',
+            detail: 'Disabled via DISABLE_NATIVE_CORE=1 (TypeScript fallback in use)',
+        };
+    }
+    const diagnostic = probeNativeLoad();
+    if (diagnostic.loaded) {
+        return { name: 'Native engine', status: 'ok', detail: `Loaded (${diagnostic.loaded})` };
+    }
+    const reason = diagnostic.errors[0] ?? 'unknown failure';
+    return {
+        name: 'Native engine',
+        status: 'warn',
+        detail: `Failed to load (${reason}). Running on the TypeScript fallback. Reinstall the platform package for your OS/arch to restore native acceleration.`,
+    };
+}
+/** Check (3): PLANU_HOME / the resolved data directory is writable. */
+function checkDataDirWritable() {
+    const layout = resolveStorageLayout();
+    const probePath = join(layout.data, `.doctor-write-probe-${String(process.pid)}`);
+    try {
+        mkdirSync(layout.data, { recursive: true, mode: 0o700 });
+        writeFileSync(probePath, 'ok', { mode: 0o600 });
+        unlinkSync(probePath);
+        return { name: 'Data directory', status: 'ok', detail: `Writable: ${layout.data}` };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            name: 'Data directory',
+            status: 'fail',
+            detail: `Cannot write to ${layout.data} (${message}). Check ownership/permissions on that path or set PLANU_HOME to a writable location.`,
+        };
+    }
+}
+/** Check (4): the runtime SQLite database opens without corruption. */
+function checkRuntimeDatabase() {
+    const layout = resolveStorageLayout();
+    try {
+        const db = new RuntimeDatabase({ path: layout.runtimeDatabase });
+        db.close();
+        return {
+            name: 'Runtime database',
+            status: 'ok',
+            detail: `Opens correctly: ${layout.runtimeDatabase}`,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            name: 'Runtime database',
+            status: 'fail',
+            detail: `Cannot open ${layout.runtimeDatabase} (${message}). Move or delete the corrupted file and retry — Planu recreates it on next use.`,
+        };
+    }
+}
+/** Check (5): the active locale resolves to a real translated message. */
+function checkLocaleResolution() {
+    const locale = getLocale();
+    const sample = t('locale.changed', locale);
+    if (sample === 'locale.changed') {
+        return {
+            name: 'Locale resolution',
+            status: 'fail',
+            detail: `Locale "${locale}" resolved but message bundle failed to load. Reinstall Planu to restore i18n/messages/.`,
+        };
+    }
+    return { name: 'Locale resolution', status: 'ok', detail: `Resolved locale: ${locale}` };
+}
+function runDeepChecks() {
+    return [
+        checkNodeVersion(),
+        checkNativeModule(),
+        checkDataDirWritable(),
+        checkRuntimeDatabase(),
+        checkLocaleResolution(),
+    ];
+}
+function deepCheckIcon(status) {
+    if (status === 'ok') {
+        return green('+');
+    }
+    return status === 'warn' ? yellow('!') : red('x');
+}
+function deepCheckLabel(status) {
+    if (status === 'ok') {
+        return green('OK');
+    }
+    return status === 'warn' ? yellow('DEGRADED') : red('FAIL');
+}
+function printDeepChecks(results) {
+    process.stdout.write(`\n${bold('Deep diagnostics')}\n\n`);
+    for (const result of results) {
+        const icon = deepCheckIcon(result.status);
+        const label = deepCheckLabel(result.status);
+        process.stdout.write(`  [${icon}] ${result.name.padEnd(18)} ${label}\n`);
+        process.stdout.write(`       ${dim(result.detail)}\n`);
+    }
+}
+// Exported for tests
+export { checkNodeVersion, checkNativeModule, checkDataDirWritable, checkRuntimeDatabase, checkLocaleResolution, runDeepChecks, };
 function statusIcon(status) {
     switch (status) {
         case 'ok':
@@ -143,9 +310,16 @@ export const doctorCommand = {
             }
         }
         printReports(allReports);
+        const deepChecks = runDeepChecks();
+        printDeepChecks(deepChecks);
         const installed = allReports.filter((r) => r.status === 'ok').length;
         const invalid = allReports.filter((r) => r.status === 'invalid-config').length;
+        const failedDeepChecks = deepChecks.filter((c) => c.status === 'fail').length;
         process.stdout.write('\n');
+        if (failedDeepChecks > 0) {
+            process.stdout.write(`${red('Warning:')} ${String(failedDeepChecks)} deep diagnostic check(s) failed. See remediation steps above.\n`);
+            process.exitCode = 1;
+        }
         if (invalid > 0) {
             process.stdout.write(`${yellow('Warning:')} ${String(invalid)} config file(s) have invalid JSON. Run ${cyan('planu install')} to fix.\n`);
         }

package/dist/engine/autopilot/bootstrap.js

@@ -99,6 +99,31 @@ function registerPluginInstalledListener() {
         })();
     });
 }
+/**
+ * SPEC-1345 AC4: Fire-and-forget semantic index refresh on spec:created.
+ * Reconciles the persisted TF-IDF index against the current corpus so the next
+ * semantic_search call hits a warm, up-to-date index.
+ */
+function registerSemanticIndexRefreshListener() {
+    onAutopilotEvent('spec:created', (event) => {
+        void (async () => {
+            try {
+                const { getOrCreateBackend } = await import('../../storage/vector-store/backend-factory.js');
+                const { SemanticIndexStore } = await import('../../storage/semantic-index-store.js');
+                const backend = await getOrCreateBackend(event.projectId);
+                const allDocs = await backend.getAll();
+                if (allDocs.length === 0) {
+                    return;
+                }
+                const indexStore = new SemanticIndexStore(event.projectId, 'all');
+                await indexStore.loadOrBuild(allDocs.map((doc) => ({ id: doc.id, content: doc.content })));
+            }
+            catch {
+                /* best-effort — never surface to user */
+            }
+        })();
+    });
+}
 const AUTOPILOT_EVENTS = [
     'spec:created',
     'spec:status:approved',
@@ -133,5 +158,7 @@ export function bootstrapAutopilotHandlers() {
     registerPluginInstalledListener();
     // SPEC-628: Register daily cron for auto_fix_health (moved from update_status cascade)
     registerDailyCronListener();
+    // SPEC-1345 AC4: Register semantic index refresh on spec:created
+    registerSemanticIndexRefreshListener();
 }
 //# sourceMappingURL=bootstrap.js.map

package/dist/engine/core-bridge.d.ts

@@ -31,6 +31,34 @@ export declare function fastExtractTsRelations(rootPath: string, paths: string[]
 export declare function fastQueryAffectedNodes(seed: string, edges: GraphEdgeInputRs[], relationFilter: string[], policy: ProjectGraphLimitsPolicyRs, overrides?: Partial<ResolvedProjectGraphLimitsRs>): AffectedNodeRs[];
 export declare function fastQueryShortestPath(from: string, to: string, edges: GraphEdgeInputRs[], relationFilter: string[], policy: ProjectGraphLimitsPolicyRs, overrides?: Partial<ResolvedProjectGraphLimitsRs>): ShortestPathResultRs;
 export declare function fastSelectCompactGraphSlice(seeds: string[], nodes: GraphNodeInputRs[], edges: GraphEdgeInputRs[], policy: ProjectGraphLimitsPolicyRs, overrides?: Partial<ResolvedProjectGraphLimitsRs>): CompactGraphSliceRs;
+/** Worker-dispatched variant of {@link fastDetectDriftParallel} for main-thread callers. */
+export declare function fastDetectDriftParallelAsync(rootPath: string, keywords: string[]): Promise<{
+    value: DriftResult;
+    degradationNotice?: string;
+}>;
+/** Worker-dispatched variant of {@link fastScanAndHashFiles} for main-thread callers. */
+export declare function fastScanAndHashFilesAsync(rootPath: string): Promise<{
+    value: FileHash[];
+    degradationNotice?: string;
+}>;
+/** Worker-dispatched variant of {@link fastScanProjectMetadata} for main-thread callers. */
+export declare function fastScanProjectMetadataAsync(rootPath: string): Promise<{
+    value: FileMetadata[];
+    degradationNotice?: string;
+}>;
+/** Worker-dispatched variant of {@link fastScanSpecs} for main-thread callers. */
+export declare function fastScanSpecsAsync(rootPath: string): Promise<{
+    value: SpecBriefRs[] | null;
+    degradationNotice?: string;
+}>;
 export declare const isNativeActive: () => boolean;
 export declare const nativeLoadDiagnostic: () => NativeLoadDiagnostic;
+/**
+ * Force a native load attempt regardless of the calling thread and return the
+ * resulting diagnostic. `nativeLoadDiagnostic()` alone only reports load state
+ * that some other main-thread-bypassing caller already triggered (e.g. the
+ * macOS Keychain port); this is the main-thread-safe way to actually probe
+ * native availability, used by `planu doctor`.
+ */
+export declare const probeNativeLoad: () => NativeLoadDiagnostic;
 //# sourceMappingURL=core-bridge.d.ts.map

package/dist/engine/core-bridge.js

@@ -12,6 +12,7 @@ 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';
+import { runNativeWorkerOperation } from './execution/native-worker-runtime.js';
 export { negotiateNativeRuntime, NATIVE_CAPABILITY_ABI, NATIVE_NODE_API_ABI, NATIVE_PROTOCOL_ABI, RUNTIME_STORAGE_SCHEMA, };
 const require = createRequire(import.meta.url);
 const reportedDegradations = new Set();
@@ -678,9 +679,75 @@ export function fastSelectCompactGraphSlice(seeds, nodes, edges, policy, overrid
     }
     return tsSelectCompactGraphSlice(seeds, nodes, edges, limits);
 }
+// Main-thread dispatch strategy (SPEC-1344) -----------------------------------
+// getNative() deliberately returns null on the main thread so long native FFI
+// calls never block the event loop (see comment above getNative()). For hot
+// paths that need acceleration anyway, dispatchViaWorker() moves the call onto
+// the existing native-worker-dispatch.ts runtime (a worker thread, where
+// isMainThread is false and native loads normally). If the worker fails to
+// spawn, times out, or the operation isn't allowlisted, it falls back to the
+// caller-supplied synchronous implementation so behavior never regresses.
+const WORKER_DISPATCH_TIMEOUT_MS = 30_000;
+const DEGRADATION_NOTICE_THRESHOLD_MS = 2_000;
+async function dispatchViaWorker(operation, payload, projectId, syncFallback) {
+    const start = Date.now();
+    if (isMainThread && process.env.DISABLE_NATIVE_CORE !== '1') {
+        try {
+            const value = (await runNativeWorkerOperation({
+                operation,
+                payload,
+                projectId,
+                deadlineAt: start + WORKER_DISPATCH_TIMEOUT_MS,
+            }));
+            return { value };
+        }
+        catch (error) {
+            /* reliability-optional: NATIVE_WORKER_DISPATCH_FAILED — falls through to sync fallback */
+            reportOnce(`NATIVE_WORKER_DISPATCH_FAILED:${operation}`, () => {
+                reportClassifiedDegradation('NATIVE_WORKER_DISPATCH_FAILED', error instanceof Error ? error : FALLBACK_ERROR);
+            });
+        }
+    }
+    const value = syncFallback();
+    const elapsedMs = Date.now() - start;
+    if (elapsedMs > DEGRADATION_NOTICE_THRESHOLD_MS) {
+        return {
+            value,
+            degradationNotice: `native engine unavailable — run planu doctor (fallback took ${String(elapsedMs)}ms)`,
+        };
+    }
+    return { value };
+}
+/** Worker-dispatched variant of {@link fastDetectDriftParallel} for main-thread callers. */
+export async function fastDetectDriftParallelAsync(rootPath, keywords) {
+    return dispatchViaWorker('detect-drift', { rootPath, keywords }, fastHashProjectPath(rootPath), () => fastDetectDriftParallel(rootPath, keywords));
+}
+/** Worker-dispatched variant of {@link fastScanAndHashFiles} for main-thread callers. */
+export async function fastScanAndHashFilesAsync(rootPath) {
+    return dispatchViaWorker('scan-and-hash-files', { rootPath }, fastHashProjectPath(rootPath), () => fastScanAndHashFiles(rootPath));
+}
+/** Worker-dispatched variant of {@link fastScanProjectMetadata} for main-thread callers. */
+export async function fastScanProjectMetadataAsync(rootPath) {
+    return dispatchViaWorker('scan-project-metadata', { rootPath }, fastHashProjectPath(rootPath), () => fastScanProjectMetadata(rootPath));
+}
+/** Worker-dispatched variant of {@link fastScanSpecs} for main-thread callers. */
+export async function fastScanSpecsAsync(rootPath) {
+    return dispatchViaWorker('scan-specs', { rootPath }, fastHashProjectPath(rootPath), () => fastScanSpecs(rootPath));
+}
 export const isNativeActive = () => getNative() !== null;
 export const nativeLoadDiagnostic = () => {
     refreshNativeCapabilityDiagnostic();
     return loadDiagnostic;
 };
+/**
+ * Force a native load attempt regardless of the calling thread and return the
+ * resulting diagnostic. `nativeLoadDiagnostic()` alone only reports load state
+ * that some other main-thread-bypassing caller already triggered (e.g. the
+ * macOS Keychain port); this is the main-thread-safe way to actually probe
+ * native availability, used by `planu doctor`.
+ */
+export const probeNativeLoad = () => {
+    loadNative();
+    return nativeLoadDiagnostic();
+};
 //# sourceMappingURL=core-bridge.js.map

package/dist/engine/drift-monitor.js

@@ -2,7 +2,7 @@
 import fs from 'node:fs';
 import { readFile, stat } from 'node:fs/promises';
 import path from 'node:path';
-import { fastScanProjectMetadata, isNativeActive, fastDetectDriftParallel, } from './core-bridge.js';
+import { fastScanProjectMetadataAsync, fastDetectDriftParallelAsync, } from './core-bridge.js';
 import { readSpecTechnicalSection } from './spec-format/read-technical-section.js';
 // ---------------------------------------------------------------------------
 // Config builder
@@ -41,13 +41,11 @@ export async function computeSummaryReport(projectPath, specList, config, rules,
     const alerts = [];
     let drifted = 0;
     let clean = 0;
-    // Layer 3 (AC coverage) Optimization:
-    // If native is active, we can do a single parallel scan for keywords across ALL specs.
-    // This is much faster than doing it one-by-one.
-    const nativeActive = isNativeActive();
-    const metadataMap = nativeActive
-        ? new Map(fastScanProjectMetadata(projectPath).map((m) => [m.path, m]))
-        : undefined;
+    // Layer 3 (AC coverage) Optimization: a single project-wide metadata scan
+    // (worker-dispatched when native is available) is much faster than doing it
+    // spec-by-spec.
+    const { value: projectMetadata } = await fastScanProjectMetadataAsync(projectPath);
+    const metadataMap = new Map(projectMetadata.map((m) => [m.path, m]));
     for (const specId of specList) {
         const technicalPath = specTechnicalPaths?.get(specId);
         const { score: healthScore } = await computeDriftScore(projectPath, specId, undefined, technicalPath, metadataMap);
@@ -272,19 +270,19 @@ async function computeAcCoverageScore(criteria, filePaths) {
         return 100;
     }
     let foundTerms;
-    if (isNativeActive()) {
-        // Use Rust to find which terms appear in implementation files across the WHOLE project.
-        // Note: Rust already does parallel walking and multi-threaded search.
-        // We pass any directory/file from the spec, but Rust will scan efficiently.
-        const firstFile = existingFiles[0];
-        if (!firstFile) {
-            return 100;
-        }
+    const firstFile = existingFiles[0];
+    if (!firstFile) {
+        return 100;
+    }
+    try {
+        // Worker-dispatched (native when available) parallel search across the WHOLE
+        // project rooted at the first file's dir — much faster than reading files
+        // one by one, and never blocks the main thread's event loop.
         const rootPath = path.dirname(firstFile); // Use first file's dir as heuristic
-        const result = fastDetectDriftParallel(rootPath, [...allTerms]);
+        const { value: result } = await fastDetectDriftParallelAsync(rootPath, [...allTerms]);
         foundTerms = new Set(result.foundKeywords);
     }
-    else {
+    catch {
         // Fallback: Read all implementation files once
         const fileContents = [];
         for (const filePath of existingFiles) {

package/dist/engine/living-spec/hash-tracker.js

@@ -3,7 +3,7 @@
 import { createHash } from 'node:crypto';
 import { readFile, stat } from 'node:fs/promises';
 import { join } from 'node:path';
-import { fastScanAndHashFiles, isNativeActive } from '../core-bridge.js';
+import { fastScanAndHashFilesAsync } from '../core-bridge.js';
 /**
  * Compute SHA-256 hash of a file's content.
  */
@@ -34,38 +34,36 @@ export async function createFileHashEntry(projectPath, relativePath) {
  * Create hash entries for multiple files.
  */
 export async function createFileHashEntries(projectPath, relativePaths) {
-    // Try native Rust implementation for bulk hashing
-    if (isNativeActive()) {
-        try {
-            const results = fastScanAndHashFiles(projectPath);
-            const resultMap = new Map(results.map((r) => [r.path, r.hash]));
-            const entries = [];
-            for (const rel of relativePaths) {
-                const fullPath = join(projectPath, rel);
-                const hash = resultMap.get(fullPath);
-                if (hash) {
-                    try {
-                        const s = await stat(fullPath);
-                        entries.push({
-                            file: rel,
-                            hash,
-                            size: s.size,
-                            snapshotAt: new Date().toISOString(),
-                        });
-                    }
-                    catch {
-                        // File might have disappeared between scan and stat
-                    }
+    // Try the accelerated bulk-hash path (worker-dispatched native, or the TS fallback).
+    try {
+        const { value: results } = await fastScanAndHashFilesAsync(projectPath);
+        const resultMap = new Map(results.map((r) => [r.path, r.hash]));
+        const entries = [];
+        for (const rel of relativePaths) {
+            const fullPath = join(projectPath, rel);
+            const hash = resultMap.get(fullPath);
+            if (hash) {
+                try {
+                    const s = await stat(fullPath);
+                    entries.push({
+                        file: rel,
+                        hash,
+                        size: s.size,
+                        snapshotAt: new Date().toISOString(),
+                    });
+                }
+                catch {
+                    // File might have disappeared between scan and stat
                 }
-            }
-            if (entries.length > 0) {
-                return entries;
             }
         }
-        catch (err) {
-            console.warn('[Planu-RS] Native bulk hash failed, falling back to Node.', err);
+        if (entries.length > 0) {
+            return entries;
         }
     }
+    catch (err) {
+        console.warn('[Planu-RS] Bulk hash failed, falling back to Node.', err);
+    }
     const entries = [];
     for (const relativePath of relativePaths) {
         const entry = await createFileHashEntry(projectPath, relativePath);

package/dist/engine/planu-core.darwin-arm64.node.manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 2,
-  "cliVersion": "5.1.1",
-  "engineVersion": "5.1.1",
-  "buildId": "1-5.1.1-aarch64-apple-darwin",
+  "cliVersion": "5.2.0",
+  "engineVersion": "5.2.0",
+  "buildId": "1-5.2.0-aarch64-apple-darwin",
   "protocolAbi": 1,
   "capabilityAbi": 2,
   "nodeApiAbi": 4,
@@ -17,15 +17,15 @@
   "platform": "darwin",
   "arch": "arm64",
   "libc": null,
-  "artifactSha256": "3791a7635fda74d3c0c5a226115ac4ab78c98afc366d0451a107ed1419139873",
+  "artifactSha256": "d651b32dc2ec3d58adc720400cab3cfd0114388d2697c861038b913cda3ad711",
   "sbom": {
     "format": "CycloneDX-1.5",
     "path": "planu-core.darwin-arm64.node.sbom.json",
-    "sha256": "434d0491e2130ac49b7eb34989f5ae2135f3ad9f54f0042f5bb3ba660bd2c568"
+    "sha256": "28c7421f2ee232830c3150449c51d89a494e2a4841a39af4348dcaaccb27f6cc"
   },
   "provenance": {
     "builder": "scripts/build-rust-local.sh",
-    "sourceCommit": "5046eff43d23641fe60bd1c01e8c34277172db16",
+    "sourceCommit": "121065e63e9fd2c067367e286ecba619ecc3f18a",
     "sourceTreeDirty": false,
     "sourceDateEpoch": 1,
     "rustToolchain": "rustc 1.95.0 (59807616e 2026-04-14)",
@@ -34,6 +34,6 @@
   "signature": {
     "algorithm": "Ed25519",
     "keyId": "e2ee765cb5ad9fbdc433ece332bce26d746d5e350b3acde0721a4c8c6337ff7b",
-    "value": "7kFQj3Sq5rFuMciulVbszYysMir4sSVuTrgLv0exAYSmkfwj16xag4ldwYRCJky/EXeCn1ZYZYJvfuCNEqZ5DQ=="
+    "value": "9R5L33t90yHh/8SXCNpjSRbCoIJ8wooiMtvkHpCKr1ByDK13NiUuH3v0uLiquqXbf4r6mMe5K4bWQ63nm/XQBg=="
   }
 }

package/dist/engine/planu-core.darwin-arm64.node.sbom.json

@@ -4,14 +4,14 @@
   "version": 1,
   "metadata": {
     "component": {
-      "bom-ref": "pkg:cargo/planu-core@5.1.1",
+      "bom-ref": "pkg:cargo/planu-core@5.2.0",
       "type": "library",
       "name": "planu-core",
-      "version": "5.1.1",
+      "version": "5.2.0",
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "3791a7635fda74d3c0c5a226115ac4ab78c98afc366d0451a107ed1419139873"
+          "content": "d651b32dc2ec3d58adc720400cab3cfd0114388d2697c861038b913cda3ad711"
         }
       ]
     }
@@ -1106,7 +1106,7 @@
       "dependsOn": []
     },
     {
-      "ref": "pkg:cargo/planu-core@5.1.1",
+      "ref": "pkg:cargo/planu-core@5.2.0",
       "dependsOn": [
         "pkg:cargo/core-foundation@0.10.1",
         "pkg:cargo/hmac@0.12.1",

package/dist/engine/planu-core.darwin-x64.node.manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 2,
-  "cliVersion": "5.1.1",
-  "engineVersion": "5.1.1",
-  "buildId": "1-5.1.1-x86_64-apple-darwin",
+  "cliVersion": "5.2.0",
+  "engineVersion": "5.2.0",
+  "buildId": "1-5.2.0-x86_64-apple-darwin",
   "protocolAbi": 1,
   "capabilityAbi": 2,
   "nodeApiAbi": 4,
@@ -17,15 +17,15 @@
   "platform": "darwin",
   "arch": "x64",
   "libc": null,
-  "artifactSha256": "339ab4dad5834869aebc0130b8c63e0863d665daf0a98d8e795f08ea51bab51c",
+  "artifactSha256": "931a0f6bc94744521f33e6ac46fb7293fe49b14d225d76446e27dd7117f12ad9",
   "sbom": {
     "format": "CycloneDX-1.5",
     "path": "planu-core.darwin-x64.node.sbom.json",
-    "sha256": "d52bf3925938ed40201a07f6a0190694d9cfd924393ebba6d47f818c8ee79c17"
+    "sha256": "ec531e41f6e0ef14b7fb2727370f817b761d28ae510c93790555796f5e2fac19"
   },
   "provenance": {
     "builder": "scripts/build-rust-local.sh",
-    "sourceCommit": "5046eff43d23641fe60bd1c01e8c34277172db16",
+    "sourceCommit": "121065e63e9fd2c067367e286ecba619ecc3f18a",
     "sourceTreeDirty": false,
     "sourceDateEpoch": 1,
     "rustToolchain": "rustc 1.95.0 (59807616e 2026-04-14)",
@@ -34,6 +34,6 @@
   "signature": {
     "algorithm": "Ed25519",
     "keyId": "e2ee765cb5ad9fbdc433ece332bce26d746d5e350b3acde0721a4c8c6337ff7b",
-    "value": "MBGihzcPhQf/7suo2XjxUz8kuC6zpZeVnNXlIjI/a14CCARPeI1gE67dWBIvVJuJ0dMmXeLfsw39quYQQNqdCg=="
+    "value": "mgppJ+aunLo8AOPqEdBnmAXfDYzWQzdmehp7AASRUk8Wyk9/mQm9A22K5T5NiUN3flTqQCLPT6ZN2L9eWp5VCw=="
   }
 }