@planu/cli 4.13.0 → 5.0.0

package/dist/tools/update-status-convention-gate.js

@@ -1,15 +1,13 @@
 // tools/update-status-convention-gate.ts — SPEC-190
 // Convention and constitution compliance gates for update_status transitions.
-import { execFile as execFileCb } from 'node:child_process';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { promisify } from 'node:util';
 import { knowledgeStore } from '../storage/index.js';
 import { checkConstitutionOnTransition } from './update-status-actions.js';
 import { computeValidationEvidenceIdentity, computeValidationEvidenceKey, readMatchingValidationEvidence, recordSuccessfulValidationEvidence, recordValidationOutcome, } from '../engine/validation-evidence-ledger.js';
 import { getToolExecutionSignal } from './safe-handler.js';
 import { VALIDATION_COMMANDS } from '../engine/validation-impact-planner.js';
-const execFile = promisify(execFileCb);
+import { runAbortableProcess } from '../engine/abortable-process-runner.js';
 const MAX_GATE_OUTPUT_BUFFER_BYTES = 64 * 1024 * 1024;
 // ---------------------------------------------------------------------------
 // Helpers
@@ -21,27 +19,30 @@ function isSafeCommand(cmd) {
 }
 async function execGate(cmd, cwd, timeoutMs) {
     const [bin, ...args] = cmd.split(/\s+/);
-    try {
-        const { stdout, stderr } = await execFile(bin ?? 'sh', args, {
-            cwd,
-            timeout: timeoutMs,
-            maxBuffer: MAX_GATE_OUTPUT_BUFFER_BYTES,
-            signal: getToolExecutionSignal(),
-        });
-        return { output: mergeCommandOutput(stdout, stderr), ok: true, timedOut: false };
-    }
-    catch (err) {
-        const e = err;
-        const raw = mergeCommandOutput(e.stdout, e.stderr);
-        const timedOut = e.killed === true || e.signal === 'SIGTERM' || e.code === 'ETIMEDOUT';
-        return {
-            output: raw.trim(),
-            ok: false,
-            timedOut,
-            errorMessage: e.message,
-            errorCode: typeof e.code === 'string' ? e.code : undefined,
-        };
+    const result = await runAbortableProcess(bin ?? 'sh', args, {
+        cwd,
+        timeoutMs,
+        maxBufferBytes: MAX_GATE_OUTPUT_BUFFER_BYTES,
+        signal: getToolExecutionSignal(),
+    });
+    const output = mergeCommandOutput(result.stdout, result.stderr);
+    if (result.status === 0 && result.error === undefined) {
+        return { output, ok: true, timedOut: false };
     }
+    const errorValue = result.error;
+    const errorCode = typeof errorValue === 'object' &&
+        errorValue !== null &&
+        'code' in errorValue &&
+        typeof errorValue.code === 'string'
+        ? errorValue.code
+        : undefined;
+    return {
+        output: output.trim(),
+        ok: false,
+        timedOut: result.timedOut,
+        ...(result.error ? { errorMessage: result.error.message } : {}),
+        ...(typeof errorCode === 'string' ? { errorCode } : {}),
+    };
 }
 function mergeCommandOutput(stdout, stderr) {
     const stdoutText = Buffer.isBuffer(stdout)

package/dist/tools/update-status-reconcile.js

@@ -1,8 +1,8 @@
 // tools/update-status-reconcile.ts — Auto-reconcile token costs when spec reaches done (SPEC-182)
 import { reconcile, formatReconciliation } from '../engine/token-optimizer/reconciler.js';
 import { getEntries } from '../storage/token-ledger-store.js';
-import { join } from 'node:path';
-const DEFAULT_DATA_DIR = join(process.cwd(), 'data');
+import { resolveStorageLayout } from '../storage/storage-layout.js';
+const DEFAULT_DATA_DIR = resolveStorageLayout().data;
 /**
  * Auto-reconcile token costs when a spec transitions to 'done'.
  * Compares pre-execution estimates stored in ledger entries against actuals.

package/dist/tools/usage-report.js

@@ -3,28 +3,13 @@
 import { usageStore } from '../storage/index.js';
 import { filterEventsByPeriod } from '../engine/usage-tracker/core.js';
 import { calculateUsageStats, formatStatsAsMarkdown } from '../engine/usage-tracker/stats.js';
-import { calculateDaysSinceFirstRun, isTrialActive } from '../engine/usage-tracker/trial.js';
-import { getCurrentTier } from './license-gate.js';
 import { compactJson, compactResult } from './output-formatter.js';
 export async function handleUsageReport(args) {
     const format = args.format ?? 'markdown';
-    const tier = await getCurrentTier();
-    // Gather data from storage
     const usageLog = await usageStore.getUsageLog();
-    const trialState = await usageStore.ensureTrialState();
-    const today = new Date().toISOString().slice(0, 10);
-    const todayCount = await usageStore.getDailyCallCount(today);
-    // Compute context values
-    const daysSinceFirstRun = calculateDaysSinceFirstRun(trialState.firstRunAt);
-    const trialActive = isTrialActive(trialState.firstRunAt);
-    let remainingDailyCalls = -1;
-    if (tier === 'free') {
-        const dailyLimit = trialActive ? 50 : 30;
-        remainingDailyCalls = Math.max(0, dailyLimit - todayCount);
-    }
     // Full report uses all events
     const allEvents = filterEventsByPeriod(usageLog.events, 'all');
-    const stats = calculateUsageStats(allEvents, 0, 0, tier, daysSinceFirstRun, trialActive, remainingDailyCalls);
+    const stats = calculateUsageStats(allEvents, 0, 0);
     if (format === 'json') {
         return compactResult(compactJson(stats));
     }

package/dist/tools/usage-stats.js

@@ -3,32 +3,15 @@
 import { usageStore } from '../storage/index.js';
 import { filterEventsByPeriod } from '../engine/usage-tracker/core.js';
 import { calculateUsageStats, formatStatsAsMarkdown } from '../engine/usage-tracker/stats.js';
-import { calculateDaysSinceFirstRun, isTrialActive } from '../engine/usage-tracker/trial.js';
-import { getCurrentTier } from './license-gate.js';
 import { addNextSteps } from './response-helpers.js';
 import { t } from '../i18n/index.js';
 export async function handleUsageStats(args) {
     const period = args.period ?? '30d';
-    const tier = await getCurrentTier();
-    // Gather data from storage
     const usageLog = await usageStore.getUsageLog();
-    const trialState = await usageStore.ensureTrialState();
-    const today = new Date().toISOString().slice(0, 10);
-    const todayCount = await usageStore.getDailyCallCount(today);
-    // Compute context values
-    const daysSinceFirstRun = calculateDaysSinceFirstRun(trialState.firstRunAt);
-    const trialActive = isTrialActive(trialState.firstRunAt);
-    // Remaining daily calls: only relevant for Starter tier
-    let remainingDailyCalls = -1;
-    if (tier === 'free') {
-        const dailyLimit = trialActive ? 50 : 30;
-        remainingDailyCalls = Math.max(0, dailyLimit - todayCount);
-    }
     // Filter events by period and calculate stats
     const filteredEvents = filterEventsByPeriod(usageLog.events, period);
     const stats = calculateUsageStats(filteredEvents, 0, // activeSpecs — placeholder, no cross-layer access to spec store
-    0, // activeProjects — placeholder
-    tier, daysSinceFirstRun, trialActive, remainingDailyCalls);
+    0);
     const markdown = formatStatsAsMarkdown(stats);
     const header = t('tools.response.statsTitle');
     const withHeader = `${header}\n\n${markdown}`;

package/dist/tools/usage-tracking.d.ts

@@ -0,0 +1,4 @@
+import type { ToolResult } from '../types/index.js';
+/** Record local tool health without entitlement, tier, trial, or quota behavior. */
+export declare function withUsageTracking<T>(toolName: string, handler: (args: T, extra?: unknown) => Promise<ToolResult>): (args: T, extra?: unknown) => Promise<ToolResult>;
+//# sourceMappingURL=usage-tracking.d.ts.map

package/dist/tools/usage-tracking.js

@@ -0,0 +1,20 @@
+import { recordUsageEvent } from '../engine/usage-tracker/index.js';
+import * as usageStore from '../storage/usage-store.js';
+import { reportClassifiedDegradation } from '../errors/classified-degradation.js';
+/** Record local tool health without entitlement, tier, trial, or quota behavior. */
+export function withUsageTracking(toolName, handler) {
+    return async (args, extra) => {
+        const rawResult = (await handler(args, extra));
+        const result = rawResult ?? {
+            content: [{ type: 'text', text: 'Internal error: tool handler returned no result' }],
+            isError: true,
+        };
+        void usageStore
+            .appendUsageEvent(recordUsageEvent(toolName, result.isError !== true))
+            .catch((error) => {
+            reportClassifiedDegradation('USAGE_EVENT_WRITE_FAILED', error);
+        });
+        return result;
+    };
+}
+//# sourceMappingURL=usage-tracking.js.map

package/dist/tools/validate-api-contract-handler.js

@@ -1,4 +1,4 @@
-// tools/validate-api-contract-handler.ts — Handler for validate_api_contract (SPEC-322)
+import { technologyValue } from '../engine/technology-registry.js';
 import { validateOpenApiContract } from '../engine/api-validation/openapi-impl-validator.js';
 import { validateGraphQLSchema } from '../engine/api-validation/graphql-schema-validator.js';
 // ---------------------------------------------------------------------------
@@ -7,7 +7,7 @@ import { validateGraphQLSchema } from '../engine/api-validation/graphql-schema-v
 function detectFormat(contractPath) {
     const lower = contractPath.toLowerCase();
     if (lower.endsWith('.graphql') || lower.endsWith('.gql') || lower.endsWith('.sdl')) {
-        return 'graphql';
+        return technologyValue('technology-graphql-aed31c');
     }
     return 'openapi';
 }
@@ -60,7 +60,7 @@ export async function handleValidateApiContract(args) {
         ? detectFormat(contractPath)
         : args.contractFormat;
     let report;
-    if (format === 'graphql') {
+    if (format === technologyValue('technology-graphql-aed31c')) {
         report = await validateGraphQLSchema(contractPath, projectPath);
     }
     else {

package/dist/tools/validate-lint.d.ts

@@ -2,6 +2,7 @@ import type { LintCheckResult } from '../types/index.js';
 interface LintCheckContext {
     projectId?: string;
     specId?: string;
+    maximumTimeoutMs?: number;
 }
 export declare function runLintCheck(projectPath: string, lintCommand: string | null, context?: LintCheckContext): Promise<LintCheckResult>;
 export {};

package/dist/tools/validate-lint.js

@@ -3,9 +3,9 @@ import { computeValidationEvidenceIdentity, computeValidationEvidenceKey, readMa
 import { formatLintFailureDiagnostics, resolveProjectCommandPlan, runProjectCommandPlan, } from '../engine/project-command-runtime.js';
 import { getToolExecutionSignal } from './safe-handler.js';
 import { VALIDATION_COMMANDS } from '../engine/validation-impact-planner.js';
+import { boundedEnvironmentDuration, getRuntimePolicy } from '../engine/runtime-policy.js';
 /** Allowlist: alphanumerics, spaces, and safe shell chars. Rejects ; | $ ` & < > */
 const SAFE_COMMAND_RE = /^[\w\s./:@~=-]+$/;
-const DEFAULT_LINT_CHECK_TIMEOUT_MS = 60_000;
 function isSafeCommand(cmd) {
     return SAFE_COMMAND_RE.test(cmd);
 }
@@ -80,7 +80,7 @@ export async function runLintCheck(projectPath, lintCommand, context = {}) {
             };
         }
     }
-    const timeoutMs = lintCheckTimeoutMs();
+    const timeoutMs = Math.min(lintCheckTimeoutMs(), context.maximumTimeoutMs ?? Number.MAX_SAFE_INTEGER);
     try {
         const startedAt = Date.now();
         const processResult = await runProjectCommandPlan(plan, projectPath, timeoutMs, getToolExecutionSignal());
@@ -113,7 +113,22 @@ export async function runLintCheck(projectPath, lintCommand, context = {}) {
             const output = `Lint command timed out after ${String(seconds)}s and was skipped so validate can complete within MCP request limits. ` +
                 `Run \`${plan.executedCommand}\` manually before marking the spec done, or set PLANU_VALIDATE_LINT_TIMEOUT_MS for an explicit full lint pass.`;
             console.warn(`[Planu] lintCheck timed out: command="${plan.executedCommand}" cwd="${projectPath}" timeoutMs=${String(timeoutMs)}`);
-            return { passed: false, command, issueCount: 1, output };
+            if (context.projectId) {
+                recordValidationOutcome({
+                    projectId: context.projectId,
+                    input: evidenceInput,
+                    action: 'aborted',
+                    producer: 'planu-validate',
+                    status: 'cancelled',
+                    durationMs: timeoutMs,
+                    output,
+                    reason: context.specId
+                        ? `Lint exceeded its deadline while validating ${context.specId}; the degraded result is non-blocking.`
+                        : 'Lint exceeded its canonical deadline; the degraded result is non-blocking.',
+                    source: 'local:planu-validate',
+                });
+            }
+            return { passed: true, command, issueCount: 0, output };
         }
         const raw = commandOutput(err);
         const output = formatLintFailureDiagnostics(plan, raw);
@@ -123,9 +138,9 @@ export async function runLintCheck(projectPath, lintCommand, context = {}) {
             recordValidationOutcome({
                 projectId: context.projectId,
                 input: evidenceInput,
-                action: isCommandTimeout(err) ? 'aborted' : 'executed',
+                action: 'executed',
                 producer: 'planu-validate',
-                status: isCommandTimeout(err) ? 'cancelled' : 'failed',
+                status: 'failed',
                 durationMs: timeoutMs,
                 output,
                 reason: context.specId
@@ -138,14 +153,6 @@ export async function runLintCheck(projectPath, lintCommand, context = {}) {
     }
 }
 function lintCheckTimeoutMs() {
-    const raw = process.env.PLANU_VALIDATE_LINT_TIMEOUT_MS;
-    if (raw === undefined || raw.trim() === '') {
-        return DEFAULT_LINT_CHECK_TIMEOUT_MS;
-    }
-    const parsed = Number.parseInt(raw, 10);
-    if (!Number.isFinite(parsed)) {
-        return DEFAULT_LINT_CHECK_TIMEOUT_MS;
-    }
-    return Math.min(300_000, Math.max(1_000, parsed));
+    return boundedEnvironmentDuration('PLANU_VALIDATE_LINT_TIMEOUT_MS', getRuntimePolicy().lintValidation);
 }
 //# sourceMappingURL=validate-lint.js.map

package/dist/tools/validate.d.ts

@@ -1,7 +1,10 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { validateContractCompliance } from '../engine/test-scaffold-generator.js';
 import type { ValidateInput, ToolResult, ContractSpec, ContractValidation } from '../types/index.js';
+import type { ValidateWorkerProgress } from '../types/validate-worker.js';
 export { validateContractCompliance };
 export type { ContractSpec, ContractValidation };
-export declare function handleValidate(args: ValidateInput, server?: McpServer): Promise<ToolResult>;
+/** Public MCP boundary: persist and acknowledge validation work without running it inline. */
+export declare function handleValidate(args: ValidateInput): Promise<ToolResult>;
+export declare function executeValidate(args: ValidateInput, server?: McpServer, onProgress?: (progress: ValidateWorkerProgress) => void): Promise<ToolResult>;
 //# sourceMappingURL=validate.d.ts.map