@planu/cli 4.14.1 → 5.0.0

package/dist/engine/abortable-process-runner.d.ts

@@ -1,8 +1,26 @@
+import { spawn } from 'node:child_process';
 import type { AbortableProcessOptions, AbortableProcessResult } from '../types/abortable-process.js';
+export declare const PROCESS_TERMINATION_GRACE_MS = 75;
+export declare const PROCESS_TREE_EXTINCTION_TIMEOUT_MS = 1000;
+export declare const PROCESS_CHILD_CLOSE_TIMEOUT_MS = 1000;
+/** Isolates platform-specific process supervision in unit tests without changing host state. */
+export declare function configureAbortableProcessRunnerForTests(options?: {
+    platform?: NodeJS.Platform;
+    spawnProcess?: typeof spawn;
+    isProcessGroupAlive?: (pid: number) => boolean;
+}): void;
+export declare class ProcessTreeTerminationError extends Error {
+    readonly code = "PROCESS_TREE_TERMINATION_UNVERIFIED";
+    constructor();
+}
+export declare class ChildProcessCloseTimeoutError extends Error {
+    readonly code = "PROCESS_CLOSE_UNOBSERVED";
+    constructor();
+}
 /**
  * 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 declare function runAbortableProcess(command: string, args: string[], options: AbortableProcessOptions): Promise<AbortableProcessResult>;
 //# sourceMappingURL=abortable-process-runner.d.ts.map

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

@@ -1,6 +1,24 @@
-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';
-const TERM_GRACE_MS = 75;
+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) {
@@ -11,29 +29,121 @@ function operationSignal(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) => {
-        const signal = operationSignal(options.signal);
-        if (signal?.aborted === true) {
-            resolve({
-                stdout: '',
-                stderr: '',
-                status: null,
-                signal: null,
-                error: abortError(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 = '';
@@ -42,53 +152,121 @@ export function runAbortableProcess(command, args, options) {
         let timedOut = false;
         let aborted = false;
         let processError;
-        let hardStop;
-        let deferredClose;
+        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 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) {
+        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;
+                }
+                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);
                 }
-                catch {
+                else {
                     child.kill('SIGKILL');
                 }
-                hardStop = undefined;
-                if (deferredClose !== undefined) {
-                    const [status, closeSignal] = deferredClose;
-                    deferredClose = undefined;
-                    finish(status, closeSignal);
+                if (!processTreeExtinct) {
+                    processError = new ProcessTreeTerminationError();
                 }
-            }, TERM_GRACE_MS);
-            hardStop.unref();
+                terminationResolved = true;
+                finishTerminatedProcess();
+                scheduleCloseFallback();
+            })();
         };
         const onAbort = () => {
+            if (terminationStarted || settled) {
+                return;
+            }
             aborted = true;
             processError = abortError(signal?.reason);
             terminateTree();
@@ -101,35 +279,26 @@ export function runAbortableProcess(command, args, options) {
         };
         signal?.addEventListener('abort', onAbort, { once: true });
         const timer = setTimeout(() => {
+            if (terminationStarted || settled) {
+                return;
+            }
             timedOut = true;
             processError = new Error(`Process timed out after ${String(timeoutMs)}ms`);
             terminateTree();
         }, timeoutMs);
-        const finish = (status, closeSignal) => {
-            if (settled) {
-                return;
-            }
-            if (hardStop !== undefined && process.platform !== 'win32') {
-                deferredClose = [status, closeSignal];
+        const onError = (error) => {
+            processError = error;
+        };
+        const onClose = (status, closeSignal) => {
+            if (terminationStarted) {
+                closeResult = [status, closeSignal];
+                finishTerminatedProcess();
                 return;
             }
-            settled = true;
-            clearTimeout(timer);
-            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/ambiguity-scorer.js

@@ -1,6 +1,6 @@
 // engine/ambiguity-scorer.ts — SPEC-632: Detect undefined units and vague triggers in criteria
 import { readFile } from 'node:fs/promises';
-import { stripFrontmatter } from './frontmatter-parser.js';
+import { extractAcceptanceCriteriaTexts } from './spec-format/acceptance-criteria.js';
 const VAGUE_UNITS = {
     fast: 'No latency target specified (e.g. "< 200ms")',
     slow: 'No latency target specified (e.g. "> 5s")',
@@ -96,27 +96,6 @@ export function scoreAmbiguity(criteriaLines) {
         : [];
     return { score, violations, blockers };
 }
-/** Minimal criteria extractor — same logic as readiness-checker without the full dependency chain. */
-function extractLines(body) {
-    const lines = body.split('\n');
-    const result = [];
-    let inSection = false;
-    for (const raw of lines) {
-        const line = raw.trim();
-        if (/^#{1,6}\s+/.test(line)) {
-            inSection = /^#{1,6}\s+(acceptance\s+criteria|criteria|criterios)\b/i.test(line);
-            continue;
-        }
-        if (/^- \[[ x]\]/i.test(line) || /^- .*\bgiven\b.*\bwhen\b.*\bthen\b/i.test(line)) {
-            result.push(line);
-            continue;
-        }
-        if (inSection && /^- \S/.test(line)) {
-            result.push(line);
-        }
-    }
-    return result;
-}
 /**
  * SPEC-632: Read spec file at path, extract criteria, and return an AmbiguityReport.
  * Returns null if file cannot be read (best-effort, never blocks).
@@ -124,12 +103,11 @@ function extractLines(body) {
 export async function scoreAmbiguityFromPath(specPath) {
     try {
         const raw = await readFile(specPath, 'utf-8');
-        const body = stripFrontmatter(raw);
-        const lines = extractLines(body);
-        if (lines.length === 0) {
+        const criteria = extractAcceptanceCriteriaTexts(raw, { allowLegacyBodyFallback: false });
+        if (criteria.length === 0) {
             return null;
         }
-        return scoreAmbiguity(lines);
+        return scoreAmbiguity(criteria);
     }
     catch {
         return null;

package/dist/engine/auth/scope-mapper.js

@@ -15,16 +15,12 @@ export const BUILTIN_SCOPE_MAPPINGS = [
             'validate',
             'analyze_spec_dependencies',
             'export_spec',
-            'export_session',
-            'list_sessions',
             'hook_status',
             'worker_status',
-            'webhook_status',
             'token_usage',
             'usage_report',
             'usage_stats',
             'llm_provider_status',
-            'license_status',
             'security_report',
             'pr_status',
             'agent_swarm_status',
@@ -56,8 +52,6 @@ export const BUILTIN_SCOPE_MAPPINGS = [
             'configure_llm_providers',
             'start_hooks',
             'stop_hooks',
-            'start_webhook',
-            'stop_webhook',
             'start_dashboard',
             'stop_dashboard',
             'manage_trash',
@@ -74,7 +68,7 @@ export const BUILTIN_SCOPE_MAPPINGS = [
     },
     {
         scope: 'planu:admin',
-        tools: ['configure_auth', 'activate_license', 'deactivate_license', 'activate_group'],
+        tools: ['configure_auth', 'activate_group'],
     },
 ];
 /**

package/dist/engine/autopilot/state-updater.js

@@ -2,12 +2,13 @@
 // engine/autopilot/state-updater.ts — SPEC-459: Auto-update external project status on every status change
 // Fire-and-forget: never blocks the event pipeline, never throws to callers.
 // SPEC-753: File-lock applied to all writes; self-healing on corrupt reads.
-import { readFile, writeFile, mkdir } from 'node:fs/promises';
-import { join, dirname } from 'node:path';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
 import { withStatusLock } from '../../storage/status-store/file-lock.js';
 import { validateStatusJson, rebuildStatusFromFrontmatters, writeRebuiltStatus, } from '../../storage/status-store/self-healing.js';
 import { syncVersionField } from '../../storage/status-store/version-sync.js';
 import { hashProjectPath, projectDataDir } from '../../storage/base-store.js';
+import { atomicStatusWrite } from '../../storage/status-store/atomic-status-write.js';
 const STATUS_FILENAME = 'status.json';
 const MAX_RECENT_CHANGES = 20;
 function getStatusPath(projectPath) {
@@ -52,8 +53,7 @@ async function loadStatus(projectPath) {
 }
 async function saveStatus(projectPath, status) {
     const filePath = getStatusPath(projectPath);
-    await mkdir(dirname(filePath), { recursive: true });
-    await writeFile(filePath, JSON.stringify(status, null, 2), 'utf-8');
+    await atomicStatusWrite(filePath, status);
 }
 /**
  * Record a spec status change and recalculate counts.

package/dist/engine/cascade-hooks/hooks/review-enricher.hook.js

@@ -1,3 +1,4 @@
+import { reportClassifiedDegradation } from '../../../errors/classified-degradation.js';
 async function handler(ctx) {
     const { projectPath, specId, spec } = ctx;
     if (!projectPath) {
@@ -7,17 +8,19 @@ async function handler(ctx) {
     if (spec.scope === 'trivial') {
         return;
     }
-    await import('../../../engine/technical-enricher/index.js')
-        .then(({ runTechnicalEnricher }) => runTechnicalEnricher({ specId, projectPath, specScope: spec.scope }))
-        .catch(() => {
-        /* best-effort — never blocks update_status */
-    });
+    try {
+        const { runTechnicalEnricher } = await import('../../../engine/technical-enricher/index.js');
+        await runTechnicalEnricher({ specId, projectPath, specScope: spec.scope });
+    }
+    catch {
+        reportClassifiedDegradation('REVIEW_ENRICHER_FAILED', new Error('Technical review enrichment failed'));
+    }
 }
 export const reviewEnricherHook = {
     id: 'review-enricher',
     triggers: ['review'],
     requiresProjectPath: true,
-    label: 'Auto-enrich technical.md when spec moves to review (SPEC-696)',
+    label: 'Auto-enrich the bounded Technical spec section on review',
     handler,
 };
 //# sourceMappingURL=review-enricher.hook.js.map

