@planu/cli 4.13.0 → 4.14.1

package/dist/tools/update-status/qa-gate.d.ts

@@ -1,5 +1,5 @@
 import type { ToolResult } from '../../types/index.js';
 import type { Spec } from '../../types/spec/core.js';
 /** SPEC-642 / SPEC-1111 / SPEC-1144: verify canonical QA evidence before done. */
-export declare function checkQaGate(spec: Spec, projectPath: string | undefined, force: boolean): Promise<ToolResult | null>;
+export declare function checkQaGate(spec: Spec, projectPath: string | undefined, force: boolean, canonicalProjectId?: string): Promise<ToolResult | null>;
 //# sourceMappingURL=qa-gate.d.ts.map

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

@@ -1,13 +1,13 @@
 import { getToolExecutionSignal } from '../safe-handler.js';
 /** SPEC-642 / SPEC-1111 / SPEC-1144: verify canonical QA evidence before done. */
-export async function checkQaGate(spec, projectPath, force) {
+export async function checkQaGate(spec, projectPath, force, canonicalProjectId) {
     if (force || !projectPath) {
         return null;
     }
     const specId = spec.id;
     const { runQaGate } = await import('../../engine/qa-gate.js');
     const effectiveResult = await runQaGate(spec, projectPath, {
-        projectId: spec.projectId,
+        projectId: canonicalProjectId,
         signal: getToolExecutionSignal(),
     });
     if (effectiveResult.passed) {

package/dist/tools/update-status/side-effects.js

@@ -1,15 +1,14 @@
 import { specStore } from '../../storage/index.js';
 import { runCascade } from '../../engine/cascade-hooks/runner.js';
 import { appendAutopilotLogEntry } from '../../storage/autopilot-log-store.js';
-const DEFAULT_POST_COMMIT_TASK_TIMEOUT_MS = 10_000;
-const MIN_POST_COMMIT_LEASE_MS = 30_000;
-const MAX_DEDUPED_TRANSITIONS = 1_000;
+import { redactFailureMessage, reportClassifiedDegradation, } from '../../errors/classified-degradation.js';
+import { getRuntimePolicy } from '../../engine/runtime-policy.js';
 const queuedTransitions = new Map();
 function rememberTransition(transitionKey) {
     if (queuedTransitions.has(transitionKey)) {
         return false;
     }
-    if (queuedTransitions.size >= MAX_DEDUPED_TRANSITIONS) {
+    if (queuedTransitions.size >= getRuntimePolicy().postCommit.maximumRememberedTransitions) {
         const oldest = queuedTransitions.keys().next().value;
         if (oldest !== undefined) {
             queuedTransitions.delete(oldest);
@@ -20,8 +19,9 @@ function rememberTransition(transitionKey) {
 }
 async function runBoundedPostCommitTask(args) {
     const { projectId, specId, transitionId, task } = args;
-    const timeoutMs = task.timeoutMs ?? DEFAULT_POST_COMMIT_TASK_TIMEOUT_MS;
-    const leaseMs = Math.max(MIN_POST_COMMIT_LEASE_MS, timeoutMs * 3);
+    const policy = getRuntimePolicy().postCommit;
+    const timeoutMs = task.timeoutMs ?? policy.defaultTaskTimeoutMs;
+    const leaseMs = Math.max(policy.minimumLeaseMs, timeoutMs * policy.leaseMultiplier);
     const claim = await specStore.claimPostCommitTask(projectId, specId, transitionId, task.name, {
         leaseMs,
     });
@@ -39,14 +39,10 @@ async function runBoundedPostCommitTask(args) {
                 leaseMs,
             })
                 .catch((error) => {
-                console.warn('[planu:post-commit] failed to renew task lease', {
-                    specId,
-                    transitionId,
-                    task: task.name,
-                    error: error instanceof Error ? error.message : String(error),
-                });
+                /* reliability-optional: POST_COMMIT_LEASE_RENEW — timeout path settles the durable task */
+                reportClassifiedDegradation('POST_COMMIT_LEASE_RENEW', error);
             });
-        }, Math.max(1_000, Math.floor(leaseMs / 3)));
+        }, Math.max(policy.minimumHeartbeatMs, Math.floor(leaseMs / policy.leaseMultiplier)));
         heartbeat.unref();
         const runPromise = Promise.resolve().then(() => task.run(controller.signal));
         const timeout = new Promise((resolve) => {
@@ -71,31 +67,25 @@ async function runBoundedPostCommitTask(args) {
                 });
             }
             catch (logError) {
-                console.warn('[planu:post-commit] failed to record late task completion', {
-                    specId,
-                    transitionId,
-                    task: task.name,
-                    error: logError instanceof Error ? logError.message : String(logError),
-                });
+                /* reliability-optional: LATE_TASK_COMPLETION_LOG — durable task is already settled */
+                reportClassifiedDegradation('LATE_TASK_COMPLETION_LOG', logError);
             }
             return;
         }
         await specStore.settlePostCommitTask(projectId, specId, transitionId, task.name, claim.executionId, { status: 'done' });
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
+        /* reliability-optional: POST_COMMIT_TASK_FAILURE — durable failed state is persisted below */
+        reportClassifiedDegradation('POST_COMMIT_TASK_FAILURE', error);
+        const message = redactFailureMessage(error);
         await specStore
             .settlePostCommitTask(projectId, specId, transitionId, task.name, claim.executionId, {
             status: 'failed',
             error: message,
         })
             .catch((settleError) => {
-            console.warn('[planu:post-commit] failed to persist task failure', {
-                specId,
-                transitionId,
-                task: task.name,
-                error: settleError instanceof Error ? settleError.message : String(settleError),
-            });
+            /* reliability-optional: TASK_FAILURE_SETTLEMENT — recovery lease remains retryable */
+            reportClassifiedDegradation('TASK_FAILURE_SETTLEMENT', settleError);
         });
         try {
             await appendAutopilotLogEntry(projectId, {
@@ -108,12 +98,8 @@ async function runBoundedPostCommitTask(args) {
             });
         }
         catch (logError) {
-            console.warn('[planu:post-commit] failed to record task failure', {
-                specId,
-                transitionId,
-                task: task.name,
-                error: logError instanceof Error ? logError.message : String(logError),
-            });
+            /* reliability-optional: TASK_FAILURE_LOG — durable failure state remains authoritative */
+            reportClassifiedDegradation('TASK_FAILURE_LOG', logError);
         }
     }
     finally {
@@ -167,7 +153,9 @@ export async function maybeSafePushOnDone(projectPath, newStatus) {
         }
         return { label: 'autopush', message: `Not pushed: ${result.reason} — ${result.message}` };
     }
-    catch {
+    catch (error) {
+        /* reliability-optional: AUTOPUSH_RESULT_UNAVAILABLE — optional result is explicitly absent */
+        reportClassifiedDegradation('AUTOPUSH_RESULT_UNAVAILABLE', error);
         return null;
     }
 }
@@ -184,7 +172,9 @@ async function readDisabledByConfig(projectPath) {
         const disabled = parsed.cascadeHooks?.disabled;
         return Array.isArray(disabled) ? new Set(disabled) : new Set();
     }
-    catch {
+    catch (error) {
+        /* reliability-optional: CASCADE_CONFIG_UNAVAILABLE — default empty disable set is explicit */
+        reportClassifiedDegradation('CASCADE_CONFIG_UNAVAILABLE', error);
         return new Set();
     }
 }
@@ -221,8 +211,9 @@ export function fireAndForgetSideEffects(params) {
             Promise.resolve(readDisabledByEnv()),
         ]);
         await runCascade(ctx, { disabledByConfig, disabledByEnv });
-    })().catch(() => {
-        /* best-effort — cascade errors never surface to the caller */
+    })().catch((error) => {
+        /* reliability-optional: ASYNC_CASCADE_FAILURE — post-commit task ledger captures retry state */
+        reportClassifiedDegradation('ASYNC_CASCADE_FAILURE', error);
     });
 }
 /**
@@ -250,7 +241,9 @@ export async function runCascadeForResponse(params) {
         ]);
         return await runCascade(ctx, { disabledByConfig, disabledByEnv });
     }
-    catch {
+    catch (error) {
+        /* reliability-optional: CASCADE_SYNC_FAILURE — explicit null reports unavailable result */
+        reportClassifiedDegradation('CASCADE_SYNC_FAILURE', error);
         return null;
     }
 }

