principles-disciple 1.7.6 → 1.7.8

package/dist/core/config.js

@@ -46,46 +46,6 @@ export const DEFAULT_SETTINGS = {
         initial_delay_ms: 5000,
         task_timeout_ms: 60 * 60 * 1000 // 1 hour, matching evolution-worker.ts default
     },
-    trust: {
-        stages: {
-            stage_1_observer: 30,
-            stage_2_editor: 60,
-            stage_3_developer: 80,
-        },
-        cold_start: {
-            // 🚀 The most important change: Start at 85 (Developer level)
-            // This allows the AI to perform medium-sized edits right out of the box
-            // without needing to beg for a PLAN.md on every single change.
-            initial_trust: 85,
-            grace_failures: 5, // Give the AI 5 free mistakes before deducting any trust points
-            cold_start_period_ms: 24 * 60 * 60 * 1000,
-        },
-        penalties: {
-            // 🛡️ Forgiving penalties for exploration
-            tool_failure_base: -2, // Was -8. A simple 'ls' typo shouldn't cost 8 points.
-            risky_failure_base: -10, // Was -15.
-            gate_bypass_attempt: -5,
-            failure_streak_multiplier: -2,
-            max_penalty: -20,
-        },
-        rewards: {
-            success_base: 2, // Was 1. Faster recovery
-            subagent_success: 5, // Was 3.
-            tool_success_reward: 0.2, // 👈 Minor reward for tool success, but resets streak!
-            streak_bonus_threshold: 3, // Was 5. Easier to get bonuses
-            streak_bonus: 5,
-            recovery_boost: 5, // Was 3. If trust drops low, it's easier to climb back up
-            max_reward: 15,
-        },
-        limits: {
-            stage_2_max_lines: 50, // Was 10. 10 lines is barely enough to fix a function signature.
-            stage_3_max_lines: 300, // Was 100. Allow substantial feature implementation.
-            stage_2_max_percentage: 10, // Percentage-based threshold for Stage 2
-            stage_3_max_percentage: 15, // Percentage-based threshold for Stage 3
-            min_lines_fallback: 20, // Minimum threshold even for small files
-        },
-        history_limit: 50
-    },
     deep_reflection: {
         enabled: true,
         mode: 'auto',
@@ -122,11 +82,12 @@ export const DEFAULT_SETTINGS = {
             large_change_block: 50, // 大规模修改警告阈值
         },
         large_change_lines: 50,
-        trust_stage_multipliers: {
-            '1': 0.5, // Observer: 更严格，阈值减半
-            '2': 0.75, // Editor: 阈值降低 25%
-            '3': 1.0, // Developer: 标准阈值
-            '4': 1.5, // Architect: 更宽松，阈值提高 50%
+        ep_tier_multipliers: {
+            '1': 0.5, // Seed: 更严格，阈值减半
+            '2': 0.75, // Sprout: 阈值降低 25%
+            '3': 1.0, // Sapling: 标准阈值
+            '4': 1.5, // Tree: 更宽松
+            '5': 2.0, // Forest: 最宽松
         },
         bash_safe_patterns: [
             '^(ls|dir|pwd|which|where|echo|env|cat|type|head|tail|less|more)\\b',
@@ -216,25 +177,9 @@ export class PainConfig {
      * Basic validation for critical settings
      */
     validate(settings) {
-        // Ensure trust scores stay within 0-100 logical range
-        const s = settings.trust.stages;
-        if (s.stage_1_observer < 0 || s.stage_1_observer > 100)
-            s.stage_1_observer = 30;
-        if (s.stage_2_editor < 0 || s.stage_2_editor > 100)
-            s.stage_2_editor = 60;
-        if (s.stage_3_developer < 0 || s.stage_3_developer > 100)
-            s.stage_3_developer = 80;
         // Ensure intervals are positive
         if (settings.intervals.worker_poll_ms < 1000)
             settings.intervals.worker_poll_ms = 15 * 60 * 1000;
-        // Ensure percentage limits are in valid range [0, 100]
-        const l = settings.trust.limits;
-        if (l.stage_2_max_percentage < 0 || l.stage_2_max_percentage > 100)
-            l.stage_2_max_percentage = 10;
-        if (l.stage_3_max_percentage < 0 || l.stage_3_max_percentage > 100)
-            l.stage_3_max_percentage = 15;
-        if (l.min_lines_fallback < 1)
-            l.min_lines_fallback = 20;
     }
     /**
      * Gets a value using dot notation (e.g. 'thresholds.pain_trigger')

package/dist/core/event-log.d.ts

@@ -1,4 +1,4 @@
-import type { EventLogEntry, DailyStats, EmpathyEventStats, ToolCallEventData, PainSignalEventData, RuleMatchEventData, RulePromotionEventData, HookExecutionEventData, GateBlockEventData, GateBypassEventData, PlanApprovalEventData, EvolutionTaskEventData, DeepReflectionEventData, TrustChangeEventData, EmpathyRollbackEventData } from '../types/event-types.js';
+import type { EventLogEntry, DailyStats, EmpathyEventStats, ToolCallEventData, PainSignalEventData, RuleMatchEventData, RulePromotionEventData, HookExecutionEventData, GateBlockEventData, GateBypassEventData, PlanApprovalEventData, EvolutionTaskEventData, DeepReflectionEventData, EmpathyRollbackEventData } from '../types/event-types.js';
 import type { PluginLogger } from '../openclaw-sdk.js';
 /**
  * EventLog - Structured event logging with daily statistics aggregation.
@@ -23,7 +23,6 @@ export declare class EventLog {
     recordPlanApproval(sessionId: string | undefined, data: PlanApprovalEventData): void;
     recordEvolutionTask(data: EvolutionTaskEventData): void;
     recordDeepReflection(sessionId: string | undefined, data: DeepReflectionEventData): void;
-    recordTrustChange(sessionId: string | undefined, data: TrustChangeEventData): void;
     recordEmpathyRollback(sessionId: string | undefined, data: EmpathyRollbackEventData): void;
     recordError(sessionId: string | undefined, message: string, context?: Record<string, unknown>): void;
     recordWarn(sessionId: string | undefined, message: string, context?: Record<string, unknown>): void;

package/dist/core/event-log.js

@@ -57,9 +57,6 @@ export class EventLog {
         const category = data.passed ? 'passed' : data.timeout ? 'failure' : 'completed';
         this.record('deep_reflection', category, sessionId, data);
     }
-    recordTrustChange(sessionId, data) {
-        this.record('trust_change', 'changed', sessionId, data);
-    }
     recordEmpathyRollback(sessionId, data) {
         this.record('empathy_rollback', 'rolled_back', sessionId, data);
     }

package/dist/core/evolution-engine.js

@@ -14,7 +14,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { resolvePdPath } from './paths.js';
 import { withLock } from '../utils/file-lock.js';
-import { CONSTRUCTIVE_TOOLS, CONTENT_LIMITED_TOOLS, EXPLORATORY_TOOLS, HIGH_RISK_TOOLS, } from '../constants/tools.js';
+import { CONSTRUCTIVE_TOOLS, EXPLORATORY_TOOLS, HIGH_RISK_TOOLS, } from '../constants/tools.js';
 import { EvolutionTier, DEFAULT_EVOLUTION_CONFIG, TIER_DEFINITIONS, TASK_DIFFICULTY_CONFIG, getTierDefinition, getTierByPoints, } from './evolution-types.js';
 // ===== 主引擎 =====
 export class EvolutionEngine {
@@ -137,26 +137,6 @@ export class EvolutionEngine {
     beforeToolCall(context) {
         const tierDef = this.getTierDefinition();
         const perms = tierDef.permissions;
-        // 行数检查（仅针对写操作工具）
-        if (CONTENT_LIMITED_TOOLS.has(context.toolName)) {
-            if (context.content) {
-                const lineCount = context.content.split('\n').length;
-                if (lineCount > perms.maxLinesPerWrite) {
-                    return {
-                        allowed: false,
-                        reason: `Tier ${this.scorecard.currentTier} (${tierDef.name}) 限制: 最多 ${perms.maxLinesPerWrite} 行，当前 ${lineCount} 行`,
-                        currentTier: this.scorecard.currentTier,
-                    };
-                }
-            }
-            if (context.lineCount && context.lineCount > perms.maxLinesPerWrite) {
-                return {
-                    allowed: false,
-                    reason: `Tier ${this.scorecard.currentTier} (${tierDef.name}) 限制: 最多 ${perms.maxLinesPerWrite} 行`,
-                    currentTier: this.scorecard.currentTier,
-                };
-            }
-        }
         // 风险路径检查
         if (context.isRiskPath && !perms.allowRiskPath) {
             return {

package/dist/core/evolution-reducer.d.ts

@@ -1,4 +1,4 @@
-import type { EvolutionLoopEvent, Principle } from './evolution-types.js';
+import type { EvolutionLoopEvent, Principle, PrincipleDetectorSpec, PrincipleEvaluatorLevel } from './evolution-types.js';
 export interface EvolutionReducer {
     emit(event: EvolutionLoopEvent): void;
     emitSync(event: EvolutionLoopEvent): void;
@@ -21,6 +21,10 @@ export interface EvolutionReducer {
         triggerPattern: string;
         action: string;
         source: string;
+        /** Evaluability level — defaults to 'manual_only' if omitted */
+        evaluability?: PrincipleEvaluatorLevel;
+        /** Detector metadata — absent or malformed = 'manual_only' evaluability */
+        detectorMetadata?: PrincipleDetectorSpec;
     }): string | null;
     getStats(): {
         candidateCount: number;
@@ -65,6 +69,8 @@ export declare class EvolutionReducerImpl implements EvolutionReducer {
         triggerPattern: string;
         action: string;
         source: string;
+        evaluability?: PrincipleEvaluatorLevel;
+        detectorMetadata?: PrincipleDetectorSpec;
     }): string | null;
     getStats(): {
         candidateCount: number;

package/dist/core/evolution-reducer.js

@@ -6,6 +6,7 @@ import { PathResolver } from './path-resolver.js';
 import { SystemLogger } from './system-logger.js';
 import { shouldIgnorePainProtocolText } from './dictionary.js';
 import { TrajectoryRegistry } from './trajectory.js';
+import { isCompleteDetectorMetadata } from './evolution-types.js';
 const PROBATION_SUCCESS_THRESHOLD = 3;
 const CIRCUIT_BREAKER_THRESHOLD = 3;
 const PROBATION_MAX_AGE_DAYS = 30;
@@ -147,15 +148,45 @@ export class EvolutionReducerImpl {
             SystemLogger.log(this.workspaceDir, 'PRINCIPLE_BLACKLISTED', `Principle creation blocked by blacklist for trigger: "${params.triggerPattern.slice(0, 50)}..."`);
             return null;
         }
+        // Evaluability defaults to 'manual_only' — the only way to get auto-trainable
+        // is to explicitly provide valid detectorMetadata.
+        // Enforce: deterministic/weak_heuristic requires complete detectorMetadata to be present.
+        let evaluability = params.evaluability ?? 'manual_only';
+        if (evaluability !== 'manual_only' && !isCompleteDetectorMetadata(params.detectorMetadata)) {
+            SystemLogger.log(this.workspaceDir, 'EVALUABILITY_DOWNGRADED', `Principle for painId "${params.painId}" requested evaluability="${evaluability}" without detectorMetadata — downgrading to "manual_only". Provide valid detectorMetadata to enable auto-training.`);
+            evaluability = 'manual_only';
+        }
         // Check if a principle already exists for this painId
         const existingPrinciple = [...this.principles.values()].find(p => p.source.painId === params.painId);
         if (existingPrinciple) {
-            // Update existing principle instead of creating new one
+            // Update existing principle instead of creating new one.
+            // Apply the same evaluability normalization as new creation:
+            // deterministic/weak_heuristic without detectorMetadata → downgraded to manual_only.
             existingPrinciple.trigger = params.triggerPattern;
             existingPrinciple.action = params.action;
             existingPrinciple.text = `When ${params.triggerPattern}, then ${params.action}.`;
             existingPrinciple.version += 1;
-            SystemLogger.log(this.workspaceDir, 'PRINCIPLE_UPDATED', `Principle ${existingPrinciple.id} updated from diagnostician: "${params.triggerPattern.slice(0, 50)}..."`);
+            if (params.evaluability !== undefined) {
+                // Apply normalization (params.evaluability may be invalid without complete metadata)
+                const normalizedEvaluability = (() => {
+                    if (params.evaluability === 'manual_only' || isCompleteDetectorMetadata(params.detectorMetadata)) {
+                        return params.evaluability;
+                    }
+                    SystemLogger.log(this.workspaceDir, 'EVALUABILITY_DOWNGRADED', `Principle update for painId "${params.painId}" requested evaluability="${params.evaluability}" without detectorMetadata — downgrading to "manual_only".`);
+                    return 'manual_only';
+                })();
+                existingPrinciple.evaluability = normalizedEvaluability;
+            }
+            // Preserve detectorMetadata unless explicitly provided in this call.
+            // Accept only if complete (defense in depth — subagent should already filter).
+            if (isCompleteDetectorMetadata(params.detectorMetadata)) {
+                existingPrinciple.detectorMetadata = structuredClone(params.detectorMetadata);
+            }
+            else if (params.detectorMetadata !== undefined) {
+                // Malformed metadata provided — clear any existing metadata
+                existingPrinciple.detectorMetadata = undefined;
+            }
+            SystemLogger.log(this.workspaceDir, 'PRINCIPLE_UPDATED', `Principle ${existingPrinciple.id} updated from diagnostician: "${params.triggerPattern.slice(0, 50)}..." [evaluability: ${existingPrinciple.evaluability}]`);
             return existingPrinciple.id;
         }
         // Create new principle with generalized content
@@ -178,6 +209,10 @@ export class EvolutionReducerImpl {
             feedbackScore: 0,
             usageCount: 0,
             createdAt: now,
+            evaluability,
+            detectorMetadata: isCompleteDetectorMetadata(params.detectorMetadata)
+                ? structuredClone(params.detectorMetadata)
+                : undefined,
         };
         this.principles.set(principleId, principle);
         this.emitSync({
@@ -185,15 +220,20 @@ export class EvolutionReducerImpl {
             type: 'candidate_created',
             data: {
                 painId: principle.source.painId,
+                painType: params.painType,
                 principleId,
                 trigger: params.triggerPattern,
                 action: params.action,
                 status: 'candidate',
+                evaluability,
+                detectorMetadata: isCompleteDetectorMetadata(params.detectorMetadata)
+                    ? structuredClone(params.detectorMetadata)
+                    : undefined,
             },
         });
         // Auto-promote since it's already generalized
         this.promote(principleId, 'diagnostician_generalized');
-        SystemLogger.log(this.workspaceDir, 'PRINCIPLE_CREATED', `Principle ${principleId} created from diagnostician: "${params.triggerPattern.slice(0, 50)}..."`);
+        SystemLogger.log(this.workspaceDir, 'PRINCIPLE_CREATED', `Principle ${principleId} created from diagnostician: "${params.triggerPattern.slice(0, 50)}..." [evaluability: ${evaluability}]`);
         return principleId;
     }
     getStats() {
@@ -260,6 +300,13 @@ export class EvolutionReducerImpl {
         const existing = this.principles.get(data.principleId);
         if (existing) {
             existing.status = 'candidate';
+            // Apply evaluability from event if present (supports event replay)
+            if (data.evaluability) {
+                existing.evaluability = data.evaluability;
+            }
+            if (data.detectorMetadata) {
+                existing.detectorMetadata = structuredClone(data.detectorMetadata);
+            }
             return;
         }
         const principle = {
@@ -268,7 +315,7 @@ export class EvolutionReducerImpl {
             text: `When ${data.trigger}, then ${data.action}.`,
             source: {
                 painId: data.painId,
-                painType: 'tool_failure',
+                painType: data.painType ?? 'tool_failure',
                 timestamp: ts,
             },
             trigger: data.trigger,
@@ -279,6 +326,11 @@ export class EvolutionReducerImpl {
             feedbackScore: 0,
             usageCount: 0,
             createdAt: ts,
+            // Evaluability defaults to 'manual_only' for replayed events without the field
+            evaluability: data.evaluability ?? 'manual_only',
+            detectorMetadata: data.detectorMetadata
+                ? structuredClone(data.detectorMetadata)
+                : undefined,
         };
         this.principles.set(principle.id, principle);
     }

package/dist/core/evolution-types.d.ts

@@ -8,10 +8,10 @@
  * - 5级成长路径：Seed → Forest
  */
 export declare enum EvolutionTier {
-    Seed = 1,// 萌芽：只读 + 基础文档
-    Sprout = 2,// 新芽：单文件编辑 (<50行)
-    Sapling = 3,// 幼苗：多文件 + 测试 + 子智能体
-    Tree = 4,// 大树：重构 + 风险路径
+    Seed = 1,// 起步：150行 + 3文件 + 子智能体（现代 AI 能力已足够强）
+    Sprout = 2,// 成长：300行 + 5文件
+    Sapling = 3,// 独当：500行 + 10文件 + 风险路径
+    Tree = 4,// 专家：1000行 + 20文件
     Forest = 5
 }
 export interface TierPermissions {
@@ -91,11 +91,6 @@ export interface EvolutionConfig {
         tier5Trivial: number;
         tier5Normal: number;
     };
-    /** 信任分系统双轨运行时的配置 */
-    dualTrack: {
-        enabled: boolean;
-        primarySystem: 'trust' | 'evolution';
-    };
 }
 export declare const DEFAULT_EVOLUTION_CONFIG: EvolutionConfig;
 export interface ArchivedEventStats {
@@ -125,6 +120,45 @@ export interface TierPromotionEvent {
     newPermissions: TierPermissions;
 }
 export type PrincipleStatus = 'candidate' | 'probation' | 'active' | 'deprecated';
+/**
+ * Evaluability classification — determines whether a P_xxx principle can enter
+ * automatic nocturnal targeting.
+ *
+ * - deterministic:    Machine-checkable via deterministic rules/tool detectors
+ * - weak_heuristic:  Checkable via heuristic signals, may have false positives
+ * - manual_only:     No machine-checkable detector — stays in prompts only
+ */
+export type PrincipleEvaluatorLevel = 'deterministic' | 'weak_heuristic' | 'manual_only';
+/**
+ * Shared alias for PrincipleEvaluatorLevel — used by modules that reference
+ * the same evaluability classification without direct coupling to evolution-types.
+ * @deprecated Use PrincipleEvaluatorLevel directly. This alias exists for
+ * backwards compatibility with principle-training-state.ts.
+ */
+export type Evaluability = PrincipleEvaluatorLevel;
+/**
+ * Structured detector metadata for P_xxx principles.
+ * Allows the principle to enter automatic nocturnal targeting.
+ *
+ * If any required field is missing, the principle defaults to 'manual_only'.
+ */
+export interface PrincipleDetectorSpec {
+    /** Topic/scenario tags where this detector applies */
+    applicabilityTags: string[];
+    /** Evidence that the principle was followed */
+    positiveSignals: string[];
+    /** Evidence that the principle was violated */
+    negativeSignals: string[];
+    /** Tool call sequences that indicate the principle is relevant */
+    toolSequenceHints: string[][];
+    /** Confidence in the detector's signal quality */
+    confidence: 'high' | 'medium' | 'low';
+}
+/**
+ * Validates that a detector metadata object has all required fields with non-empty values.
+ * Used as defense-in-depth before accepting detectorMetadata for auto-trainable principles.
+ */
+export declare function isCompleteDetectorMetadata(meta: unknown): meta is PrincipleDetectorSpec;
 export interface Principle {
     id: string;
     version: number;
@@ -148,6 +182,18 @@ export interface Principle {
     createdAt: string;
     activatedAt?: string;
     deprecatedAt?: string;
+    /**
+     * Evaluability classification. Defaults to 'manual_only' if not set.
+     * Principles with 'manual_only' evaluability cannot enter automatic
+     * nocturnal targeting.
+     */
+    evaluability: PrincipleEvaluatorLevel;
+    /**
+     * Structured detector metadata. If present and valid, the principle
+     * may be auto-trainable (deterministic / weak_heuristic).
+     * Absent or malformed = 'manual_only' evaluability.
+     */
+    detectorMetadata?: PrincipleDetectorSpec;
 }
 export type EvolutionLoopEventType = 'pain_detected' | 'candidate_created' | 'principle_promoted' | 'principle_deprecated' | 'principle_rolled_back' | 'circuit_breaker_opened' | 'legacy_import';
 export interface PainDetectedData {
@@ -167,6 +213,12 @@ export interface CandidateCreatedData {
     trigger: string;
     action: string;
     status: 'candidate';
+    /** Pain type that generated this candidate — preserved on replay */
+    painType?: 'tool_failure' | 'subagent_error' | 'user_frustration';
+    /** Optional evaluability — defaults to 'manual_only' if omitted */
+    evaluability?: PrincipleEvaluatorLevel;
+    /** Optional detector metadata — absent = manual_only */
+    detectorMetadata?: PrincipleDetectorSpec;
 }
 export interface PrinciplePromotedData {
     principleId: string;

package/dist/core/evolution-types.js

@@ -14,13 +14,19 @@ export var EvolutionTier;
     EvolutionTier[EvolutionTier["Sprout"] = 2] = "Sprout";
     EvolutionTier[EvolutionTier["Sapling"] = 3] = "Sapling";
     EvolutionTier[EvolutionTier["Tree"] = 4] = "Tree";
-    EvolutionTier[EvolutionTier["Forest"] = 5] = "Forest"; // 森林：完全自主
+    EvolutionTier[EvolutionTier["Forest"] = 5] = "Forest"; // 大师：完全自主
 })(EvolutionTier || (EvolutionTier = {}));
 export const TIER_DEFINITIONS = [
-    { tier: EvolutionTier.Seed, name: 'Seed', requiredPoints: 0, permissions: { maxLinesPerWrite: 20, maxFilesPerTask: 1, allowRiskPath: false, allowSubagentSpawn: false } },
-    { tier: EvolutionTier.Sprout, name: 'Sprout', requiredPoints: 50, permissions: { maxLinesPerWrite: 50, maxFilesPerTask: 2, allowRiskPath: false, allowSubagentSpawn: false } },
-    { tier: EvolutionTier.Sapling, name: 'Sapling', requiredPoints: 200, permissions: { maxLinesPerWrite: 200, maxFilesPerTask: 5, allowRiskPath: false, allowSubagentSpawn: true } },
-    { tier: EvolutionTier.Tree, name: 'Tree', requiredPoints: 500, permissions: { maxLinesPerWrite: 500, maxFilesPerTask: 10, allowRiskPath: true, allowSubagentSpawn: true } },
+    // 2026-03-28: 大幅放宽限制，现代 AI 能力已很强
+    // Seed: 从 20 行提升到 150 行，允许 3 文件，允许子智能体
+    { tier: EvolutionTier.Seed, name: 'Seed', requiredPoints: 0, permissions: { maxLinesPerWrite: 150, maxFilesPerTask: 3, allowRiskPath: false, allowSubagentSpawn: true } },
+    // Sprout: 中等规模开发
+    { tier: EvolutionTier.Sprout, name: 'Sprout', requiredPoints: 50, permissions: { maxLinesPerWrite: 300, maxFilesPerTask: 5, allowRiskPath: false, allowSubagentSpawn: true } },
+    // Sapling: 较大规模开发，可访问风险路径（需 PLAN）
+    { tier: EvolutionTier.Sapling, name: 'Sapling', requiredPoints: 200, permissions: { maxLinesPerWrite: 500, maxFilesPerTask: 10, allowRiskPath: true, allowSubagentSpawn: true } },
+    // Tree: 大型重构
+    { tier: EvolutionTier.Tree, name: 'Tree', requiredPoints: 500, permissions: { maxLinesPerWrite: 1000, maxFilesPerTask: 20, allowRiskPath: true, allowSubagentSpawn: true } },
+    // Forest: 完全自主
     { tier: EvolutionTier.Forest, name: 'Forest', requiredPoints: 1000, permissions: { maxLinesPerWrite: Infinity, maxFilesPerTask: Infinity, allowRiskPath: true, allowSubagentSpawn: true } },
 ];
 export function getTierDefinition(tier) {
@@ -49,8 +55,24 @@ export const DEFAULT_EVOLUTION_CONFIG = {
         tier5Trivial: 0.1,
         tier5Normal: 0.5,
     },
-    dualTrack: {
-        enabled: true,
-        primarySystem: 'evolution',
-    },
 };
+/**
+ * Validates that a detector metadata object has all required fields with non-empty values.
+ * Used as defense-in-depth before accepting detectorMetadata for auto-trainable principles.
+ */
+export function isCompleteDetectorMetadata(meta) {
+    if (!meta || typeof meta !== 'object')
+        return false;
+    const m = meta;
+    const VALID_CONFIDENCE = ['high', 'medium', 'low'];
+    if (typeof m.confidence !== 'string' ||
+        !VALID_CONFIDENCE.includes(m.confidence)) {
+        return false;
+    }
+    const nonEmptyStringArray = (arr) => Array.isArray(arr) &&
+        arr.length > 0 &&
+        arr.every((s) => typeof s === 'string' && s.length > 0);
+    return (nonEmptyStringArray(m.applicabilityTags) &&
+        nonEmptyStringArray(m.positiveSignals) &&
+        nonEmptyStringArray(m.negativeSignals));
+}