AWESOME
JEV

questions: {
  direction: choice,
}

questions: {
  requested: boolean,
  issued: boolean,
  route: choice,
  // +1
}

questions: {
  intent: choice,
  is_urgent: boolean,
  frustration: score,
}

questions: {
  department: choice,
  return_reason: choice,
  requested_resolution: choice,
  // +2
}

questions: {
  correctness: boolean,
  security: boolean,
  reliability: boolean,
  // +2
}

questions: {
  action: choice,
  done: boolean,
  risk: boolean,
}

questions: {
  refund: boolean,
  spam: boolean,
}

questions: {
  next_action: boolean,
  danger: score,
}

questions: {
  window: choice,
  source_reddit: boolean,
  plain: boolean,
}

questions: {
  positive: boolean,
}

questions: {
  billing: boolean,
}

questions: {
  intent: boolean,
  target: boolean,
  site: boolean,
  // +5
}

questions: {
  severity: score,
  needs_tool: boolean,
}

questions: {
  destructive: boolean,
  exfiltration: boolean,
  beyond_scope: boolean,
  // +1
}

questions: {
  urgency: score,
}

questions: {
  queue: choice,
  escalate: boolean,
  urgency: score,
  // +1
}

questions: {
  risk: score,
}

questions: {
  stale: choice,
}

questions: {
  intent: choice,
  needs_reasoning: score,
}

questions: {
  relevant: boolean,
}

questions: {
  urgent: boolean,
}

questions: {
  ok: boolean,
}

questions: {
  sentiment_spectrum: score,
  catalyst_impact: score,
}

questions: {
  refund: boolean,
}

questions: {
  department: choice,
  urgent: boolean,
  frustration: score,
}

questions: {
  intent: choice,
  reuse_cache: boolean,
  needs_subagent: boolean,
  // +2
}

questions: {
  refund: boolean,
  team: choice,
}

questions: {
  next_reference: choice,
}

questions: {
  problem: score,
  customer: score,
  demand: score,
  // +5
}

questions: {
  ok: boolean,
}

questions: {
  r0_missing: boolean,
  r0_instruction: boolean,
}

questions: {
  is_billing: boolean,
  category: choice,
}

questions: {
  stuck: boolean,
  destructive: boolean,
}

questions: {
  injection: boolean,
  hidden: boolean,
  exfiltration: boolean,
  // +3
}

questions: {
  intent: boolean,
  target: boolean,
  site: boolean,
  // +5
}

questions: {
  questions: boolean,
}

questions: {
  binary: boolean,
  rating: score,
}

questions: {
  conflict: boolean,
}

questions: {
  s0: boolean,
  s1: boolean,
}

questions: {
  color: choice,
}

questions: {
  does_pass: boolean,
}

questions: {
  value: choice,
  surprising: boolean,
  funny: boolean,
  // +4
}

questions: {
  movement: choice,
  start_jump: boolean,
  ceiling_hop: boolean,
  // +1
}

questions: {
  action: choice,
  in_danger: boolean,
  threat: score,
}

questions: {
  amount_disclosed: boolean,
}

questions: {
  directed: boolean,
  kind: choice,
}

questions: {
  is_urgent: boolean,
  department: choice,
  frustration: score,
}

questions: {
  team: choice,
  human_requested: boolean,
  refund_requested: boolean,
  // +3
}

questions: {
  skill: choice,
}

questions: {
  route: choice,
}

questions: {
  noul: boolean,
}

questions: {
  lane_action: choice,
  speed_action: choice,
  hazard: score,
  // +1
}

questions: {
  route: choice,
  urgent: boolean,
  severity: score,
}

questions: {
  claims_done: boolean,
  claims_verified: boolean,
  verification_applies: boolean,
  // +1
}

questions: {
  route: choice,
  toolFree: boolean,
}

questions: {
  intent: boolean,
}

questions: {
  intent: choice,
  rage_bait: boolean,
  synthetic: boolean,
  // +1
}

questions: {
  actionable: boolean,
  priority: choice,
  value: score,
}

questions: {
  is_bug: boolean,
  team: choice,
  urgency: score,
}