package/dist/tools/update-status/transition-guard.d.ts

@@ -53,15 +53,17 @@ export declare function checkTransition(currentStatus: SpecStatus, newStatus: Sp
  * Returns an error ToolResult if blocked, null if passed.
  */
 export declare function checkDorGate(spec: Spec, specId: string, projectId: string, newStatus: SpecStatus): ToolResult | null;
+/** Reject implementation until every declared dependency exists and is done. */
+export declare function checkImplementationDependencyGate(spec: Spec, allSpecs: readonly Spec[], newStatus: SpecStatus): ToolResult | null;
 /**
  * SPEC-632: Block transition to 'approved' if ambiguity score < 70.
- * Best-effort: if spec file cannot be read, gate is skipped.
+ * Fails closed when the spec cannot be scored.
  */
 export declare function checkAmbiguityGate(spec: Spec, newStatus: SpecStatus): Promise<ToolResult | null>;
 /**
  * SPEC-769/SPEC-492: Readiness gate — block 'review'/'approved' when spec
  * quality is too low or the persisted spec document is not English.
- * Best-effort: if spec.md cannot be read, the gate is skipped (returns no block).
+ * Fails closed if spec.md cannot be read or evaluated.
  *
  * - 0 criteria → InteractiveQuestion (hard block, no force path)
  * - score < 70 on approved && !forceApprove → InteractiveQuestion with 3 options

package/dist/tools/update-status/transition-guard.js

@@ -10,6 +10,8 @@ import { checkGroundedSpecContract } from '../../engine/spec-grounding/contract.
 import { checkGenericSpecOutput } from '../../engine/spec-quality/generic-output-gate.js';
 import { formatKeyValue } from '../output-formatter.js';
 import { getResolvedChallengeEvidence, requiredResolvedChallenges, } from '../challenge-spec/challenge-report.js';
+import { evaluateSpecDependencies } from '../../engine/dependency-evaluator.js';
+import { reportClassifiedDegradation } from '../../errors/classified-degradation.js';
 /**
  * Valid state transitions for spec lifecycle.
  * draft -> review -> approved -> implementing -> done
@@ -129,7 +131,8 @@ export function checkDorGate(spec, specId, projectId, newStatus) {
             delta: { failedCount: dorResult.blockingItems.length },
             timestamp: new Date().toISOString(),
         }).catch((err) => {
-            console.error('[planu] DoR feedback event failed:', err);
+            /* reliability-optional: DOR_FEEDBACK_EVENT — blocking gate result remains authoritative */
+            reportClassifiedDegradation('DOR_FEEDBACK_EVENT', err);
         });
         return {
             content: [
@@ -162,16 +165,47 @@ export function checkDorGate(spec, specId, projectId, newStatus) {
     }
     return null;
 }
+/** Reject implementation until every declared dependency exists and is done. */
+export function checkImplementationDependencyGate(spec, allSpecs, newStatus) {
+    if (newStatus !== 'implementing' || isReverseTransition(spec.status, newStatus)) {
+        return null;
+    }
+    const evaluation = evaluateSpecDependencies(spec, allSpecs);
+    if (evaluation.allowed) {
+        return null;
+    }
+    const blockingIds = [...new Set(evaluation.blockers.map((blocker) => blocker.specId))];
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Dependency gate blocked implementation: ${evaluation.blockers
+                    .map((blocker) => `${blocker.specId} (${blocker.reason})`)
+                    .join(', ')}.`,
+            },
+        ],
+        isError: true,
+        structuredContent: {
+            error: 'DEPENDENCY_GATE_BLOCKED',
+            code: 'UNMET_DEPENDENCIES',
+            blockingIds,
+            blockers: evaluation.blockers,
+        },
+    };
+}
 /**
  * SPEC-632: Block transition to 'approved' if ambiguity score < 70.
- * Best-effort: if spec file cannot be read, gate is skipped.
+ * Fails closed when the spec cannot be scored.
  */
 export async function checkAmbiguityGate(spec, newStatus) {
     if (newStatus !== 'approved' || !spec.specPath) {
         return null;
     }
     const report = await scoreAmbiguityFromPath(spec.specPath);
-    if (!report || report.score >= 70) {
+    if (!report) {
+        return gateUnavailableResult('AMBIGUITY_GATE_UNAVAILABLE', 'Ambiguity scoring failed.');
+    }
+    if (report.score >= 70) {
         return null;
     }
     return {
@@ -201,7 +235,7 @@ export async function checkAmbiguityGate(spec, newStatus) {
 /**
  * SPEC-769/SPEC-492: Readiness gate — block 'review'/'approved' when spec
  * quality is too low or the persisted spec document is not English.
- * Best-effort: if spec.md cannot be read, the gate is skipped (returns no block).
+ * Fails closed if spec.md cannot be read or evaluated.
  *
  * - 0 criteria → InteractiveQuestion (hard block, no force path)
  * - score < 70 on approved && !forceApprove → InteractiveQuestion with 3 options
@@ -218,13 +252,14 @@ export async function checkReadinessGate(spec, newStatus, forceApprove) {
     try {
         body = await readFile(spec.specPath, 'utf-8');
     }
-    catch {
-        // Best-effort — if file is unreadable, skip gate
-        return { blockResult: null, qualityWarnings: [] };
+    catch (error) {
+        /* reliability-optional: READINESS_SPEC_UNREADABLE — transition fails closed below */
+        reportClassifiedDegradation('READINESS_SPEC_UNREADABLE', error);
+        return readinessUnavailable('READINESS_SPEC_UNREADABLE', error instanceof Error ? error.message : 'spec.md could not be read');
     }
     // Guard: mock environments return undefined; unreadable files return non-string
     if (typeof body !== 'string') {
-        return { blockResult: null, qualityWarnings: [] };
+        return readinessUnavailable('READINESS_SPEC_INVALID', 'spec.md did not return text content');
     }
     const languageValidation = validateEnglishOnlySpecText(body);
     if (!languageValidation.ok) {
@@ -302,8 +337,10 @@ export async function checkReadinessGate(spec, newStatus, forceApprove) {
     try {
         ({ score, warnings, criteriaCount } = checkReadinessInternal(body));
     }
-    catch {
-        return { blockResult: null, qualityWarnings: [] };
+    catch (error) {
+        /* reliability-optional: READINESS_EVALUATION_FAILED — transition fails closed below */
+        reportClassifiedDegradation('READINESS_EVALUATION_FAILED', error);
+        return readinessUnavailable('READINESS_EVALUATION_FAILED', error instanceof Error ? error.message : 'readiness evaluation failed');
     }
     if (criteriaCount === 0) {
         if (newStatus === 'review') {
@@ -423,6 +460,16 @@ export async function checkReadinessGate(spec, newStatus, forceApprove) {
         qualityWarnings: [],
     };
 }
+function gateUnavailableResult(code, message) {
+    return {
+        content: [{ type: 'text', text: `${message} Transition blocked until the gate succeeds.` }],
+        isError: true,
+        structuredContent: { error: code, message, retryable: true },
+    };
+}
+function readinessUnavailable(code, message) {
+    return { blockResult: gateUnavailableResult(code, message), qualityWarnings: [] };
+}
 /**
  * SPEC-964: Challenge gate — block 'review' if challenge_spec was never run
  * or does not contain enough explicit resolution evidence.

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/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.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);
 }
@@ -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

@@ -3,5 +3,7 @@ import { validateContractCompliance } from '../engine/test-scaffold-generator.js
 import type { ValidateInput, ToolResult, ContractSpec, ContractValidation } from '../types/index.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): Promise<ToolResult>;
 //# sourceMappingURL=validate.d.ts.map