@planu/cli 5.3.26 → 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/handoff-artifacts/io.js

@@ -32,6 +32,7 @@ function eventTypeForKind(kind) {
         review_feedback: 'handoff.review_feedback',
         'implementation-report': 'handoff.implementation-report',
         'validation-report': 'handoff.validation-report',
+        implementation_review: 'handoff.implementation_review',
     };
     return map[kind];
 }

package/dist/engine/handoff-artifacts/schemas.d.ts

@@ -53,6 +53,29 @@ export declare const ReviewFeedbackV1Schema: z.ZodObject<{
     body: z.ZodString;
     reviewedAt: z.ZodISODateTime;
 }, z.core.$strip>;
+export declare const ImplementationReviewV1Schema: z.ZodObject<{
+    schema_version: z.ZodString;
+    specId: z.ZodString;
+    verdict: z.ZodEnum<{
+        approved: "approved";
+        "changes-requested": "changes-requested";
+    }>;
+    reviewer: z.ZodObject<{
+        kind: z.ZodEnum<{
+            human: "human";
+            "implementation-review-agent": "implementation-review-agent";
+        }>;
+        agent: z.ZodString;
+        verdict: z.ZodEnum<{
+            approved: "approved";
+            "changes-requested": "changes-requested";
+        }>;
+    }, z.core.$strip>;
+    blockers: z.ZodArray<z.ZodString>;
+    suggestions: z.ZodArray<z.ZodString>;
+    body: z.ZodString;
+    reviewedAt: z.ZodISODateTime;
+}, z.core.$strip>;
 export declare const ImplementationReportV1Schema: z.ZodObject<{
     schema_version: z.ZodString;
     specId: z.ZodString;
@@ -314,6 +337,29 @@ export declare const ARTIFACT_SCHEMAS: {
         score: z.ZodOptional<z.ZodNumber>;
         completedAt: z.ZodISODateTime;
     }, z.core.$strip>;
+    readonly implementation_review: z.ZodObject<{
+        schema_version: z.ZodString;
+        specId: z.ZodString;
+        verdict: z.ZodEnum<{
+            approved: "approved";
+            "changes-requested": "changes-requested";
+        }>;
+        reviewer: z.ZodObject<{
+            kind: z.ZodEnum<{
+                human: "human";
+                "implementation-review-agent": "implementation-review-agent";
+            }>;
+            agent: z.ZodString;
+            verdict: z.ZodEnum<{
+                approved: "approved";
+                "changes-requested": "changes-requested";
+            }>;
+        }, z.core.$strip>;
+        blockers: z.ZodArray<z.ZodString>;
+        suggestions: z.ZodArray<z.ZodString>;
+        body: z.ZodString;
+        reviewedAt: z.ZodISODateTime;
+    }, z.core.$strip>;
 };
 /**
  * Validate a payload against the schema for the given artifact kind.

package/dist/engine/handoff-artifacts/schemas.js

@@ -39,6 +39,20 @@ export const ReviewFeedbackV1Schema = z.object({
     body: z.string(),
     reviewedAt: z.iso.datetime(),
 });
+export const ImplementationReviewV1Schema = z.object({
+    schema_version: SchemaVersion,
+    specId: z.string(),
+    verdict: z.enum(['approved', 'changes-requested']),
+    reviewer: z.object({
+        kind: z.enum(['implementation-review-agent', 'human']),
+        agent: z.string().min(1),
+        verdict: z.enum(['approved', 'changes-requested']),
+    }),
+    blockers: z.array(z.string()),
+    suggestions: z.array(z.string()),
+    body: z.string(),
+    reviewedAt: z.iso.datetime(),
+});
 export const ImplementationReportV1Schema = z.object({
     schema_version: SchemaVersion,
     specId: z.string(),
@@ -163,6 +177,7 @@ export const ARTIFACT_SCHEMAS = {
     review_feedback: ReviewFeedbackV1Schema,
     'implementation-report': ImplementationReportV1Schema,
     'validation-report': ValidationReportV1Schema,
+    implementation_review: ImplementationReviewV1Schema,
 };
 // ---------------------------------------------------------------------------
 // Validate function