@planu/cli 5.3.27 → 5.3.28

package/dist/engine/core-bridge.js

@@ -1,20 +1,12 @@
-import { createRequire } from 'node:module';
-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';
-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);
+/** Must match RuntimeDatabase.schemaVersion and the packaged runtime's release contract. */
+export const RUNTIME_STORAGE_SCHEMA = 4;
 const reportedDegradations = new Set();
 const FALLBACK_ERROR = new Error('Native fallback operation degraded');
 function reportOnce(code, report) {
@@ -25,209 +17,6 @@ function reportOnce(code, report) {
 }
 class InvalidFallbackPatternError extends Error {
 }
-function getPlatformInfo() {
-    return {
-        platform: process.platform,
-        arch: process.arch,
-        libc: process.platform === 'linux' ? (detectMusl() ? 'musl' : 'glibc') : null,
-    };
-}
-function platformPackageName(info) {
-    const { platform, arch, libc } = info;
-    if (platform === 'darwin') {
-        if (arch === 'arm64') {
-            return '@planu/core-darwin-arm64';
-        }
-        if (arch === 'x64') {
-            return '@planu/core-darwin-x64';
-        }
-    }
-    if (platform === 'linux') {
-        if (arch === 'x64') {
-            return libc === 'musl' ? '@planu/core-linux-x64-musl' : '@planu/core-linux-x64-gnu';
-        }
-        if (arch === 'arm64') {
-            return libc === 'musl' ? '@planu/core-linux-arm64-musl' : '@planu/core-linux-arm64-gnu';
-        }
-    }
-    if (platform === 'win32') {
-        if (arch === 'x64') {
-            return '@planu/core-win32-x64-msvc';
-        }
-        if (arch === 'arm64') {
-            return '@planu/core-win32-arm64-msvc';
-        }
-    }
-    return null;
-}
-export function currentNativePackageName() {
-    return platformPackageName(getPlatformInfo());
-}
-function localBinaryName(info) {
-    const { platform, arch, libc } = info;
-    if (platform === 'linux') {
-        const suffix = libc === 'musl' ? 'musl' : 'gnu';
-        return `planu-core.linux-${arch}-${suffix}.node`;
-    }
-    if (platform === 'win32') {
-        return `planu-core.win32-${arch}-msvc.node`;
-    }
-    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;
-function loadNative() {
-    if (process.env.DISABLE_NATIVE_CORE === '1') {
-        loadDiagnostic = { attempted: [], errors: [] };
-        loaded = true;
-        return null;
-    }
-    if (loaded) {
-        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 target = nativeTarget(info);
-    const tryRequire = (originLabel, id, artifactPath) => {
-        attempts.push(originLabel);
-        try {
-            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) 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(`local:${localName}`, localPath, localPath);
-        if (mod) {
-            loadDiagnostic = {
-                ...loadDiagnostic,
-                attempted: attempts,
-                errors,
-                loaded: localName,
-                origin: 'local',
-            };
-            nativeModule = mod;
-            console.error(`[Planu-RS] Verified native core loaded (${localName}).`);
-            return mod;
-        }
-    }
-    // 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(`package:${pkg}`, pkg);
-        if (mod) {
-            loadDiagnostic = {
-                ...loadDiagnostic,
-                attempted: attempts,
-                errors,
-                loaded: pkg,
-                origin: 'package',
-            };
-            nativeModule = mod;
-            console.error(`[Planu-RS] Verified native core loaded (${pkg}).`);
-            return mod;
-        }
-    }
-    loadDiagnostic = { ...loadDiagnostic, attempted: attempts, errors };
-    return null;
-}
-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, loadDiagnostic.compatibility);
-}
-// 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']);
@@ -427,8 +216,6 @@ function tsHnswSearchFlat(query, nodes, topK) {
         .slice(0, topK);
 }
 function tsHmacSign(secret, data) {
-    // Must produce the same digest as the Rust `fastHmacSign` (HMAC-SHA256, not
-    // a plain SHA-256 of `secret + data`) so signatures roundtrip across paths.
     return createHmac('sha256', secret).update(data).digest('hex');
 }
 function tsHmacVerify(secret, data, signature) {
@@ -500,39 +287,27 @@ function tsGetProjectDataPath(baseDir, projectId) {
 }
 // Public API -----------------------------------------------------------------
 export function fastHashProjectPath(projectPath) {
-    const n = getNative();
-    return n ? n.hashProjectPath(projectPath) : tsHashProjectPath(projectPath);
+    return tsHashProjectPath(projectPath);
 }
 export function fastGetProjectDataPath(baseDir, projectId) {
-    const n = getNative();
-    return n ? n.getProjectDataPath(baseDir, projectId) : tsGetProjectDataPath(baseDir, projectId);
+    return tsGetProjectDataPath(baseDir, projectId);
 }
 export function fastIsSafeProjectId(projectId) {
-    const n = getNative();
-    return n ? n.isSafeProjectId(projectId) : PROJECT_ID_RE.test(projectId);
+    return PROJECT_ID_RE.test(projectId);
 }
 export function fastScanAndHashFiles(rootPath) {
-    const n = getNative();
-    return n ? n.scanAndHashFiles(rootPath) : tsScanAndHashFiles(rootPath);
+    return tsScanAndHashFiles(rootPath);
 }
 export function fastScanProjectMetadata(rootPath) {
-    const n = getNative();
-    return n ? n.scanProjectMetadata(rootPath) : tsScanProjectMetadata(rootPath);
+    return tsScanProjectMetadata(rootPath);
 }
 export function fastScanSpecAnnotations(rootPath) {
-    const n = getNative();
-    return n ? n.scanSpecAnnotations(rootPath) : tsScanSpecAnnotations(rootPath);
+    return tsScanSpecAnnotations(rootPath);
 }
 export function fastCheckAcCoverage(filePaths, keywords) {
-    const n = getNative();
-    return n ? n.checkAcCoverage(filePaths, keywords) : tsCheckAcCoverage(filePaths, keywords);
+    return tsCheckAcCoverage(filePaths, keywords);
 }
 export function fastDetectDriftParallel(rootPath, keywords) {
-    const n = getNative();
-    if (n) {
-        return n.fastDetectDriftParallel(rootPath, keywords);
-    }
-    // Fallback: simple sequential scan.
     const files = Array.from(walkFiles(rootPath));
     const lowered = keywords.map((k) => k.toLowerCase());
     const found = new Set();
@@ -562,192 +337,76 @@ export function fastDetectDriftParallel(rootPath, keywords) {
     return { foundKeywords: Array.from(found), fileCount: files.length };
 }
 export function fastFindDuplicateBlocks(paths, minLines) {
-    const n = getNative();
-    if (n) {
-        return n.fastFindDuplicateBlocks(paths, minLines);
-    }
     return findDuplicateBlocks(paths, minLines);
 }
 export function fastFindPatterns(rootPath, patterns, extensions = [], exclude = []) {
-    const n = getNative();
-    return n
-        ? n.fastFindPatterns(rootPath, patterns, extensions, exclude)
-        : tsFindPatterns(rootPath, patterns, extensions, exclude);
+    return tsFindPatterns(rootPath, patterns, extensions, exclude);
 }
 export function fastFindFilesByName(rootPath, names) {
-    const n = getNative();
-    return n ? n.fastFindFilesByName(rootPath, names) : tsFindFilesByName(rootPath, names);
+    return tsFindFilesByName(rootPath, names);
 }
 export function fastFindFilesByExt(rootPath, extensions) {
-    const n = getNative();
-    return n ? n.fastFindFilesByExt(rootPath, extensions) : tsFindFilesByExt(rootPath, extensions);
+    return tsFindFilesByExt(rootPath, extensions);
 }
 export function fastReadFiles(paths) {
-    const n = getNative();
-    return n ? n.fastReadFiles(paths) : tsReadFiles(paths);
+    return tsReadFiles(paths);
 }
-export function fastScanSpecs(rootPath) {
-    const n = getNative();
-    if (n) {
-        return n.fastScanSpecs(rootPath);
-    }
-    // No TS fallback yet — callers should detect and use the regular spec
-    // scanner instead. Returning null preserves the existing semantics.
+/** No TS-only replacement exists yet — callers detect `null` and use the regular spec scanner. */
+export function fastScanSpecs(_rootPath) {
     return null;
 }
 export function fastVerifyGapsChain(filePath) {
-    const n = getNative();
-    if (n) {
-        return n.fastVerifyGapsChain(filePath);
-    }
     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);
-    }
     return appendGapEntry(filePath, id, timestamp, specId, description, severity, affectedSpecs);
 }
 export function fastCosineSimilarity(v1, v2) {
-    const n = getNative();
-    return n ? n.fastCosineSimilarity(v1, v2) : tsCosineSimilarity(v1, v2);
+    return tsCosineSimilarity(v1, v2);
 }
 export function fastHnswSearchFlat(query, nodes, topK) {
-    const n = getNative();
-    return n ? n.fastHnswSearchFlat(query, nodes, topK) : tsHnswSearchFlat(query, nodes, topK);
+    return tsHnswSearchFlat(query, nodes, topK);
 }
 export function fastHmacSign(secret, data) {
-    const n = getNative();
-    return n ? n.fastHmacSign(secret, data) : tsHmacSign(secret, data);
+    return tsHmacSign(secret, data);
 }
 export function fastHmacVerify(secret, data, signature) {
-    const n = getNative();
-    return n ? n.fastHmacVerify(secret, data, signature) : tsHmacVerify(secret, data, signature);
+    return tsHmacVerify(secret, data, signature);
 }
 export function fastScanProjectGraphSources(rootPath, policy, overrides = {}) {
     const limits = resolveProjectGraphLimits(policy, overrides);
-    const n = getNative();
-    if (typeof n?.scanProjectGraphSources === 'function') {
-        return n.scanProjectGraphSources(rootPath, limits);
-    }
     return tsScanProjectGraphSources(rootPath, limits);
 }
 export function fastExtractTsRelations(rootPath, paths, policy, overrides = {}) {
     const limits = resolveProjectGraphLimits(policy, overrides);
-    const n = getNative();
-    if (typeof n?.extractTsRelations === 'function') {
-        return n.extractTsRelations(rootPath, paths, limits);
-    }
     return tsExtractTsRelations(rootPath, paths, limits);
 }
-function compactEdges(edges) {
-    return {
-        ids: edges.map((edge) => edge.id),
-        from: edges.map((edge) => edge.from),
-        to: edges.map((edge) => edge.to),
-        relations: edges.map((edge) => edge.relation),
-    };
-}
 export function fastQueryAffectedNodes(seed, edges, relationFilter, policy, overrides = {}) {
     const limits = resolveProjectGraphLimits(policy, overrides);
-    const n = getNative();
-    if (typeof n?.queryAffectedNodesCompact === 'function') {
-        return n.queryAffectedNodesCompact(seed, compactEdges(edges), relationFilter, limits);
-    }
-    if (typeof n?.queryAffectedNodes === 'function') {
-        return n.queryAffectedNodes(seed, edges, relationFilter, limits);
-    }
     return tsQueryAffectedNodes(seed, edges, relationFilter, limits);
 }
 export function fastQueryShortestPath(from, to, edges, relationFilter, policy, overrides = {}) {
     const limits = resolveProjectGraphLimits(policy, overrides);
-    const n = getNative();
-    if (typeof n?.queryShortestPath === 'function') {
-        return n.queryShortestPath(from, to, edges, relationFilter, limits);
-    }
     return tsQueryShortestPath(from, to, edges, relationFilter, limits);
 }
 export function fastSelectCompactGraphSlice(seeds, nodes, edges, policy, overrides = {}) {
     const limits = resolveProjectGraphLimits(policy, overrides);
-    const n = getNative();
-    if (typeof n?.selectCompactGraphSliceCompact === 'function') {
-        return n.selectCompactGraphSliceCompact(seeds, nodes.map((node) => node.id), compactEdges(edges), limits);
-    }
-    if (typeof n?.selectCompactGraphSlice === 'function') {
-        return n.selectCompactGraphSlice(seeds, nodes, edges, limits);
-    }
     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();
-};
+// Async wrappers (SPEC-1344) --------------------------------------------------
+// These used to dispatch onto a native worker thread for hot paths. With the
+// native runtime removed, they call the synchronous TS implementation
+// directly; the shape stays a Promise so existing callers are unaffected.
+export function fastDetectDriftParallelAsync(rootPath, keywords) {
+    return Promise.resolve({ value: fastDetectDriftParallel(rootPath, keywords) });
+}
+export function fastScanAndHashFilesAsync(rootPath) {
+    return Promise.resolve({ value: fastScanAndHashFiles(rootPath) });
+}
+export function fastScanProjectMetadataAsync(rootPath) {
+    return Promise.resolve({ value: fastScanProjectMetadata(rootPath) });
+}
+export function fastScanSpecsAsync(rootPath) {
+    return Promise.resolve({ value: fastScanSpecs(rootPath) });
+}
 //# sourceMappingURL=core-bridge.js.map

package/dist/engine/execution/job-runtime.d.ts

@@ -1,6 +1,5 @@
 import { type DurableJobRecord } from '../../storage/runtime-db.js';
 import type { DurableJobIdentity, DurableJobRuntimeOptions, WatchJobInput } from '../../types/durable-job.js';
-import type { NativeWorkerOperation } from '../../types/native-worker.js';
 export declare class DurableJobNotFoundError extends Error {
     constructor(operationId: string);
 }
@@ -18,16 +17,6 @@ export declare class DurableJobRuntime implements Disposable {
         readonly payload: unknown;
         readonly maxAttempts?: number;
     }): DurableJobRecord;
