principles-disciple 1.51.0 → 1.53.0

package/src/core/pain-signal.ts

@@ -0,0 +1,136 @@
+/**
+ * Universal PainSignal schema for the Evolution SDK.
+ *
+ * This module defines a framework-agnostic pain signal that any AI agent
+ * framework can produce. It extends the existing PainFlagData format with
+ * additional structured fields (domain, severity, context) needed for
+ * cross-workspace evolution and multi-domain support.
+ *
+ * Validation uses @sinclair/typebox to match existing project patterns.
+ */
+import { Type, type Static } from '@sinclair/typebox';
+import { Value } from '@sinclair/typebox/value';
+
+// ---------------------------------------------------------------------------
+// PainSignal Schema
+// ---------------------------------------------------------------------------
+
+/**
+ * Severity levels derived from pain score thresholds.
+ * - low:      0-39  (minor issue, informational)
+ * - medium:   40-69 (moderate error)
+ * - high:     70-89 (severe violation)
+ * - critical: 90-100 (systemic failure, spiral detected)
+ */
+export const PainSeverity = Type.Union([
+  Type.Literal('low'),
+  Type.Literal('medium'),
+  Type.Literal('high'),
+  Type.Literal('critical'),
+]);
+
+export type PainSeverity = Static<typeof PainSeverity>;
+
+/**
+ * TypeBox schema for a universal pain signal.
+ *
+ * Every signal MUST have: source, score, timestamp, reason, sessionId,
+ * agentId, traceId, triggerTextPreview. Optional fields (domain, severity,
+ * context) default during validation.
+ */
+export const PainSignalSchema = Type.Object({
+  /** What triggered this pain signal (e.g., 'tool_failure', 'human_intervention') */
+  source: Type.String({ minLength: 1 }),
+  /** Pain score 0-100 */
+  score: Type.Number({ minimum: 0, maximum: 100 }),
+  /** ISO 8601 timestamp */
+  timestamp: Type.String({ minLength: 1 }),
+  /** Human-readable reason / error description */
+  reason: Type.String({ minLength: 1 }),
+  /** Session ID — identifies which conversation this happened in */
+  sessionId: Type.String({ minLength: 1 }),
+  /** Agent ID — identifies which agent (main, builder, diagnostician, etc.) */
+  agentId: Type.String({ minLength: 1 }),
+  /** Correlation trace ID for linking events across the pipeline */
+  traceId: Type.String({ minLength: 1 }),
+  /** Preview of the text that triggered this pain */
+  triggerTextPreview: Type.String(),
+  /** Domain context (e.g., 'coding', 'writing', 'analysis') */
+  domain: Type.String({ default: 'coding' }),
+  /** Severity level derived from score */
+  severity: PainSeverity,
+  /** Additional structured context payload */
+  context: Type.Record(Type.String(), Type.Unknown()),
+});
+
+export type PainSignal = Static<typeof PainSignalSchema>;
+
+// ---------------------------------------------------------------------------
+// Default Derivation
+// ---------------------------------------------------------------------------
+
+/**
+ * Derives severity from a numeric pain score.
+ */
+export function deriveSeverity(score: number): PainSeverity {
+  if (score >= 90) return 'critical';
+  if (score >= 70) return 'high';
+  if (score >= 40) return 'medium';
+  return 'low';
+}
+
+// ---------------------------------------------------------------------------
+// Validation
+// ---------------------------------------------------------------------------
+
+export interface PainSignalValidationResult {
+  valid: boolean;
+  errors: string[];
+  signal?: PainSignal;
+}
+
+/**
+ * Validates an arbitrary object against the PainSignal schema.
+ *
+ * Returns a structured result with:
+ * - `valid`: whether the input conforms to the schema
+ * - `errors`: human-readable list of validation failures
+ * - `signal`: the typed signal (only present when valid)
+ *
+ * Missing optional fields (domain, severity, context) are filled with defaults
+ * before validation so callers get a fully-formed signal back.
+ */
+export function validatePainSignal(input: unknown): PainSignalValidationResult {
+  if (typeof input !== 'object' || input === null || Array.isArray(input)) {
+    return { valid: false, errors: ['Input must be a non-null object'] };
+  }
+
+  const raw = input as Record<string, unknown>;
+
+  // Apply defaults for optional fields before validation
+  const hydrated = {
+    ...raw,
+    domain: raw.domain ?? 'coding',
+    severity: raw.severity ?? deriveSeverity(
+      typeof raw.score === 'number' ? raw.score : 0,
+    ),
+    context: raw.context ?? {},
+  };
+
+  // Collect TypeBox errors
+  const errors = [...Value.Errors(PainSignalSchema, hydrated)];
+  if (errors.length > 0) {
+    return {
+      valid: false,
+      errors: errors.map(
+        (e) => `${e.path ? `${e.path}: ` : ''}${e.message}`,
+      ),
+    };
+  }
+
+  return {
+    valid: true,
+    errors: [],
+    signal: Value.Cast(PainSignalSchema, hydrated) as PainSignal,
+  };
+}

