@planu/cli 5.3.26 → 5.3.28

package/CHANGELOG.md

@@ -1,3 +1,19 @@
+## [5.3.28] - 2026-08-20
+
+### Bug Fixes
+- fix(spec-1577): single universal TS-only release artifact, remove native crate
+
+
+## [5.3.27] - 2026-08-19
+
+### Bug Fixes
+- fix(spec-1575): require clause to assert forbidden action for outOfScope contradiction
+- fix(spec-1539): require real independent implementation-review before done
+
+### Chores
+- chore(spec-1539-1575): close done ceremonies, reconcile specs, file SPEC-1576
+
+
 ## [5.3.26] - 2026-08-19
 
 ### Bug Fixes

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

@@ -19,20 +19,14 @@ interface DeepCheckResult {
 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. */
+/** Check (2): PLANU_HOME / the resolved data directory is writable. */
 declare function checkDataDirWritable(): DeepCheckResult;
-/** Check (4): the runtime SQLite database opens without corruption. */
+/** Check (3): the runtime SQLite database opens without corruption. */
 declare function checkRuntimeDatabase(): DeepCheckResult;
-/** Check (5): the active locale resolves to a real translated message. */
+/** Check (4): 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 { checkNodeVersion, checkDataDirWritable, checkRuntimeDatabase, checkLocaleResolution, runDeepChecks, };
 export { checkTool };
 export declare const doctorCommand: CliCommand;
 //# sourceMappingURL=doctor.d.ts.map

package/dist/cli/commands/doctor.js

@@ -1,5 +1,5 @@
 // cli/commands/doctor.ts — planu doctor: verify MCP installations health (SPEC-236)
-// Deep diagnostics (Node version, native engine, storage writability, runtime DB,
+// Deep diagnostics (Node version, 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';
@@ -9,7 +9,6 @@ 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
@@ -144,31 +143,7 @@ function checkNodeVersion() {
         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. */
+/** Check (2): PLANU_HOME / the resolved data directory is writable. */
 function checkDataDirWritable() {
     const layout = resolveStorageLayout();
     const probePath = join(layout.data, `.doctor-write-probe-${String(process.pid)}`);
@@ -187,7 +162,7 @@ function checkDataDirWritable() {
         };
     }
 }
-/** Check (4): the runtime SQLite database opens without corruption. */
+/** Check (3): the runtime SQLite database opens without corruption. */
 function checkRuntimeDatabase() {
     const layout = resolveStorageLayout();
     try {
@@ -208,7 +183,7 @@ function checkRuntimeDatabase() {
         };
     }
 }