-    acceptNative(input: {
-        readonly projectId: string;
-        readonly workspaceId?: string;
-        readonly operationId?: string;
-        readonly operation: NativeWorkerOperation;
-        readonly payload: Readonly<Record<string, unknown>>;
-        readonly deadlineAt: number;
-        readonly cancellationId?: string;
-        readonly maxAttempts?: number;
-    }): DurableJobRecord;
     get(input: DurableJobIdentity): DurableJobRecord;
     /** Return the allowlisted public projection for one job and its current queue scope. */
     observe(input: DurableJobIdentity | DurableJobRecord): ReturnType<typeof publicJobObservation>;

package/dist/engine/execution/job-runtime.js

@@ -2,7 +2,6 @@ import { createHash, randomUUID } from 'node:crypto';
 import { RuntimeDatabase, } from '../../storage/runtime-db.js';
 import { resolveStorageLayout } from '../../storage/storage-layout.js';
 import { getRuntimePolicy } from '../runtime-policy.js';
-import { isNativeWorkerOperation } from './native-worker-protocol.js';
 import { getExecutionContext } from './context.js';
 import { sanitizePublicJobValue } from './public-job-sanitizer.js';
 const DEFAULT_WORKSPACE_ID = 'global';
@@ -42,28 +41,6 @@ export class DurableJobRuntime {
         });
         return this.requireJob({ operationId, projectId: input.projectId, workspaceId });
     }
