@planu/cli 5.3.26 → 5.3.28

package/dist/engine/lifecycle-reconciliation.js

@@ -4,6 +4,7 @@ import { join } from 'node:path';
 import { projectDataDir } from '../storage/base-store.js';
 import { specStore } from '../storage/index.js';
 import { ValidationReportV1Schema } from './handoff-artifacts/schemas.js';
+import { AUTOMATED_VALIDATOR_AGENT } from './validator/validation-report-writer.js';
 import { rollbackTransitionSpec, transitionSpec, } from './spec-state-machine/transition-spec.js';
 import { acquireLock, releaseLock } from './safety/cross-process-lock.js';
 import { appendTransitionEvent, readTransitionLog } from '../storage/transition-log.js';
@@ -144,10 +145,10 @@ async function validateRequest(args) {
     const report = ValidationReportV1Schema.safeParse(JSON.parse(reportBytes.toString('utf8')));
     if (!report.success ||
         report.data.passed ||
-        report.data.reviewer.kind !== 'implementation-review-agent' ||
-        report.data.reviewer.agent !== 'planu-implementation-reviewer' ||
+        report.data.reviewer.kind !== 'automation' ||
+        report.data.reviewer.agent !== AUTOMATED_VALIDATOR_AGENT ||
         report.data.reviewer.verdict !== 'changes-requested') {
-        return failure('validation report is not an independent changes-requested finding');
+        return failure('validation report is not an automated changes-requested finding');
     }
     const reviewDigest = digest(reportBytes);
     if (reviewDigest !== input.implementationReviewDigest) {
@@ -197,8 +198,8 @@ async function validateStoredBinding(args) {
         const report = ValidationReportV1Schema.safeParse(JSON.parse(reportBytes.toString('utf8')));
         if (!report.success ||
             report.data.passed ||
-            report.data.reviewer.kind !== 'implementation-review-agent' ||
-            report.data.reviewer.agent !== 'planu-implementation-reviewer' ||
+            report.data.reviewer.kind !== 'automation' ||
+            report.data.reviewer.agent !== AUTOMATED_VALIDATOR_AGENT ||
             report.data.reviewer.verdict !== 'changes-requested' ||
             digest(reportBytes) !== args.receipt.implementationReviewDigest) {
             return failure('implementation review no longer matches the durable receipt', 'RECONCILIATION_BINDING_CONFLICT');

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)

package/dist/engine/scan-project/module-discoverer.js

@@ -2,9 +2,8 @@ import { technologyValue } from '../technology-registry.js';
 // engine/scan-project/module-discoverer.ts — Detects module boundaries in a project (SPEC-134)
 // Language-agnostic: supports monorepo, package-based, framework-based, and directory-based detection.
 import { readFile, readdir, stat } from 'node:fs/promises';
-import { join, relative, basename, dirname } from 'node:path';
+import { join, relative, basename } from 'node:path';
 import { glob } from 'glob';
-import { isNativeActive, fastFindFilesByName } from '../core-bridge.js';
 // === Constants ===
 const IGNORE_PATTERNS = [
     'node_modules',
@@ -210,29 +209,15 @@ async function detectMonorepo(projectPath) {
         return null;
     }
     const resolved = [];
-    if (isNativeActive()) {
-        // Rust: optimized directory resolution for monorepo patterns
-        const pkgJsonPaths = fastFindFilesByName(projectPath, ['package.json']);
-        // Filter directories that match the workspace globs (simplified heuristic).
-        const dirs = pkgJsonPaths
-            .map((p) => dirname(p))
-            .map((p) => relative(projectPath, p))
-            .filter((rel) => rel !== '' && !isIgnored(rel.split('/')[0] ?? ''));
-        // In a real implementation we would match against workspaceGlobs exactly,
-        // but for speed we take all dirs with package.json that aren't ignored.
-        resolved.push(...dirs);
-    }
-    if (resolved.length === 0) {
-        for (const pattern of workspaceGlobs) {
-            // Append '/' to match only directories (glob treats trailing slash as dir-only)
-            const dirPattern = pattern.endsWith('/') ? pattern : `${pattern}/`;
-            const matches = await glob(dirPattern, {
-                cwd: projectPath,
-                ignore: IGNORE_PATTERNS.map((p) => `**/${p}/**`),
-            });
-            // Strip trailing slash glob may add
-            resolved.push(...matches.map((m) => m.replace(/\/$/, '')));
-        }
+    for (const pattern of workspaceGlobs) {
+        // Append '/' to match only directories (glob treats trailing slash as dir-only)
+        const dirPattern = pattern.endsWith('/') ? pattern : `${pattern}/`;
+        const matches = await glob(dirPattern, {
+            cwd: projectPath,
+            ignore: IGNORE_PATTERNS.map((p) => `**/${p}/**`),
+        });
+        // Strip trailing slash glob may add
+        resolved.push(...matches.map((m) => m.replace(/\/$/, '')));
     }
     if (resolved.length === 0) {
         return null;
@@ -255,34 +240,6 @@ async function detectMonorepo(projectPath) {
 }
 // === Package-based detection ===
 async function detectPackageBased(projectPath) {
-    if (isNativeActive()) {
-        const manifests = fastFindFilesByName(projectPath, PACKAGE_MANIFESTS);
-        if (manifests.length > 0) {
-            const modules = [];
-            const seen = new Set();
-            for (const m of manifests) {
-                const rel = relative(projectPath, dirname(m));
-                if (rel === '' || rel.includes('/') || isIgnored(rel) || seen.has(rel)) {
-                    continue;
-                }
-                seen.add(rel);
-                const [estimatedFiles, language] = await Promise.all([
-                    countSourceFiles(join(projectPath, rel)),
-                    detectLanguage(join(projectPath, rel)),
-                ]);
-                modules.push({
-                    name: rel,
-                    path: rel,
-                    estimatedFiles,
-                    language,
-                    detectionMethod: 'package',
-                });
-            }
-            if (modules.length > 0) {
-                return modules;
-            }
-        }
-    }
     const subdirs = await getSubdirs(projectPath);
     const modules = [];
     for (const subdir of subdirs) {

package/dist/engine/scope-boundaries/contradiction-checker.js

@@ -66,7 +66,7 @@ function splitClauses(text) {
         .map((clause) => clause.trim())
         .filter(Boolean);
 }
-const AFFIRMATIVE_ACTION_VERBS = /\b(?:changes?|modif(?:y|ies)|alters?|adds?|introduces?|implements?|enables?|exposes?|exposed|mutat(?:e|es|ing))\b/;
+const AFFIRMATIVE_ACTION_VERBS = /\b(?:build(?:s|ing)?|chang(?:e|es|ing)|modif(?:y|ies|ying)|alter(?:s|ing)?|add(?:s|ing)?|introduc(?:e|es|ing)|implement(?:s|ing)?|enabl(?:e|es|ing)|expos(?:e|es|ing|ed)|mutat(?:e|es|ing)|rewrit(?:e|es|ing|ten))\b/;
 function assertsForbiddenAction(text) {
     return AFFIRMATIVE_ACTION_VERBS.test(normalize(text));
 }

package/dist/engine/validation/validation-receipt.d.ts

@@ -3,6 +3,11 @@ import type { RuntimeDatabase } from '../../storage/runtime-db.js';
 import { type StorageCatalogContext } from '../../storage/storage-catalog.js';
 export { normalizeValidationCommand } from './validation-receipt-codec.js';
 export declare const LOCAL_VALIDATION_RECEIPT_ISSUER = "planu-local-validator";
+export declare class ValidationReceiptSignerUnavailableError extends Error {
+    readonly reason: 'PLATFORM_UNSUPPORTED' | 'PROVIDER_NONCANONICAL' | 'PROVIDER_UNAVAILABLE';
+    readonly code: 'VALIDATION_RECEIPT_SIGNER_UNAVAILABLE';
+    constructor(reason: 'PLATFORM_UNSUPPORTED' | 'PROVIDER_NONCANONICAL' | 'PROVIDER_UNAVAILABLE', remediation?: string);
+}
 export declare class ValidationReceiptStore implements ValidationReceiptPersistence {
     private readonly options;
     private readonly logDirectory;

package/dist/engine/validation/validation-receipt.js

@@ -6,11 +6,19 @@ import { reportClassifiedDegradation } from '../../errors/classified-degradation
 import { resolvedStorageArtifactPath, } from '../../storage/storage-catalog.js';
 import { formatSecretReference, getSecretProvider, parseSecretReference, SecretProviderError, } from '../../security/secret-provider.js';
 import { redactText } from '../../security/redactor.js';
-import { ValidationReceiptSignerUnavailableError } from '../macos-keychain-native-port.js';
 import { acquireLock, releaseLock } from '../safety/file-mutex.js';
 import { canonicalize, DIGEST, ISSUER_ID, PROJECT_ID, receiptCore, safeProof, sha256, SPEC_ID, validBindings, validReceiptShape, } from './validation-receipt-codec.js';
 export { normalizeValidationCommand } from './validation-receipt-codec.js';
 export const LOCAL_VALIDATION_RECEIPT_ISSUER = 'planu-local-validator';
+export class ValidationReceiptSignerUnavailableError extends Error {
+    reason;
+    code = 'VALIDATION_RECEIPT_SIGNER_UNAVAILABLE';
+    constructor(reason, remediation = 'Restart the MCP host and retry.') {
+        super(`[Planu] VALIDATION_RECEIPT_SIGNER_UNAVAILABLE:${reason} ${remediation}`);
+        this.reason = reason;
+        this.name = 'ValidationReceiptSignerUnavailableError';
+    }
+}
 export class ValidationReceiptStore {
     options;
     logDirectory;

package/dist/engine/validator/deep-code-checker.js

@@ -1,7 +1,7 @@
 // Planu — Validator: deep code checker
 // Performs real filesystem/grep analysis for spec criteria that go beyond file-name matching.
 import { readFile, stat } from 'node:fs/promises';
-import { join, relative } from 'node:path';
+import { join } from 'node:path';
 import { glob } from 'glob';
 const DEFAULT_IGNORE = ['node_modules/**', 'dist/**', 'build/**', '.git/**', 'coverage/**'];
 function escapeRegex(input) {
@@ -152,7 +152,6 @@ async function resolveFiles(scopeGlob, projectPath, exclude) {
     }
 }
 // ─── Checkers ─────────────────────────────────────────────────────────────────
-import { isNativeActive, fastFindPatterns } from '../core-bridge.js';
 function buildRegex(pattern) {
     try {
         return new RegExp(pattern, 'g');
@@ -174,32 +173,26 @@ function buildRegex(pattern) {
  */
 export async function grepCheck(config, projectPath, checkType) {
     const evidence = [];
-    if (isNativeActive()) {
-        const results = fastFindPatterns(projectPath, [config.pattern], [], config.exclude ? [config.exclude] : []);
-        evidence.push(...results.map((r) => `${relative(projectPath, r.path)}:${r.line}`));
-    }
-    else {
-        const files = await resolveFiles(config.scope, projectPath, config.exclude);
-        const regex = buildRegex(config.pattern);
-        if (regex) {
-            await Promise.all(files.map(async (file) => {
-                const fullPath = join(projectPath, file);
-                try {
-                    const content = await readFile(fullPath, 'utf-8');
-                    const lines = content.split('\n');
-                    for (let i = 0; i < lines.length; i++) {
-                        const line = lines[i];
-                        if (line !== undefined && regex.test(line)) {
-                            evidence.push(`${file}:${i + 1}`);
-                            regex.lastIndex = 0;
-                        }
+    const files = await resolveFiles(config.scope, projectPath, config.exclude);
+    const regex = buildRegex(config.pattern);
+    if (regex) {
+        await Promise.all(files.map(async (file) => {
+            const fullPath = join(projectPath, file);
+            try {
+                const content = await readFile(fullPath, 'utf-8');
+                const lines = content.split('\n');
+                for (let i = 0; i < lines.length; i++) {
+                    const line = lines[i];
+                    if (line !== undefined && regex.test(line)) {
+                        evidence.push(`${file}:${i + 1}`);
+                        regex.lastIndex = 0;
                     }
                 }
-                catch {
-                    // Skip unreadable files
-                }
-            }));
-        }
+            }
+            catch {
+                // Skip unreadable files
+            }
+        }));
     }
     const matchCount = evidence.length;
     const passed = checkType === 'grep_absent' ? matchCount === 0 : matchCount >= config.expected;

package/dist/engine/validator/validation-report-writer.d.ts

@@ -1,6 +1,7 @@
 import type { Spec } from '../../types/index.js';
 import type { ValidationReportV1 } from '../../types/handoff-artifacts.js';
 import type { MinimalImplementationReport } from '../../types/minimal-implementation-gate.js';
+export declare const AUTOMATED_VALIDATOR_AGENT = "planu-automated-validator";
 export declare function writeImplementationReviewReport(input: {
     projectId: string;
     specId: string;

package/dist/engine/validator/validation-report-writer.js

@@ -1,5 +1,6 @@
 import { appendArtifact, readArtifact } from '../handoff-artifacts/io.js';
 import { runSpecCompliance, } from './spec-compliance-runner.js';
+export const AUTOMATED_VALIDATOR_AGENT = 'planu-automated-validator';
 export async function writeImplementationReviewReport(input) {
     const specCompliance = await runSpecCompliance(input.spec, input.projectPath, input.signal, input.projectId);
     const reportScore = resolveExecutableValidationScore(input.score, specCompliance);
@@ -13,8 +14,8 @@ export async function writeImplementationReviewReport(input) {
     const mergedGates = await preserveUnobservedGates(input, gates);
     const passed = mergedGates.every((gate) => gate.passed);
     const reviewer = {
-        kind: 'implementation-review-agent',
-        agent: 'planu-implementation-reviewer',
+        kind: 'automation',
+        agent: AUTOMATED_VALIDATOR_AGENT,
         verdict: passed ? 'approved' : 'changes-requested',
     };
     const reportCompliance = toValidationReportCompliance(specCompliance);

package/dist/security/adapters/macos-keychain.d.ts

@@ -1,15 +1,17 @@
-import type { MacOSKeychainNativePort, MacOSKeychainOperation, SecretStoreAdapter } from '../../types/security.js';
+import type { MacOSKeychainOperation, SecretStoreAdapter } from '../../types/security.js';
 export declare class MacOSKeychainOperationError extends Error {
     readonly code: 'KEYCHAIN_TIMEOUT' | 'KEYCHAIN_OUTCOME_UNKNOWN';
     constructor(code: 'KEYCHAIN_TIMEOUT' | 'KEYCHAIN_OUTCOME_UNKNOWN', operation: MacOSKeychainOperation);
 }
 export declare class MacOSKeychainAdapter implements SecretStoreAdapter {
-    private readonly nativePort;
+    private readonly run;
     private readonly timeoutMs;
     readonly kind: 'macos-keychain';
     private readonly pending;
     private nextFence;
-    constructor(nativePort?: () => MacOSKeychainNativePort, timeoutMs?: number);
+    constructor(run?: (args: string[]) => Promise<{
+        stdout: string;
+    }>, timeoutMs?: number);
     get(id: string): Promise<string | null>;
     set(id: string, value: string): Promise<void>;
     delete(id: string): Promise<void>;

package/dist/security/adapters/macos-keychain.js

@@ -1,6 +1,20 @@
-import { requireMacOSKeychainNativePort } from '../../engine/core-bridge.js';
+import { execFile as execFileCallback } from 'node:child_process';
+import { promisify } from 'node:util';
+import { reportClassifiedDegradation } from '../../errors/classified-degradation.js';
+const execFile = promisify(execFileCallback);
 const TIMEOUT_MS = 10_000;
-const decoder = new TextDecoder('utf-8', { fatal: true });
+const SERVICE_LABEL = 'Planu';
+const MISSING_ITEM_EXIT_CODE = 44;
+async function defaultSecurityRun(args) {
+    return execFile('/usr/bin/security', args, { timeout: TIMEOUT_MS });
+}
+function isMissingCredentialExit(error) {
+    const failure = error;
+    return failure.code === MISSING_ITEM_EXIT_CODE || failure.code === String(MISSING_ITEM_EXIT_CODE);
+}
+function stripTrailingNewline(value) {
+    return value.endsWith('\n') ? value.slice(0, -1) : value;
+}
 export class MacOSKeychainOperationError extends Error {
     code;
     constructor(code, operation) {
@@ -12,13 +26,13 @@ export class MacOSKeychainOperationError extends Error {
     }
 }
 export class MacOSKeychainAdapter {
-    nativePort;
+    run;
     timeoutMs;
     kind = 'macos-keychain';
     pending = new Map();
     nextFence = 0;
-    constructor(nativePort = requireMacOSKeychainNativePort, timeoutMs = TIMEOUT_MS) {
-        this.nativePort = nativePort;
+    constructor(run = defaultSecurityRun, timeoutMs = TIMEOUT_MS) {
+        this.run = run;
         this.timeoutMs = timeoutMs;
         if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1) {
             throw new Error('[Planu] macOS Keychain timeout must be a positive integer');
@@ -26,32 +40,44 @@ export class MacOSKeychainAdapter {
     }
     get(id) {
         return this.enqueue(id, 'get', false, async () => {
-            const secret = await this.nativePort().get(id);
-            if (secret === null) {
-                return null;
-            }
             try {
-                return decoder.decode(secret);
+                const result = await this.run([
+                    'find-generic-password',
+                    '-a',
+                    id,
+                    '-s',
+                    SERVICE_LABEL,
+                    '-w',
+                ]);
+                return Buffer.from(stripTrailingNewline(result.stdout), 'base64').toString('utf8');
             }
-            finally {
-                secret.fill(0);
+            catch (error) {
+                if (isMissingCredentialExit(error)) {
+                    return null;
+                }
+                throw error;
             }
         });
     }
     set(id, value) {
-        return this.enqueue(id, 'set', true, () => {
-            const secret = Buffer.from(value, 'utf8');
+        return this.enqueue(id, 'set', true, async () => {
+            const encoded = Buffer.from(value, 'utf8').toString('base64');
+            await this.run(['add-generic-password', '-U', '-a', id, '-s', SERVICE_LABEL, '-w', encoded]);
+        });
+    }
+    delete(id) {
+        return this.enqueue(id, 'delete', true, async () => {
             try {
-                return this.nativePort().set(id, secret);
+                await this.run(['delete-generic-password', '-a', id, '-s', SERVICE_LABEL]);
             }
-            finally {
-                secret.fill(0);
+            catch (error) {
+                if (!isMissingCredentialExit(error)) {
+                    throw error;
+                }
+                reportClassifiedDegradation('MACOS_SECRET_DELETE', error);
             }
         });
     }
-    delete(id) {
-        return this.enqueue(id, 'delete', true, () => this.nativePort().delete(id));
-    }
     enqueue(id, operation, mutates, execute) {
         const predecessor = this.pending.get(id)?.settled ?? Promise.resolve();
         const fence = (this.nextFence += 1);

package/dist/tools/create-spec/autopilot-analyzer.d.ts

@@ -20,7 +20,7 @@ export declare function getEmptyAutopilotResult(): AutopilotAnalysis;
  * Analyze the project to enrich a spec with real file paths and patterns.
  * Runs automatically during create_spec — no user interaction needed.
  */
-export declare function analyzeProjectForSpec(projectPath: string, description: string, title: string, _knowledge: ProjectKnowledge | null, signal?: AbortSignal): Promise<AutopilotAnalysis>;
+export declare function analyzeProjectForSpec(projectPath: string, description: string, title: string, _knowledge: ProjectKnowledge | null): Promise<AutopilotAnalysis>;
 /**
  * SPEC-619 AC1: Detect broad-scope descriptions that mention 2+ major subsystems.
  * When true, create_spec should ask clarifying questions before proceeding.

package/dist/tools/create-spec/autopilot-analyzer.js

@@ -17,7 +17,7 @@ export function getEmptyAutopilotResult() {
  * Analyze the project to enrich a spec with real file paths and patterns.
  * Runs automatically during create_spec — no user interaction needed.
  */
-export async function analyzeProjectForSpec(projectPath, description, title, _knowledge, signal) {
+export async function analyzeProjectForSpec(projectPath, description, title, _knowledge) {
     const result = {
         suggestedFiles: { create: [], modify: [], test: [] },
         detectedPatterns: [],
@@ -44,7 +44,7 @@ export async function analyzeProjectForSpec(projectPath, description, title, _kn
     const keywords = extractKeywordsScorer(`${title} ${description}`);
     // Scan project files to find semantically related ones
     try {
-        const relatedFiles = await findRelevantFiles(projectPath, keywords, 10, signal);
+        const relatedFiles = await findRelevantFiles(projectPath, keywords, 10);
         if (relatedFiles.length === 0) {
             result.noRelatedFilesMessage =
                 'No related files detected — please populate ## Technical manually';

package/dist/tools/create-spec/relevance-scorer.d.ts

@@ -14,5 +14,5 @@ export declare function scoreFile(filePath: string, keywords: Set<string>): Prom
  * Scans `src/**\/\*.ts` and `tests/**\/\*.ts` under projectPath,
  * scores each, drops score=0 entries, returns top-`limit` by descending score.
  */
-export declare function findRelevantFiles(projectPath: string, keywords: Set<string>, limit?: number, signal?: AbortSignal): Promise<string[]>;
+export declare function findRelevantFiles(projectPath: string, keywords: Set<string>, limit?: number): Promise<string[]>;
 //# sourceMappingURL=relevance-scorer.d.ts.map

package/dist/tools/create-spec/relevance-scorer.js

@@ -4,9 +4,6 @@
 import { readFile } from 'node:fs/promises';
 import { glob } from 'glob';
 import { join } from 'node:path';
-import { isNativeActive } from '../../engine/core-bridge.js';
-import { runNativeWorkerOperation } from '../../engine/execution/native-worker-runtime.js';
-import { hashProjectPath } from '../../storage/base-store.js';
 /** Stop words to exclude from keyword extraction. */
 const STOP_WORDS = new Set([
     // English stop words
@@ -136,23 +133,10 @@ export async function scoreFile(filePath, keywords) {
  * Scans `src/**\/\*.ts` and `tests/**\/\*.ts` under projectPath,
  * scores each, drops score=0 entries, returns top-`limit` by descending score.
  */
-export async function findRelevantFiles(projectPath, keywords, limit = 10, signal) {
+export async function findRelevantFiles(projectPath, keywords, limit = 10) {
     if (keywords.size === 0) {
         return [];
     }
-    if (isNativeActive()) {
-        const result = await runNativeWorkerOperation({
-            projectId: hashProjectPath(projectPath),
-            operation: 'find-relevant-files',
-            payload: { rootPath: projectPath, keywords: [...keywords], limit },
-            deadlineAt: Date.now() + 5_000,
-            signal,
-        });
-        if (!Array.isArray(result) || !result.every((filePath) => typeof filePath === 'string')) {
-            throw new Error('[Planu] Native relevance worker returned an invalid payload');
-        }
-        return result;
-    }
     const patterns = [join(projectPath, 'src/**/*.ts'), join(projectPath, 'tests/**/*.ts')];
     const candidates = [];
     for (const pattern of patterns) {

package/dist/tools/create-spec.js

@@ -1099,7 +1099,7 @@ async function prepareCreateSpecCandidate(initialParams, server) {
     if (constitutionCheck.blocked && constitutionCheck.errorResult) {
         return earlyPreparation(constitutionCheck.errorResult);
     }
-    const inlineAnalysis = await withBudget('create-spec-inline-analysis', getRuntimePolicy().createSpec.inlineAnalysisBudgetMs, (signal) => analyzeProjectForSpec(params.projectPath ?? '', params.description, spec.title, knowledge, signal));
+    const inlineAnalysis = await withBudget('create-spec-inline-analysis', getRuntimePolicy().createSpec.inlineAnalysisBudgetMs, () => analyzeProjectForSpec(params.projectPath ?? '', params.description, spec.title, knowledge));
     const autopilot = unwrapBudget(inlineAnalysis, getEmptyAutopilotResult());
     if (autopilot.isIdea) {
         return earlyPreparation({

package/dist/tools/update-status/dod-gates.d.ts

@@ -107,6 +107,7 @@ export declare function checkValidationReportGate(specId: string, projectId: str
 export declare function readApprovedValidationReportGate(specId: string, projectId: string, force: boolean | undefined): Promise<ValidationReportGateResult>;
 /** SPEC-1051: Approval requires a dedicated spec reviewer artifact. */
 export declare function checkSpecReviewGate(specId: string, projectId: string, _forceApprove: boolean | undefined): Promise<ToolResult | null>;
+export declare function checkImplementationReviewGate(specId: string, projectId: string, _force: boolean | undefined): Promise<ToolResult | null>;
 /**
  * SPEC-335: Combined done-gates runner — DoD + security.
  * When force=true, gates are not blocking but failing items are recorded in