package/dist/engine/cascade-hooks/state-drift-detector.d.ts

@@ -1,8 +1,8 @@
-import type { DriftReport } from '../../types/cascade-hooks.js';
+import type { StateFilesDriftReport } from '../../types/cascade-hooks.js';
 /**
  * SPEC-776: Compare in-memory spec counts vs external status.json and
  * recently-done spec vs planu/session-context.md.
- * Returns a DriftReport with any detected mismatches.
+ * Returns a StateFilesDriftReport with any detected mismatches.
  */
-export declare function verifyStateFiles(projectPath: string): Promise<DriftReport>;
+export declare function verifyStateFiles(projectPath: string): Promise<StateFilesDriftReport>;
 //# sourceMappingURL=state-drift-detector.d.ts.map

package/dist/engine/cascade-hooks/state-drift-detector.js

@@ -62,7 +62,7 @@ function extractLastDoneSpecFromContext(content) {
 /**
  * SPEC-776: Compare in-memory spec counts vs external status.json and
  * recently-done spec vs planu/session-context.md.
- * Returns a DriftReport with any detected mismatches.
+ * Returns a StateFilesDriftReport with any detected mismatches.
  */
 export async function verifyStateFiles(projectPath) {
     const alerts = [];

package/dist/engine/ci-generator/planu-config.js

@@ -4,7 +4,7 @@
  * This file configures the Planu CI check workflow behavior.
  */
 export function generatePlanuConfigYaml(options) {
-    const { specsDir, failOnDrift, severityThreshold, postComment, badge, include, exclude, licenseKeyRef, } = options;
+    const { specsDir, failOnDrift, severityThreshold, postComment, badge, include, exclude } = options;
     const lines = ['# .planu.yml — Planu CI configuration', ''];
     // Specs section
     lines.push('specs:');
@@ -28,12 +28,6 @@ export function generatePlanuConfigYaml(options) {
     lines.push(`  severity-threshold: ${severityThreshold}`);
     lines.push(`  post-comment: ${String(postComment)}`);
     lines.push(`  badge: ${String(badge)}`);
-    // License section
-    if (licenseKeyRef) {
-        lines.push('');
-        lines.push('license:');
-        lines.push(`  key: \${${licenseKeyRef}}`);
-    }
     lines.push('');
     return lines.join('\n');
 }

package/dist/engine/clarification-gate/gate.d.ts

@@ -1,5 +1,5 @@
-import type { GateContext, GateResult } from '../../types/clarification-token.js';
-export type { GateContext, GateResult };
+import type { ClarificationGateContext, GateResult } from '../../types/clarification-token.js';
+export type { ClarificationGateContext as GateContext, GateResult };
 /**
  * Check whether the tool is allowed to proceed.
  *
@@ -11,5 +11,5 @@ export type { GateContext, GateResult };
  * Fails open: if token storage is unavailable, the gate allows the call
  * to proceed rather than blocking the entire tool.
  */
-export declare function checkGate(ctx: GateContext): Promise<GateResult>;
+export declare function checkGate(ctx: ClarificationGateContext): Promise<GateResult>;
 //# sourceMappingURL=gate.d.ts.map

package/dist/engine/code-scanner/layer-scanner.js

@@ -1,5 +1,5 @@
 // src/engine/code-scanner/layer-scanner.ts — Scans the 4 implementation layers (SPEC-441)
-import { readFile, stat } from 'node:fs/promises';
+import { stat } from 'node:fs/promises';
 import { join, relative, basename } from 'node:path';
 import { fastFindFilesByExt, fastReadFiles } from '../core-bridge.js';
 /**
@@ -25,8 +25,8 @@ export async function scanLayers(projectPath, keywords, symbolVariants) {
     const symbols = findSymbols(filesToScanForSymbols, symbolVariants);
     // Layer 3: test files matching keywords
     const matchedTests = testFiles.filter((f) => keywords.some((kw) => basename(f).toLowerCase().includes(kw)));
-    // Layer 4: registrations in license-plans.json and register-*.ts files
-    const registrations = await findRegistrations(projectPath, srcFiles, keywords);
+    // Layer 4: registrations in canonical registry source files.
+    const registrations = findRegistrations(projectPath, srcFiles, keywords);
     return {
         files: matchedFiles.map((f) => relative(projectPath, f)),
         symbols,
@@ -55,27 +55,11 @@ function findSymbols(files, variants) {
     }
     return [...found];
 }
-async function findRegistrations(projectPath, srcFiles, keywords) {
+function findRegistrations(_projectPath, srcFiles, keywords) {
     const found = new Set();
-    // Check license-plans.json for tool names matching keywords
-    const licensePath = join(projectPath, 'src', 'config', 'license-plans.json');
-    try {
-        const content = await readFile(licensePath, 'utf8');
-        const json = JSON.parse(content);
-        const allTools = [...(json.freeTools ?? []), ...(json.proTools ?? [])];
-        for (const tool of allTools) {
-            if (keywords.some((kw) => tool.includes(kw))) {
-                found.add(`license:${tool}`);
-            }
-        }
-    }
-    catch {
-        // not a planu project — skip
-    }
-    // Check register-*.ts files for registerTool calls matching keywords
-    const registerFiles = srcFiles.filter((f) => /register.*\.ts$/.test(f));
+    const registerFiles = srcFiles.filter((f) => /register.*\.ts$|tool-registry\/.*\.ts$/.test(f));
     if (registerFiles.length > 0) {
-        const REGISTER_RE = /registerTool\s*\(\s*['"]([^'"]+)['"]/g;
+        const REGISTER_RE = /(?:registerTool\s*\(\s*|name:\s*)['"]([^'"]+)['"]/g;
         for (const file of fastReadFiles(registerFiles)) {
             let match;
             while ((match = REGISTER_RE.exec(file.content)) !== null) {