questions: {
  topic: choice,
}

questions: {
  category: choice,
  urgency: score,
  isPersonal: boolean,
}

questions: {
  unambiguous_match: boolean,
}

questions: {
  call_t1: boolean,
}

questions: {
  intent: choice,
  isUrgent: boolean,
}

questions: {
  a: boolean,
  b: boolean,
}

questions: {
  billing: boolean,
  urgency: score,
}

questions: {
  context_needed: choice,
}

questions: {
  beauty: boolean,
  cat: choice,
}

questions: {
  irreversible: boolean,
  goal_done: boolean,
}

questions: {
  partial: boolean,
  score: boolean,
}

questions: {
  urgent: boolean,
}

questions: {
  category: choice,
  tech: boolean,
  ai_written: boolean,
}

questions: {
  q1: boolean,
}

questions: {
  is_spam: boolean,
}

questions: {
  instructions: boolean,
}

questions: {
  odd: boolean,
}

questions: {
  throttle: choice,
  yaw: choice,
  pitch: choice,
  // +3
}

questions: {
  unsolicited_promotion: boolean,
  profile_bait: boolean,
  scam_or_phishing: boolean,
  // +5
}

questions: {
  operation: choice,
}

questions: {
  about: boolean,
  keep: choice,
}

questions: {
  is_spam: boolean,
  folder: choice,
  suspicion: score,
}

questions: {
  connected: boolean,
}

questions: {
  operation: choice,
  click_target: choice,
  goal_reached: boolean,
  // +1
}

questions: {
  department: boolean,
  frustration: boolean,
}

questions: {
  delivery: boolean,
  department: choice,
  urgency: score,
}

questions: {
  done: boolean,
}

questions: {
  is_impossible: boolean,
}

questions: {
  is_urgent: boolean,
  frustration: score,
}

questions: {
  is_urgent: boolean,
}

questions: {
  routine: boolean,
}

questions: {
  automated: boolean,
}

questions: {
  done: boolean,
  blocked: boolean,
}

questions: {
  intent: boolean,
  target: boolean,
  site: boolean,
  // +5
}

questions: {
  department: choice,
  frustration: score,
  is_urgent: boolean,
}

questions: {
  instructions: boolean,
}

questions: {
  urgent: boolean,
}

questions: {
  what: choice,
}

questions: {
  t: boolean,
}

questions: {
  model: choice,
  effort: choice,
  is_followup: boolean,
}

questions: {
  needs_skill: boolean,
}

questions: {
  confidentiality: choice,
}

questions: {
  comparison: choice,
}

questions: {
  blocking: boolean,
}

questions: {
  department: choice,
}

questions: {
  content_type: choice,
}

questions: {
  is_command: boolean,
  complete: boolean,
}

questions: {
  department: choice,
  frustration: score,
  is_urgent: boolean,
}

questions: {
  requires_uncertainty_notice: boolean,
  response_depth: score,
}

questions: {
  verdict: choice,
  should: boolean,
  doom: score,
  // +1
}

questions: {
  difficulty: score,
  needs_reasoning: boolean,
  stakes: score,
  // +5
}

questions: {
  category: choice,
  reached_assertion: boolean,
  missing_context: boolean,
}

questions: {
  is_toxic: boolean,
  is_profane: boolean,
  severity: score,
  // +2
}

questions: {
  complexity: score,
  needsPlanning: boolean,
}

questions: {
  ping: boolean,
}

questions: {
  task_completion: score,
  instruction_following: boolean,
  grounded_in_evidence: boolean,
  // +5
}

questions: {
  is_billing: boolean,
}

questions: {
  complete: boolean,
}

questions: {
  wants_refund: boolean,
  intent: choice,
}

questions: {
  operation: choice,
}

questions: {
  destructive: boolean,
  exfiltration: boolean,
  privilege: boolean,
  // +4
}

questions: {
  enabled: boolean,
  color: choice,
  progress: score,
}

questions: {
  category: choice,
  bug_severity: score,
  has_repro_steps: boolean,
  // +2
}

