@planu/cli 4.13.0 → 5.0.0

package/dist/engine/abortable-process-runner.js

@@ -1,26 +1,149 @@
-import { execFileSync, spawn } from 'node:child_process';
+/* eslint-disable max-lines-per-function -- process-tree termination and single-settlement share one ownership boundary. */
+import { spawn } from 'node:child_process';
+import { getExecutionSignal, remainingExecutionMs } from './execution/context.js';
+export const PROCESS_TERMINATION_GRACE_MS = 75;
+export const PROCESS_TREE_EXTINCTION_TIMEOUT_MS = 1_000;
+export const PROCESS_CHILD_CLOSE_TIMEOUT_MS = 1_000;
+let platformOverrideForTests;
+let spawnOverrideForTests;
+let processGroupLivenessOverrideForTests;
+/** Isolates platform-specific process supervision in unit tests without changing host state. */
+export function configureAbortableProcessRunnerForTests(options = {}) {
+    platformOverrideForTests = options.platform;
+    spawnOverrideForTests = options.spawnProcess;
+    processGroupLivenessOverrideForTests = options.isProcessGroupAlive;
+}
+function runtimePlatform() {
+    return platformOverrideForTests ?? process.platform;
+}
+function spawnProcess(...args) {
+    return (spawnOverrideForTests ?? spawn)(...args);
+}
+function operationSignal(signal) {
+    const parentSignal = getExecutionSignal();
+    if (signal === undefined) {
+        return parentSignal;
+    }
+    if (parentSignal === undefined || parentSignal === signal) {
+        return signal;
+    }
+    return AbortSignal.any([signal, parentSignal]);
+}
+function immediateAbortResult(reason) {
+    return {
+        stdout: '',
+        stderr: '',
+        status: null,
+        signal: null,
+        error: abortError(reason),
+        timedOut: false,
+        aborted: true,
+    };
+}
+function appendOutput(current, chunk, maxBufferBytes) {
+    return `${current}${chunk.toString('utf8')}`.slice(-maxBufferBytes);
+}
+function detachOwnedStreams(child, onStdout, onStderr) {
+    child.stdout?.removeListener('data', onStdout);
+    child.stderr?.removeListener('data', onStderr);
+    child.stdout?.destroy();
+    child.stderr?.destroy();
+}
+function delay(ms) {
+    return new Promise((resolve) => {
+        const timer = setTimeout(resolve, ms);
+        timer.unref();
+    });
+}
+function processGroupIsAlive(pid) {
+    if (processGroupLivenessOverrideForTests !== undefined) {
+        return processGroupLivenessOverrideForTests(pid);
+    }
+    try {
+        process.kill(-pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === 'EPERM';
+    }
+}
+async function awaitProcessGroupExtinction(pid) {
+    const deadlineAt = Date.now() + PROCESS_TREE_EXTINCTION_TIMEOUT_MS;
+    while (processGroupIsAlive(pid) && Date.now() < deadlineAt) {
+        await delay(Math.min(10, Math.max(1, deadlineAt - Date.now())));
+    }
+    return !processGroupIsAlive(pid);
+}
+async function terminateWindowsTree(child, childPid) {
+    if (childPid === undefined) {
+        child.kill('SIGKILL');
+        return false;
+    }
+    try {
+        const taskkill = spawnProcess('taskkill', ['/pid', String(childPid), '/T', '/F'], {
+            stdio: 'ignore',
+            windowsHide: true,
+        });
+        const succeeded = await new Promise((resolve) => {
+            let settled = false;
+            const finish = (value) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                clearTimeout(timer);
+                resolve(value);
+            };
+            const timer = setTimeout(() => {
+                taskkill.kill('SIGKILL');
+                finish(false);
+            }, PROCESS_TREE_EXTINCTION_TIMEOUT_MS);
+            timer.unref();
+            taskkill.once('error', () => {
+                finish(false);
+            });
+            taskkill.once('close', (status) => {
+                finish(status === 0);
+            });
+        });
+        if (!succeeded) {
+            child.kill('SIGKILL');
+        }
+        return succeeded;
+    }
+    catch {
+        child.kill('SIGKILL');
+        return false;
+    }
+}
+export class ProcessTreeTerminationError extends Error {
+    code = 'PROCESS_TREE_TERMINATION_UNVERIFIED';
+    constructor() {
+        super('[Planu] PROCESS_TREE_TERMINATION_UNVERIFIED');
+        this.name = 'ProcessTreeTerminationError';
+    }
+}
+export class ChildProcessCloseTimeoutError extends Error {
+    code = 'PROCESS_CLOSE_UNOBSERVED';
+    constructor() {
+        super('[Planu] PROCESS_CLOSE_UNOBSERVED');
+        this.name = 'ChildProcessCloseTimeoutError';
+    }
+}
 /**
  * Runs a validation command in its own process group. Cancellation and timeouts
- * terminate the complete group and settle only after the child has closed, so a
- * cancelled gate cannot keep writing output or publish late evidence.
+ * terminate the complete group and settle only after child closure or a bounded,
+ * typed close-observation failure, so a cancelled gate cannot publish late evidence.
  */
 export function runAbortableProcess(command, args, options) {
+    const signal = operationSignal(options.signal);
+    if (signal?.aborted === true) {
+        return Promise.resolve(immediateAbortResult(signal.reason));
+    }
     return new Promise((resolve) => {
-        if (options.signal?.aborted === true) {
-            resolve({
-                stdout: '',
-                stderr: '',
-                status: null,
-                signal: null,
-                error: abortError(options.signal.reason),
-                timedOut: false,
-                aborted: true,
-            });
-            return;
-        }
-        const child = spawn(command, args, {
+        const child = spawnProcess(command, args, {
             cwd: options.cwd,
-            detached: process.platform !== 'win32',
+            detached: runtimePlatform() !== 'win32',
             stdio: ['ignore', 'pipe', 'pipe'],
         });
         let stdout = '';
@@ -29,76 +152,153 @@ export function runAbortableProcess(command, args, options) {
         let timedOut = false;
         let aborted = false;
         let processError;
-        let hardStop;
-        const append = (current, chunk) => `${current}${chunk.toString('utf8')}`.slice(-options.maxBufferBytes);
-        child.stdout.on('data', (chunk) => {
-            stdout = append(stdout, chunk);
-        });
-        child.stderr.on('data', (chunk) => {
-            stderr = append(stderr, chunk);
-        });
-        const terminateTree = () => {
-            if (child.pid === undefined) {
+        let terminationStarted = false;
+        let observedTerminationSignal = null;
+        let closeResult;
+        let terminationResolved = false;
+        let processTreeExtinct = false;
+        let closeFallbackTimer;
+        const childPid = child.pid;
+        const parentRemainingMs = remainingExecutionMs();
+        const timeoutMs = Math.max(0, Math.min(options.timeoutMs, parentRemainingMs));
+        const onStdout = (chunk) => {
+            stdout = appendOutput(stdout, chunk, options.maxBufferBytes);
+        };
+        const onStderr = (chunk) => {
+            stderr = appendOutput(stderr, chunk, options.maxBufferBytes);
+        };
+        child.stdout?.on('data', onStdout);
+        child.stderr?.on('data', onStderr);
+        const finish = (status, closeSignal, forced = false) => {
+            if (settled) {
                 return;
             }
-            if (process.platform === 'win32') {
-                try {
-                    execFileSync('taskkill', ['/pid', String(child.pid), '/T', '/F'], { stdio: 'ignore' });
-                }
-                catch {
-                    child.kill('SIGKILL');
-                }
+            settled = true;
+            clearTimeout(timer);
+            if (closeFallbackTimer !== undefined) {
+                clearTimeout(closeFallbackTimer);
+                closeFallbackTimer = undefined;
+            }
+            signal?.removeEventListener('abort', onAbort);
+            child.removeListener('error', onError);
+            child.removeListener('close', onClose);
+            if (forced) {
+                detachOwnedStreams(child, onStdout, onStderr);
+            }
+            resolve({
+                stdout,
+                stderr,
+                status,
+                signal: closeSignal,
+                ...(processError ? { error: processError } : {}),
+                timedOut,
+                aborted,
+            });
+        };
+        const finishTerminatedProcess = () => {
+            if (!terminationResolved) {
                 return;
             }
-            try {
-                process.kill(-child.pid, 'SIGTERM');
+            if (!processTreeExtinct) {
+                finish(null, observedTerminationSignal, true);
+                return;
             }
-            catch {
-                child.kill('SIGTERM');
+            if (closeResult === undefined) {
+                return;
+            }
+            finish(closeResult[0], closeResult[1] ?? observedTerminationSignal, true);
+        };
+        const scheduleCloseFallback = () => {
+            if (closeFallbackTimer !== undefined || closeResult !== undefined || !processTreeExtinct) {
+                return;
             }
-            hardStop = setTimeout(() => {
-                try {
-                    process.kill(-(child.pid ?? 0), 'SIGKILL');
+            closeFallbackTimer = setTimeout(() => {
+                closeFallbackTimer = undefined;
+                if (settled || closeResult !== undefined || !terminationResolved || !processTreeExtinct) {
+                    return;
                 }
-                catch {
+                processError = new ChildProcessCloseTimeoutError();
+                finish(null, observedTerminationSignal, true);
+            }, PROCESS_CHILD_CLOSE_TIMEOUT_MS);
+            closeFallbackTimer.unref();
+        };
+        const terminateTree = () => {
+            if (terminationStarted || settled) {
+                return;
+            }
+            terminationStarted = true;
+            void (async () => {
+                if (runtimePlatform() === 'win32') {
+                    processTreeExtinct = await terminateWindowsTree(child, childPid);
+                }
+                else if (childPid !== undefined) {
+                    try {
+                        process.kill(-childPid, 'SIGTERM');
+                        observedTerminationSignal = 'SIGTERM';
+                    }
+                    catch {
+                        child.kill('SIGTERM');
+                    }
+                    await delay(PROCESS_TERMINATION_GRACE_MS);
+                    if (processGroupIsAlive(childPid)) {
+                        try {
+                            process.kill(-childPid, 'SIGKILL');
+                            observedTerminationSignal = 'SIGKILL';
+                        }
+                        catch {
+                            child.kill('SIGKILL');
+                            observedTerminationSignal = 'SIGKILL';
+                        }
+                    }
+                    processTreeExtinct = await awaitProcessGroupExtinction(childPid);
+                }
+                else {
                     child.kill('SIGKILL');
                 }
-            }, 250);
-            hardStop.unref();
+                if (!processTreeExtinct) {
+                    processError = new ProcessTreeTerminationError();
+                }
+                terminationResolved = true;
+                finishTerminatedProcess();
+                scheduleCloseFallback();
+            })();
         };
         const onAbort = () => {
+            if (terminationStarted || settled) {
+                return;
+            }
             aborted = true;
-            processError = abortError(options.signal?.reason);
+            processError = abortError(signal?.reason);
             terminateTree();
+            try {
+                options.onCancellationAcknowledged?.();
+            }
+            catch {
+                // A diagnostic callback must never interfere with process termination.
+            }
         };
-        options.signal?.addEventListener('abort', onAbort, { once: true });
+        signal?.addEventListener('abort', onAbort, { once: true });
         const timer = setTimeout(() => {
+            if (terminationStarted || settled) {
+                return;
+            }
             timedOut = true;
-            processError = new Error(`Process timed out after ${String(options.timeoutMs)}ms`);
+            processError = new Error(`Process timed out after ${String(timeoutMs)}ms`);
             terminateTree();
-        }, options.timeoutMs);
-        const finish = (status, closeSignal) => {
-            if (settled) {
+        }, timeoutMs);
+        const onError = (error) => {
+            processError = error;
+        };
+        const onClose = (status, closeSignal) => {
+            if (terminationStarted) {
+                closeResult = [status, closeSignal];
+                finishTerminatedProcess();
                 return;
             }
-            settled = true;
-            clearTimeout(timer);
-            clearTimeout(hardStop);
-            options.signal?.removeEventListener('abort', onAbort);
-            resolve({
-                stdout,
-                stderr,
-                status,
-                signal: closeSignal,
-                ...(processError ? { error: processError } : {}),
-                timedOut,
-                aborted,
-            });
+            finish(status, closeSignal);
         };
-        child.on('error', (error) => {
-            processError = error;
-        });
-        child.on('close', finish);
+        child.on('error', onError);
+        child.on('close', onClose);
     });
 }
 function abortError(reason) {

package/dist/engine/advanced-testing/accessibility-checker.js

@@ -1,7 +1,4 @@
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
-// engine/advanced-testing/accessibility-checker.ts — SPEC-049
-// Generates WCAG 2.1 Level AA criteria and axe-core test scaffolds.
+import { technologyValue } from '../technology-registry.js';
 /** WCAG 2.1 Level AA criteria list for create_spec. */
 export function buildA11yCriteria() {
     return [
@@ -112,10 +109,11 @@ urls:
 /** Map framework name to A11yFramework type. */
 function toA11yFramework(testFramework) {
     const fw = testFramework.toLowerCase();
-    if (fw.includes('playwright')) {
+    if (fw.includes(technologyValue('technology-playwright-7827e8'))) {
         return 'axe-core';
     }
-    if (fw.includes('jest') || fw.includes('react-testing-library')) {
+    if (fw.includes(technologyValue('technology-jest-35e99f')) ||
+        fw.includes('react-testing-library')) {
         return 'jest-axe';
     }
     if (fw.includes('pa11y')) {
@@ -151,20 +149,20 @@ export function generateA11yTests(testFramework) {
 /** Detect if the project is a web project based on stack signals. */
 export function isWebProject(stack) {
     const webSignals = [
-        'react',
-        'vue',
-        'angular',
-        'svelte',
+        technologyValue('technology-react-275976'),
+        technologyValue('technology-vue-564382'),
+        technologyValue('technology-angular-a39f89'),
+        technologyValue('technology-svelte-c190ac'),
         'next',
-        'nuxt',
-        'remix',
-        'astro',
+        technologyValue('technology-nuxt-22c407'),
+        technologyValue('technology-remix-0c5d96'),
+        technologyValue('technology-astro-23661e'),
         'html',
         'css',
         'browser',
         'frontend',
         'web',
-        'playwright',
+        technologyValue('technology-playwright-7827e8'),
         'cypress',
     ];
     const stackLower = stack.map((s) => s.toLowerCase()).join(' ');

package/dist/engine/advanced-testing/mutation-advisor.js

@@ -1,5 +1,4 @@
-// engine/advanced-testing/mutation-advisor.ts — SPEC-049
-// Recommends mutation testing configuration based on project language and coverage.
+import { technologyValue } from '../technology-registry.js';
 import { getJvmVersion } from '../../config/version-defaults.js';
 /** Minimum coverage required before recommending mutation testing. */
 const MIN_COVERAGE_FOR_MUTATION = 90;
@@ -13,7 +12,7 @@ export function shouldRecommendMutation(coverage) {
 /** Map a language to its primary mutation testing tool. */
 export function getMutationTool(language) {
     const lang = language.toLowerCase();
-    if (lang === 'typescript' || lang === 'javascript') {
+    if (lang === technologyValue('technology-typescript-969545') || lang === 'javascript') {
         return 'stryker';
     }
     if (lang === 'python') {
@@ -213,7 +212,7 @@ export function generateMutationConfig(tool, language) {
 /** Return sensible default exclude patterns for a language. */
 function getDefaultExcludePatterns(language) {
     const lang = language.toLowerCase();
-    if (lang === 'typescript' || lang === 'javascript') {
+    if (lang === technologyValue('technology-typescript-969545') || lang === 'javascript') {
         return ['**/*.test.ts', '**/*.spec.ts', '**/index.ts', 'src/config/**', 'src/types/**'];
     }
     if (lang === 'python') {

package/dist/engine/advanced-testing/property-based.js

@@ -1,5 +1,4 @@
-// engine/advanced-testing/property-based.ts — SPEC-049
-// Detects property-based testing needs and generates scaffold code.
+import { technologyValue } from '../technology-registry.js';
 /** Keywords (case-insensitive) that indicate a property-based testing need. */
 const PBT_KEYWORDS_ES = [
     'siempre',
@@ -34,7 +33,7 @@ export function detectPropertyBasedNeed(criteria) {
 /** Map a language identifier to its property test framework. */
 export function getPropertyTestFramework(language) {
     const lang = language.toLowerCase();
-    if (lang === 'typescript' || lang === 'javascript') {
+    if (lang === technologyValue('technology-typescript-969545') || lang === 'javascript') {
         return 'fast-check';
     }
     if (lang === 'python') {

package/dist/engine/advanced-testing/test-data-advisor.js

@@ -1,5 +1,4 @@
-// engine/advanced-testing/test-data-advisor.ts — SPEC-049
-// Provides test data management criteria and synthetic data tooling recommendations.
+import { technologyValue } from '../technology-registry.js';
 /** PII/PHI signals in stack or project descriptions. */
 const PII_SIGNALS = [
     'pii',
@@ -90,7 +89,7 @@ function pythonTestDataTools() {
  */
 export function getTestDataTooling(language) {
     const lang = language.toLowerCase();
-    if (lang === 'typescript' || lang === 'javascript') {
+    if (lang === technologyValue('technology-typescript-969545') || lang === 'javascript') {
         return jsTestDataTools();
     }
     if (lang === 'python') {

package/dist/engine/agent-generator.js

@@ -1,3 +1,4 @@
+import { technologyValue } from './technology-registry.js';
 // @crash-shield-ignore-file — config/cache reader for Planu-controlled JSON; writer is this codebase, shape guaranteed by build/seed.
 // Planu — Agent Generator Engine
 // Generates sub-agent definitions for various multi-agent frameworks.
@@ -73,7 +74,7 @@ export async function getFrameworkConfig(framework) {
     const platforms = await loadFrameworks();
     return (platforms.subAgentFrameworks[framework] ?? {
         name: framework,
-        languages: ['typescript'],
+        languages: [technologyValue('technology-typescript-969545')],
         docsUrl: '',
         supportsHandoffs: false,
         supportsMcp: false,

package/dist/engine/agent-handoff-store.js

@@ -1,8 +1,9 @@
 // engine/agent-handoff-store.ts — SPEC-639: handoff.json protocol for agent teams
 import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
+import { hashProjectPath, projectDataDir } from '../storage/base-store.js';
 function handoffPath(projectPath, specId) {
-    return join(projectPath, '.planu', 'team', specId, 'handoff.json');
+    return join(projectDataDir(hashProjectPath(projectPath)), 'team', specId, 'handoff.json');
 }
 /**
  * SPEC-639: Initialize handoff.json for a spec team.

package/dist/engine/agent-prompt-generator.js

@@ -1,3 +1,4 @@
+import { technologyValue } from './technology-registry.js';
 // ── Layer path mappings ────────────────────────────────────────────────────
 const LAYER_PATHS = {
     frontend: ['src/components/', 'src/pages/', 'src/app/', 'src/views/', 'src/ui/', 'src/screens/'],
@@ -37,24 +38,25 @@ function stackInstructions(knowledge, layer) {
     const lines = [];
     const { framework, language } = knowledge;
     if (layer === 'frontend') {
-        if (framework === 'react' || framework === 'next') {
+        if (framework === technologyValue('technology-react-275976') || framework === 'next') {
             lines.push('Use functional components with hooks (no class components).');
             lines.push('JSX files must use .tsx extension. Props typed with interfaces.');
         }
-        if (framework === 'vue') {
+        if (framework === technologyValue('technology-vue-564382')) {
             lines.push('Use Composition API with <script setup> syntax.');
             lines.push('Props defined with defineProps<T>(). Emits with defineEmits<T>().');
         }
-        if (framework === 'svelte') {
+        if (framework === technologyValue('technology-svelte-c190ac')) {
             lines.push('Use Svelte 5 runes ($state, $derived, $effect) when available.');
         }
     }
     if (layer === 'backend' || layer === 'engine') {
-        if (language === 'typescript') {
+        if (language === technologyValue('technology-typescript-969545')) {
             lines.push('Strict TypeScript — no `any`, no non-null assertions without comment.');
             lines.push('Return types must be explicit on all exported functions.');
         }
-        if (framework === 'express' || framework === 'fastify') {
+        if (framework === technologyValue('technology-express-008231') ||
+            framework === technologyValue('technology-fastify-cbe57e')) {
             lines.push('Validate all request inputs with Zod before business logic.');
         }
     }

package/dist/engine/agent-telemetry.js

@@ -3,11 +3,12 @@ import { appendFile, stat, readFile, writeFile, mkdir } from 'node:fs/promises';
 import { createReadStream } from 'node:fs';
 import { createInterface } from 'node:readline';
 import { join } from 'node:path';
+import { hashProjectPath, projectDataDir } from '../storage/base-store.js';
 const MAX_FILE_BYTES = 1024 * 1024; // 1 MB
 const PRUNE_AGE_MS = 30 * 24 * 60 * 60 * 1000; // 30 days
 const EVICT_RATIO = 0.2; // drop oldest 20%
 function telemetryPath(projectPath, specId) {
-    return join(projectPath, '.planu', 'team', specId, 'telemetry.jsonl');
+    return join(projectDataDir(hashProjectPath(projectPath)), 'team', specId, 'telemetry.jsonl');
 }
 async function pruneIfNeeded(file) {
     let size;

package/dist/engine/ai-integration/gemini/extensions-advisor.js

@@ -1,12 +1,14 @@
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
-// engine/ai-integration/gemini/extensions-advisor.ts — Gemini extensions advisor (SPEC-267)
+import { technologyValue } from '../../technology-registry.js';
 const EXTENSION_CATALOG = [
     {
         name: 'Conductor',
         url: 'https://geminicli.com/extensions/conductor',
         reason: 'Feature specification and planning',
-        stackSignals: ['python', 'django', 'fastapi'],
+        stackSignals: [
+            'python',
+            technologyValue('technology-django-7d8a08'),
+            technologyValue('technology-fastapi-6aee0e'),
+        ],
     },
     {
         name: 'BigQuery Extension',
@@ -24,31 +26,61 @@ const EXTENSION_CATALOG = [
         name: 'Figma Extension',
         url: 'https://geminicli.com/extensions/figma',
         reason: 'Figma design file access',
-        stackSignals: ['figma', 'design', 'frontend', 'react', 'vue'],
+        stackSignals: [
+            technologyValue('technology-figma-5b79d0'),
+            'design',
+            'frontend',
+            technologyValue('technology-react-275976'),
+            technologyValue('technology-vue-564382'),
+        ],
     },
     {
         name: 'GitHub Extension',
         url: 'https://geminicli.com/extensions/github',
         reason: 'GitHub issues, PRs, and repo management',
-        stackSignals: ['github', 'git', 'typescript', 'javascript', 'node'],
+        stackSignals: [
+            'github',
+            'git',
+            technologyValue('technology-typescript-969545'),
+            'javascript',
+            'node',
+        ],
     },
     {
         name: 'Firebase Extension',
         url: 'https://geminicli.com/extensions/firebase',
         reason: 'Firebase project management and Firestore queries',
-        stackSignals: ['firebase', 'firestore', 'gcp', 'react-native', 'flutter'],
+        stackSignals: [
+            'firebase',
+            'firestore',
+            'gcp',
+            'react-native',
+            technologyValue('technology-flutter-be1396'),
+        ],
     },
     {
         name: 'Kubernetes Extension',
         url: 'https://geminicli.com/extensions/kubernetes',
         reason: 'Kubernetes cluster inspection and deployment management',
-        stackSignals: ['kubernetes', 'k8s', 'docker', 'helm', 'gcp'],
+        stackSignals: [
+            technologyValue('technology-kubernetes-94abcb'),
+            'k8s',
+            technologyValue('technology-docker-d548c5'),
+            'helm',
+            'gcp',
+        ],
     },
     {
         name: 'Terraform Extension',
         url: 'https://geminicli.com/extensions/terraform',
         reason: 'Terraform plan inspection and infrastructure management',
-        stackSignals: ['terraform', 'aws', 'azure', 'gcp', 'infrastructure'],
+        stackSignals: [
+            technologyValue('technology-terraform-94dc3e'),
+            'aws',
+            'azure',
+            'gcp',
+            'infrastructure',
+        ],
     },
 ];
 export function getRecommendedExtensions(stack) {