Enhanced Skill Matrix with Templates and Interaction Types

Core Architecture

4×3 Matrix Structure

Interaction Type Matrix

PERCEPTION Domain

STRATEGY Domain

RISK Domain

EXECUTION Domain

Available Interaction Types

Parameter Pools & Context System

Asset Pools (Rotating)

ASSET_POOLS = {
  "equities": ["AAPL", "NVDA", "MSFT", "AMZN", "GOOGL", 
               "META", "TSLA", "JPM", "BAC", "XOM"],
  "indices": ["SPY", "QQQ", "IWM", "DIA", "VTI", 
              "EEM", "XLF", "XLE"],
  "forex": ["EURUSD", "GBPUSD", "USDJPY", "AUDUSD"],
  "crypto": ["BTCUSD", "ETHUSD", "SOLUSD", "BNBUSD"],
  "commodities": ["GC", "CL", "NG", "SI", "ZC", "ZS"]
}

Market Context Parameters

Template Examples

PERCEPTION–Apply: Chart Drawing Selection

function generate_A1_chart_selection(complexity="basic") {
  const patterns = {
    "basic": {
      "pattern": "support_touch",
      "instruction": "Click all points where price touches support",
      "chart_elements": ["support_line", "price_candles"],
      "correct_zones": [(x1, y1), (x2, y2)]
    },
    "advanced": {
      "pattern": "divergence_signals", 
      "instruction": "Mark areas showing price/indicator divergence",
      "chart_elements": ["price_chart", "RSI_panel", "trend_lines"],
      "correct_zones": [(x1, y1, x2, y2), (x3, y3, x4, y4)]
    }
  };
  
  return {
    "interaction_type": "chart_drawing_selection",
    "prompt": `On the chart below, ${params.instruction}`,
    "chart_config": {
      "interactive": true,
      "selection_mode": "multiple_points"
    },
    "correct_selections": params.correct_zones,
    "tolerance_pixels": 10
  };
}

STRATEGY–Analyze: Sequencing

function generate_S2_sequencing() {
  const scenario = {
    "context": "Trading AAPL before earnings with high IV",
    "considerations": [
      "Assess implied vs historical volatility spread",
      "Check expected move from options pricing", 
      "Review past earnings reactions",
      "Determine position sizing based on risk",
      "Select strategy (straddle, condor, directional)",
      "Set exit plan for post-announcement"
    ],
    "correct_order": [1, 2, 3, 4, 5, 6]
  };
  
  return {
    "interaction_type": "sequencing",
    "prompt": `Context: ${scenario.context}. Order these steps:`,
    "items": shuffled_items,
    "correct_sequence": ordered_items,
    "scoring_method": "kendall_tau"
  };
}

RISK–Apply: Computed Position Sizing

function generate_R1_computed_choice() {
  // Calculate correct position size
  const risk_amount = account * (risk_pct / 100);
  const stop_distance = Math.abs(entry - stop);
  const correct_shares = Math.floor(risk_amount / stop_distance);
  
  // Generate plausible distractors
  const distractors = [
    Math.floor(correct_shares * 0.5),  // Too conservative
    Math.floor(correct_shares * 2),    // Too aggressive
    Math.floor(correct_shares * 1.3)   // Slightly over
  ];
  
  return {
    "interaction_type": "single_choice",
    "prompt": `Account: $${account} | Risk: ${risk_pct}%
              Entry: $${entry} | Stop: $${stop}
              Select correct position size:`,
    "options": [`${shares} shares` for shares in options],
    "correct_answer": `${correct_shares} shares`,
    "show_calculation": true
  };
}

Gap Mitigation Strategies

Numeric Input Limitation

Multi-Chart Analysis

Validation System

Interaction Validator

VALID_INTERACTIONS = {
  "single_choice": {
    "required_fields": ["prompt", "options", "correct_answer"],
    "options_range": [3, 5],
    "supports_justification": true
  },
  "multi_select": {
    "required_fields": ["prompt", "options", "correct_answers"], 
    "options_range": [5, 8],
    "min_correct": 2,
    "supports_partial_credit": true
  },
  "chart_drawing_selection": {
    "required_fields": ["prompt", "chart_config", "correct_selections"],
    "requires_visual": true,
    "supports_tolerance": true
  }
}

Cell-Interaction Matching

Complexity Measurement

Objective Complexity Metrics

Complexity Scoring

function calculate_objective_complexity(question_data) {
  const metrics = {
    numerical_values: count_numbers(question_data.prompt),
    calculation_steps: count_operations(question_data.calculation),
    conditional_branches: count_conditionals(question_data.logic),
    interaction_complexity: score_interaction(question_data.interaction_type)
  };
  
  // Score each metric (total 100 points)
  let score = 0;
  score += Math.min(16.67, metrics.numerical_values * 3.33);
  score += Math.min(16.67, metrics.calculation_steps * 5.56);
  score += Math.min(16.67, metrics.conditional_branches * 8.33);
  score += Math.min(16.67, metrics.interaction_complexity * 5.56);
  
  const level = score <= 33 ? "basic" : 
               score <= 66 ? "intermediate" : "advanced";
  
  return {score, level, metrics};
}

Coverage Tracking

Usage Distribution

Implementation Example

function generate_question_with_interaction(cell_id, complexity="intermediate") {
  // Get recommended interaction type for balance
  const interaction_type = coverage_tracker.recommend_next_interaction(cell_id);
  
  // Generate using appropriate template
  const generator = generator_map[`${cell_id}_${interaction_type}`];
  const question_data = generator(complexity);
  
  // Validate structure and cell-interaction match
  const [is_valid, message] = validator.validate_question(question_data);
  
  // Calculate objective complexity
  const {score, level, metrics} = calculate_objective_complexity(question_data);
  
  // Mark coverage for spacing
  coverage_tracker.mark_used(cell_id, asset, timeframe, context, interaction_type);
  
  return {
    ...question_data,
    complexity_score: score,
    complexity_level: level,
    complexity_metrics: metrics
  };
}