-/** Check (5): the active locale resolves to a real translated message. */
+/** Check (4): the active locale resolves to a real translated message. */
 function checkLocaleResolution() {
     const locale = getLocale();
     const sample = t('locale.changed', locale);
@@ -224,7 +199,6 @@ function checkLocaleResolution() {
 function runDeepChecks() {
     return [
         checkNodeVersion(),
-        checkNativeModule(),
         checkDataDirWritable(),
         checkRuntimeDatabase(),
         checkLocaleResolution(),
@@ -252,7 +226,7 @@ function printDeepChecks(results) {
     }
 }
 // Exported for tests
-export { checkNodeVersion, checkNativeModule, checkDataDirWritable, checkRuntimeDatabase, checkLocaleResolution, runDeepChecks, };
+export { checkNodeVersion, checkDataDirWritable, checkRuntimeDatabase, checkLocaleResolution, runDeepChecks, };
 function statusIcon(status) {
     switch (status) {
         case 'ok':

package/dist/cli/commands/inspect.js

@@ -5,7 +5,7 @@ import { homedir } from 'node:os';
 import { PLANU_VERSION } from '../../config/version.js';
 import { createStorageCatalog } from '../../storage/storage-catalog.js';
 import { resolveStorageLayout } from '../../storage/storage-layout.js';
-import { NATIVE_CAPABILITY_ABI, NATIVE_PROTOCOL_ABI, RUNTIME_STORAGE_SCHEMA, nativeLoadDiagnostic, } from '../../engine/core-bridge.js';
+import { RUNTIME_STORAGE_SCHEMA } from '../../engine/core-bridge.js';
 import { readInstallationManifest } from './install.js';
 import { getProjects } from '../../storage/global-projects-store.js';
 async function inspectPath(path) {
@@ -96,23 +96,11 @@ export async function buildInspectionReport() {
         path: portablePath(path),
         exists: (await inspectPath(path)).exists,
     })));
-    const native = nativeLoadDiagnostic();
-    const displayArtifact = (value) => isAbsolute(value) ? `<local>/${basename(value)}` : value;
     return {
         schemaVersion: 1,
         cliVersion: PLANU_VERSION,
         offline: process.env.PLANU_OFFLINE === '1',
-        native: {
-            loaded: native.loaded ? displayArtifact(native.loaded) : null,
-            compatibility: native.compatibility ?? null,
-            attempted: native.attempted.map(displayArtifact),
-            errorCount: native.errors.length,
-            capabilities: native.capabilities ?? [],
-            executionScope: native.executionScope ?? null,
-            protocolAbi: NATIVE_PROTOCOL_ABI,
-            capabilityAbi: NATIVE_CAPABILITY_ABI,
-            storageSchema: RUNTIME_STORAGE_SCHEMA,
-        },
+        storageSchema: RUNTIME_STORAGE_SCHEMA,
         installation,
         hostAdapters: installation && typeof installation === 'object' && 'installations' in installation
             ? installation.installations

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

@@ -2,9 +2,8 @@ import type { CliCommand } from '../../types/cli.js';
 interface OfflinePrepareReport {
     schemaVersion: 1;
     cli: string;
-    native: string | null;
     cacheReady: boolean;
-    nativeCompatible: boolean;
+    schemaReady: boolean;
     mcpStartupReady: boolean;
     smokeReady: boolean;
     errors: string[];

package/dist/cli/commands/offline.js

@@ -1,6 +1,6 @@
 import { spawnSync } from 'node:child_process';
 import { PLANU_VERSION } from '../../config/version.js';
-import { currentNativePackageName, RUNTIME_STORAGE_SCHEMA } from '../../engine/core-bridge.js';
+import { RUNTIME_STORAGE_SCHEMA } from '../../engine/core-bridge.js';
 const MCP_INITIALIZE_REQUEST = `${JSON.stringify({
     jsonrpc: '2.0',
     id: 1,
@@ -38,47 +38,31 @@ function provesMcpStartup(stdout) {
         }
     });
 }
-function provesNativeAsset(stdout) {
+function provesStorageSchema(stdout) {
     try {
         const report = JSON.parse(stdout);
-        const handshake = report.native?.compatibility?.handshake;
-        const storageSchemaMin = handshake?.storageSchemaMin;
-        const storageSchemaMax = handshake?.storageSchemaMax;
-        return (typeof report.native?.loaded === 'string' &&
-            report.native.loaded.length > 0 &&
-            report.native.compatibility?.compatible === true &&
-            typeof storageSchemaMin === 'number' &&
-            typeof storageSchemaMax === 'number' &&
-            storageSchemaMin <= RUNTIME_STORAGE_SCHEMA &&
-            storageSchemaMax >= RUNTIME_STORAGE_SCHEMA);
+        return report.storageSchema === RUNTIME_STORAGE_SCHEMA;
     }
     catch {
         return false;
     }
 }
-// eslint-disable-next-line complexity -- report aggregates cache, native and smoke diagnostics
 export function prepareOfflineRuntime() {
-    const nativeName = currentNativePackageName();
-    const packages = [`@planu/cli@${PLANU_VERSION}`];
-    if (nativeName) {
-        packages.push(`${nativeName}@${PLANU_VERSION}`);
-    }
+    const packageSpec = `@planu/cli@${PLANU_VERSION}`;
     const npmExecutable = process.platform === 'win32' ? 'npm.cmd' : 'npm';
     const errors = [];
     let cacheReady = true;
-    for (const packageSpec of packages) {
-        const cache = spawnSync(npmExecutable, ['cache', 'add', ...(process.env.PLANU_OFFLINE === '1' ? ['--offline'] : []), packageSpec], {
-            encoding: 'utf8',
-            timeout: 120_000,
-            env: { ...process.env },
-        });
-        if (cache.error) {
-            errors.push(cache.error.message);
-        }
-        if (cache.status !== 0) {
-            cacheReady = false;
-            errors.push((cache.stderr || cache.stdout || `npm cache add failed: ${packageSpec}`).trim());
-        }
+    const cache = spawnSync(npmExecutable, ['cache', 'add', ...(process.env.PLANU_OFFLINE === '1' ? ['--offline'] : []), packageSpec], {
+        encoding: 'utf8',
+        timeout: 120_000,
+        env: { ...process.env },
+    });
+    if (cache.error) {
+        errors.push(cache.error.message);
+    }
+    if (cache.status !== 0) {
+        cacheReady = false;
+        errors.push((cache.stderr || cache.stdout || `npm cache add failed: ${packageSpec}`).trim());
     }
     const npxExecutable = process.platform === 'win32' ? 'npx.cmd' : 'npx';
     const smokeEnvironment = { ...process.env, PLANU_OFFLINE: '1' };
@@ -92,22 +76,21 @@ export function prepareOfflineRuntime() {
     if (!mcpStartupReady) {
         errors.push(errorText(mcpSmoke, 'offline MCP startup handshake failed'));
     }
-    const nativeSmoke = spawnSync(npxExecutable, ['--offline', '-y', `@planu/cli@${PLANU_VERSION}`, 'inspect', '--json'], {
+    const schemaSmoke = spawnSync(npxExecutable, ['--offline', '-y', `@planu/cli@${PLANU_VERSION}`, 'inspect', '--json'], {
         encoding: 'utf8',
         timeout: 30_000,
         env: smokeEnvironment,
     });
-    const nativeCompatible = nativeSmoke.status === 0 && provesNativeAsset(nativeSmoke.stdout);
-    if (!nativeCompatible) {
-        errors.push(errorText(nativeSmoke, 'cached native asset failed isolated compatibility check'));
+    const schemaReady = schemaSmoke.status === 0 && provesStorageSchema(schemaSmoke.stdout);
+    if (!schemaReady) {
+        errors.push(errorText(schemaSmoke, 'cached runtime failed storage schema verification'));
     }
-    const smokeReady = mcpStartupReady && nativeCompatible;
+    const smokeReady = mcpStartupReady && schemaReady;
     return {
         schemaVersion: 1,
-        cli: `@planu/cli@${PLANU_VERSION}`,
-        native: nativeName ? `${nativeName}@${PLANU_VERSION}` : null,
+        cli: packageSpec,
         cacheReady,
-        nativeCompatible,
+        schemaReady,
         mcpStartupReady,
         smokeReady,
         errors: errors.filter(Boolean),
@@ -115,7 +98,7 @@ export function prepareOfflineRuntime() {
 }
 export const offlineCommand = {
     name: 'offline',
-    description: 'Preload and verify exact CLI/native assets for offline startup',
+    description: 'Preload and verify the exact CLI asset for offline startup',
     usage: 'planu offline prepare [--json]',
     run(args, flags) {
         if (args[0] !== 'prepare') {
@@ -123,7 +106,7 @@ export const offlineCommand = {
         }
         const report = prepareOfflineRuntime();
         process.stdout.write(`${JSON.stringify(report, null, flags?.json ? 0 : 2)}\n`);
-        if (!report.cacheReady || !report.nativeCompatible || !report.smokeReady) {
+        if (!report.cacheReady || !report.schemaReady || !report.smokeReady) {
             process.exitCode = 1;
         }
         return Promise.resolve();

package/dist/config/release-policy.json

@@ -1,21 +1,8 @@
 {
   "schemaVersion": 1,
-  "supportedNativeTargets": 8,
   "gitIdentity": { "name": "planudev", "email": "hello@planu.dev" },
   "quality": { "branchCoverageMinimum": 88.1, "mutationScoreMinimum": 80 },
-  "native": {
-    "blockingCommands": [
-      "cargo fmt --manifest-path rust/planu-core/Cargo.toml --all -- --check",
-      "cargo clippy --manifest-path rust/planu-core/Cargo.toml --all-targets --all-features -- -D warnings",
-      "cargo test --manifest-path rust/planu-core/Cargo.toml --all-features",
-      "cargo test --manifest-path rust/planu-core/Cargo.toml --test property_invariants",
-      "cargo audit --file rust/planu-core/Cargo.lock",
-      "cargo deny check --config deny.toml"
-    ],
-    "performance": { "samples": 30, "warmups": 5, "p95RatioMaximum": 1.1, "rssP95RatioMaximum": 1.15 }
-  },
   "releaseOptimization": {
-    "rustNightlyToolchain": "nightly-2026-04-14",
     "releaseSloSeconds": { "warm": 1500, "cold": 2100, "recovery": 180 },
     "sourceReceiptInputPatterns": [
       "(^|/)package\\.json$",
@@ -29,72 +16,7 @@
       { "id": "reliability", "executable": "pnpm", "args": ["check:reliability"], "timeoutSeconds": 1800 },
       { "id": "dependency-freshness", "executable": "pnpm", "args": ["check:deps:fresh"], "timeoutSeconds": 1800 },
       { "id": "coverage", "executable": "pnpm", "args": ["test:coverage"], "timeoutSeconds": 1800 },
-      { "id": "mutation", "executable": "pnpm", "args": ["audit:mutation"], "timeoutSeconds": 1800 },
-      {
-        "id": "rust-format",
-        "executable": "cargo",
-        "args": ["fmt", "--manifest-path", "rust/planu-core/Cargo.toml", "--all", "--", "--check"],
-        "timeoutSeconds": 1800
-      },
-      {
-        "id": "rust-clippy",
-        "executable": "cargo",
-        "args": [
-          "clippy",
-          "--manifest-path",
-          "rust/planu-core/Cargo.toml",
-          "--all-targets",
-          "--all-features",
-          "--",
-          "-D",
-          "warnings"
-        ],
-        "timeoutSeconds": 1800
-      },
-      {
-        "id": "rust-test",
-        "executable": "cargo",
-        "args": ["test", "--manifest-path", "rust/planu-core/Cargo.toml", "--all-features"],
-        "timeoutSeconds": 1800
-      },
-      {
-        "id": "rust-audit",
-        "executable": "cargo",
-        "args": ["audit", "--file", "rust/planu-core/Cargo.lock"],
-        "timeoutSeconds": 1800
-      },
-      {
-        "id": "rust-policy",
-        "executable": "cargo",
-        "args": [
-          "deny",
-          "--manifest-path",
-          "rust/planu-core/Cargo.toml",
-          "check",
-          "--config",
-          "rust/planu-core/deny.toml"
-        ],
-        "timeoutSeconds": 1800
-      },
-      {
-        "id": "rust-fuzz",
-        "executable": "cargo",
-        "args": [
-          "+nightly-2026-04-14",
-          "fuzz",
-          "run",
-          "public-inputs",
-          "--fuzz-dir",
-          "rust/planu-core/fuzz",
-          "--",
-          "-max_total_time=60"
-        ],
-        "timeoutSeconds": 1800
-      }
-    ],
-    "effectiveLinkers": [
-      { "id": "CC", "command": "clang" },
-      { "id": "CXX", "command": "clang++" }
+      { "id": "mutation", "executable": "pnpm", "args": ["audit:mutation"], "timeoutSeconds": 1800 }
     ]
   }
 }

package/dist/engine/auto-updater/release-verifier.js

@@ -1,5 +1,5 @@
 import { spawnSync } from 'node:child_process';
-import { currentNativePackageName, RUNTIME_STORAGE_SCHEMA } from '../core-bridge.js';
+import { RUNTIME_STORAGE_SCHEMA } from '../core-bridge.js';
 import { redactFailureMessage, reportClassifiedDegradation, } from '../../errors/classified-degradation.js';
 const EXACT_VERSION = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)$/;
 const CLI_PACKAGE = '@planu/cli';
@@ -35,23 +35,14 @@ function verifiesMcp(stdout, version) {
         }
     });
 }
-function verifiesNative(stdout, version, nativePackage) {
+function verifiesSchema(stdout, version) {
     try {
         const report = JSON.parse(stdout);
-        const handshake = report.native?.compatibility?.handshake;
-        return (report.cliVersion === version &&
-            typeof report.native?.loaded === 'string' &&
-            report.native.loaded.includes(nativePackage) &&
-            report.native.compatibility?.compatible === true &&
-            handshake?.engineVersion === version &&
-            typeof handshake.storageSchemaMin === 'number' &&
-            typeof handshake.storageSchemaMax === 'number' &&
-            handshake.storageSchemaMin <= RUNTIME_STORAGE_SCHEMA &&
-            handshake.storageSchemaMax >= RUNTIME_STORAGE_SCHEMA);
+        return report.cliVersion === version && report.storageSchema === RUNTIME_STORAGE_SCHEMA;
     }
     catch (error) {
-        /* reliability-optional: UPGRADE_NATIVE_REPORT_INVALID */
-        reportClassifiedDegradation('UPGRADE_NATIVE_REPORT_INVALID', error);
+        /* reliability-optional: UPGRADE_SCHEMA_REPORT_INVALID */
+        reportClassifiedDegradation('UPGRADE_SCHEMA_REPORT_INVALID', error);
         return false;
     }
 }
@@ -59,24 +50,17 @@ export function stageAndVerifyRelease(version, runner = spawnSync) {
     if (!EXACT_VERSION.test(version)) {
         throw new Error(`[Planu upgrade] Refusing non-exact release version: ${version}`);
     }
-    const nativeName = currentNativePackageName();
-    if (nativeName === null) {
-        throw new Error('[Planu upgrade] No native package exists for this platform; upgrade aborted.');
-    }
     const cliPackage = `${CLI_PACKAGE}@${version}`;
-    const nativePackage = `${nativeName}@${version}`;
     const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm';
     const npx = process.platform === 'win32' ? 'npx.cmd' : 'npx';
     const environment = { ...process.env };
-    for (const packageSpec of [cliPackage, nativePackage]) {
-        const staged = runner(npm, ['cache', 'add', packageSpec], {
-            encoding: 'utf8',
-            timeout: 120_000,
-            env: environment,
-        });
-        if (staged.status !== 0 || staged.error) {
-            throw commandFailure(`failed to stage ${packageSpec}`, staged);
-        }
+    const staged = runner(npm, ['cache', 'add', cliPackage], {
+        encoding: 'utf8',
+        timeout: 120_000,
+        env: environment,
+    });
+    if (staged.status !== 0 || staged.error) {
+        throw commandFailure(`failed to stage ${cliPackage}`, staged);
     }
     const isolatedEnvironment = { ...environment, PLANU_OFFLINE: '1' };
     const mcpSmoke = runner(npx, ['--offline', '-y', cliPackage], {
@@ -88,22 +72,20 @@ export function stageAndVerifyRelease(version, runner = spawnSync) {
     if (mcpSmoke.status !== 0 || mcpSmoke.error || !verifiesMcp(mcpSmoke.stdout, version)) {
         throw commandFailure(`exact CLI ${version} failed MCP smoke test`, mcpSmoke);
     }
-    const nativeSmoke = runner(npx, ['--offline', '-y', cliPackage, 'inspect', '--json'], {
+    const schemaSmoke = runner(npx, ['--offline', '-y', cliPackage, 'inspect', '--json'], {
         encoding: 'utf8',
         timeout: 30_000,
         env: isolatedEnvironment,
     });
-    if (nativeSmoke.status !== 0 ||
-        nativeSmoke.error ||
-        !verifiesNative(nativeSmoke.stdout, version, nativeName)) {
-        throw commandFailure(`exact native ${nativePackage} failed compatibility smoke test`, nativeSmoke);
+    if (schemaSmoke.status !== 0 ||
+        schemaSmoke.error ||
+        !verifiesSchema(schemaSmoke.stdout, version)) {
+        throw commandFailure(`exact CLI ${version} failed storage schema smoke test`, schemaSmoke);
     }
     return Promise.resolve({
         version,
         cliPackage,
-        nativePackage,
         cliVerified: true,
-        nativeVerified: true,
         mcpSmokeVerified: true,
         canaryVerified: true,
         verifiedAt: new Date().toISOString(),

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

@@ -1,11 +1,7 @@
-import type { FileHash, FileMetadata, SpecAnnotation, DriftResult, PlanuCore, DuplicateRawBlockRs, DuplicateBlockLocationRs, FastGrepMatch, FileContent, SpecBriefRs, AmbiguousCriterionRs, GapsLogChainResultRs, NativeVectorSearchResult, VectorNode, ProjectGraphSourceFileRs, TsRelationRs, GraphNodeInputRs, GraphEdgeInputRs, AffectedNodeRs, ShortestPathResultRs, CompactGraphSliceRs, CompactGraphEdgesRs, ProjectGraphLimitsPolicyRs, ResolvedProjectGraphLimitsRs, NativeRuntimeHandshake, NativeRuntimeCompatibility, NativeArtifactManifest, NativeLoadDiagnostic } from '../types/core-bridge.js';
-import type { MacOSKeychainNativePort } from '../types/security.js';
-import { negotiateNativeRuntime, NATIVE_CAPABILITY_ABI, NATIVE_NODE_API_ABI, NATIVE_PROTOCOL_ABI, RUNTIME_STORAGE_SCHEMA } from './native-runtime-handshake.js';
-export { negotiateNativeRuntime, NATIVE_CAPABILITY_ABI, NATIVE_NODE_API_ABI, NATIVE_PROTOCOL_ABI, RUNTIME_STORAGE_SCHEMA, };
-export type { FileHash, FileMetadata, SpecAnnotation, DriftResult, PlanuCore, DuplicateRawBlockRs, DuplicateBlockLocationRs, FastGrepMatch, FileContent, SpecBriefRs, AmbiguousCriterionRs, GapsLogChainResultRs, NativeVectorSearchResult, VectorNode, ProjectGraphSourceFileRs, TsRelationRs, GraphNodeInputRs, GraphEdgeInputRs, AffectedNodeRs, ShortestPathResultRs, CompactGraphSliceRs, CompactGraphEdgesRs, ProjectGraphLimitsPolicyRs, ResolvedProjectGraphLimitsRs, NativeRuntimeHandshake, NativeRuntimeCompatibility, NativeArtifactManifest, NativeLoadDiagnostic as LoadDiagnostic, };
-export declare function currentNativePackageName(): string | null;
-/** Main-thread port for async Keychain calls; never accepts override or unverified native code. */
-export declare function requireMacOSKeychainNativePort(): MacOSKeychainNativePort;
+import type { FileHash, FileMetadata, SpecAnnotation, DriftResult, DuplicateRawBlockRs, DuplicateBlockLocationRs, FastGrepMatch, FileContent, SpecBriefRs, AmbiguousCriterionRs, GapsLogChainResultRs, NativeVectorSearchResult, VectorNode, ProjectGraphSourceFileRs, TsRelationRs, GraphNodeInputRs, GraphEdgeInputRs, AffectedNodeRs, ShortestPathResultRs, CompactGraphSliceRs, CompactGraphEdgesRs, ProjectGraphLimitsPolicyRs, ResolvedProjectGraphLimitsRs } from '../types/core-bridge.js';
+/** Must match RuntimeDatabase.schemaVersion and the packaged runtime's release contract. */
+export declare const RUNTIME_STORAGE_SCHEMA = 4;
+export type { FileHash, FileMetadata, SpecAnnotation, DriftResult, DuplicateRawBlockRs, DuplicateBlockLocationRs, FastGrepMatch, FileContent, SpecBriefRs, AmbiguousCriterionRs, GapsLogChainResultRs, NativeVectorSearchResult, VectorNode, ProjectGraphSourceFileRs, TsRelationRs, GraphNodeInputRs, GraphEdgeInputRs, AffectedNodeRs, ShortestPathResultRs, CompactGraphSliceRs, CompactGraphEdgesRs, ProjectGraphLimitsPolicyRs, ResolvedProjectGraphLimitsRs, };
 export declare function fastHashProjectPath(projectPath: string): string;
 export declare function fastGetProjectDataPath(baseDir: string, projectId: string): string | null;
 export declare function fastIsSafeProjectId(projectId: string): boolean;
@@ -19,7 +15,8 @@ export declare function fastFindPatterns(rootPath: string, patterns: string[], e
 export declare function fastFindFilesByName(rootPath: string, names: string[]): string[];
 export declare function fastFindFilesByExt(rootPath: string, extensions: string[]): string[];
 export declare function fastReadFiles(paths: string[]): FileContent[];
-export declare function fastScanSpecs(rootPath: string): SpecBriefRs[] | null;
+/** No TS-only replacement exists yet — callers detect `null` and use the regular spec scanner. */
+export declare function fastScanSpecs(_rootPath: string): SpecBriefRs[] | null;
 export declare function fastVerifyGapsChain(filePath: string): GapsLogChainResultRs;
 export declare function fastAppendGapEntry(filePath: string, id: string, timestamp: string, specId: string, description: string, severity: string, affectedSpecs: string[]): string;
 export declare function fastCosineSimilarity(v1: number[], v2: number[]): number;
@@ -31,34 +28,20 @@ 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