questions: {
  action: choice,
}

questions: {
  content_type: choice,
  already_known: boolean,
  insight_density: score,
}

questions: {
  completion: choice,
}

questions: {
  relevant: boolean,
  category: choice,
}

questions: {
  hallucination_sensitive: boolean,
}

questions: {
  ping: boolean,
}

questions: {
  criteria: boolean,
}

questions: {
  claims_success: boolean,
}

questions: {
  label: choice,
}

questions: {
  irreversible: boolean,
}

questions: {
  composition: choice,
  legibility: boolean,
}

questions: {
  is_urgent: boolean,
  severity: score,
}

questions: {
  action: choice,
  asset: choice,
  condition_operator: choice,
}

questions: {
  tier: choice,
  is_greeting: boolean,
}

questions: {
  line: choice,
  pace: choice,
  overtake: boolean,
  // +1
}

questions: {
  severity: score,
  area: choice,
}

questions: {
  destructive: boolean,
  secrets: boolean,
}

questions: {
  is_exquisite_and_dynamic: boolean,
  animation_verdict: choice,
  primary_deficiency: choice,
}

questions: {
  person_name: boolean,
  email_or_phone: boolean,
  postal_address: boolean,
  // +5
}

questions: {
  is_regulation: boolean,
  mentions_deadline: boolean,
  mentions_fines: boolean,
  // +5
}

questions: {
  topic: choice,
  requests_credentials: boolean,
  sender_identity_mismatch: boolean,
  // +4
}

questions: {
  needs_rewrite: boolean,
  visual: choice,
}

questions: {
  states_application_instruction: boolean,
}

questions: {
  a: boolean,
  b: boolean,
}

questions: {
  is_urgent: boolean,
  department: choice,
}

questions: {
  file_removal: score,
  credential_theft: score,
  data_exfiltration: score,
  // +5
}

questions: {
  kind: choice,
  relationship: choice,
  review_priority: score,
}

questions: {
  uses: boolean,
}

questions: {
  ok: boolean,
}

questions: {
  alive: boolean,
}

questions: {
  urgent: boolean,
  severity: score,
}

questions: {
  outOfScope: boolean,
  contradictsPrevious: boolean,
  shouldFlag: boolean,
}

questions: {
  scope_alignment: score,
  touches_state: boolean,
  breaks_contracts: boolean,
  // +2
}

questions: {
  failure_domain: choice,
  customer_impact: score,
  systemic_outage: boolean,
}

questions: {
  succeeded: boolean,
}

questions: {
  action: choice,
  close_intent: boolean,
  intentional_control: boolean,
  // +1
}

questions: {
  edit: choice,
  contract: choice,
  caller: choice,
  // +2
}

questions: {
  next_move: choice,
}

questions: {
  same_intent: boolean,
}

questions: {
  instructions: boolean,
}

questions: {
  needs_vision: boolean,
  needs_tools: boolean,
}

questions: {
  eligible: boolean,
}

questions: {
  intent: choice,
  urgent: boolean,
  frustration: score,
}

questions: {
  disposition: choice,
  risk: score,
  data_exfil_risk: boolean,
  // +2
}

questions: {
  should_review: boolean,
  risk: choice,
  route: choice,
  // +1
}

questions: {
  fraud: choice,
}

questions: {
  is_project: boolean,
  substance: score,
}

questions: {
  impact: score,
}

questions: {
  q: boolean,
}

questions: {
  action: choice,
}

questions: {
  intent: choice,
  connection: choice,
  supported: boolean,
}

questions: {
  category: choice,
  bug_severity: score,
  wants_refund: boolean,
  // +1
}

questions: {
  is_urgent: boolean,
  needs_human: boolean,
  is_financial: boolean,
}

questions: {
  condition: choice,
}

questions: {
  q: boolean,
}

questions: {
  answered: boolean,
}

questions: {
  risky: boolean,
  submit_after_typing: boolean,
}

questions: {
  relevance: choice,
}

questions: {
  billing: boolean,
  urgent: boolean,
  team: choice,
  // +1
}

questions: {
  refund: boolean,
}