-    acceptNative(input) {
-        if (!isNativeWorkerOperation(input.operation)) {
-            throw new Error('[Planu] Native worker operation is not allowlisted');
-        }
-        if (!Number.isSafeInteger(input.deadlineAt) || input.deadlineAt <= Date.now()) {
-            throw new Error('[Planu] Native durable job requires a future absolute deadline');
-        }
-        const payload = {
-            kind: 'native-worker',
-            operation: input.operation,
-            payload: input.payload,
-            deadlineAt: input.deadlineAt,
-            ...(input.cancellationId === undefined ? {} : { cancellationId: input.cancellationId }),
-        };
-        return this.accept({
-            projectId: input.projectId,
-            workspaceId: input.workspaceId,
-            operationId: input.operationId,
-            payload,
-            maxAttempts: input.maxAttempts,
-        });
-    }
     get(input) {
         return this.requireJob(input);
     }

package/dist/engine/living-spec/annotation-parser.js

@@ -68,24 +68,10 @@ export function parseAnnotationsFromContent(content, file) {
     }
     return annotations;
 }
-import { fastScanSpecAnnotations, isNativeActive } from '../core-bridge.js';
 /**
  * Parse all @spec annotations from a project directory.
  */
 export async function parseAnnotationsFromProject(projectPath, filterSpecId) {
-    if (isNativeActive()) {
-        const allAnnotations = fastScanSpecAnnotations(projectPath);
-        const annotations = filterSpecId
-            ? allAnnotations.filter((a) => a.specId === filterSpecId)
-            : allAnnotations;
-        // Estimate file counts (approximate for performance if native)
-        const annotatedFilePaths = new Set(allAnnotations.map((a) => a.file));
-        return {
-            annotations,
-            fileCount: 0, // In native mode, we don't count files unless requested
-            annotatedFileCount: annotatedFilePaths.size,
-        };
-    }
     const annotations = [];
     let fileCount = 0;
     let annotatedFileCount = 0;

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

@@ -1,4 +1,4 @@
-import { fastExtractTsRelations, fastQueryAffectedNodes, fastQueryShortestPath, fastScanProjectGraphSources, fastSelectCompactGraphSlice, isNativeActive, } from '../core-bridge.js';
+import { fastExtractTsRelations, fastQueryAffectedNodes, fastQueryShortestPath, fastScanProjectGraphSources, fastSelectCompactGraphSlice, } from '../core-bridge.js';
 function toNativeNodes(nodes) {
     return nodes.map((node) => ({ id: node.id }));
 }
@@ -12,7 +12,7 @@ function toNativeEdges(edges) {
 }
 export function createNativeProjectGraphRuntime(limitsPolicy) {
     return {
-        nativeActive: isNativeActive(),
+        nativeActive: false,
         scanSources(projectPath, maxFiles) {
             return fastScanProjectGraphSources(projectPath, limitsPolicy, maxFiles === undefined ? {} : { maxFiles });
         },

package/dist/engine/sandbox/profiles/macos.sb

@@ -0,0 +1,33 @@
+;; macos.sb — sandbox-exec profile for Planu execute_sdd_flow (SPEC-742)
+;; TinyScheme syntax (Apple sandbox profile language).
+;; Denies all by default, then allows specific operations.
+
+(version 1)
+
+;; Deny everything by default
+(deny default)
+
+;; Allow read-only filesystem access (system libraries, binaries)
+(allow file-read*)
+
+;; Allow write access to project root (parameterized) and /tmp
+;; Note: The profile is parameterized with PROJECT_ROOT at runtime.
+(allow file-write*
+  (subpath (param "PROJECT_ROOT"))
+  (subpath "/tmp")
+  (subpath "/private/tmp"))
+
+;; Allow process execution (for spawning build tools)
+(allow process-exec)
+(allow process-fork)
+
+;; Allow network for npm registry only (optional — controlled by network param)
+;; Blocked by default — uncomment to allow specific connections
+;; (allow network-outbound (remote ip "104.16.0.0/12"))
+
+;; Allow IPC for process communication
+(allow ipc-posix-shm)
+(allow mach-lookup)
+
+;; Allow reading system information
+(allow sysctl-read)