package/src/core/pd-task-reconciler.ts

@@ -144,7 +144,7 @@ function diff(declared: PDTaskSpec[], actual: CronJob[]): DiffAction[] {
 function buildCronJob(
   task: PDTaskSpec,
   nowMs: number,
-   
+  workspaceDir: string,
   logger?: { info?: (_: string) => void },
 ): CronJob {
   logger?.info?.(`[PD:Reconciler] Building cron job: ${task.name} (id=${task.id}, interval=${task.schedule.everyMs}ms)`);
@@ -159,9 +159,7 @@ function buildCronJob(
     wakeMode: 'now',
     payload: {
       kind: 'agentTurn',
-       
-       
-      message: buildTaskPrompt(task, logger),
+      message: buildTaskPrompt(task, workspaceDir, logger),
       lightContext: task.execution.lightContext ?? true,
       timeoutSeconds: task.execution.timeoutSeconds ?? 120,
       toolsAllow: task.execution.toolsAllow,
@@ -180,7 +178,12 @@ function buildCronJob(
 }
 
  
-function buildTaskPrompt(task: PDTaskSpec, logger?: { info?: (_: string) => void }): string {
+function buildTaskPrompt(task: PDTaskSpec, workspaceDir: string, logger?: { info?: (_: string) => void }): string {
+  // Resolve paths dynamically from workspaceDir instead of hardcoding
+  const stateDir = path.join(workspaceDir, '.state');
+  const empathyKeywordsPath = path.join(stateDir, 'empathy_keywords.json');
+  const eventsJsonlPath = path.join(stateDir, 'logs', 'events.jsonl');
+
   if (task.id === 'empathy-optimizer') {
     logger?.info?.(`[PD:Reconciler] Building empathy optimizer prompt`);
     return `You are the Principles Disciple Empathy Keyword Optimizer.
@@ -195,7 +198,7 @@ Analyze the current empathy keyword store and recent user message logs to:
 
 ### Step 1: Read current keyword store
 Use read_file to load:
-\`~/.openclaw/workspace-main/.state/empathy_keywords.json\`
+\`${empathyKeywordsPath}\`
 
 Examine the "terms" object. For each term note:
 - weight (0.1-0.9): higher = stronger frustration signal
@@ -204,7 +207,7 @@ Examine the "terms" object. For each term note:
 
 ### Step 2: Read recent message logs
 Use search_file_content to scan:
-\`~/.openclaw/workspace-main/.state/logs/events.jsonl\`
+\`${eventsJsonlPath}\`
 
 Look for user messages containing frustration signals:
 - Negation: "不对", "错了", "不行", "重做"
@@ -214,7 +217,7 @@ Look for user messages containing frustration signals:
 
 ### Step 3: Write updated keyword store
 Use write_file to save the updated store back to:
-\`~/.openclaw/workspace-main/.state/empathy_keywords.json\`
+\`${empathyKeywordsPath}\`
 
 The file format is:
 \`\`\`json
@@ -304,7 +307,7 @@ export async function reconcilePDTasks(
       case 'CREATE':
         if (action.task) {
           if (!dryRun) {
-            const job = buildCronJob(action.task, nowMs, logger);
+            const job = buildCronJob(action.task, nowMs, workspaceDir, logger);
             cronStore.jobs.push(job);
             logger.info?.(`[PD:Reconciler] Created job: ${action.task.name}`);
           }
@@ -315,7 +318,7 @@ export async function reconcilePDTasks(
         if (action.task && action.job) {
           if (!dryRun) {
             const idx = cronStore.jobs.indexOf(action.job);
-            const newJob = buildCronJob(action.task, nowMs, logger);
+            const newJob = buildCronJob(action.task, nowMs, workspaceDir, logger);
             newJob.id = action.job.id;
             // Preserve original state — only CronService should recalculate nextRunAtMs
             newJob.state = {
@@ -449,7 +452,7 @@ export async function trigger(
     existingJob.deleteAfterRun = undefined;
   } else {
     log(`Creating new job for manual trigger: ${task.name}`);
-    const newJob = buildCronJob(task, nowMs, { info: log });
+    const newJob = buildCronJob(task, nowMs, workspaceDir, { info: log });
     newJob.enabled = true;
     newJob.state.nextRunAtMs = nowMs;
     cronStore.jobs.push(newJob);

package/src/core/principle-injection.ts

@@ -0,0 +1,208 @@
+/**
+ * Principle Injection — Budget-Aware Principle Selection
+ * ========================================================
+ *
+ * PURPOSE: Select principles for prompt injection within a character budget,
+ * prioritizing by priority tier (P0 > P1 > P2) and recency, while ensuring
+ * at least one P0 principle is included when available.
+ *
+ * DESIGN:
+ *  - Sorts principles by priority (P0 first, then P1, then P2)
+ *  - Within same priority, sorts by recency (createdAt descending)
+ *  - Selects principles until the cumulative character budget is exceeded
+ *  - Guarantees at least one P0 principle is included if any exist
+ *  - Returns the selected principles and total character usage
+ *
+ * This replaces the previous hardcoded slice(-3)/slice(0,5) approach in
+ * prompt.ts with a budget-aware, priority-respecting selection algorithm.
+ */
+
+import type { PrinciplePriority } from '../types/principle-tree-schema.js';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/**
+ * Minimal principle shape required for injection selection.
+ * Accepts both evolution-types.Principle and principle-tree-schema.Principle.
+ */
+export interface InjectablePrinciple {
+  id: string;
+  text: string;
+  /** Priority level. Defaults to 'P1' if not set by the source. */
+  priority?: PrinciplePriority;
+  createdAt: string;
+}
+
+/**
+ * Result of principle selection for injection.
+ */
+export interface PrincipleSelectionResult {
+  /** Selected principles in injection order (priority-first, then recency) */
+  selected: InjectablePrinciple[];
+  /** Total character count of selected principles' formatted output */
+  totalChars: number;
+  /** Number of principles by priority tier */
+  breakdown: {
+    p0: number;
+    p1: number;
+    p2: number;
+  };
+  /** Whether at least one P0 principle was included */
+  hasP0: boolean;
+  /** Whether the selection was truncated due to budget */
+  wasTruncated: boolean;
+}
+
+// ---------------------------------------------------------------------------
+// Priority Ordering
+// ---------------------------------------------------------------------------
+
+const PRIORITY_ORDER: Record<PrinciplePriority, number> = {
+  P0: 0,
+  P1: 1,
+  P2: 2,
+};
+
+/**
+ * Compare two principles for sorting.
+ * Primary: priority (P0 < P1 < P2 — lower is higher priority).
+ * Secondary: recency (newer createdAt first).
+ */
+function comparePrinciples(a: InjectablePrinciple, b: InjectablePrinciple): number {
+  const priorityA = PRIORITY_ORDER[a.priority ?? 'P1'] ?? 99;
+  const priorityB = PRIORITY_ORDER[b.priority ?? 'P1'] ?? 99;
+
+  if (priorityA !== priorityB) {
+    return priorityA - priorityB;
+  }
+
+  // Same priority: sort by recency (newer first)
+  return b.createdAt.localeCompare(a.createdAt);
+}
+
+// ---------------------------------------------------------------------------
+// Formatting
+// ---------------------------------------------------------------------------
+
+/**
+ * Format a single principle for injection.
+ * Returns the formatted string including ID and text.
+ *
+ * Format: "- [ID] text" (matches existing prompt.ts format)
+ */
+export function formatPrinciple(p: InjectablePrinciple): string {
+  return `- [${p.id}] ${p.text}`;
+}
+
+/**
+ * Calculate the character length of a formatted principle, including newline.
+ */
+function formattedLength(p: InjectablePrinciple): number {
+  return formatPrinciple(p).length + 1; // +1 for newline separator
+}
+
+// ---------------------------------------------------------------------------
+// Selection Algorithm
+// ---------------------------------------------------------------------------
+
+/**
+ * Select principles for prompt injection within a character budget.
+ *
+ * Algorithm:
+ *  1. Sort all principles by priority (P0 > P1 > P2), then by recency
+ *  2. Iterate through sorted principles, accumulating character count
+ *  3. Stop when adding the next principle would exceed budgetChars
+ *  4. Ensure at least one P0 principle is included (even if it exceeds budget)
+ *
+ * @param principles - All available principles to select from
+ * @param budgetChars - Maximum character budget for formatted output
+ * @returns Selection result with chosen principles and metadata
+ */
+export function selectPrinciplesForInjection(
+  principles: InjectablePrinciple[],
+  budgetChars: number,
+): PrincipleSelectionResult {
+  if (principles.length === 0) {
+    return {
+      selected: [],
+      totalChars: 0,
+      breakdown: { p0: 0, p1: 0, p2: 0 },
+      hasP0: false,
+      wasTruncated: false,
+    };
+  }
+
+  // Sort by priority then recency
+  const sorted = [...principles].sort(comparePrinciples);
+
+  const selected: InjectablePrinciple[] = [];
+  let totalChars = 0;
+  let p0Included = false;
+  let wasTruncated = false;
+
+  for (const principle of sorted) {
+    const cost = formattedLength(principle);
+
+    // Check if adding this principle would exceed budget
+    if (totalChars + cost > budgetChars) {
+      // Special case: if no P0 has been included yet, force-include the first P0
+      // even if it exceeds the budget (P0 principles are critical)
+      if (!p0Included && principle.priority === 'P0') {
+        selected.push(principle);
+        totalChars += cost;
+        p0Included = true;
+        wasTruncated = true;
+        // Continue to try to fit more principles after this forced inclusion
+        continue;
+      }
+
+      wasTruncated = true;
+      break;
+    }
+
+    selected.push(principle);
+    totalChars += cost;
+    if (principle.priority === 'P0') {
+      p0Included = true;
+    }
+  }
+
+  // Safety net: if we went through all principles and still no P0 included
+  // (because P0 was beyond budget threshold), force-include the first P0
+  if (!p0Included) {
+    const firstP0 = sorted.find(p => p.priority === 'P0');
+    if (firstP0 && !selected.includes(firstP0)) {
+      // Insert P0 at the beginning of selected (highest priority)
+      selected.unshift(firstP0);
+      totalChars += formattedLength(firstP0);
+      p0Included = true;
+    }
+  }
+
+  const breakdown = {
+    p0: selected.filter(p => (p.priority ?? 'P1') === 'P0').length,
+    p1: selected.filter(p => (p.priority ?? 'P1') === 'P1').length,
+    p2: selected.filter(p => (p.priority ?? 'P1') === 'P2').length,
+  };
+
+  return {
+    selected,
+    totalChars,
+    breakdown,
+    hasP0: p0Included,
+    wasTruncated,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Default Budget
+// ---------------------------------------------------------------------------
+
+/**
+ * Default character budget for principle injection.
+ * 4000 characters is ~800 tokens, leaving ample room for other prompt sections
+ * within the 10K character injection limit.
+ */
+export const DEFAULT_PRINCIPLE_BUDGET = 4000;

package/src/core/principle-injector.ts

@@ -0,0 +1,84 @@
+/**
+ * PrincipleInjector interface for the Evolution SDK.
+ *
+ * Wraps the existing principle injection logic into a framework-agnostic
+ * contract. Per D-05, this delegates to selectPrinciplesForInjection and
+ * formatPrinciple without any behavioral changes.
+ *
+ * Per D-06, InjectionContext contains only generic fields (domain, sessionId,
+ * budgetChars) -- no framework-specific fields.
+ */
+import type { InjectablePrinciple } from './principle-injection.js';
+import { selectPrinciplesForInjection, formatPrinciple } from './principle-injection.js';
+
+// ---------------------------------------------------------------------------
+// InjectionContext
+// ---------------------------------------------------------------------------
+
+/** Generic injection context -- no framework-specific fields. */
+export interface InjectionContext {
+  /** Domain context (e.g., 'coding', 'writing', 'analysis') */
+  domain: string;
+  /** Session identifier */
+  sessionId: string;
+  /** Maximum characters allowed for injected principles */
+  budgetChars: number;
+}
+
+// ---------------------------------------------------------------------------
+// PrincipleInjector Interface
+// ---------------------------------------------------------------------------
+
+/**
+ * Framework-agnostic principle injection interface.
+ *
+ * Wraps the existing budget-aware selection and formatting logic.
+ * Framework adapters convert their context to InjectionContext before calling.
+ */
+export interface PrincipleInjector {
+  /**
+   * Select principles relevant for injection within a character budget.
+   * Delegates to selectPrinciplesForInjection from principle-injection.ts.
+   *
+   * @param principles - All available principles to select from
+   * @param context - Generic injection context with budget constraint
+   * @returns Selected principles in injection order
+   */
+  getRelevantPrinciples(
+    principles: InjectablePrinciple[],
+    context: InjectionContext,
+  ): InjectablePrinciple[];
+
+  /**
+   * Format a single principle for prompt injection.
+   * Delegates to formatPrinciple from principle-injection.ts.
+   *
+   * Format: "- [ID] text"
+   *
+   * @param principle - The principle to format
+   * @returns Formatted string for prompt injection
+   */
+  formatForInjection(principle: InjectablePrinciple): string;
+}
+
+// ---------------------------------------------------------------------------
+// Default Implementation
+// ---------------------------------------------------------------------------
+
+/**
+ * Default implementation that delegates to existing functions.
+ * Zero rewrite risk -- behavior is identical to calling the functions directly.
+ */
+export class DefaultPrincipleInjector implements PrincipleInjector {
+  getRelevantPrinciples(
+    principles: InjectablePrinciple[],
+    context: InjectionContext,
+  ): InjectablePrinciple[] {
+    const result = selectPrinciplesForInjection(principles, context.budgetChars);
+    return result.selected;
+  }
+
+  formatForInjection(principle: InjectablePrinciple): string {
+    return formatPrinciple(principle);
+  }
+}

package/src/core/storage-adapter.ts

@@ -0,0 +1,65 @@
+/**
+ * StorageAdapter interface for the Evolution SDK.
+ *
+ * This interface decouples the evolution engine from specific persistence
+ * implementations (file system, SQLite, remote API). All higher-level
+ * modules that need to read or mutate the principle ledger should depend
+ * on this interface rather than importing principle-tree-ledger directly.
+ *
+ * The interface uses HybridLedgerStore from principle-tree-ledger as the
+ * canonical store shape, but future adapters can map alternative backends
+ * to this shape.
+ */
+import type { HybridLedgerStore } from './principle-tree-ledger.js';
+
+// ---------------------------------------------------------------------------
+// StorageAdapter Interface
+// ---------------------------------------------------------------------------
+
+/**
+ * Abstract storage adapter for the principle ledger.
+ *
+ * Implementations must guarantee:
+ * - Atomic writes (no partial/corrupted state on crash)
+ * - Thread-safe concurrent access (locking or equivalent)
+ * - Consistent read-after-write visibility
+ *
+ * The `mutateLedger` method is the preferred way to perform read-modify-write
+ * cycles. It encapsulates locking so callers never need to manage it.
+ */
+export interface StorageAdapter {
+  /**
+   * Load the current ledger state from persistence.
+   *
+   * If no persisted state exists (first run), returns an empty store.
+   */
+  loadLedger(): Promise<HybridLedgerStore>;
+
+  /**
+   * Persist the full ledger state.
+   *
+   * Must be atomic — partial writes must never be visible to readers.
+   */
+  saveLedger(store: HybridLedgerStore): Promise<void>;
+
+  /**
+   * Perform a read-modify-write cycle with automatic locking.
+   *
+   * The `mutate` function receives the current store and may return a
+   * value synchronously or via Promise. The store is persisted after
+   * the mutate function resolves, regardless of its return value.
+   *
+   * If two concurrent `mutateLedger` calls overlap, one must wait for
+   * the other to complete (pessimistic locking) or retry on conflict
+   * (optimistic locking). The choice is left to the implementation.
+   *
+   * @example
+   * ```ts
+   * const count = await adapter.mutateLedger((store) => {
+   *   store.tree.principles['p-1'] = newPrinciple;
+   *   return Object.keys(store.tree.principles).length;
+   * });
+   * ```
+   */
+  mutateLedger<T>(mutate: (store: HybridLedgerStore) => T | Promise<T>): Promise<T>;
+}

package/src/core/telemetry-event.ts

@@ -0,0 +1,109 @@
+/**
+ * TelemetryEvent schema for the Evolution SDK.
+ *
+ * TypeBox schema describing the shape of in-process evolution events.
+ * Per D-07, this is a documentation artifact -- the existing EvolutionLogger
+ * output should conform to this schema. No new TelemetryService is created.
+ *
+ * Per D-08, covers the 3 core events aligned with EvolutionHook:
+ * - pain_detected (maps to EvolutionStage 'pain_detected')
+ * - principle_candidate_created (maps to EvolutionStage 'principle_generated')
+ * - principle_promoted (maps to EvolutionStage 'completed')
+ *
+ * Injection and storage events are out of scope for this phase.
+ */
+import { Type, type Static } from '@sinclair/typebox';
+import { Value } from '@sinclair/typebox/value';
+
+// ---------------------------------------------------------------------------
+// Event Type Union
+// ---------------------------------------------------------------------------
+
+/**
+ * The 3 core telemetry event types, aligned with EvolutionHook methods.
+ *
+ * Mapping to existing EvolutionLogger stages:
+ * - pain_detected -> EvolutionStage 'pain_detected'
+ * - principle_candidate_created -> EvolutionStage 'principle_generated'
+ * - principle_promoted -> EvolutionStage 'completed'
+ */
+export const TelemetryEventType = Type.Union([
+  Type.Literal('pain_detected'),
+  Type.Literal('principle_candidate_created'),
+  Type.Literal('principle_promoted'),
+]);
+
+export type TelemetryEventType = Static<typeof TelemetryEventType>;
+
+// ---------------------------------------------------------------------------
+// TelemetryEvent Schema
+// ---------------------------------------------------------------------------
+
+/**
+ * Schema for an in-process telemetry event.
+ *
+ * Fields align with existing EvolutionLogEntry:
+ * - traceId <-> EvolutionLogEntry.traceId
+ * - timestamp <-> EvolutionLogEntry.timestamp
+ * - sessionId <-> EvolutionLogEntry.sessionId
+ * - payload <-> EvolutionLogEntry.metadata
+ *
+ * No PII fields. The agentId field is optional and contains only
+ * system identifiers (e.g., 'main', 'builder'), never user data.
+ */
+export const TelemetryEventSchema = Type.Object({
+  /** Event type (one of the 3 core types) */
+  eventType: TelemetryEventType,
+  /** Correlation trace ID for linking events across the pipeline */
+  traceId: Type.String({ minLength: 1 }),
+  /** ISO 8601 timestamp */
+  timestamp: Type.String({ minLength: 1 }),
+  /** Session identifier */
+  sessionId: Type.String(),
+  /** Agent identifier (system identifier only, no PII) */
+  agentId: Type.Optional(Type.String()),
+  /** Event-specific payload */
+  payload: Type.Record(Type.String(), Type.Unknown()),
+});
+
+export type TelemetryEvent = Static<typeof TelemetryEventSchema>;
+
+// ---------------------------------------------------------------------------
+// Validation
+// ---------------------------------------------------------------------------
+
+export interface TelemetryEventValidationResult {
+  valid: boolean;
+  errors: string[];
+  event?: TelemetryEvent;
+}
+
+/**
+ * Validates an arbitrary object against the TelemetryEvent schema.
+ *
+ * Returns a structured result with:
+ * - `valid`: whether the input conforms to the schema
+ * - `errors`: human-readable list of validation failures
+ * - `event`: the typed event (only present when valid)
+ */
+export function validateTelemetryEvent(input: unknown): TelemetryEventValidationResult {
+  if (typeof input !== 'object' || input === null || Array.isArray(input)) {
+    return { valid: false, errors: ['Input must be a non-null object'] };
+  }
+
+  const errors = [...Value.Errors(TelemetryEventSchema, input)];
+  if (errors.length > 0) {
+    return {
+      valid: false,
+      errors: errors.map(
+        (e) => `${e.path ? `${e.path}: ` : ''}${e.message}`,
+      ),
+    };
+  }
+
+  return {
+    valid: true,
+    errors: [],
+    event: Value.Cast(TelemetryEventSchema, input) as TelemetryEvent,
+  };
+}