@planu/cli 4.12.3 → 4.14.1

package/dist/tools/clarify-requirements/multiple-choice.js

@@ -1,5 +1,4 @@
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
+import { technologyValue } from '../../engine/technology-registry.js';
 // tools/clarify-requirements/multiple-choice.ts — SPEC-337
 // Structured multiple-choice options for clarify_requirements interview mode.
 // Provides: per-question options[], stack detection, suggestedDescription builder.
@@ -7,23 +6,23 @@ import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 const OPTIONS_CATALOG = {
     stack_frontend: [
-        'Next.js',
-        'Remix',
-        'Nuxt',
-        'SvelteKit',
-        'Astro',
+        technologyValue('technology-next-js-30b7f8'),
+        technologyValue('technology-remix-f84ed4'),
+        technologyValue('technology-nuxt-e88c87'),
+        technologyValue('technology-sveltekit-b62200'),
+        technologyValue('technology-astro-c490cc'),
         'Vite + React',
-        'Angular',
+        technologyValue('technology-angular-e79052'),
         'Other: ___',
     ],
     stack_backend: [
-        'Express',
-        'Fastify',
-        'NestJS',
+        technologyValue('technology-express-572a14'),
+        technologyValue('technology-fastify-ed8050'),
+        technologyValue('technology-nestjs-58b822'),
         'Hono',
-        'FastAPI',
-        'Django',
-        'Spring Boot',
+        technologyValue('technology-fastapi-2dd9eb'),
+        technologyValue('technology-django-4445d9'),
+        technologyValue('technology-spring-boot-8d9a80'),
         'Other: ___',
     ],
     stack_database: [
@@ -31,12 +30,20 @@ const OPTIONS_CATALOG = {
         'MySQL',
         'SQLite',
         'MongoDB',
-        'Redis',
-        'Supabase',
+        technologyValue('technology-redis-a7f641'),
+        technologyValue('technology-supabase-fe7ceb'),
         'PlanetScale',
         'Other: ___',
     ],
-    stack_language: ['TypeScript', 'JavaScript', 'Python', 'Go', 'Java', 'Rust', 'Other: ___'],
+    stack_language: [
+        technologyValue('technology-typescript-ed0504'),
+        'JavaScript',
+        'Python',
+        'Go',
+        'Java',
+        'Rust',
+        'Other: ___',
+    ],
     auth_method: [
         'Email + password',
         'Google OAuth',
@@ -101,35 +108,37 @@ export async function detectStack(projectPath) {
         result.detectedLibs = libs;
         // Framework detection
         if (libs.includes('next')) {
-            result.framework = 'Next.js';
+            result.framework = technologyValue('technology-next-js-30b7f8');
         }
         else if (libs.includes('@remix-run/react') || libs.includes('@remix-run/node')) {
-            result.framework = 'Remix';
+            result.framework = technologyValue('technology-remix-f84ed4');
         }
-        else if (libs.includes('nuxt')) {
-            result.framework = 'Nuxt';
+        else if (libs.includes(technologyValue('technology-nuxt-22c407'))) {
+            result.framework = technologyValue('technology-nuxt-e88c87');
         }
         else if (libs.includes('@sveltejs/kit')) {
-            result.framework = 'SvelteKit';
+            result.framework = technologyValue('technology-sveltekit-b62200');
         }
-        else if (libs.includes('astro')) {
-            result.framework = 'Astro';
+        else if (libs.includes(technologyValue('technology-astro-23661e'))) {
+            result.framework = technologyValue('technology-astro-c490cc');
         }
-        else if (libs.includes('fastify')) {
-            result.framework = 'Fastify';
+        else if (libs.includes(technologyValue('technology-fastify-cbe57e'))) {
+            result.framework = technologyValue('technology-fastify-ed8050');
         }
         else if (libs.includes('@nestjs/core')) {
-            result.framework = 'NestJS';
+            result.framework = technologyValue('technology-nestjs-58b822');
         }
-        else if (libs.includes('express')) {
-            result.framework = 'Express';
+        else if (libs.includes(technologyValue('technology-express-008231'))) {
+            result.framework = technologyValue('technology-express-572a14');
         }
         else if (libs.includes('hono')) {
             result.framework = 'Hono';
         }
         // Language (TypeScript presence)
-        if (libs.includes('typescript') || libs.includes('ts-node') || libs.includes('tsx')) {
-            result.language = 'TypeScript';
+        if (libs.includes(technologyValue('technology-typescript-969545')) ||
+            libs.includes('ts-node') ||
+            libs.includes('tsx')) {
+            result.language = technologyValue('technology-typescript-ed0504');
         }
         else {
             result.language = 'JavaScript';
@@ -144,14 +153,16 @@ export async function detectStack(projectPath) {
         else if (libs.includes('better-sqlite3') || libs.includes('sqlite3')) {
             result.database = 'SQLite';
         }
-        else if (libs.includes('mongoose') || libs.includes('mongodb')) {
+        else if (libs.includes(technologyValue('technology-mongoose-4e1812')) ||
+            libs.includes('mongodb')) {
             result.database = 'MongoDB';
         }
         else if (libs.includes('@supabase/supabase-js')) {
-            result.database = 'Supabase';
+            result.database = technologyValue('technology-supabase-fe7ceb');
         }
-        else if (libs.includes('ioredis') || libs.includes('redis')) {
-            result.database = 'Redis';
+        else if (libs.includes('ioredis') ||
+            libs.includes(technologyValue('technology-redis-34fb46'))) {
+            result.database = technologyValue('technology-redis-a7f641');
         }
     }
     catch {
@@ -162,16 +173,17 @@ export async function detectStack(projectPath) {
                 .split('\n')
                 .map((l) => (l.split('=')[0] ?? l).split('>')[0]?.split('<')[0]?.trim().toLowerCase() ?? '');
             result.detectedLibs = lines.filter(Boolean);
-            if (lines.includes('django') || lines.includes('django-rest-framework')) {
-                result.framework = 'Django';
+            if (lines.includes(technologyValue('technology-django-7d8a08')) ||
+                lines.includes('django-rest-framework')) {
+                result.framework = technologyValue('technology-django-4445d9');
                 result.language = 'Python';
             }
-            else if (lines.includes('fastapi')) {
-                result.framework = 'FastAPI';
+            else if (lines.includes(technologyValue('technology-fastapi-6aee0e'))) {
+                result.framework = technologyValue('technology-fastapi-2dd9eb');
                 result.language = 'Python';
             }
-            else if (lines.includes('flask')) {
-                result.framework = 'Flask';
+            else if (lines.includes(technologyValue('technology-flask-b87aa5'))) {
+                result.framework = technologyValue('technology-flask-c08622');
                 result.language = 'Python';
             }
             else {

package/dist/tools/comments-handler.js

@@ -1,11 +1,10 @@
-// tools/comments-handler.ts — Spec Comments tool handlers (SPEC-282)
-import { join } from 'node:path';
 import { addComment, listComments, resolveComment, replyComment, } from '../storage/comments-store.js';
+import { hashProjectPath, projectDataDir } from '../storage/base-store.js';
 // ---------------------------------------------------------------------------
 // Data directory helper
 // ---------------------------------------------------------------------------
 function getDataDir(projectPath) {
-    return join(projectPath, 'data');
+    return projectDataDir(hashProjectPath(projectPath));
 }
 // ---------------------------------------------------------------------------
 // add_comment handler

package/dist/tools/compliance-test-handler.js

@@ -1,4 +1,4 @@
-// tools/compliance-test-handler.ts — SPEC-390: Compliance Test Suite Generator handlers
+import { technologyValue } from '../engine/technology-registry.js';
 import { generateComplianceTests } from '../engine/compliance-test-generator/index.js';
 import { getControlsForFrameworks } from '../engine/compliance-test-generator/control-mapper.js';
 import { specStore } from '../storage/index.js';
@@ -17,7 +17,7 @@ export async function handleGenerateComplianceTests(input) {
             ],
         };
     }
-    const outputFormat = input.outputFormat ?? 'jest';
+    const outputFormat = input.outputFormat ?? technologyValue('technology-jest-35e99f');
     const result = await generateComplianceTests(spec.specPath, input.specId, input.frameworks, outputFormat);
     const fileLines = result.generatedFiles.map((f) => `  ${f.path} (${f.content.split('\n').length} lines)`);
     const coveredCount = result.coverageReport.filter((r) => r.covered).length;

package/dist/tools/configure-telemetry.js

@@ -1,18 +1,18 @@
-import { readTelemetryConfig, writeTelemetryConfig, getOrCreateInstallationId, } from '../engine/telemetry/index.js';
+import { readTelemetryConfig, writeTelemetryConfig, TELEMETRY_CONSENT_VERSION, } from '../engine/telemetry/index.js';
 import { compactResult, compactError, formatKeyValue } from './output-formatter.js';
 export async function handleConfigureTelemetry(input) {
     try {
-        const installationId = await getOrCreateInstallationId();
         const existing = await readTelemetryConfig();
+        const enabled = existing?.enabled === true && existing.consentVersion === TELEMETRY_CONSENT_VERSION;
         if (input.action === 'status') {
             const observatoryStatus = existing?.enableObservatory === true
                 ? ' Observatory: ENABLED (cross-project insights active).'
                 : ' Observatory: DISABLED (use enableObservatory=true to opt in).';
             const result = {
                 action: 'status',
-                enabled: existing?.enabled ?? false,
-                installationId,
-                message: (existing?.enabled
+                enabled,
+                consentVersion: existing?.consentVersion,
+                message: (enabled
                     ? 'Telemetry is ENABLED. Anonymous usage events are being sent to help improve Planu.'
                     : 'Telemetry is DISABLED. No data is being collected.') + observatoryStatus,
             };
@@ -21,8 +21,8 @@ export async function handleConfigureTelemetry(input) {
         if (input.action === 'enable') {
             await writeTelemetryConfig({
                 enabled: true,
-                installationId,
                 promptedAt: existing?.promptedAt ?? new Date().toISOString(),
+                consentVersion: TELEMETRY_CONSENT_VERSION,
                 enableObservatory: input.enableObservatory ?? existing?.enableObservatory,
             });
             const observatoryNote = input.enableObservatory === true
@@ -31,10 +31,10 @@ export async function handleConfigureTelemetry(input) {
             const result = {
                 action: 'enable',
                 enabled: true,
-                installationId,
+                consentVersion: TELEMETRY_CONSENT_VERSION,
                 message: 'Telemetry ENABLED. Thank you! Only anonymous usage data is collected — ' +
-                    'no paths, emails, or personal info. Your installation ID is ' +
-                    `${installationId}. Run configure_telemetry with action=disable to opt out anytime.` +
+                    'no paths, emails, identifiers, source content, or raw errors. ' +
+                    'Run configure_telemetry with action=disable to opt out anytime.' +
                     observatoryNote,
             };
             return compactResult(formatKeyValue(result));
@@ -42,14 +42,14 @@ export async function handleConfigureTelemetry(input) {
         // disable
         await writeTelemetryConfig({
             enabled: false,
-            installationId,
             promptedAt: existing?.promptedAt ?? new Date().toISOString(),
+            consentVersion: existing?.consentVersion,
             enableObservatory: existing?.enableObservatory,
         });
         const result = {
             action: 'disable',
             enabled: false,
-            installationId,
+            consentVersion: existing?.consentVersion,
             message: 'Telemetry DISABLED. No usage data will be sent.',
         };
         return compactResult(formatKeyValue(result));

package/dist/tools/create-spec/auto-pipeline.js

@@ -207,8 +207,17 @@ export async function runAutoPostCreatePipeline(specId, projectId, _projectPath)
     const timeout = setTimeout(() => {
         controller.abort(abortError(`Auto-pipeline timeout (${String(AUTO_PIPELINE_TIMEOUT_MS / 1000)}s)`));
     }, AUTO_PIPELINE_TIMEOUT_MS);
+    let rejectOnAbort;
+    const aborted = new Promise((_resolve, reject) => {
+        rejectOnAbort = () => {
+            reject(controller.signal.reason instanceof Error
+                ? controller.signal.reason
+                : abortError('Auto-pipeline aborted'));
+        };
+        controller.signal.addEventListener('abort', rejectOnAbort, { once: true });
+    });
     try {
-        return await runPipelineInternal(specId, projectId, controller.signal);
+        return await Promise.race([runPipelineInternal(specId, projectId, controller.signal), aborted]);
     }
     catch (err) {
         if (err instanceof Error && err.name === 'AbortError') {
@@ -229,6 +238,9 @@ export async function runAutoPostCreatePipeline(specId, projectId, _projectPath)
     }
     finally {
         clearTimeout(timeout);
+        if (rejectOnAbort) {
+            controller.signal.removeEventListener('abort', rejectOnAbort);
+        }
     }
 }
 //# sourceMappingURL=auto-pipeline.js.map

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): Promise<AutopilotAnalysis>;
+export declare function analyzeProjectForSpec(projectPath: string, description: string, title: string, _knowledge: ProjectKnowledge | null, signal?: AbortSignal): 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

@@ -1,5 +1,3 @@
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
 // tools/create-spec/autopilot-analyzer.ts — SPEC-461 Phase 3: Autopilot analysis for create_spec
 // Analyzes project code to suggest real files, detect patterns, and enrich specs automatically.
 import { relative, extname } from 'node:path';
@@ -19,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) {
+export async function analyzeProjectForSpec(projectPath, description, title, _knowledge, signal) {
     const result = {
         suggestedFiles: { create: [], modify: [], test: [] },
         detectedPatterns: [],
@@ -46,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);
+        const relatedFiles = await findRelevantFiles(projectPath, keywords, 10, signal);
         if (relatedFiles.length === 0) {
             result.noRelatedFilesMessage =
                 'No related files detected — please populate ## Technical manually';

package/dist/tools/create-spec/mcp-tool-contract.d.ts

@@ -1,13 +1,19 @@
-import type { ProjectKnowledge, ToolContract } from '../../types/index.js';
+import type { ProjectKnowledge, ToolContract, MCPErrorCode } from '../../types/index.js';
 export declare function isMcpToolContract(knowledge: ProjectKnowledge | null): boolean;
+export interface McpToolContractOptions {
+    /** Explicit effects declared by the caller; descriptions are never treated as executable metadata. */
+    sideEffects?: readonly string[];
+    /** Explicit protocol errors beyond the safe default contract. */
+    errorCodes?: readonly MCPErrorCode[];
+}
 /**
  * Generate a ToolContract for an MCP tool.
  * Criterion 4: name, description, inputSchema (Zod), outputSchema, side effects, error codes, timeout.
  */
-export declare function generateMcpToolContract(toolName: string, description: string, inputFields: string[]): ToolContract;
-export declare function formatMcpToolContractAsMarkdown(tools: {
+export declare function generateMcpToolContract(toolName: string, description: string, inputFields: string[], options?: McpToolContractOptions): ToolContract;
+export declare function formatMcpToolContractAsMarkdown(tools: ({
     name: string;
     description: string;
     fields: string[];
-}[], knowledge: ProjectKnowledge): string;
+} & McpToolContractOptions)[], knowledge: ProjectKnowledge): string;
 //# sourceMappingURL=mcp-tool-contract.d.ts.map

package/dist/tools/create-spec/mcp-tool-contract.js

@@ -2,6 +2,7 @@
 // SPEC-016b: Generates Tool Contracts for MCP tools.
 // Criterion 4: define_ui_contract generates "Tool Contract" for MCP servers.
 import { isMcpServerProject } from '../../engine/detectors/mcp-server-detector.js';
+import { getRuntimePolicy } from '../../engine/runtime-policy.js';
 // === Detection ===
 export function isMcpToolContract(knowledge) {
     if (!knowledge) {
@@ -10,42 +11,12 @@ export function isMcpToolContract(knowledge) {
     return isMcpServerProject(knowledge);
 }
 // === Tool Contract builder ===
-function buildErrorCodes(toolName, description) {
-    const codes = ['InvalidParams', 'InternalError'];
-    const lower = description.toLowerCase();
-    if (lower.includes('not found') ||
-        lower.includes('missing') ||
-        lower.includes(toolName.toLowerCase())) {
-        codes.push('MethodNotFound');
-    }
-    // Deduplicate
-    return [...new Set(codes)];
-}
-function buildSideEffects(description) {
-    const lower = description.toLowerCase();
-    const effects = [];
-    if (lower.includes('write') || lower.includes('create') || lower.includes('save')) {
-        effects.push('filesystem-write');
-    }
-    if (lower.includes('delete') || lower.includes('remove')) {
-        effects.push('filesystem-delete');
-    }
-    if (lower.includes('http') || lower.includes('fetch') || lower.includes('api')) {
-        effects.push('network-call');
-    }
-    if (lower.includes('database') || lower.includes('db') || lower.includes('query')) {
-        effects.push('database-read');
-    }
-    if (lower.includes('email') || lower.includes('notify') || lower.includes('send')) {
-        effects.push('external-service-call');
-    }
-    return effects;
-}
+const DEFAULT_ERROR_CODES = ['InvalidParams', 'InternalError'];
 /**
  * Generate a ToolContract for an MCP tool.
  * Criterion 4: name, description, inputSchema (Zod), outputSchema, side effects, error codes, timeout.
  */
-export function generateMcpToolContract(toolName, description, inputFields) {
+export function generateMcpToolContract(toolName, description, inputFields, options = {}) {
     const inputSchema = {};
     for (const field of inputFields) {
         inputSchema[field] = {
@@ -79,9 +50,9 @@ export function generateMcpToolContract(toolName, description, inputFields) {
             },
             required: ['content'],
         },
-        sideEffects: buildSideEffects(description),
-        errorCodes: buildErrorCodes(toolName, description),
-        timeoutMs: 30000,
+        sideEffects: [...new Set(options.sideEffects ?? [])],
+        errorCodes: [...new Set(options.errorCodes ?? DEFAULT_ERROR_CODES)],
+        timeoutMs: getRuntimePolicy().toolExecution.defaultTimeoutMs,
     };
 }
 // === Formatted output for define_ui_contract ===
@@ -93,7 +64,7 @@ export function formatMcpToolContractAsMarkdown(tools, knowledge) {
         '',
     ];
     for (const tool of tools) {
-        const contract = generateMcpToolContract(tool.name, tool.description, tool.fields);
+        const contract = generateMcpToolContract(tool.name, tool.description, tool.fields, tool);
         lines.push(`### Tool: \`${contract.name}\``);
         lines.push('');
         lines.push(`**Description**: ${contract.description}`);

package/dist/tools/create-spec/post-creation.d.ts

@@ -20,5 +20,6 @@ export declare function formatPostCreationSuggestion(suggestion: PostCreationSug
  * Writes results to Planu's external project data dir and appends an
  * autopilot-log entry on completion. Never throws — fully best-effort.
  */
-export declare function runAutopilotAsync(specId: string, projectPath: string, _description: string): void;
+export declare function runAutopilotAnalysis(specId: string, projectPath: string, description: string): Promise<void>;
+export declare function runAutopilotAsync(specId: string, projectPath: string, description: string): void;
 //# sourceMappingURL=post-creation.d.ts.map

package/dist/tools/create-spec/post-creation.js

@@ -1,19 +1,15 @@
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
-// tools/create-spec/post-creation.ts — Git setup + contradiction detection + post-creation suggestions.
-// Extracted from create-spec.ts to keep file sizes within limits.
+import { technologyValue } from '../../engine/technology-registry.js';
 import { specStore } from '../../storage/index.js';
 import { detectContradictions } from '../../engine/contradiction-detector.js';
 import { detectCiCd } from '../../engine/detectors/cicd-detector.js';
 import { tryAutoSetupGit } from '../create-spec-helpers.js';
 import { emitAutopilotEvent } from '../../engine/autopilot/event-bus.js';
 import { incrementSpecCount } from '../../engine/autopilot/state-updater.js';
-import { writeFile, mkdir } from 'node:fs/promises';
-import { join, dirname } from 'node:path';
+import { join } from 'node:path';
 import { hashProjectPath, projectDataDir } from '../../storage/base-store.js';
 import { appendAutopilotLogEntry } from '../../storage/autopilot-log-store.js';
 import { analyzeContextPreflight, buildTokenWasteReport, loadTokenWastePolicy, recommendRelevantTools, toolsFromPolicyGroups, } from '../../engine/token-optimizer/index.js';
-import { queryProjectGraphSlice } from '../../engine/project-graph/index.js';
+import { atomicWriteFile } from '../../engine/safety/atomic-write-file.js';
 const ASYNC_ANALYSIS_HOOK = 'create-spec-async-analysis';
 export function getAsyncAnalysisPath(projectPath, specId) {
     const projectId = hashProjectPath(projectPath);
@@ -25,21 +21,15 @@ export async function buildInitialTokenWasteMetadata(specId, projectPath, descri
         if (!policy.enabled) {
             return null;
         }
-        const graphSlice = await queryProjectGraphSlice({ projectPath, specId }).catch(() => null);
-        const graphCandidates = graphSlice?.nodes
-            .filter((node) => node.type === 'file' || node.type === 'test')
-            .slice(0, 12)
-            .map((node) => ({
-            path: node.label,
-            reason: 'Related by Project Knowledge Graph compact slice.',
-        })) ?? [];
         const context = analyzeContextPreflight({
             action: 'create_spec',
             policy,
-            candidates: [
-                ...graphCandidates,
-                { path: 'planu/specs', reason: 'New spec workspace metadata.' },
-            ],
+            // A just-created spec cannot exist in the previous graph snapshot. Asking
+            // for a slice by its new ID therefore produced no candidates while forcing
+            // a full graph freshness scan/rebuild after every mutation. Graph refresh
+            // belongs to the durable post-commit worker; the acknowledgement metadata
+            // starts with the canonical spec workspace only.
+            candidates: [{ path: 'planu/specs', reason: 'New spec workspace metadata.' }],
             spec: { id: specId },
         });
         const tools = recommendRelevantTools({
@@ -156,7 +146,13 @@ function hasAffirmedPattern(description, pattern) {
     });
 }
 // === Serverless platform detection ===
-const SERVERLESS_PLATFORMS = ['vercel', 'netlify', 'lambda', 'cloudflare-workers', 'deno-deploy'];
+const SERVERLESS_PLATFORMS = [
+    technologyValue('technology-vercel-9d3508'),
+    technologyValue('technology-netlify-58465a'),
+    'lambda',
+    'cloudflare-workers',
+    'deno-deploy',
+];
 function isServerlessKnowledge(knowledge) {
     if (!knowledge) {
         return false;
@@ -235,41 +231,47 @@ export function formatPostCreationSuggestion(suggestion) {
  * Writes results to Planu's external project data dir and appends an
  * autopilot-log entry on completion. Never throws — fully best-effort.
  */
-export function runAutopilotAsync(specId, projectPath, _description) {
+export async function runAutopilotAnalysis(specId, projectPath, description) {
     const projectId = hashProjectPath(projectPath);
     const start = Date.now();
-    void (async () => {
-        try {
-            const analysisResult = {
-                specId,
-                completedAt: new Date().toISOString(),
-                pendingAnalysis: false,
-                tokenWasteAutopilot: await buildInitialTokenWasteMetadata(specId, projectPath, _description),
-            };
-            const analysisPath = getAsyncAnalysisPath(projectPath, specId);
-            await mkdir(dirname(analysisPath), { recursive: true });
-            await writeFile(analysisPath, JSON.stringify(analysisResult, null, 2), 'utf-8');
-            await appendAutopilotLogEntry(projectId, {
-                specId,
-                hookName: ASYNC_ANALYSIS_HOOK,
-                result: 'pass',
-                timestamp: new Date().toISOString(),
-                durationMs: Date.now() - start,
-            });
-        }
-        catch (err) {
-            const error = err instanceof Error ? err.message : String(err);
-            await appendAutopilotLogEntry(projectId, {
-                specId,
-                hookName: ASYNC_ANALYSIS_HOOK,
-                result: 'fail',
-                error,
-                timestamp: new Date().toISOString(),
-                durationMs: Date.now() - start,
-            }).catch(() => {
-                /* double best-effort */
-            });
-        }
-    })();
+    try {
+        const analysisResult = {
+            specId,
+            completedAt: new Date().toISOString(),
+            pendingAnalysis: false,
+            tokenWasteAutopilot: await buildInitialTokenWasteMetadata(specId, projectPath, description),
+        };
+        const analysisPath = getAsyncAnalysisPath(projectPath, specId);
+        await atomicWriteFile(analysisPath, JSON.stringify(analysisResult, null, 2), {
+            encoding: 'utf-8',
+        });
+        await appendAutopilotLogEntry(projectId, {
+            specId,
+            hookName: ASYNC_ANALYSIS_HOOK,
+            result: 'pass',
+            timestamp: new Date().toISOString(),
+            durationMs: Date.now() - start,
+        });
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        await appendAutopilotLogEntry(projectId, {
+            specId,
+            hookName: ASYNC_ANALYSIS_HOOK,
+            result: 'fail',
+            error,
+            timestamp: new Date().toISOString(),
+            durationMs: Date.now() - start,
+        }).catch(() => {
+            /* double best-effort */
+        });
+        throw err;
+    }
+}
+export function runAutopilotAsync(specId, projectPath, description) {
+    void runAutopilotAnalysis(specId, projectPath, description).catch(() => {
+        // The durable outbox consumer uses the awaited entry point above. This wrapper
+        // remains for callers that have not yet migrated and always observes rejection.
+    });
 }
 //# sourceMappingURL=post-creation.js.map

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): Promise<string[]>;
+export declare function findRelevantFiles(projectPath: string, keywords: Set<string>, limit?: number, signal?: AbortSignal): Promise<string[]>;
 //# sourceMappingURL=relevance-scorer.d.ts.map

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

@@ -4,6 +4,9 @@
 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
@@ -133,10 +136,23 @@ 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) {
+export async function findRelevantFiles(projectPath, keywords, limit = 10, signal) {
     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) {