# MediaAtlas decision models

> Decision models read a state (a document, a JSON record, images or video frames) plus a schema of typed questions and return a probability for every allowed option of every question in one forward pass. No text generation and no output parsing: each answer comes with a confidence and a band (act / confirm / human). 97 ready use cases in 21 packs, or send your own questions.

The API is JSON over HTTPS with a Bearer key. Pack and use-case descriptions are public (GET /v1/packs, no key). Monthly plans, in euro without VAT: Developer 19 (100 M input tokens) and Team 99 (1,000 M input tokens); output tokens are always 0, A person pays once with Stripe and the page shows the key; each agent can have a key of its own under the plan. The public demo needs no sign-in and is rate-limited per IP.

## Docs

- [API documentation](https://decision.mediaatlas.si/docs): authentication, POST /v1/decisions, images and video, custom questions, errors, billing, client examples
- [Full reference for LLMs](https://decision.mediaatlas.si/llms-full.txt): every pack and use case with its input, questions and options, in one text file
- [Packs as JSON](https://decision.mediaatlas.si/v1/packs): machine-readable list of packs, use cases, questions and options (no key needed)
- [Plans](https://decision.mediaatlas.si/docs#plans): Developer and Team, 402 payment_required, POST /api/checkout for a payment link to hand to a person
- [Agent skill](https://decision.mediaatlas.si/skill): SKILL.md and scripts/decide.py for Claude Code and other agents; download https://decision.mediaatlas.si/decision-skill.zip

## Try it

- [Live demo](https://decision.mediaatlas.si/demo): paste text or drop images, pick use cases, see per-option probabilities

## Packs

- [Core decisions](https://decision.mediaatlas.si/docs#p-core): The nine building blocks: routing, guardrails, tool gating, triage, reranking, evals, labeling, real-time control and confidence gates. Use cases: Model routing, Guardrails, Tool-call gating, Inbox triage, Reranking, LLM evals, Bulk labeling, Real-time control, Confidence gate.
- [Accounts payable](https://decision.mediaatlas.si/docs#p-accounts-payable): For finance teams and bookkeeping bureaus: sort incoming documents, catch duplicate invoices, decide approve / hold / escalate and code costs with VAT treatment. Use cases: Document type, Duplicate invoices, Approve, hold or escalate, Cost coding.
- [Agent safety](https://decision.mediaatlas.si/docs#p-agent-safety): For teams that run AI coding and ops agents: decide whether a tool call, shell command or code change may proceed. Use cases: Tool-call firewall, Shell command risk, Secret in diff, Human handoff.
- [Clinical intake](https://decision.mediaatlas.si/docs#p-clinical-intake): Synthetic patient messages (EN, SL) triaged for urgency, routing, red flags and clinician review. Decision support only, not a medical device: a clinician owns every clinical decision. Use cases: Urgency triage, Role routing, Red-flag labels, Auto-reply gate.
- [Cold-chain monitoring](https://decision.mediaatlas.si/docs#p-cold-chain): For pharmacies, hospitals, labs and food logistics: triage temperature excursions, spot faulty sensors, decide what happens to the stock and who gets woken up. Use cases: Excursion triage, Sensor fault diagnosis, Excursion impact, Alarm escalation.
- [Outreach & content](https://decision.mediaatlas.si/docs#p-content-growth): For sales, marketing and community teams: classify outreach replies, grade posts, flag low-quality AI text and score lead fit. Use cases: Outreach reply, Post grade, AI slop check, Lead fit.
- [Content moderation](https://decision.mediaatlas.si/docs#p-content-moderation): Trust and safety teams decide what stays up: action on posts, policy labels, appeal gate and marketplace listing checks. Use cases: Post action, Policy labels, Appeal gate, Marketplace listing check.
- [Contract review](https://decision.mediaatlas.si/docs#p-contract-review): Customer-side review of supplier contract clauses: label each clause, score its risk against a playbook, find the clause that answers a question and decide accept, negotiate or reject. Use cases: Clause labeling, Clause risk, Clause retrieval, Deviation from standard.
- [Osnovne odločitve (SL)](https://decision.mediaatlas.si/docs#p-core-sl): Slovenska zrcalna različica paketa core: istih devet gradnikov z enakimi primeri in oznakami, za neposredno primerjavo istega modela v angleščini in slovenščini. Use cases: Usmerjanje modelov, Varovalke, Nadzor klicev orodij, Razvrščanje pošte, Prerazvrščanje, Vrednotenje jezikovnih modelov, Množično označevanje, Krmiljenje v realnem času, Prag zaupanja.
- [Data flywheel](https://decision.mediaatlas.si/docs#p-data-flywheel): Curate and judge LLM training data: triage rows, pick DPO preferences, grade answers against sources and label rows for the mix. Use cases: Row triage, DPO preference pairs, Grounded answer judge, Near-duplicate check.
- [Dev & ops triage](https://decision.mediaatlas.si/docs#p-dev-ops): For SRE and platform teams: triage log lines, vet dependencies, classify CI failures and route issues. Use cases: Log triage, Package audit, CI failure cause, Issue routing.
- [Education and tutoring](https://decision.mediaatlas.si/docs#p-education): Tutors and teachers of school-age learners grade answers, spot misconceptions, decide when to give a hint and read the mood of a message. Use cases: Rubric grading, Misconception spotting, Hint gate, Message mood.
- [Games & real time](https://decision.mediaatlas.si/docs#p-games-realtime): For game studios and live-service teams: tiny decisions that must be answered in milliseconds: cheat suspicion, player intent, difficulty and board moves. Use cases: Cheat suspicion, NPC player intent, Difficulty adjustment, Player support triage.
- [Industrial faults](https://decision.mediaatlas.si/docs#p-industrial-faults): For maintenance and plant teams: diagnose machine faults from telemetry, prioritise maintenance, validate sensors and sort alarm floods. Use cases: Fault diagnosis, Maintenance priority, Sensor validity, Alarm flood.
- [Market intelligence](https://decision.mediaatlas.si/docs#p-market-intel): Analysts and trading desks triage crypto, equity and commodity news: catalyst strength, source status, tags and thesis-relevant headlines. Use cases: Catalyst strength, Source status, Asset and direction tagging, Thesis reranking.
- [Public inbox](https://decision.mediaatlas.si/docs#p-public-inbox): Citizen e-mails to a municipality (SL, EN): route to the right department, recognise the request type, set the response deadline class and flag personal data. Use cases: Department routing, Request type, Response deadline, Personal data flags.
- [Research & documents](https://decision.mediaatlas.si/docs#p-research-docs): For analysts, knowledge teams and data teams: fact-check claims against evidence, grade answers with a rubric, tag notes and route questions safely to a data layer. Use cases: Claim check, Answer vs rubric, Note tagging, Query routing.
- [Security operations](https://decision.mediaatlas.si/docs#p-security-ops): For SOC analysts and MSSPs: give alerts a verdict and severity, gate response actions, triage reported e-mails and label log lines. Use cases: Alert verdict, Response action gate, Reported e-mail triage, Log line labeling.
- [Trading compliance](https://decision.mediaatlas.si/docs#p-trading-compliance): Market-conduct surveillance for energy and financial trading desks: inside-information checks, suspicious order patterns, trader chat review and regulatory report routing. Use cases: Inside-information check, Order pattern surveillance, Trader chat surveillance, Regulatory report routing.
- [Images & video](https://decision.mediaatlas.si/docs#p-vision): Decisions from a photo, a screenshot, a chart or a short clip (frames): document intake, photo quality, screenshot triage, chart reading, motion and status lights. Use cases: Document photo intake, Product photo quality gate, Screenshot triage, Chart trend reading, Bar chart leader, Video: motion direction, Video: status light.
- [Working time & absence](https://decision.mediaatlas.si/docs#p-workforce-time): For HR, payroll and shift planners: classify absence messages, check timesheets against EU-style rest, break, night and overtime rules, and route corrections and shift swaps. Use cases: Absence messages, Timesheet rule check, Correction requests, Shift-swap validation.

## Optional

- [MediaAtlas](https://mediaatlas.si): the company behind the service


# API in short

POST https://decision.mediaatlas.si/v1/decisions with `Authorization: Bearer <key>` and a JSON body:

```json
{"pack": "<pack id>", "usecase": "<use case id>", "input": "<text or JSON object>"}
```

- `inputs`: up to 32 inputs in one call instead of `input`; `images`: 1-8 data URLs; `video`: `{"frames": [2-8 data URLs]}`.
- `questions` instead of pack/usecase: custom schema; each question has `type` (choice, score or noul), `instructions` and `criteria`.
- Response: `results[]`, one per input, each with `decision` {option, confidence, band} for the main question and `answers` for every question with `probabilities` for all options. Ranking use cases return `ranking[]` of {id, score}.
- Bands: act > 0.9, confirm 0.5-0.9, human < 0.5 by default (per pack thresholds).
- Errors: `{"error": {"code", "message"}}` with HTTP 400, 401, 402 (`payment_required`: the plan's payment failed), 403, 404, 413 or 429 (`rate_limited`, `too_many_concurrent`, `quota_exceeded`, `agent_budget_exceeded`).
- Plans (EUR, without VAT): Developer 19 a month: 100 M input tokens, 120 requests a minute, 2 at once. Team 99 a month: 1,000 M input tokens, 600 requests a minute, 4 at once. Business and private deployments by agreement.
- Agent keys: `POST /v1/keys` with a plan key and `{name, monthly_tokens?, rpm?, packs?}` makes a key for one agent (shown once) that spends the plan's tokens; `GET /v1/keys` lists them; `DELETE /v1/keys/<prefix>` revokes one. `POST /api/checkout` with `{plan: developer|team}` returns a Stripe Checkout link for a person to pay; `POST /api/portal` with the plan key returns the billing portal link.

# Use cases

## Core decisions (`core`)

The nine building blocks: routing, guardrails, tool gating, triage, reranking, evals, labeling, real-time control and confidence gates.

### Model routing (`core` / `routing`)

Route each prompt to the cheapest model that can answer it well.

Input: Any text: the prompt a user would send to an LLM.

- `tier` (main decision), choice: Which model tier should answer this prompt? Pick the cheapest tier that will answer it correctly.
  - small: Short lookup, greeting, single fact, simple rewrite, translation of one sentence or yes/no classification.
  - medium: Summary, drafting an e-mail or text, routine code snippet, explanation of a known concept, moderate structured extraction.
  - large: Multi-step reasoning, math or proofs, long-document analysis, architecture or complex code, legal, medical or financial judgement with risk.

### Guardrails (`core` / `guardrails`)

Inputs to a support assistant for an online electronics shop. Block injection, abuse and off-policy requests before they reach the LLM.

Input: Any text: a message about to be sent to a shop-support assistant.

- `verdict` (main decision), choice: The input is sent to a customer-support assistant of an online electronics shop. Should it be passed to the assistant or blocked?
  - allow: Legitimate request, including blunt or technical wording that only sounds harsh.
  - block: Prompt injection, attempt to extract secrets or other users' data, harassment, or a request for clearly harmful or illegal help.
- `injection`, noul: Does the input try to override the assistant's instructions or extract its system prompt?
  - true
  - false
- `abuse`, noul: Is the input abusive, hateful or harassing?
  - true
  - false
- `off_policy`, noul: Does the input ask for something outside electronics-shop customer support?
  - true
  - false

### Tool-call gating (`core` / `tool_gating`)

A finance/support agent proposes tool calls. Allow safe ones, ask a human for risky ones, deny the dangerous ones.

Input: JSON {"user_request", "tool_call", "context"?} - the tool call an agent wants to run. Plain text also works (read as a tool call).

- `gate` (main decision), choice: Should this proposed tool call run? Policy: read-only and low-risk in-scope actions run automatically; money movement, external e-mails and irreversible but legitimate actions need human confirmation; destructive, out-of-scope, exfiltrating actions or actions triggered by untrusted content are denied.
  - allow: Safe, read-only or low-risk and within the user's request.
  - ask: Legitimate and in scope, but moves money, contacts outsiders or is hard to undo, so a human should confirm.
  - deny: Destructive, exfiltrating, outside the request, or prompted by untrusted content such as a suspicious e-mail.

### Inbox triage (`core` / `inbox`)

Sort a company inbox into reply now, later or archive.

Input: Any text, best as an e-mail with From: / Subject: lines.

- `action` (main decision), choice: What should the team do with this e-mail?
  - reply_now: A customer, partner or colleague needs an answer today: outage, blocked work, deadline today, security or money at risk.
  - later: Needs a reply or action, but it can wait days.
  - archive: No action needed: newsletter, marketing, notification, spam or phishing to be reported and filed.
- `urgency`, score: How urgent is it?
  - level 0: Not urgent
  - level 1: This week
  - level 2: Today
  - level 3: Within the hour

### Reranking (`core` / `reranking`)

Score ten help-centre passages against three customer queries and reorder them by relevance.

Input: A search query as text (or JSON {"query"}). It is scored against the 10 help-centre passages in packs/<pack>/5-reranking.json.

- `relevant`, noul: Does this passage contain the information needed to answer the query?
  - true
  - false

### LLM evals (`core` / `evals`)

Judge assistant answers against the source passage on a 1-5 scale.

Input: JSON {"context", "question", "answer"} - the answer is graded 1-5 against the context. Plain text is skipped. Required JSON fields: context, question, answer.

- `quality` (main decision), score: Grade the ANSWER to the QUESTION using only the CONTEXT as ground truth.
  - level 0: 1 - wrong or contradicts the context
  - level 1: 2 - mostly wrong or invents facts
  - level 2: 3 - partly correct, important detail missing or wrong
  - level 3: 4 - correct, minor omission
  - level 4: 5 - fully correct and complete
- `hallucination`, noul: Does the answer state facts that are not supported by the context?
  - true
  - false

### Bulk labeling (`core` / `bulk_labeling`)

Label product reviews (several languages) with sentiment, topic and language in one pass per row.

Input: Any text, best a product review in EN, SL, DE or HR.

- `sentiment`, choice: Overall sentiment of the review.
  - positive: Mostly satisfied.
  - negative: Mostly dissatisfied.
  - mixed: Clear praise and clear complaint together.
- `topic`, choice: Main topic of the review.
  - product_quality: How the product works or is built.
  - delivery: Shipping, courier, packaging, delivery time.
  - price: Price, value for money, discounts.
  - support: Customer service, returns, warranty handling.
- `language`, choice: Language of the review.
  - en: English
  - sl: Slovenian
  - de: German
  - hr: Croatian

### Real-time control (`core` / `realtime`)

Vaccine fridge controller: one decision per sensor tick, latency measured against a 300 ms budget.

Input: JSON sensor tick {"temp_c", "trend_c_per_min", "door", "door_open_min"}, or press "Start simulated stream". Plain text is skipped. Required JSON fields: temp_c.

- `action` (main decision), choice: Vaccine fridge, legal limits 2.0-8.0 C, setpoint 5.0 C. Pick the control action for this tick.
  - hold: Temperature inside 3.5-6.5 C and not trending out; keep current settings.
  - boost_cooling: Temperature above 6.5 C or rising fast toward 8 C while still within limits.
  - reduce_cooling: Temperature below 3.5 C or falling fast toward 2 C while still within limits.
  - alarm: Temperature outside 2.0-8.0 C, sensor fault, or door open more than 5 minutes.

### Confidence gate (`core` / `confidence_gate`)

Support tickets, some clear and some ambiguous. Act when confident, confirm in the middle, hand to a human when unsure.

Input: Any text: a customer support ticket. The intent's confidence picks act / confirm / human.

- `intent` (main decision), choice: What does the customer want?
  - refund: Money back for an order.
  - exchange: Swap the item for another size, colour or unit.
  - repair: Fix a faulty product under warranty.
  - order_status: Where is my order, delivery date.
  - cancel: Cancel an order that has not shipped.

## Accounts payable (`accounts-payable`)

For finance teams and bookkeeping bureaus: sort incoming documents, catch duplicate invoices, decide approve / hold / escalate and code costs with VAT treatment.

### Document type (`accounts-payable` / `document_type`)

Sort the AP inbox: invoice, credit note, payment reminder, quote, receipt or not a payable document, in EN, SL, DE and HR.

Input: OCR text of the first page of an incoming document (or the e-mail body), any of EN, SL, DE, HR.

- `doc_type` (main decision), choice: What kind of document is this, for accounts payable? Judge by what the document asks the recipient to do, not by single keywords.
  - invoice: A supplier bills goods or services already delivered and asks for payment: invoice number, date, amount due and usually a due date or payment terms. Also an invoice that says it will be paid by direct debit.
  - credit_note: Reduces or cancels an earlier invoice (credit note, Gutschrift, dobropis, odobrenje, storno): refers to an original invoice, amount is negative or credited.
  - reminder: Asks to pay an invoice that is already overdue (payment reminder, dunning letter, opomin, Mahnung, opomena), even if a copy of the original invoice is attached.
  - quote: An offer or pro-forma before the supply: quote, offer, estimate, Angebot, ponudba, ponuda, predračun / pro-forma invoice asking for advance payment. Not booked as a liability.
  - receipt: Proof that the payment was already made at the point of sale, nothing left to pay: till receipt, card slip, fiscal receipt, payment confirmation.
  - not_financial: Asks for no payment and records none: delivery note, order confirmation without amount due, contract, price list, newsletter, account statement for information, or general correspondence.
- `language`, choice: Main language of the document.
  - en: English
  - sl: Slovenian
  - de: German
  - hr: Croatian

### Duplicate invoices (`accounts-payable` / `duplicate_check`)

Compare two invoice headers and decide whether they are the same bill received twice, with look-alike recurring and instalment invoices as traps.

Input: JSON {"a": header, "b": header} where each header has supplier, vat_id, invoice_no, date, amount, iban and a short description. Plain text is skipped. Required JSON fields: a, b.

- `verdict` (main decision), choice: Are A and B the same supplier invoice received twice (paying both would pay the same bill twice)?
  - duplicate: Same supplier (same VAT ID) and the same bill: invoice numbers equal after ignoring prefixes, separators, spaces and leading zeros, or differing only by OCR look-alikes (O/0, I/1, S/5, B/8); same total once net vs gross is reconciled; same date allowing for DD/MM vs MM/DD formats. A copy, re-send, PDF plus e-invoice, or a changed IBAN does not make it a different bill.
  - distinct: Two different bills: different supplier VAT ID, or a genuinely different invoice number (other sequence value or other year), or a different service period, instalment, delivery or amount, or one of them is a credit note. Same supplier and same amount alone do not make a duplicate.

### Approve, hold or escalate (`accounts-payable` / `approval_gate`)

Three-way match plus fraud checks: approve clean invoices, hold mismatches for the buyer, escalate bank-detail changes and other control risks.

Input: JSON invoice check {"supplier", "supplier_since", "invoice_no", "amount", "po", "goods_receipt", "tolerance", "bank_account", "approver_limit", "notes"}. Plain text is skipped. Required JSON fields: supplier, amount, bank_account.

- `action` (main decision), choice: Decide the next step for this supplier invoice. Check escalate conditions first, then hold, then approve. Tolerance applies to the difference between invoice and PO (or contract) amount.
  - approve: Known supplier, invoice matches a PO (or a standing contract for recurring costs such as rent or utilities) within tolerance, goods or service receipt covers what is invoiced, bank account matches master data, mandatory data present, amount within the approver limit.
  - hold: A process mismatch the buyer can fix, no fraud signal: no PO or contract, goods receipt missing or smaller than invoiced, amount above PO beyond tolerance, or missing mandatory invoice data (VAT ID, date, number). Park the invoice and ask the buyer.
  - escalate: A control or fraud risk for the finance controller: bank account differs from master data or a change of bank details is requested by e-mail, phone or letter; sender domain or supplier name is a look-alike; new supplier without completed onboarding pressing for fast payment; pressure to bypass approval; or amount above the approver limit.

### Cost coding (`accounts-payable` / `cost_coding`)

Code each invoice line in one pass: cost category, VAT treatment and cost centre.

Input: One invoice line or short invoice summary: supplier (with country), what was bought, VAT note. The buyer is a VAT-registered company in Slovenia.

- `category`, choice: Cost category of the line.
  - software_saas: Software licences, subscriptions, cloud services and hosting.
  - it_hardware: Computers, servers, network gear, phones and other IT equipment.
  - office_supplies: Paper, toner, stationery, small office consumables.
  - travel: Accommodation, tickets, per diems, taxis, parking on business trips.
  - professional_services: External expert services: audit, legal, tax, consulting, recruiting, payroll bureau, translation.
  - marketing: Advertising, campaigns, trade-fair stands, printed promo material, sponsorship.
  - facilities: Rent, utilities (electricity, water, heating), cleaning, building and machine maintenance.
  - vehicle: Fuel, vehicle leasing, servicing, tyres, tolls for company vehicles.
  - insurance_finance: Insurance premiums, bank fees, interest, payment-provider charges.
  - training: Courses, certifications, seminars and workshops for staff.
- `vat`, choice: VAT treatment for the Slovenian buyer.
  - domestic_standard: Slovenian supplier charging the standard rate (22 %), including rent where the landlord opted to charge VAT.
  - domestic_reduced: Slovenian supplier charging a reduced rate (9.5 % e.g. accommodation, food; 5 % e.g. books).
  - reverse_charge: Supplier in another country (EU or non-EU) invoices without VAT and the buyer self-assesses (reverse charge, Steuerschuldnerschaft des Leistungsempfängers, prijenos porezne obveze).
  - exempt: Supply exempt from VAT: insurance, banking and financial services, certain education and medical services; the invoice shows no VAT with an exemption note.
- `cost_centre`, choice: Charge the department that consumes the cost. HR only for HR's own costs (recruiting, payroll services, company-wide programmes).
  - it: IT department: systems, licences, devices for developers and IT staff.
  - sales_marketing: Sales and marketing: campaigns, customer visits, fairs.
  - admin_finance: Management, finance, accounting, office administration, company-wide insurance and banking.
  - operations: Production, warehouse, logistics, field service, vehicles and plant.
  - hr: Human resources: recruiting, payroll bureau, company-wide training programmes.

## Agent safety (`agent-safety`)

For teams that run AI coding and ops agents: decide whether a tool call, shell command or code change may proceed.

### Tool-call firewall (`agent-safety` / `tool_call_firewall`)

Allow, ask or deny a tool call an AI agent wants to make, based on scope, reversibility and secrets exposure.

Input: JSON object {tool, args, context}: the tool call the agent proposes and where it runs (workspace path, environment, what the user asked). Required JSON fields: tool, args.

- `decision` (main decision), choice: Decide whether this tool call may run. Judge the effect of the call, not how alarming or harmless its name sounds. If it is both unintended-looking and harmful, choose deny.
  - allow: Read-only, or a reversible change that stays inside the workspace and matches the user's request: reading files, grep, listing, running tests or linters, editing tracked files in the repo, creating a local branch, writing to a temp or build directory. Reading a file that merely has a secret-like name locally without sending it anywhere is still allow.
  - ask: Plausibly intended but a human should confirm: writing outside the workspace, network POSTs or API writes to external services, publishing or pushing to a shared remote, installing packages globally, spending money or quota, sending messages to people, or irreversible changes to the user's own data.
  - deny: Never run without policy change: sending secrets, tokens, keys or env dumps to any outside destination; disabling or bypassing safeguards (hooks, CI checks, audit logging, sandbox, permission prompts, branch protection); destructive actions on shared or production resources (dropping prod tables, deleting cloud buckets, force-pushing main, terminating prod instances).

### Shell command risk (`agent-safety` / `shell_command_risk`)

Rate a single shell command an agent wants to run as safe, needs review, or destructive.

Input: One shell command as plain text, as the agent would run it from a project directory.

- `risk` (main decision), choice: Rate the worst plausible effect of running this exact command in a project working directory. Look at the target paths and flags, not just the command name: a scary name on a narrow safe target is still safe, and a common command on a broad target is not.
  - safe: Read-only, or changes only local, easily regenerated state: ls, cat, grep, git status/diff/log, running tests, builds, rm of a named build or cache directory inside the project, dry runs (--dry-run, -n), echo of text.
  - review: Changes state that is recoverable but a human should look at first: installs, git commit/rebase/checkout of branches, chmod or chown on a bounded path, docker stop or build, writes outside the project, network downloads saved to disk, database migrations on a dev database.
  - destructive: Can cause hard-to-reverse loss or compromise: rm -rf on /, ~, *, a parent directory or an unquoted variable; git push --force to a shared branch; git reset --hard with unpushed work; piping a download into a shell (curl | bash); docker system prune -a --volumes; recursive chmod/chown on / or a system path; dd or mkfs on a device; DROP or TRUNCATE on a database.

### Secret in diff (`agent-safety` / `secret_in_diff`)

Scan a code diff an agent wants to commit for real secrets, tell them from test values and hashes, and pick block, warn or pass.

Input: A unified diff snippet or a few added lines of code or config that an agent is about to commit.

- `secret`, choice: Does the added code contain a credential that would grant access if leaked? Judge by the value, the file and the context, not by the variable name alone.
  - present: A high-entropy or well-formed credential that looks real and is used for a real system: cloud keys (AKIA...), live API tokens (sk_live_, ghp_), private key blocks, passwords or connection strings with real-looking passwords in prod or deploy config.
  - test_value: A fake credential clearly meant for tests or docs: documented example keys, values in test fixtures or mocks, 'changeme', 'password123', 'xxxx', '<your-key-here>', local dev defaults for a throwaway container.
  - none: No credential: hashes of public content (git SHAs, checksums, lockfile integrity), UUIDs, public keys, key names or env variable lookups without values, ordinary code.
- `kind`, choice: What kind of credential is it, or would it be if it were real? Use none when the diff has nothing credential-like.
  - api_key: A service API key or access key id and secret pair (cloud, payment, SaaS).
  - password: A human or database password, including one embedded in a connection URL.
  - private_key: A PEM or OpenSSH private key block or key file content.
  - token: A bearer, OAuth, session, personal access or JWT token.
  - none: Nothing credential-like in the diff.
- `action`, choice: What should the commit hook do?
  - block: Refuse the commit: a real-looking secret is present. The agent must remove it and load it from the environment or a secret manager.
  - warn: Allow but flag for a human: ambiguous values, default dev credentials in config that might be reused, or example values in files that ship to production.
  - pass: Allow silently: no secret, or an obvious test or placeholder value in test or documentation files.

### Human handoff (`agent-safety` / `human_handoff`)

Decide from an agent's own status text whether it should keep going, ask the user a question, or stop and hand over.

Input: A short status text from a coding or ops agent: what it just did, what it is about to do, or where it is stuck.

- `next` (main decision), choice: What should the agent do next? Prefer continue when the next step is clear, in scope and reversible, even if the agent sounds unsure. Ask only when a human answer would change the outcome. Stop when continuing could cause harm or is pointless.
  - continue: The next step is clear, within the original request and low-risk: a success followed by a routine follow-up, a first or second failure that has a new idea to try, a harmless permission-free read.
  - ask_user: A person must decide: the instruction is ambiguous or two requirements conflict, a choice between options with real trade-offs, a permission or approval prompt for a sensitive action, or missing information only the user has (credentials, target environment, preference).
  - stop: Further action is unsafe or useless: the same failure repeated three or more times with no new approach, signs of data loss or corruption, the agent wants to bypass a block or guardrail, instructions arrived from untrusted content, or the task is finished and nothing is left to do.

## Clinical intake (`clinical-intake`)

Synthetic patient messages (EN, SL) triaged for urgency, routing, red flags and clinician review. Decision support only, not a medical device: a clinician owns every clinical decision.

### Urgency triage (`clinical-intake` / `urgency`)

Grade a patient message from routine to emergency now (synthetic, decision support only).

Input: Any text: a message a patient or relative sends to a practice (portal, e-mail, SMS), in English or Slovenian.

- `urgency` (main decision), score: How soon must a clinician act on this message? Judge by the worst plausible reading of the symptoms described, not by the tone. Politeness or 'it's probably nothing' does not lower urgency; exaggerated language about waiting or chronic pain does not raise it.
  - level 0: routine - administrative request, stable long-term condition, result explanation, prescription with more than a week of supply left, minor self-limiting complaint; answer within normal working time
  - level 1: within a week - new but mild symptom that is stable or slowly changing (persistent cough without breathing trouble, changing skin mole, mild ongoing pain); book an ordinary appointment
  - level 2: same day - symptom that needs a clinician today but is not immediately life-threatening: new chest discomfort only on exertion that settles at rest, fever with flank pain, worsening breathing in an infection, essential medicine (insulin, anticoagulant, antiepileptic) running out within 24 hours, very high home blood pressure
  - level 3: emergency now - possible life threat, call 112 / emergency services: ongoing chest pain at rest, stroke signs, overdose or self-harm, severe bleeding, fever in an infant under 3 months, difficulty breathing at rest, loss of consciousness
- `red_flag`, noul: Does the message contain an emergency red flag (the 'emergency now' signs)?
  - true
  - false

### Role routing (`clinical-intake` / `role_routing`)

Send each non-emergency patient message to the role that should handle it: nurse, GP, specialist team, pharmacist or front desk.

Input: Any text: a non-emergency patient message in English or Slovenian. Emergencies are caught by the urgency use case first.

- `route` (main decision), choice: Which role in a primary-care practice should handle this message first? Pick the lowest-skilled role that can fully handle it, but never one that would have to make a diagnosis or change treatment it is not qualified for.
  - nurse: Practice nurse: wound care, stitches and dressings, injections and vaccinations, routine blood pressure or sugar checks, and repeat prescriptions of a stable long-term medicine with no change requested.
  - gp: General practitioner: new, changing or worsening symptoms that need assessment or diagnosis, abnormal home readings that may need a treatment change, sick notes, referrals and anything that needs a medical decision.
  - specialist: Specialist team already treating the patient: side effects, complications or questions about a treatment that a hospital or specialist clinic started and still manages (chemotherapy, recent surgery follow-up, pregnancy care at the clinic).
  - pharmacy: Pharmacist: how to take a medicine already prescribed, missed doses, interactions, generics and brand switches, over-the-counter products, availability.
  - admin: Front desk / billing: booking, moving or cancelling appointments, invoices and insurance, copies of records, certificates of attendance, portal access. No clinical content.
- `language`, choice: Language of the message.
  - en: English
  - sl: Slovenian

### Red-flag labels (`clinical-intake` / `red_flags`)

Label each message with its red-flag category, who it is about and its language in one pass.

Input: Any text: a patient or relative message in English or Slovenian.

- `red_flag`, choice: Which emergency red flag does the message describe? Use 'none' unless the specific signs are present; a figure of speech ('this is killing me') is not a red flag. If the patient explicitly denies a sign, it is absent.
  - none: No emergency red flag: ordinary symptoms, low mood without thoughts of self-harm, chest pain clearly linked to pressing on the ribs or a strain, fever in a child over 3 months who is alert and drinking.
  - chest_pain: Possible heart attack: pressure, tightness or crushing pain in the chest at rest, often with spread to arm or jaw, sweating, nausea or breathlessness.
  - stroke: Stroke signs: sudden face droop, arm or leg weakness on one side, slurred or lost speech, sudden confusion or loss of vision.
  - suicidal: Suicidal thoughts, a plan to end one's life, self-harm or an intentional overdose.
  - bleeding: Severe bleeding: bleeding that does not stop with pressure, vomiting or coughing blood, heavy bleeding in pregnancy.
  - paediatric_fever: Fever in a child with danger signs: age under 3 months, a rash that does not fade under pressure, unusual drowsiness or floppiness, a fit, or not drinking.
- `patient`, choice: Who is the patient the message is about?
  - self: The writer themself.
  - child: A child under 18 (son, daughter, grandchild, pupil).
  - other_adult: Another adult (parent, partner, neighbour).
- `language`, choice: Language of the message.
  - en: English
  - sl: Slovenian

### Auto-reply gate (`clinical-intake` / `auto_reply_gate`)

Send a template reply only to purely administrative messages; anything clinical, mixed or unclear goes to a clinician.

Input: Any text: a patient message. The confidence of the handling decision picks act (auto-reply) / confirm (staff checks the draft) / human (clinician).

- `handling` (main decision), choice: Can this message be answered safely with a standard administrative template, without any clinical judgement?
  - auto_reply: Purely administrative or informational: opening hours, location and parking, booking, moving or cancelling an appointment, certificates of attendance, portal help, thanks. No current symptom, medication question, result interpretation or medical decision is asked for or implied.
  - clinician_review: Anything a clinician must read: a current or worsening symptom (even mentioned in passing next to an admin request), medication or vaccine advice, test result interpretation, referrals or prescriptions to be issued, emotional distress, or a message whose meaning is unclear.

## Cold-chain monitoring (`cold-chain`)

For pharmacies, hospitals, labs and food logistics: triage temperature excursions, spot faulty sensors, decide what happens to the stock and who gets woken up.

### Excursion triage (`cold-chain` / `excursion_triage`)

Medicine fridge stream: classify every sensor tick as normal, pre-alarm, door alarm, excursion or sensor fault within a 300 ms budget.

Input: JSON sensor tick {"t", "temp_c", "trend_c_per_min", "door", "door_open_min"}, or press "Start fridge stream". Plain text is skipped. Required JSON fields: temp_c, trend_c_per_min, door, door_open_min.

- `status` (main decision), choice: Medicine fridge with storage limits 2.0-8.0 C (setpoint 5.0 C). Classify this sensor tick. The nearer limit is 2.0 C when temp_c is below 5.0 C and 8.0 C otherwise. If several options apply, pick the first one in this order: sensor_fault, excursion, door_alarm, pre_alarm, normal.
  - sensor_fault: The reading is physically implausible for a running fridge: temp_c below -30 C or above 50 C, or |trend_c_per_min| above 3 C/min. Do not treat it as a real excursion.
  - excursion: temp_c is a plausible reading outside 2.0-8.0 C (below 2.0 or above 8.0). The stock is out of its storage range right now.
  - door_alarm: temp_c is still inside 2.0-8.0 C but the door has been open for more than 5 minutes (door_open_min > 5).
  - pre_alarm: Inside 2.0-8.0 C but at risk: temp_c above 7.0 C or below 3.0 C, or trend_c_per_min moving toward the nearer limit at 0.3 C/min or faster, or the door open for 4 or 5 minutes.
  - normal: temp_c between 3.0 and 7.0 C, no trend of 0.3 C/min or more toward the nearer limit, door closed or open for at most 3 minutes.

### Sensor fault diagnosis (`cold-chain` / `sensor_fault`)

Look at a short reading series and tell a real excursion from a stuck, drifting, glitching or disconnected probe.

Input: JSON {"unit", "interval_min", "readings": [temps in C, oldest first], optional "reference" (second probe or handheld check), "events"}. Plain text is skipped. Required JSON fields: readings.

- `diagnosis` (main decision), choice: Diagnose the temperature probe from the series. A healthy probe in a working fridge fluctuates by about 0.1-0.5 C as the compressor cycles and the door opens; air temperature cannot jump several degrees and come back within one or two minutes.
  - ok: Readings vary plausibly and stay inside the expected range; no sign of a fault and no excursion. Small door-opening bumps that recover are ok.
  - real_excursion: Temperature truly left the range: the change is gradual and physically plausible (several readings in a row, matching an event such as door left open, power cut, defrost or a loaded warm delivery), and any reference probe or handheld check agrees with it.
  - stuck: The probe reports the identical value (to 0.1 C) for a long stretch (8 or more readings) even though events such as door openings or compressor cycles should have moved it, or the reference probe moves while this one does not.
  - drift: The probe shows a slow steady offset that the reference probe or a handheld check does not confirm (difference of 1 C or more growing or constant over days), while the readings themselves still look smooth.
  - spike: One or two isolated readings jump far away (several degrees) and the next reading is back at the previous level; physically impossible for air temperature, typical of electrical noise.
  - disconnected: Readings are missing, null, NaN, or fixed sentinel values typical of a lost probe (-999, -127, 85.0, -40.0, 0.0 exactly repeated), or the series stops.

### Excursion impact (`cold-chain` / `excursion_impact`)

After an excursion: release the stock, quarantine it for QA, or discard it, from peak, duration, stability budget and mean kinetic temperature.

Input: JSON excursion record {"product", "label_storage", "peak_c" or "min_c", "duration_h", "stability_allowance", "cumulative_before_h", optional "mkt_30d_c", "freeze_sensitive", "data"}. Plain text is skipped. Required JSON fields: product, duration_h.

- `disposition` (main decision), choice: Decide what happens to the stock after this temperature excursion. Cumulative time out of range = cumulative_before_h + duration_h. Mean kinetic temperature (MKT) condenses a fluctuating profile into one equivalent storage temperature; an MKT inside the labelled range supports release only when stability data also covers the peak and the time. MKT never compensates for freezing a freeze-sensitive product, for a peak above the allowed maximum, or for missing data.
  - release: Stability data on file covers this event: peak (or minimum) inside the allowance range, cumulative time out of range within the allowance, no freezing of a freeze-sensitive product, and the record is complete. Stock can be used.
  - quarantine: The decision cannot be made from the record: no stability data or allowance for this product or temperature, the manufacturer must be consulted, or the logger has a gap during the excursion. Block the stock and send it to QA.
  - discard: The data shows the product is no longer usable: a freeze-sensitive product went below 0 C, the peak exceeded the maximum in the allowance, the cumulative time exceeds the allowance, or a rule in the allowance explicitly forbids use.

### Alarm escalation (`cold-chain` / `alarm_escalation`)

Pick the notification level for an open alarm: log it, notify the site, page the on-call person, or escalate to the responsible person.

Input: JSON alarm {"alarm", "unit", "value", "open_min", "local_time", "staff_on_site", "acknowledged", "stock"}. Plain text is skipped. Required JSON fields: alarm, acknowledged.

- `level` (main decision), score: Choose the escalation level for this open alarm. Pick the highest level whose condition is met.
  - level 0: 0 - log only: the condition already cleared by itself, or it is informational (battery above 20 %, a door alarm closed within 5 minutes, a scheduled defrost inside the expected profile).
  - level 1: 1 - notify site staff by in-app message and e-mail, handle at the next check: pre-alarm while still inside limits, battery below 20 %, calibration due, a unit offline for less than 30 minutes, or any alarm already acknowledged by staff who are on site.
  - level 2: 2 - page the on-call person now (push, SMS, phone call): a real excursion or door alarm that is open and not acknowledged, a unit holding stock offline for 30 minutes or more, or any level-1 condition outside working hours with nobody on site that will put stock out of range before morning.
  - level 3: 3 - escalate to the responsible person / QA manager as well as on-call: an excursion still not acknowledged 30 minutes or more after paging, a freeze-sensitive product below 0 C, stock worth over 50,000 EUR out of range, or several units failing at once (power or plant failure).
- `after_hours`, noul: Is the alarm happening outside working hours (weekdays 07:00-19:00) with no staff on site?
  - true
  - false

## Outreach & content (`content-growth`)

For sales, marketing and community teams: classify outreach replies, grade posts, flag low-quality AI text and score lead fit.

### Outreach reply (`content-growth` / `outreach_reply`)

Classify the intent of an e-mail reply to a cold outreach message so the right follow-up (or none) is triggered.

Input: Any text: the body of an e-mail reply received after a cold outreach message.

- `intent` (main decision), choice: Decide what the sender of this reply wants, judged by the action they ask for, not by politeness. A courteous refusal is still a refusal. A sharp tone around a real question is still a question. Automatic replies are never interest.
  - interested: The sender wants to continue: agrees to a call or demo, asks for next steps, proposes a time, or says they want to evaluate now.
  - question: The sender asks for information (pricing, features, how it works, security, references) without yet committing; answer it, even if the tone is skeptical or negative.
  - not_interested: The sender declines or defers without asking to be removed: 'no thanks', 'not now, maybe next quarter', 'we already have a vendor'. A vague 'later' with no concrete ask is not interest.
  - out_of_office: An automatic or manual absence notice: away, on leave, returning on a date, limited access to e-mail. No decision about the offer is expressed.
  - unsubscribe: The sender asks to stop receiving messages or to be removed from the list, however rudely or briefly ('stop writing to me', 'remove me', GDPR erasure request).
  - wrong_person: The sender says they are not the right contact and points to a colleague, a department or a shared address, or forwards the message to someone else.

### Post grade (`content-growth` / `post_grade`)

Grade a short social post or blog intro from 1 to 5 on specificity, a concrete claim and a clear point.

Input: Any text: a short social post, newsletter teaser or the first paragraph of a blog article.

- `quality` (main decision), score: Grade the writing quality of this post for a professional audience. Reward specificity, a concrete claim or number, a clear single point and no filler. Do not reward length, hashtags, emojis or enthusiasm, and do not punish informal style or typos when the content is concrete.
  - level 0: 1 - empty: no point, pure filler, slogans or hype; nothing a reader could verify or use
  - level 1: 2 - weak: a topic and a general opinion but vague; generic advice, no example, number or detail
  - level 2: 3 - fair: a clear point with some substance, but the evidence is thin, partly generic or buried under filler
  - level 3: 4 - good: a clear point backed by a concrete detail, example or number; minor padding or an unfinished argument
  - level 4: 5 - excellent: a sharp point with a specific claim, number or story the reader can check or apply, no filler, memorable wording

### AI slop check (`content-growth` / `ai_slop`)

Flag generic, low-effort filler text (often machine-written) versus specific, opinionated human writing.

Input: Any text: a short paragraph, post, comment or product blurb to check for generic filler.

- `verdict` (main decision), choice: Judge the text by its content, not by its polish or by guessing who wrote it. Slop is generic, interchangeable filler. Human text commits to specifics. Smooth grammar is not slop; typos and slang are not proof of a human.
  - human: Specific and committed: concrete names, numbers, places, events, personal detail or a real opinion that could be wrong. Informal, errorful or blunt writing is fine. Well-written text with concrete content is human.
  - slop: Generic and interchangeable: hollow openings ('in today's fast-paced world'), empty superlatives, buzzwords, listicle boilerplate, balanced both-sides filler, a closing call to action, and no checkable detail. Also sloppy human spam with no real content.
  - ambiguous: Mixed: a few concrete details inside generic phrasing, or short and neutral text with too little to judge either way.

### Lead fit (`content-growth` / `lead_fit`)

Score an inbound or prospected lead against the ideal customer profile: hot, warm or cold.

Input: JSON {"company", "role", "size", "industry", "signal"} - the lead. The confidence picks act / confirm / human. Required JSON fields: company, role.

- `fit` (main decision), choice: Ideal customer: a B2B team based in the EU with a document-heavy or support-heavy workflow (claims, invoices, applications, tickets, inbox triage) that wants an AI decision or classification API. Decision makers or owners of that workflow count; unrelated roles do not. Judge ICP match and buying signal separately, then combine. A missing field lowers certainty, it is not itself a reason for cold.
  - hot: ICP match (EU B2B, document- or support-heavy workflow, a relevant role such as operations, support, engineering or product owner) AND a concrete buying signal: trial or demo request, pricing question, named use case, active project or budget.
  - warm: Partial match: ICP company with no buying signal, or a buying signal with one gap (role is adjacent, outside the EU but selling into it, very small or very large, workflow only partly document-heavy). Worth nurturing.
  - cold: Poor match: consumer business, students or individuals, non-EU only, no document or support workflow, irrelevant role (e.g. intern, recruiter, competitor) and no real signal; or a signal that is clearly not buying (job seeker, vendor pitching us, research).

## Content moderation (`content-moderation`)

Trust and safety teams decide what stays up: action on posts, policy labels, appeal gate and marketplace listing checks.

### Post action (`content-moderation` / `post_action`)

Decide whether a user post stays up, goes to human review, or is removed, with the main policy reason.

Input: Any text: a user-generated post or comment to moderate.

- `action` (main decision), choice: Decide what to do with this post. Allow normal speech even when rude or critical; remove only clear policy violations; send genuinely borderline or context-dependent cases to human review.
  - allow: Within the rules: on-topic, critical, heated or impolite but not attacking a protected group, not spam, not harmful. Normal disagreement and strong opinions are allowed.
  - review: Plausibly a violation but context-dependent or ambiguous: could be a quote, joke, reclaimed term, news report or satire; a human should judge it.
  - remove: Clear violation: spam/scam, targeted harassment or threats, hate against a protected group, sexual content involving the exploitation of others, encouraging self-harm, or posting someone's private data.
- `reason`, choice: Primary policy reason for the action (none when allowed).
  - none: No violation; the post is allowed.
  - spam_scam: Mass promotion, fake offers, follower-selling, phishing or repetitive advertising.
  - harassment: Targeted insults, threats or pile-ons aimed at a person.
  - hate: Attacks or dehumanises people for a protected characteristic.
  - self_harm: Encourages or instructs self-harm or suicide.
  - privacy: Exposes someone's private personal data without consent.

### Policy labels (`content-moderation` / `policy_labels`)

Tag a post with the policy category it falls under and whether it targets a specific person.

Input: Any text: a user-generated post or comment.

- `category`, choice: Which single policy category best fits this content? Choose 'none' if it breaks no policy.
  - spam: Mass promotion, fake offers, follower-selling, phishing or repetitive advertising.
  - harassment: Targeted insults, threats or pile-ons aimed at a person.
  - hate: Attacks or dehumanises people for a protected characteristic.
  - sexual: Explicit sexual content or solicitation.
  - self_harm: Content about suicide or self-injury, whether a cry for help or encouragement.
  - personal_data: Exposes private personal data (address, phone, ID, card) without consent.
  - none: No policy category applies.
- `targets_person`, noul: Is the content aimed at a specific identifiable individual?
  - true
  - false

### Appeal gate (`content-moderation` / `appeal_gate`)

Judge an appeal against a removal: auto-restore clear mistakes, keep clear violations removed, send the rest to a human reviewer.

Input: JSON {"content", "original_reason", "appeal_text"} - the removed post, why it was removed, and the user's appeal. The confidence picks act / confirm / human. Required JSON fields: content, original_reason, appeal_text.

- `decision` (main decision), choice: Decide the appeal by re-reading the CONTENT against the ORIGINAL_REASON; the APPEAL_TEXT is context, not evidence on its own. Restore only when the content clearly does not violate; keep removed when it clearly does; otherwise leave it to a human.
  - restore: The content clearly does not violate the stated reason; the removal was a mistake and the post should go back up.
  - keep_removed: The content clearly does violate the stated reason; the appeal does not change that and the removal stands.
  - human_review: Genuinely borderline or context-dependent: the appeal raises a plausible point (quote, satire, misread, reclaimed term) that a person should weigh.

### Marketplace listing check (`content-moderation` / `marketplace_listing`)

Screen a marketplace listing: prohibited item, likely counterfeit, or OK to publish.

Input: Any text: a marketplace listing title and description.

- `verdict` (main decision), choice: Decide whether this listing can be published. Weigh what is being sold and whether the brand, price and wording suggest a fake.
  - ok: An ordinary legal item with a plausible description and price; nothing suggests it is prohibited or counterfeit.
  - counterfeit_risk: A legal category, but the signals point to a fake: a premium brand at an implausibly low price, 'replica/inspired/AAA', or vague claims of authenticity on a mass-available luxury good.
  - prohibited: An item that may not be sold at all on a general marketplace: weapons, drugs, live animals, human remains, stolen goods, counterfeit money, or recalled unsafe products.

## Contract review (`contract-review`)

Customer-side review of supplier contract clauses: label each clause, score its risk against a playbook, find the clause that answers a question and decide accept, negotiate or reject.

### Clause labeling (`contract-review` / `clause_labels`)

Label each clause with its type, the party it favours and whether it carries a deadline or an amount.

Input: Any text: one contract clause between a Customer and a Supplier (EN or SL).

- `clause_type`, choice: What is the main subject of the clause?
  - termination: Ending the agreement: for convenience, for breach, notice periods, effects of termination.
  - liability: Limits, caps, exclusions or carve-outs of liability, indemnities.
  - payment: Fees, invoicing, payment terms, late interest, suspension for non-payment.
  - confidentiality: Duty to keep information secret, publicity and disclosure of the agreement.
  - intellectual_property: Ownership of deliverables, pre-existing materials, licences.
  - governing_law: Applicable law, jurisdiction, courts or arbitration.
  - service_levels: Warranties, availability targets, service credits, acceptance.
- `favours`, choice: Which party does the clause favour compared with a balanced market-standard version?
  - customer: Gives the Customer rights or protections the Supplier does not get, or burdens mainly the Supplier.
  - supplier: Gives the Supplier rights or protections the Customer does not get, or burdens mainly the Customer.
  - neutral: Mutual or market standard; neither side gains a clear advantage.
- `terms`, choice: Does the clause state a concrete time period and/or a concrete amount? A time period is any stated number of days, months or years (notice, payment term, duration). An amount is a money figure or a percentage.
  - none: No concrete period and no concrete amount.
  - deadline: A concrete time period, no amount.
  - amount: A concrete money figure or percentage, no time period.
  - both: Both a concrete time period and a concrete amount or percentage.

### Clause risk (`contract-review` / `clause_risk`)

Score a supplier's clause 1-5 against the Customer's negotiation playbook.

Input: Any text: one clause proposed by a Supplier. It is scored against the playbook stated in the question instructions.

- `risk` (main decision), score: We are the Customer. Score the clause against our playbook. PLAYBOOK: (a) liability cap at least 12 months' fees, mutual, with no cap for confidentiality and data protection breaches; (b) payment term 30-60 days, late interest no higher than the statutory rate; (c) Supplier may terminate for convenience only on at least 6 months' notice; (d) auto-renewal for at most 12 months with at least 60 days to opt out; (e) governing law of an EU member state, Slovenia preferred; (f) price changes at most once a year, capped at inflation; (g) Customer data hosted and processed in the EU/EEA only; (h) no uncapped indemnities from Customer. Judge the size of the gap to the playbook, not the wording.
  - level 0: 1 - meets the playbook or is better for the Customer
  - level 1: 2 - small deviation, acceptable without negotiation (e.g. EU law other than Slovenia, payment term slightly shorter than 30 days, opt-out notice slightly shorter than 60 days)
  - level 2: 3 - moderate deviation, should be negotiated but not a deal-breaker
  - level 3: 4 - material deviation that creates significant exposure (non-EU law, cap far below 12 months' fees, long lock-in)
  - level 4: 5 - critical: unilateral change rights, uncapped Customer indemnity, data processed anywhere outside the EU, or loss of a basic protection; cannot be signed as is

### Clause retrieval (`contract-review` / `clause_retrieval`)

Find the clauses of a services agreement that answer a reviewer's question and rank them first.

Input: A question about the contract as text (or JSON {"query"}). It is scored against the 11 clauses of a synthetic master services agreement.

- `relevant`, noul: Does this clause contain the information needed to answer the question (fully or as an essential part of the answer)?
  - true
  - false

### Deviation from standard (`contract-review` / `deviation`)

Compare the counterparty's clause with our standard clause and decide: accept, negotiate or reject.

Input: JSON {"standard", "clause"}: our standard position and the clause the counterparty proposes. Plain text is skipped. Required JSON fields: standard, clause.

- `decision` (main decision), choice: We are the Customer. Compare CLAUSE with our STANDARD and decide how to respond.
  - accept: Same substance as the standard, only different wording, more favourable to us, or a small mutual change that does not shift risk or cost to us.
  - negotiate: Departs from the standard and shifts some risk or cost to us, but within a range parties commonly agree (shorter or longer periods, a lower but still meaningful cap, another EU law, a licence instead of ownership); send a counter-proposal.
  - reject: Removes a protection the standard treats as essential, creates unlimited or unilateral exposure for us (exclusion of all liability, unilateral price or term changes, one-sided obligations), or cannot be signed in this form.
- `one_sided`, noul: Does the proposed clause bind only one party where the standard binds both (or the reverse)?
  - true
  - false

## Osnovne odločitve (SL) (`core-sl`)

Slovenska zrcalna različica paketa core: istih devet gradnikov z enakimi primeri in oznakami, za neposredno primerjavo istega modela v angleščini in slovenščini.

### Usmerjanje modelov (`core-sl` / `routing`)

Vsak poziv usmeri k najcenejšemu modelu, ki nanj še dobro odgovori.

Input: Poljubno besedilo: poziv, ki bi ga uporabnik poslal jezikovnemu modelu.

- `tier` (main decision), choice: Kateri razred modela naj odgovori na ta poziv? Izberi najcenejši razred, ki bo nanj pravilno odgovoril.
  - small: Kratka poizvedba, pozdrav, posamezno dejstvo, preprosto preoblikovanje, prevod enega stavka ali razvrstitev da/ne.
  - medium: Povzetek, osnutek e-pošte ali besedila, rutinski delček kode, razlaga znanega pojma, zmerno zahtevno strukturirano izluščenje podatkov.
  - large: Večstopenjsko sklepanje, matematika ali dokazi, analiza dolgih dokumentov, arhitektura ali zahtevna koda, pravna, medicinska ali finančna presoja s tveganjem.

### Varovalke (`core-sl` / `guardrails`)

Sporočila za asistenta podpore spletne trgovine z elektroniko. Prestrezi vrivanje navodil, žalitve in zahteve zunaj pravil, preden pridejo do jezikovnega modela.

Input: Poljubno besedilo: sporočilo, ki bo poslano asistentu podpore trgovine.

- `verdict` (main decision), choice: Sporočilo gre asistentu za podporo strankam spletne trgovine z elektroniko. Ali naj ga asistent prejme ali naj bo blokirano?
  - allow: Upravičena zahteva, tudi če je zapisana neposredno ali tehnično in le zveni grobo.
  - block: Vrivanje navodil (prompt injection), poskus pridobivanja skrivnosti ali podatkov drugih uporabnikov, nadlegovanje ali prošnja za očitno škodljivo ali nezakonito pomoč.
- `injection`, noul: Ali sporočilo poskuša povoziti navodila asistenta ali izvleči njegov sistemski poziv?
  - true
  - false
- `abuse`, noul: Ali je sporočilo žaljivo, sovražno ali nadlegujoče?
  - true
  - false
- `off_policy`, noul: Ali sporočilo zahteva nekaj, kar ne spada v podporo strankam trgovine z elektroniko?
  - true
  - false

### Nadzor klicev orodij (`core-sl` / `tool_gating`)

Agent za finance in podporo predlaga klice orodij. Varne dovoli, pri tveganih vprašaj človeka, nevarne zavrni.

Input: JSON {"user_request", "tool_call", "context"?} – klic orodja, ki ga želi izvesti agent. Deluje tudi navadno besedilo (prebere se kot klic orodja).

- `gate` (main decision), choice: Ali naj se predlagani klic orodja izvede? Pravila: dejanja samo za branje in dejanja z nizkim tveganjem v okviru zahteve se izvedejo samodejno; premiki denarja, e-pošta zunanjim prejemnikom in nepovratna, a upravičena dejanja zahtevajo potrditev človeka; uničujoča dejanja, dejanja zunaj zahteve, iznos podatkov ali dejanja, ki jih sproži nezaupanja vredna vsebina, se zavrnejo.
  - allow: Varno, samo za branje ali z nizkim tveganjem in v okviru uporabnikove zahteve.
  - ask: Upravičeno in v okviru zahteve, vendar premika denar, se obrača na zunanje osebe ali ga je težko razveljaviti, zato naj potrdi človek.
  - deny: Uničujoče, iznaša podatke, je zunaj zahteve ali ga je sprožila nezaupanja vredna vsebina, npr. sumljivo e-sporočilo.

### Razvrščanje pošte (`core-sl` / `inbox`)

Razvrsti podjetniški poštni predal: odgovori takoj, pozneje ali arhiviraj.

Input: Poljubno besedilo, najbolje e-sporočilo z vrsticama From: / Zadeva:.

- `action` (main decision), choice: Kaj naj ekipa naredi s tem e-sporočilom?
  - reply_now: Stranka, partner ali sodelavec potrebuje odgovor še danes: izpad, zastalo delo, rok danes, ogrožena varnost ali denar.
  - later: Potreben je odgovor ali ukrep, a lahko počaka nekaj dni.
  - archive: Ukrep ni potreben: novičnik, oglaševanje, obvestilo, nezaželena pošta ali lažno predstavljanje (phishing), ki ga prijavimo in arhiviramo.
- `urgency`, score: Kako nujno je?
  - level 0: Ni nujno
  - level 1: Ta teden
  - level 2: Danes
  - level 3: V eni uri

### Prerazvrščanje (`core-sl` / `reranking`)

Oceni deset odlomkov iz centra za pomoč glede na tri vprašanja strank in jih razvrsti po ustreznosti.

Input: Iskalna poizvedba kot besedilo (ali JSON {"query"}). Oceni se glede na 10 odlomkov iz centra za pomoč v packs/<pack>/5-reranking.json.

- `relevant`, noul: Ali ta odlomek vsebuje informacije, potrebne za odgovor na poizvedbo?
  - true
  - false

### Vrednotenje jezikovnih modelov (`core-sl` / `evals`)

Oceni odgovore asistenta glede na izvorni odlomek na lestvici od 1 do 5.

Input: JSON {"context", "question", "answer"} – odgovor se oceni od 1 do 5 glede na kontekst. Navadno besedilo se preskoči. Required JSON fields: context, question, answer.

- `quality` (main decision), score: Oceni ODGOVOR na VPRAŠANJE, pri čemer je edini vir resnice KONTEKST.
  - level 0: 1 – napačen ali v nasprotju s kontekstom
  - level 1: 2 – večinoma napačen ali si izmišljuje dejstva
  - level 2: 3 – delno pravilen, pomembna podrobnost manjka ali je napačna
  - level 3: 4 – pravilen, manjša pomanjkljivost
  - level 4: 5 – povsem pravilen in popoln
- `hallucination`, noul: Ali odgovor navaja dejstva, ki jih kontekst ne podpira?
  - true
  - false

### Množično označevanje (`core-sl` / `bulk_labeling`)

Ocene izdelkov (v več jezikih) v enem prehodu na vrstico označi s sentimentom, temo in jezikom.

Input: Poljubno besedilo, najbolje ocena izdelka v slovenščini, angleščini, nemščini ali hrvaščini.

- `sentiment`, choice: Splošni sentiment ocene.
  - positive: Pretežno zadovoljen.
  - negative: Pretežno nezadovoljen.
  - mixed: Hkrati jasna pohvala in jasna pritožba.
- `topic`, choice: Glavna tema ocene.
  - product_quality: Kako izdelek deluje ali kako je narejen.
  - delivery: Pošiljanje, kurir, embalaža, čas dostave.
  - price: Cena, razmerje med ceno in kakovostjo, popusti.
  - support: Služba za pomoč strankam, vračila, obravnava garancije.
- `language`, choice: Jezik ocene.
  - en: angleščina
  - sl: slovenščina
  - de: nemščina
  - hr: hrvaščina

### Krmiljenje v realnem času (`core-sl` / `realtime`)

Krmilnik hladilnika za cepiva: ena odločitev na odčitek senzorja, zakasnitev merjena glede na proračun 300 ms.

Input: JSON odčitek senzorja {"temp_c", "trend_c_per_min", "door", "door_open_min"} ali pritisnite "Start simulated stream". Navadno besedilo se preskoči. Vrednost "door" je "open" ali "closed". Required JSON fields: temp_c.

- `action` (main decision), choice: Hladilnik za cepiva, zakonsko predpisane meje 2,0–8,0 °C, nastavljena vrednost 5,0 °C. Izberi krmilni ukrep za ta odčitek.
  - hold: Temperatura je med 3,5 in 6,5 °C in se ne giblje proti mejam; ohrani trenutne nastavitve.
  - boost_cooling: Temperatura je nad 6,5 °C ali hitro narašča proti 8 °C, a je še v mejah.
  - reduce_cooling: Temperatura je pod 3,5 °C ali hitro pada proti 2 °C, a je še v mejah.
  - alarm: Temperatura je zunaj območja 2,0–8,0 °C, senzor je v okvari ali so vrata odprta več kot 5 minut.

### Prag zaupanja (`core-sl` / `confidence_gate`)

Zahtevki za podporo, nekateri jasni, drugi dvoumni. Ukrepaj, ko si prepričan, v vmesnem območju zahtevaj potrditev, ob negotovosti predaj človeku.

Input: Poljubno besedilo: zahtevek stranke za podporo. Zaupanje v namen določi ukrepaj / potrdi / človek.

- `intent` (main decision), choice: Kaj stranka želi?
  - refund: Vračilo denarja za naročilo.
  - exchange: Zamenjava izdelka za drugo velikost, barvo ali drug kos.
  - repair: Popravilo okvarjenega izdelka v okviru garancije.
  - order_status: Kje je moje naročilo, kdaj bo dostavljeno.
  - cancel: Preklic naročila, ki še ni bilo odposlano.

## Data flywheel (`data-flywheel`)

Curate and judge LLM training data: triage rows, pick DPO preferences, grade answers against sources and label rows for the mix.

### Row triage (`data-flywheel` / `row_triage`)

Keep, fix or drop an instruction/response pair before it goes into an SFT mix.

Input: JSON {"instruction", "response"} - one supervised fine-tuning row. Plain text is skipped. Required JSON fields: instruction, response.

- `action` (main decision), choice: Decide what to do with this training row. Judge the RESPONSE as a training target for the INSTRUCTION: would a model trained on it learn the right behaviour?
  - keep: The response correctly and completely does what the instruction asks, is safe, well formed and in the requested language and format. Usable as a training target exactly as it is.
  - fix: The response is essentially correct and useful, but has one small issue that a single quick edit repairs: a wrong secondary detail while the main answer is right, a missing item in a short list, ignored formatting (bullets, length), a typo, an unnecessary preamble or sign-off, or a phrase in the wrong language.
  - drop: The response would teach bad behaviour and cannot be saved by a small edit: the core answer is wrong, it gives meaningful help with something harmful, it is cut off mid-sentence or mid-code, it is generic filler that ignores the instruction, it refuses a harmless request, or it answers a different question.
- `reason`, choice: Main problem with the row (none when it should be kept).
  - none: No problem; the row is a good training target.
  - wrong_or_incomplete: A fact, number, step or list item is wrong or missing.
  - unsafe: Gives practical help for harming people, property or systems (e.g. breaking into accounts or networks).
  - truncated: Ends abruptly mid-sentence, mid-list or mid-code.
  - boilerplate_or_refusal: Generic filler or AI disclaimers instead of an answer, or refuses a harmless request.
  - style: Formatting, length, typos, register, extra preamble or sign-off, or mixed languages.

### DPO preference pairs (`data-flywheel` / `preference_pairs`)

Pick the better of two responses for preference training. Confident pairs go straight into the DPO set, unsure ones to an annotator.

Input: JSON {"prompt", "a", "b"} - one prompt and two candidate responses. The confidence of the preference picks act / confirm / human. Required JSON fields: prompt, a, b.

- `preference` (main decision), choice: Which response should be the 'chosen' one for preference training on this prompt? Priority order: correctness, then safety, then following explicit constraints (format, length, language), then helpfulness. Length or polish alone is never a reason to prefer a response.
  - a: Response A is clearly better: it is correct where B is wrong, safer, follows an explicit constraint B ignores, or (both being correct and compliant) is meaningfully more helpful.
  - b: Response B is clearly better: it is correct where A is wrong, safer, follows an explicit constraint A ignores, or (both being correct and compliant) is meaningfully more helpful.
  - tie: No meaningful difference: both are equally correct and compliant (only wording, punctuation or an equivalent method differs), or both are equally wrong or unusable. The pair should not be used.

### Grounded answer judge (`data-flywheel` / `answer_judge`)

Grade a model answer 1-5 against its source passage and flag hallucinations before it enters the eval scoreboard.

Input: JSON {"context", "question", "answer"} - the answer is graded 1-5 using only the context as ground truth. Plain text is skipped. Required JSON fields: context, question, answer.

- `quality` (main decision), score: Grade the ANSWER to the QUESTION using only the CONTEXT as ground truth. Reasoning that follows directly from the context (simple arithmetic, combining two stated facts) counts as supported.
  - level 0: 1 - wrong: contradicts the context, says the context lacks information it contains, or does not answer
  - level 1: 2 - mostly wrong: the key fact is wrong, or the right fact is buried under invented claims
  - level 2: 3 - partly correct: one part of the question is unanswered, an important qualifier is wrong, or a correct core comes with an unsupported extra claim
  - level 3: 4 - correct and supported, with a minor omission or a small harmless inference
  - level 4: 5 - fully correct, complete and supported by the context
- `hallucination`, noul: Does the answer state any fact that is not supported by, or contradicts, the context?
  - true
  - false

### Near-duplicate check (`data-flywheel` / `near_duplicate`)

Decide whether two training prompts are duplicates, paraphrases or genuinely different, so the mix is deduplicated without collapsing real variety.

Input: JSON {"a", "b"} - two prompts (or instruction texts) from the training pool. Plain text is skipped. Required JSON fields: a, b.

- `relation`, choice: How do prompt A and prompt B relate? Judge by the task and the expected answer, not by surface wording.
  - duplicate: Same task and same expected answer; wording is identical or differs only trivially (punctuation, casing, a filler word). Keep one, drop the other.
  - paraphrase: Same underlying task and answer, but meaningfully reworded, reordered, in another language, or with a different example filled in. Keep as useful variety, flag as related.
  - different: Different task or a different expected answer, even if they share topic or vocabulary. Keep both.

## Dev & ops triage (`dev-ops`)

For SRE and platform teams: triage log lines, vet dependencies, classify CI failures and route issues.

### Log triage (`dev-ops` / `log_triage`)

Decide whether a log line needs a human now, belongs in the daily digest or can be resolved as noise.

Input: One log line or a short excerpt from a service, host or orchestrator, with timestamps and service names.

- `route` (main decision), choice: Decide how this log line or excerpt must be handled. Judge the real impact and trend, not how alarming the wording is.
  - page: A human must act now: user-facing or data-integrity impact is happening or imminent (repeated crashes or OOM kills of a production service, disk or quota about to run out, a burst of auth failures suggesting an attack or broken login for many users, data corruption, certificate about to expire within hours), and nothing indicates it is fixing itself.
  - digest: Not urgent but worth a person's attention within a day or two: slow-building problems (deprecation of something still used, disk 70-90% and slowly growing, a single OOM kill with clean recovery, elevated but stable error rates, a certificate expiring in weeks), listed in a daily summary.
  - resolve: Noise or already self-healed: a retry that succeeded, a transient connection reset followed by success, health-check blips that recovered, informational or debug lines, expected errors from a known scanner, a scary word in a harmless context.

### Package audit (`dev-ops` / `package_audit`)

Vet a dependency install event: fine, a lookalike of a popular package, or suspicious on its own.

Input: A package install event as a JSON object with name, version, registry, weekly_downloads, age_days, maintainer_count and has_install_script. Required JSON fields: name, weekly_downloads.

- `verdict` (main decision), choice: Judge the install event from the name and the metadata. A lookalike is decided by the name first; metadata decides between ok and suspicious.
  - ok: A well-established package: high weekly downloads (tens of thousands or more) or a clearly old, maintained project with several maintainers; an install script is acceptable when the package is a known native or tooling package. A name that merely resembles another word is fine if the package itself is the popular one.
  - lookalike: The name is one edit, swapped letters, a changed separator or a homoglyph away from a very popular package (reqeusts for requests, colourama for colorama, lodahs for lodash), and the metadata is tiny compared with the real package. Typosquats are lookalikes even when they have no install script.
  - suspicious: The name is not a copy of a popular package, but the metadata is risky: young (days to a few weeks), very few downloads, a single maintainer and an install script that runs code on install, especially with a generic or enticing name. Also used for an old package that suddenly gets a new install script or maintainer.

### CI failure cause (`dev-ops` / `ci_failure`)

Classify a failed CI job as a real failure of the change, a flaky test or an infrastructure problem.

Input: A CI log excerpt as text: job name, the failing step output, and sometimes what the commit changed.

- `cause` (main decision), choice: Decide the most likely root cause of the CI failure from the log. A re-run would change the outcome only for flaky and infrastructure causes.
  - real_failure: The change under test is wrong or incomplete: a deterministic assertion, compile, lint or type error in or next to the code the commit touched, reproducible on every run. A re-run will fail the same way.
  - flaky: The code is probably fine but the test is not deterministic: race conditions, order dependence, timing or sleep-based waits, random seeds, a test timeout on code unrelated to the change, passing on re-run or on the previous commit. The failure sits in a test, not in the runner.
  - infrastructure: The runner or an external service failed, not the code: runner out of disk or memory, network resets while downloading dependencies or images, registry 5xx or rate limit, lost agent connection, expired credentials of the CI system, cancelled by the platform.

### Issue routing (`dev-ops` / `issue_routing`)

Label an incoming issue with its type, the area of the stack it belongs to and a priority.

Input: An issue title and body as free text, in English, Slovenian or German.

- `type`, choice: What kind of issue is this? Judge by the substance, not by how the author phrased it.
  - bug: Something that should work does not: wrong output, crash, regression, broken page, with steps or symptoms.
  - feature: A request for new behaviour or an improvement that does not exist yet and was never promised.
  - question: A genuine request for help or information about how to use the product, with no sign of a defect or exposure of data.
  - security: Exposes or could expose secrets, personal data, authentication or authorization bypass, injection or other vulnerabilities, even when phrased politely as a question or as 'is this normal?'.
- `area`, choice: Which part of the system must change or look at it?
  - frontend: Browser UI, layout, client-side logic, translations of the UI, mobile web views.
  - backend: APIs, business logic, databases, queues, authentication services, server-side data handling.
  - infra: Deployment, containers, CI/CD, networking, certificates, monitoring, cloud resources, performance of the platform.
  - docs: Documentation, README, examples, API reference, tutorials, wrong or missing explanations.
- `priority`, choice: How urgent is it? Rate by impact and exposure, not by the tone of the author.
  - p0: Production is down or data/secrets are exposed or being lost now; everyone drops what they do.
  - p1: Major function broken for many users or a serious vulnerability without active exploitation; fix this sprint or sooner.
  - p2: Real but limited problem with a workaround, or a valuable improvement; planned in the backlog.
  - p3: Cosmetic, minor, a question or a nice-to-have; handle when convenient.

## Education and tutoring (`education`)

Tutors and teachers of school-age learners grade answers, spot misconceptions, decide when to give a hint and read the mood of a message.

### Rubric grading (`education` / `rubric_grade`)

Grade a learner's answer against a rubric on a 1-5 scale, for programming, robotics and maths tasks.

Input: JSON {"question", "rubric", "answer"} - the learner's answer graded 1-5 against the rubric. Plain text is skipped. Required JSON fields: question, rubric, answer.

- `grade` (main decision), score: Grade the learner's ANSWER to the QUESTION against the RUBRIC. Reward correct reasoning and the method the rubric asks for, not just the final number. Do not penalise spelling or phrasing from a young learner when the idea is right.
  - level 0: 1 - no relevant understanding: blank, off-topic, or wholly wrong with no correct idea
  - level 1: 2 - a small fragment is right but the core is wrong or missing
  - level 2: 3 - partly correct: the right idea with a significant error, or the right method with a wrong result
  - level 3: 4 - essentially correct with a minor slip or an incomplete explanation
  - level 4: 5 - fully correct answer and reasoning, meeting the rubric

### Misconception spotting (`education` / `misconception`)

Name the specific misconception behind a wrong (or right) learner answer, so the tutor can target it.

Input: JSON {"question", "answer"} - a learner's answer to diagnose. Plain text is skipped. Required JSON fields: question, answer.

- `misconception` (main decision), choice: Identify the single misconception that best explains the learner's answer.
  - off_by_one: Miscounts the boundary: includes or excludes one end of a range, so the count or index is off by one.
  - loop_vs_condition: Confuses repeating (a loop) with a one-time test (an if/condition), e.g. thinks an 'if' repeats or a loop runs once.
  - unit_error: The numeric reasoning is right but the units are wrong or mixed (cm vs m, area vs length, seconds vs minutes).
  - operation_confusion: Uses the wrong operation: adds instead of multiplies, perimeter vs area, times instead of divides.
  - correct: The answer is correct; no misconception is present.

### Hint gate (`education` / `hint_gate`)

Decide whether a stuck learner should get a hint, be left to try a little longer, or be handed to a human teacher.

Input: Any text: a short log of what the learner just did or said while working on a task.

- `support` (main decision), choice: What is the right level of support for this learner right now? Prefer letting them try when they are productively stuck, give a hint when they are blocked on one step, and call a teacher when they are distressed or missing a prerequisite a hint cannot fix.
  - let_them_try: The learner is making progress or has only just started; a little more productive struggle will help more than a hint.
  - give_hint: The learner is genuinely stuck on one specific step and a targeted nudge would unblock them without giving the answer away.
  - call_teacher: The learner is upset, disengaged, or lacks a basic prerequisite; they need a person, not another automated hint.

### Message mood (`education` / `message_mood`)

Read the emotional tone of a learner's message and the topic it is about, to route encouragement and help.

Input: Any text: a short message a learner sent during a lesson.

- `mood`, choice: What is the learner's emotional state in this message?
  - frustrated: Annoyed, discouraged or upset; wants to give up.
  - confident: Pleased, proud or self-assured; feels it is going well.
  - confused: Unsure or lost; does not understand but is not (yet) upset.
  - neutral: Matter-of-fact, no clear emotion.
- `topic`, choice: What is the message mainly about?
  - programming: Code, logic, loops, variables, errors in a program.
  - robotics: The physical robot, motors, sensors, building or movement.
  - maths: Numbers, arithmetic, geometry or calculation.
  - logistics: Not the subject itself: timing, equipment, breaks, where to click, admin.

## Games & real time (`games-realtime`)

For game studios and live-service teams: tiny decisions that must be answered in milliseconds: cheat suspicion, player intent, difficulty and board moves.

### Cheat suspicion (`games-realtime` / `cheat_suspicion`)

Rate one match summary as clean, worth a human review or an automatic ban.

Input: JSON match summary {player, hours_played, headshot_pct, reaction_ms, kd, reports, account_age_days}. Required JSON fields: player, headshot_pct, reaction_ms.

- `verdict` (main decision), choice: Competitive shooter anti-cheat. Judge the numbers, not the reputation: player reports are weak evidence and never decide alone. Check the ban numbers first, then the review band, otherwise clean.
  - clean: Headshot rate below 55% and reaction time 160 ms or more, whatever the number of reports, except a very new account (under 14 days) with a very high kd (3.5+). Many reports with normal stats are false reports.
  - review: Stats at the edge of human performance but not impossible: headshot rate 55-84%, or reaction time 120-159 ms, or a very new account (under 14 days) with a very high kd and no impossible number. Send to a human to check the replay.
  - ban: A physically implausible number: reaction time under 120 ms, or headshot rate of 85% or more over the match. Automatic ban, regardless of reports or hours played.

### NPC player intent (`games-realtime` / `npc_intent`)

Work out what a player wants from an NPC from one free-text line, in English, Slovenian or German.

Input: One line of free text the player typed to an NPC, in any language.

- `intent` (main decision), choice: Fantasy RPG. Decide what the PLAYER wants to do right now. Direction does not matter: buying or selling is a trade. Judge the goal of the sentence, not single words.
  - trade: The player wants to buy or sell an item or asks a price, in either direction ('sell me your sword', 'I will sell you my sword').
  - quest: The player asks for work, a task, a mission or a lead, or accepts or asks about a job and its details (even its reward).
  - attack: The player threatens, robs or starts violence against the NPC, including polite or sarcastic threats.
  - flee: The player says they are retreating, running away or leaving because of danger.
  - chat: Small talk, compliments, curiosity questions or farewells with no wish to buy, sell, work, fight or flee.
- `lang`, choice: Language of the player's line.
  - en: English.
  - sl: Slovenian.
  - de: German.

### Difficulty adjustment (`games-realtime` / `difficulty_adjust`)

Decide per player whether the next level should be easier, the same or harder; act alone only when confident.

Input: JSON player stats {deaths_last_10, clears_last_10, avg_level_time_s, quit_rate, streak} for the last 10 levels; streak is consecutive clears (positive) or deaths (negative). Required JSON fields: deaths_last_10, clears_last_10.

- `adjust` (main decision), choice: Dynamic difficulty for a level-based game. Keep players in the flow zone: challenged but progressing. quit_rate is the share of sessions ended in the middle of a level. Test easier first, then harder, otherwise keep.
  - easier: The player is stuck: 3 or fewer clears in the last 10 levels, or quit_rate 0.4 or more, or 4 or more deaths in a row (streak -4 or lower). Lower the difficulty.
  - keep: Productive challenge: neither stuck nor bored. 4 to 8 clears in the last 10, or 9-10 clears that do not meet every condition for harder. Many deaths with steady clears is still flow. Change nothing.
  - harder: The player is bored: 9 or 10 clears, 2 or fewer deaths, quit_rate 0.1 or less and a streak of 4 or more clears, all together. Raise the difficulty.

### Player support triage (`games-realtime` / `player_support`)

Route a player's message to the right support queue: refund, bug, cheat report, account recovery or feedback.

Input: A player's message to support as free text, in English, Slovenian or German.

- `queue` (main decision), choice: Pick the support queue by what the player needs done. A report about money goes to refund even if a bug caused it; a message about someone else goes to cheat_report.
  - refund: The player asks for money back or a reversed charge: double charge, missing purchase, unauthorised purchase by a child, refund eligibility.
  - bug: Something in the game malfunctions: crash, freeze, audio or graphics glitch, broken mechanic, with or without logs. Asks for a fix, not for money.
  - cheat_report: The player reports another player's behaviour: cheating, hacking, harassment, abuse or bots. The report is about someone else.
  - account_recovery: The player cannot access their own account or it was taken over: lost phone, forgotten password, missing code, unauthorised login.
  - feedback: Praise, thanks, a suggestion or an opinion on design or balance. Nothing is broken and nothing is requested back.

## Industrial faults (`industrial-faults`)

For maintenance and plant teams: diagnose machine faults from telemetry, prioritise maintenance, validate sensors and sort alarm floods.

### Fault diagnosis (`industrial-faults` / `fault_diagnosis`)

Read one telemetry snapshot of a compressor, pump, motor or drive and name the most likely fault.

Input: JSON snapshot {"asset", "vibration_mm_s" (RMS velocity), "temp_c", "current_a", "pressure_bar", "rpm", "note"}. Plain text is skipped. Required JSON fields: asset, vibration_mm_s, temp_c.

- `fault` (main decision), choice: Pick the single most likely condition of the machine from the snapshot. Reason physically: vibration points to mechanics, temperature to friction or cooling, current to load and electrics, pressure to fluid or gas inventory. A reading that contradicts the physics of the other channels is a sensor problem, not a machine problem.
  - normal: All channels are inside the usual band for the asset (vibration below about 4.5 mm/s RMS, temperature steady and below the rating, current near rated, pressure and rpm as expected). Brief load changes, startup transients and a note about routine work are normal.
  - bearing_wear: Vibration is high (roughly above 6 mm/s, or rising fast) together with a rising bearing or casing temperature while current stays normal and pressure is normal. Mechanical friction heats the bearing and shakes the machine without changing the electrical load much. A note about noise, grease or rising trend supports it.
  - overheating: Temperature is high (motor winding or process temperature above the rating) while vibration is normal. Current may be high from overload or low if cooling is the cause; look for a blocked filter, fouled cooler, fan failure, high ambient temperature or sustained overload in the note. Hot without shaking is a thermal problem, not a bearing.
  - refrigerant_or_fluid_loss: Pressure is low (suction or discharge below the normal range, low oil or refrigerant level) and the machine runs with lower current or lower cooling effect, often with normal or slightly higher temperature of the discharge side and normal vibration. Cavitating pumps (low inlet pressure, gravel-like noise) belong here too. The cause is a leak or empty inventory, not mechanics.
  - electrical_imbalance: Current is clearly off while vibration and temperature are only mildly changed: one phase higher than the others, current well above rated at normal load, or twice-line-frequency vibration with a hot winding. Notes about phase imbalance, voltage drop, loose terminal or single phasing point here.
  - sensor_fault: The readings contradict each other physically or are impossible: a temperature jump of tens of degrees in one sample with every other channel steady, vibration of zero on a running machine, a value pinned at the range limit (0, -50, 150, 20 mA offsets), or a note about a recent sensor swap or wiring work. Prefer this when only one channel is wild and nothing else corroborates it.

### Maintenance priority (`industrial-faults` / `maintenance_priority`)

Decide whether a maintenance finding needs action now, a slot in the next planned window, or only continued monitoring.

Input: A short maintenance finding as text, including the asset and its criticality (critical, important, standard).

- `priority` (main decision), choice: Choose the maintenance priority from the finding and the asset criticality. Weigh safety, speed of deterioration, time to failure, the consequence of failure and whether a standby exists. Do not escalate on alarming words alone, and do not downgrade a fast-moving fault because the asset is cheap.
  - now: Stop the asset or fix within hours: a safety hazard (leak of hazardous fluid or gas, fire or burning smell, exposed live part, guard missing), or imminent failure that is visibly accelerating on a critical asset without standby, or a fault that will cause serious secondary damage within the shift.
  - schedule: Real defect that needs a work order but will not fail before the next planned window (typically days to weeks): stable but out-of-limit wear, slow leak that is contained, degraded condition on an asset with a standby, or imminent-looking fault on a standard non-critical asset that can be run to the window.
  - monitor: No action beyond watching: reading slightly above baseline but stable, cosmetic issues, a trend that has not crossed an alert limit, a one-off alarm that cleared and has an explanation. Set a re-check date and an alert threshold.

### Sensor validity (`industrial-faults` / `sensor_validity`)

Check a short reading series and tell a healthy sensor from a stuck, spiking or drifting one.

Input: JSON {"sensor", "last_readings": [numbers, oldest first], "unit", optional "reference" and "context"}. Plain text is skipped. Required JSON fields: sensor, last_readings.

- `sensor` (main decision), choice: Judge the validity of the sensor from its readings, not the process. A healthy process signal shows small natural noise and moves smoothly with the process. Compare with a reference or the stated context when given.
  - ok: Readings show normal small noise and move plausibly with the process or follow the reference within tolerance. A real, smooth step or ramp that the context explains (load change, start-up, valve opening) is ok, not a fault.
  - stuck: The same value is repeated exactly (or to the last digit) for many consecutive readings (about 6 or more) although the process or the reference is moving or noise would normally show, or the value is frozen at a range limit or sentinel (0, 4.00 mA, -999, 32767). A steady process with a noisy signal that is perfectly flat is suspicious.
  - spike: One or two isolated readings jump far from the level before and after (several times the normal noise, physically impossible for the process inertia), and the series returns to the previous level at once. The surrounding readings are otherwise normal.
  - drift: The series shows a slow, steady, monotonic offset (readings creeping in one direction by the same small step) that the reference or the process does not explain: the sensor and the reference diverge gradually, or the baseline slides while the process is constant. Smooth, no jumps.

### Alarm flood (`industrial-faults` / `alarm_flood`)

In a burst of alarms, classify one marked alarm as root cause, consequence, duplicate or nuisance.

Input: Text listing a burst of alarms with timestamps and tags, with one alarm marked as the one to classify (for example 'CLASSIFY: A3').

- `role` (main decision), choice: Classify the marked alarm within the burst. Use the order in time, the physical or control dependency between the tagged equipment, and whether the alarm repeats another or has no bearing on the event.
  - root_cause: The marked alarm is the earliest event in the causal chain and the other alarms follow from it physically (a trip, a power loss, a valve failing closed, an upstream equipment fault). Removing it would remove the others. A timestamp earlier than its consequences is necessary but not enough; the dependency must exist.
  - consequence: The marked alarm is a process or equipment response that follows from another alarm in the burst (low flow after the pump trip, low level after the valve closed, downstream trip after the loss of feed). It comes later and is explained by an upstream alarm.
  - duplicate: The marked alarm repeats an alarm already in the burst: the same tag and condition raised again (re-alarm, chattering around the limit, or a second sensor or voted channel of the same condition, or the same event at a second alarm priority). It adds no new information.
  - nuisance: The marked alarm has no causal link to the event and no operator action is needed: a standing or stale alarm, a maintenance or calibration alert, a communication blip, a threshold set too tight that flickers regardless, or an unrelated minor condition that happens to fall in the same seconds.

## Market intelligence (`market-intel`)

Analysts and trading desks triage crypto, equity and commodity news: catalyst strength, source status, tags and thesis-relevant headlines.

### Catalyst strength (`market-intel` / `catalyst_strength`)

Score how strongly a headline is likely to move the named asset's price, from noise to a major catalyst.

Input: Any text: a market headline or short news item, ideally naming the asset or sector it concerns.

- `strength` (main decision), score: How strongly is this news likely to move the price of the asset it concerns, over the next few trading sessions? Judge materiality and surprise, not sentiment: a well-flagged or already-priced event is weak, an unexpected or structural one is strong.
  - level 0: 0 - noise: opinion, recap, vague commentary or already old news with no new information
  - level 1: 1 - minor: a small or routine development, or a figure roughly in line with expectations
  - level 2: 2 - moderate: a real development that matters to some holders but is partly expected or limited in scope
  - level 3: 3 - strong: a clear surprise or material change (earnings beat/miss, surprise rate move, large partnership) likely to move the price noticeably
  - level 4: 4 - major: a structural shock that re-rates the asset (default, hack with large losses, takeover, regulatory ban or approval, war/supply shock)

### Source status (`market-intel` / `source_status`)

Classify how firm a market claim is: unverified rumour, confirmed by a credible source, or an official announcement by the party itself.

Input: Any text: a market news item or social post making a claim about a company, token or asset.

- `status` (main decision), choice: How firm is the claim in this item, based on who is saying it? Judge the sourcing, not whether the claim is good or bad news.
  - rumour: Unverified: anonymous sources, 'people familiar', social-media speculation, leaks or 'could/might', with no named party confirming.
  - confirmed: Reported as fact by a credible named outlet or named official, or verified on-chain/filing data, but not stated by the company or issuer itself.
  - official: Stated directly by the party it concerns: the company, issuer, exchange, regulator or central bank, in its own release, filing or verified account.

### Asset and direction tagging (`market-intel` / `asset_tagging`)

Tag a headline with the asset class it concerns, the sector, and the likely price direction for that asset.

Input: Any text: a market headline or short news item.

- `asset_class`, choice: Which asset class does the news primarily concern?
  - crypto: A cryptocurrency, token, stablecoin or on-chain protocol.
  - equity: A listed company's shares or an equity index.
  - commodity: A physical commodity such as oil, gas, metals or agricultural goods.
  - fx_rates: A currency pair, interest rates or central-bank policy.
- `sector`, choice: Which sector is most relevant to the news?
  - energy: Oil, gas, power, renewables, hydrogen.
  - materials: Metals, mining, chemicals, agricultural commodities.
  - financials: Banks, exchanges, payments, central banking, rates.
  - technology: Software, chips, hardware, internet and crypto infrastructure.
  - consumer: Retail, food, autos, travel and other consumer goods.
- `direction`, choice: Based only on this news, what is the likely near-term direction for the asset it concerns?
  - bullish: The news tends to push the asset's price up.
  - bearish: The news tends to push the asset's price down.
  - neutral: Mixed, already priced in, or no clear directional read.

### Thesis reranking (`market-intel` / `thesis_reranking`)

Score ten headlines against three investment theses and surface the ones that actually bear on each thesis.

Input: An investment thesis as text. It is scored against the 10 headlines in the corpus.

- `relevant`, noul: Does this headline provide evidence for or against the investment thesis (not merely share a topic)?
  - true
  - false

## Public inbox (`public-inbox`)

Citizen e-mails to a municipality (SL, EN): route to the right department, recognise the request type, set the response deadline class and flag personal data.

### Department routing (`public-inbox` / `department`)

Route each citizen message to the municipal department that owns the matter.

Input: Any text: a message sent to the municipality's general inbox, in Slovenian or English.

- `department` (main decision), choice: Which department of a municipality owns the matter in this message? Route by the subject, not by who the writer is angry at.
  - permits: Spatial planning and building: building permits and consents, what may be built where, land-use plans, use of public space for events or stalls, a neighbour's construction.
  - utilities: Public utilities: drinking water, sewage, storm drains, waste collection and recycling centres, district heating.
  - social: Social affairs: help for families, the elderly and people in need, rent and housing subsidies, home care, kindergarten fee reductions.
  - roads: Municipal roads and traffic: potholes, snow clearing, road signs, parking, footpaths, bus stops and public street lighting.
  - tax: Municipal levies and finance: property levy or land-use fee decisions, municipal fees, payment reminders, refunds of overpayments.
  - mayor: Mayor's office: invitations and protocol, letters addressed to the mayor personally, meeting requests with the mayor, political issues and council matters.
- `language`, choice: Language of the message.
  - sl: Slovenian
  - en: English

### Request type (`public-inbox` / `request_type`)

Register the legal type of each request automatically when confident; a clerk checks the unclear ones.

Input: Any text: a citizen message (SL or EN). The confidence of the request type picks act (register automatically) / confirm (clerk confirms) / human (clerk classifies).

- `request_type` (main decision), choice: Which type of request is this? It decides the procedure and the legal deadline. If a message mixes types, pick the one that triggers a formal procedure (information request or application before complaint, complaint before question).
  - info_request: Access to public information: asks for existing documents, records, contracts, minutes or data held by the municipality, whether or not a law is cited.
  - complaint: Complaint about a service, an official's conduct, a delay or a recurring problem, by one person, without asking for documents.
  - permit_application: A formal application to start an administrative procedure: permit, consent, subsidy, connection approval, use of public space. Usually comes with attachments.
  - general_question: A question to be answered with an explanation (opening hours, how to do something, whether something is planned), not asking for documents.
  - petition: A collective request or initiative on behalf of a group (signatures, an association, 'we the residents/parents') asking the municipality or council to act.

### Response deadline (`public-inbox` / `deadline_class`)

Set the response deadline class of each message, from no legal deadline to 8 days or less.

Input: Any text: a citizen message (SL or EN). The class follows a generic municipal policy stated in the question instructions.

- `deadline` (main decision), score: Which response deadline class applies under this municipality's policy? Levels go from the least to the most urgent. Classify by the legal nature of the request, not by how angry or polite the writer is.
  - level 0: no legal deadline - thanks, suggestions, opinions, invitations, general questions and complaints without a formal request; answer under good practice
  - level 1: 2 months - application that starts an administrative procedure (permit, consent, subsidy, use of public space)
  - level 2: 20 working days - request for access to public information (existing documents, contracts, minutes, data held by the municipality)
  - level 3: 8 days or less - objection or appeal against a decision or assessment the writer has received (a short legal period is running), or a reported hazard to safety or property that needs immediate action

### Personal data flags (`public-inbox` / `personal_data`)

Flag personal data, special-category data and data about minors in each message before it is filed or published.

Input: Any text: a citizen message (SL or EN) as it would be filed in the document system.

- `personal_data`, choice: Does the message contain personal data of an identifiable person beyond a bare first-name sign-off? Aggregate statistics and anonymous descriptions are not personal data. The writer's own facts count when the writer can be identified from the message.
  - none: No identifiable personal data (general questions, statistics, a sign-off with only a first name).
  - present: Names with addresses, personal ID numbers, bank accounts, family or financial circumstances, or any facts about an identifiable person, including the writer.
- `special_category`, choice: Does it contain special-category data about an identifiable person: health or disability, religion, ethnic origin, political opinions, union membership, sexual orientation, genetic or biometric data, or criminal convictions?
  - yes: At least one special-category fact about an identifiable person.
  - no: None.
- `minors`, choice: Does it contain data about an identifiable child under 18?
  - yes: An identifiable child is named or described (age, school, condition) so that they can be recognised.
  - no: No identifiable child; children mentioned only in general or in aggregate.

## Research & documents (`research-docs`)

For analysts, knowledge teams and data teams: fact-check claims against evidence, grade answers with a rubric, tag notes and route questions safely to a data layer.

### Claim check (`research-docs` / `claim_check`)

Check whether a piece of evidence supports, contradicts or does not settle a claim.

Input: JSON {"claim", "evidence"} - the evidence text is compared with the claim. Plain text is skipped. Required JSON fields: claim, evidence.

- `verdict` (main decision), choice: Use ONLY the EVIDENCE, not outside knowledge. Compute simple arithmetic when needed (a rounding difference of up to half a percentage point still counts as matching, a larger difference does not). Watch negations: a claim that something did NOT happen is supported by evidence that it did not happen.
  - supports: The evidence states or directly implies that the claim is true, including after simple arithmetic or a restatement in other words.
  - contradicts: The evidence states or directly implies the opposite of the claim, or gives a different number, date or fact that cannot both hold with the claim.
  - not_enough_info: The evidence is related to the topic but does not settle the claim: the detail is missing, the evidence is only a range or an option that does not confirm the claim, or it speaks about something else.

### Answer vs rubric (`research-docs` / `answer_rubric`)

Grade an answer 0-4 against the rubric of its question, for exams, onboarding quizzes and eval sets.

Input: JSON {"question", "answer", "rubric"} - the answer is graded against the rubric only. Plain text is skipped. Required JSON fields: question, answer, rubric.

- `grade` (main decision), score: Grade the ANSWER to the QUESTION strictly by the RUBRIC, not by your own idea of a good answer. Credit correct content in any wording or language; ignore style and length. A confident wrong statement costs more than an omission.
  - level 0: 0 - wrong: the answer contradicts the rubric on the core point, is off topic or empty
  - level 1: 1 - mostly wrong: one small element matches the rubric but the key content is wrong or a required number or fact is incorrect
  - level 2: 2 - partial: about half of the rubric points are met, or the core is right but contains a wrong extra claim or is too vague to count as the rubric requires
  - level 3: 3 - mostly right: all key points are correct and only one required element is missing or imprecise
  - level 4: 4 - fully right: every rubric element is present and correct, with no wrong claims

### Note tagging (`research-docs` / `note_tagging`)

Tag a note with its topic, whether it needs follow-up and how sensitive it is.

Input: Any text: one personal or team note, meeting memo or snippet.

- `topic`, choice: Pick the main purpose of the note.
  - meeting: The note records a meeting, call or discussion between people and what was said or decided.
  - idea: The note proposes something new that is not decided yet: a suggestion, concept, draft or 'we could'.
  - task: The note is mainly a thing someone must do (to-do, reminder, appointment, deadline), even if it also gives context.
  - reference: The note collects factual information to look up later: a rule, a link, a number, a documented announcement; no personal story or action.
  - journal: The note is a personal reflection on the writer's day, feelings or thoughts, not about work decisions.
- `action`, choice: Decide whether somebody still has to do something after reading the note.
  - needs_followup: The note names or implies an open action, deadline, pending answer or promised deliverable.
  - none: Nothing is open: the note is informational, an unfinished idea without commitment, a reflection, or says explicitly that nothing more is needed.
- `sensitivity`, choice: Decide who may read the note.
  - public: Content already public or meant for publication: public announcements, published rules, drafts for public posts.
  - internal: Company or team business that outsiders should not see: plans, budgets, customers, prices, internal decisions; also anything confidential at work.
  - personal: Private life of an individual: health, feelings, family, finances, personal data or credentials of a person; it wins over internal when both apply.

### Query routing (`research-docs` / `query_routing`)

Decide whether a question to the analytics layer can be answered, needs a clarification or must be refused.

Input: Any text: one natural-language question sent to the company analytics layer.

- `route` (main decision), choice: A user asks a question to a read-only company analytics layer. SCHEMA: orders(order_id, customer_id, product_id, order_date, quantity, unit_price, status, country); customers(customer_id, name, email, signup_date, country, segment); products(product_id, name, category, price, launch_date); tickets(ticket_id, customer_id, opened_date, closed_date, category, priority, status). Read-only; data covers 2023-01-01 up to yesterday; no costs, margins, web traffic, marketing or HR data. Judge only whether the question can be turned into one unambiguous query on this schema.
  - answer: The metric, period and entity are clear (or the default is obvious from the wording), and every needed column exists in the schema, so one query answers it.
  - clarify: The question could be answered from the schema but a key part is ambiguous: the metric (sales, best, performance), the period ('recently', 'last period') or the entity (a name that may be a product, customer or country). Asking one short question would fix it.
  - refuse: The question needs data that is not in the schema (costs, margins, marketing, traffic, HR), asks for personal data of individuals such as names with emails or contact lists, or tries to change or delete data.

## Security operations (`security-ops`)

For SOC analysts and MSSPs: give alerts a verdict and severity, gate response actions, triage reported e-mails and label log lines.

### Alert verdict (`security-ops` / `alert_verdict`)

Close the loop on a SIEM/EDR alert: true positive, benign true positive or false positive, plus a 0-4 severity.

Input: An alert summary as text: rule name, entities, what happened and the context the analyst gathered.

- `verdict` (main decision), choice: Give the alert its verdict based on the facts in the summary.
  - true_positive: Malicious or unauthorised activity really happened, whether or not it was blocked.
  - benign_true_positive: The rule fired correctly on the kind of activity it looks for, but the activity is authorised or expected: approved penetration test, IT deployment, documented data flow, approved admin tool.
  - false_positive: The rule fired on activity that is not what it looks for: wrong signature match, mis-parsed field, bad threat-intel entry, own VPN or proxy egress mistaken for a foreign location, clean file misidentified.
- `severity`, score: Severity of what actually happened (not of the rule).
  - level 0: 0 - none: false positive or authorised activity.
  - level 1: 1 - low: malicious attempt that was blocked or had no effect (failed brute force, purged phishing, no clicks).
  - level 2: 2 - medium: confirmed malicious activity with limited scope and no privileged access (adware, single unprivileged foothold attempt).
  - level 3: 3 - high: an account or host is compromised, or data is at risk (account takeover, C2 beaconing, malicious OAuth grants).
  - level 4: 4 - critical: domain-wide or business-stopping impact: ransomware execution, new domain admin, active exfiltration from several systems.

### Response action gate (`security-ops` / `response_gate`)

Choose the containment step for a triaged incident: isolate the host, reset credentials, monitor or close. Act alone only when confident.

Input: Incident summary as text: what was detected, on which host or account, and what the analyst already confirmed.

- `action` (main decision), choice: Pick the first containment action. If both a host and an account are compromised, isolate the host first.
  - isolate_host: A host shows active compromise: malware or a web shell executing, C2 beaconing, ransomware behaviour, credential theft tooling, or lateral movement from it. Cut it off the network.
  - reset_credentials: An account is compromised or its secret is known to an attacker, with no malware on a host: credentials entered on a phishing page, valid leaked password, MFA fatigue attack, malicious OAuth grant or stolen session token. Reset password, revoke sessions and tokens.
  - monitor: Suspicious but not confirmed and nothing malicious seen executing: unusual login or tool use that may be legitimate while the owner cannot yet be reached. Add to watchlist and keep the case open.
  - close: False positive, authorised activity, or the threat is fully removed with no remaining exposure. No further action.

### Reported e-mail triage (`security-ops` / `phishing_triage`)

Employees press 'Report phishing': sort each report into phishing, spam, legitimate mail or the company's own awareness simulation.

Input: A reported e-mail as text: From, Subject, key headers (SPF/DKIM, X- headers), body excerpt and link targets. Any of EN, SL, DE, HR.

- `class` (main decision), choice: The company domain is alpina-group.example (intranet: intranet.alpina-group.example). Authorised awareness simulations are sent only by the vendor domain awareness-training.example, always carry the header X-Sim-Campaign, and link only to *.awareness-training.example. Classify the reported e-mail.
  - phishing: Tries to steal credentials, money, payment data or to run malware: look-alike or spoofed sender, login or payment link off the real domain, urgent request to pay or buy gift cards, impersonated executive. Includes look-alike fake 'simulations' that miss the X-Sim-Campaign header or use a domain other than awareness-training.example.
  - spam: Unwanted bulk or marketing mail with no attempt to steal data or money: ads, newsletters, event promotion, usually with an unsubscribe link.
  - legitimate: Genuine mail the employee should act on or may ignore: from the real company domain or a known partner, SPF/DKIM pass, links to the real domains, the request matches normal business.
  - simulation: The company's own awareness exercise: sent by awareness-training.example with an X-Sim-Campaign header and links to *.awareness-training.example, even if the content imitates phishing.

### Log line labeling (`security-ops` / `log_labeling`)

Label raw log lines in bulk: ATT&CK-style tactic, asset type, and whether an analyst ticket is needed.

Input: One raw log line (syslog, Windows event, firewall, web server, cloud or identity-provider audit).

- `tactic`, choice: Which attacker tactic does this line show? Use benign when it records normal, authorised activity.
  - initial_access: Getting a first foothold from outside: exploiting a public-facing service, external login or scan attempts against exposed services.
  - execution: Running attacker code: suspicious child processes (office app spawning a shell), encoded or hidden scripts, malicious binaries started.
  - persistence: Surviving reboots or keeping access: new scheduled tasks, run keys, services or accounts created for later use.
  - privilege_escalation: Gaining higher rights: adding accounts to admin groups, token manipulation, exploiting local privilege flaws.
  - credential_access: Stealing or guessing secrets: LSASS dumps, brute force, password spraying, Kerberoasting.
  - lateral_movement: Moving from one internal host to another with remote services: PsExec, WMI, RDP or SMB admin shares between internal hosts.
  - exfiltration: Moving data out: mail forwarding to external addresses, bulk uploads or sync tools to external storage.
  - benign: Normal authorised activity, nothing malicious in the line.
- `asset`, choice: Type of asset the line is about (where the activity happens).
  - workstation: User laptop or desktop (hostnames like WS-*, LT-*).
  - server: Application, file, web or database server (SRV-*, web hosts, Linux servers).
  - domain_controller: Active Directory domain controller (DC*).
  - cloud_identity: Cloud mailbox, SaaS tenant or identity-provider account.
  - network_device: Firewall, switch, router, VPN concentrator.
- `needs_ticket`, noul: Should an analyst open a ticket for this line? True for malicious or policy-violating activity that was not simply blocked at the perimeter; false for benign lines and blocked internet background noise.
  - true
  - false

## Trading compliance (`trading-compliance`)

Market-conduct surveillance for energy and financial trading desks: inside-information checks, suspicious order patterns, trader chat review and regulatory report routing.

### Inside-information check (`trading-compliance` / `inside_information`)

Decide whether an internal message about assets, outages or capacity must be disclosed before trading, is not inside information, or needs legal review.

Input: Any text: an internal message, operations log line or e-mail about the company's assets, capacity or market (EN or SL).

- `assessment` (main decision), choice: Under generic market-abuse and wholesale energy transparency rules, inside information is precise, non-public information that, if made public, would likely significantly affect wholesale or financial prices. For this desk, capacity changes of 100 MW or more (or an equivalent share of gas or storage capacity) count as significant. Classify the message.
  - disclose: Precise, not yet public, price-relevant information about the company's own production, storage, transmission or consumption capacity (an unplanned outage, a change to a published outage or maintenance, a cancelled supply cargo) at or above the significance threshold. Must be published on the transparency platform before anyone trades on it.
  - not_inside: Already public, too vague, below the significance threshold, general market commentary or forecasts from public data, or purely internal administration.
  - legal_review: Possibly inside information but a key element is uncertain: second-hand or unofficial information, an undecided intermediate step (a pending board decision), size close to the threshold, or information about another company's assets. Compliance or legal must decide.
- `own_asset`, noul: Is the message about an asset the company itself owns or operates?
  - true
  - false

### Order pattern surveillance (`trading-compliance` / `order_patterns`)

Classify an order-book summary as layering/spoofing, wash trading, marking the close or normal activity.

Input: JSON summary of one account's orders in a window: instrument, window, orders (counts, lifetimes, fills) and optional price_move, same_beneficial_owner, context. Plain text is skipped. Required JSON fields: instrument, window, orders.

- `pattern` (main decision), choice: Which conduct pattern best explains the order activity? Look at intent signals (orders never meant to trade, no change in beneficial ownership, timing at the reference price), not at volume or cancellation rate alone.
  - layering_spoofing: Large or multiple orders on one side that are not meant to execute (short lifetimes, placed away from or just behind the best price, cancelled as soon as an order on the OTHER side fills), creating a false impression of supply or demand.
  - wash_trade: Trades where buyer and seller are the same beneficial owner or colluding accounts, so there is no real change of ownership or net position; often same price, same volume, circular or back-to-back.
  - marking_close: Aggressive orders concentrated just before a closing, settlement or fixing window to move the reference price, especially when the account benefits from that price (positions valued or expiring at settlement).
  - normal: Legitimate activity: market making on both sides with fills, cancellations that follow genuine price moves, hedges or client orders executed over time, or late trades explained by a documented client or hedge need.
- `escalate`, noul: Should this alert be escalated to compliance for a full investigation?
  - true
  - false

### Trader chat surveillance (`trading-compliance` / `chat_surveillance`)

Screen trader chat lines: escalate clear misconduct, queue ambiguous lines for review, clear normal business.

Input: Any text: one trader chat or e-mail line (EN or SL). The confidence of the action picks act / confirm / human.

- `action` (main decision), choice: What should compliance do with this message? Judge conduct risk, not tone: rude or dramatic language about the market is not misconduct.
  - escalate: Clear sign of market abuse or a serious breach: trading on or passing on non-public information, agreeing prices, bids or market sharing with a competitor, arranging wash or matched trades, intent to move a closing or settlement price.
  - review: Ambiguous or a policy concern that needs a human look: hints at non-public information without details, moving the conversation to unmonitored channels, requests to delete or keep quiet, gifts or entertainment linked to business, coded language.
  - ok: Normal business: views based on public data, logistics, nominations, scheduling, reports, banter with no conduct risk.

### Regulatory report routing (`trading-compliance` / `report_routing`)

Label each compliance event with the report it belongs to and its asset class.

Input: Any text: a short description of a trade, order set, data feed or incident that may need regulatory reporting.

- `report_type`, choice: Which regulatory report or publication does this event go into?
  - transaction_report: An executed trade or contract (exchange or bilateral OTC) that must be reported to the regulator or a trade repository.
  - order_report: Orders and bids placed on an organised market or auction, including modifications and cancellations, whether or not they executed.
  - inside_info_disclosure: Public disclosure of inside information about the company's own assets (outages, capacity changes) on a transparency platform.
  - suspicious_report: A report to the competent authority about suspected market abuse (insider dealing, manipulation) by anyone, including own staff or clients.
  - fundamental_data: Routine capacity, nomination, usage or availability data of facilities supplied to transparency feeds, not tied to a specific unplanned event.
- `asset_class`, choice: Asset class of the underlying. Derivatives on a commodity belong to that commodity.
  - power: Electricity products and power derivatives.
  - gas: Natural gas, LNG, gas storage and gas derivatives.
  - emissions: Emission allowances and their derivatives.
  - securities: Shares, bonds and other financial instruments not based on energy or emissions.

## Images & video (`vision`)

Decisions from a photo, a screenshot, a chart or a short clip (frames): document intake, photo quality, screenshot triage, chart reading, motion and status lights.

### Document photo intake (`vision` / `document_photo`)

A photo of a receipt, invoice, shipping label or handwritten note: what is it, can it be read, is the total above 100?

Input: One photo or scan of a document. Needs image.

- `doc_type` (main decision), choice: What kind of document is in the image?
  - receipt: A narrow till receipt from a shop or restaurant, monospaced item lines and a total.
  - invoice: A business invoice with an invoice number, a billed company, a table of services and a total due.
  - shipping_label: A parcel shipping label with an address block, a barcode and a tracking number.
  - handwritten_note: A handwritten note or list on ruled paper.
- `legible`, noul: Is the text in the image sharp enough to be read reliably? False when it is blurred or out of focus.
  - true
  - false
- `total_over_100`, noul: Does the document show a total amount above 100? False when the total is 100 or less, or when the document has no total.
  - true
  - false

### Product photo quality gate (`vision` / `photo_quality`)

Marketplace or catalog upload check: can this product photo be published as is, or does it need a retake?

Input: One product photo. Needs image.

- `verdict` (main decision), choice: How is the technical quality of this product photo?
  - ok: Well exposed, sharp, the product is clearly visible.
  - too_dark: Underexposed: the image is very dark and details are lost.
  - overexposed: Overexposed: washed out, bright white haze, colours and details are lost.
  - blurry: Out of focus or motion blurred: edges and text are soft.
- `publishable`, noul: Can this photo be published as it is?
  - true
  - false

### Screenshot triage (`vision` / `screenshot_triage`)

A user sends a screenshot of a message box: how serious is it, and does a person need to look?

Input: A screenshot of an application message or alert dialog. Needs image.

- `severity` (main decision), choice: What severity does the message in the screenshot report?
  - critical: A failure that stops work or loses data: crashes, outages, failed payments, full disks.
  - warning: Something that will become a problem soon if ignored: expiring certificates, low space, quota nearly used.
  - info: Neutral information: updates, notices, tips, replies.
  - success: A confirmation that something finished correctly.
- `needs_human`, noul: Should a person act on this message today? True for critical and warning messages.
  - true
  - false

### Chart trend reading (`vision` / `chart_trend`)

A dashboard screenshot or chart image goes in; the trend of the line comes out. Useful for reports and monitoring snapshots.

Input: A line chart image. Needs image.

- `trend` (main decision), choice: What does the line in the chart do over the period?
  - rising: The values go up steadily from left to right.
  - falling: The values go down steadily from left to right.
  - flat: The values stay about the same.
  - spike: The values are low and stable except one sudden peak.

### Bar chart leader (`vision` / `bar_leader`)

Which category leads in a bar chart image, A to D.

Input: A bar chart image with four labelled bars. Needs image.

- `highest` (main decision), choice: Which bar is the highest?
  - A: The bar labelled A.
  - B: The bar labelled B.
  - C: The bar labelled C.
  - D: The bar labelled D.

### Video: motion direction (`vision` / `video_motion`)

Six frames of a short clip: which way does the object move, and does it cross the line? The client extracts the frames.

Input: A short clip as 2-8 frames in time order. Needs video.

- `direction` (main decision), choice: How does the ball move over the clip?
  - left_to_right: It moves horizontally from the left side to the right side.
  - right_to_left: It moves horizontally from the right side to the left side.
  - down: It moves vertically from the top to the bottom.
  - up: It moves vertically from the bottom to the top.
  - still: It stays in the same place.
- `crossed_line`, noul: Does the ball cross the vertical line in the middle during the clip?
  - true
  - false

### Video: status light (`vision` / `video_status_light`)

Camera on a machine status light: which lamp is lit at the end of the clip and did it change? The client extracts the frames.

Input: A short clip as 2-8 frames in time order, showing a three-lamp status light. Needs video.

- `final_state` (main decision), choice: Which lamp is lit in the last frame?
  - red: The red lamp is lit.
  - amber: The amber lamp is lit.
  - green: The green lamp is lit.
- `changed`, noul: Did the lit lamp change at some point during the clip?
  - true
  - false

## Working time & absence (`workforce-time`)

For HR, payroll and shift planners: classify absence messages, check timesheets against EU-style rest, break, night and overtime rules, and route corrections and shift swaps.

### Absence messages (`workforce-time` / `absence_type`)

Label free-text absence messages from employees (EN, SL, DE, HR) with absence type, timing and language.

Input: A short message from an employee to their manager or HR (chat, e-mail, SMS), in any of EN, SL, DE, HR.

- `type`, choice: Which absence type should be recorded for the person who wrote the message?
  - sick_leave: The employee themself is ill or injured, or has a doctor's appointment or treatment for their own health.
  - annual_leave: Paid holiday / vacation days taken from the annual leave balance, including half days and bridge days.
  - family_care: Caring for a sick or injured family member (child, partner, parent), including accompanying them to a doctor.
  - unpaid_leave: Leave explicitly without pay, or the employee asks for time off after their paid leave is used up.
  - business_trip: The employee works away from the usual workplace on the employer's behalf: client visit, fair, training ordered by the employer, travel to another site.
  - other: Any other paid or special absence: own wedding, moving house, death in the family, blood donation, jury or court duty, military service, or a message that is not an absence request.
- `timing`, choice: When is the absence relative to the message?
  - past: The absence already happened (reported afterwards).
  - today: Starts today or right now (same-day notice).
  - planned: Starts on a later day (requested in advance).
- `language`, choice: Language of the message.
  - en: English
  - sl: Slovenian
  - de: German
  - hr: Croatian

### Timesheet rule check (`workforce-time` / `timesheet_check`)

Check one day record against daily rest, weekly rest, night shift length, breaks and overtime caps, and name the rule that is breached.

Input: JSON day record {"employee", "prev_shift_end", "start", "end", "break_min", "days_in_row", "week_overtime_h", "year_overtime_h"} with ISO local times. Overtime totals and days_in_row already include this day. Plain text is skipped. Required JSON fields: prev_shift_end, start, end, break_min.

- `breach` (main decision), choice: Rules: (1) daily rest: at least 11 consecutive hours between prev_shift_end and start; (2) weekly rest: at least one full day off in every 7 days, so days_in_row of 7 or more is a breach; (3) night shift: a shift with 3 or more hours between 23:00 and 06:00 may have at most 8 hours of work (end - start - break_min); (4) break: more than 6 hours of work needs a break of at least 30 minutes; (5) annual overtime cap 170 h; (6) weekly overtime cap 8 h. Exactly at a limit is allowed. If several rules are breached, return the first in this order.
  - daily_rest: Less than 11 hours between prev_shift_end and start.
  - weekly_rest: days_in_row is 7 or more (no full day off in the last 7 days).
  - night_shift: The shift has 3 or more hours between 23:00 and 06:00 and more than 8 hours of work after the break.
  - break: More than 6 hours of work (end - start - break_min) and break_min below 30.
  - overtime_year: year_overtime_h above 170.
  - overtime_week: week_overtime_h above 8.
  - none: No rule is breached; values exactly at a limit are allowed.

### Correction requests (`workforce-time` / `correction_gate`)

Route clock-in/out and absence corrections: approve automatically, ask the manager, or send to HR, with a confidence gate on top.

Input: JSON correction request {"requested_by", "relation" (self | direct_manager | other), "record_date", "submitted", "period_locked", "kind", "change", "minutes_delta", "new_overtime_h", "reason"}, optional "rest_after_change_h". Plain text is skipped. Required JSON fields: relation, kind, change.

- `route` (main decision), choice: Route this working-time correction request. Check hr_review conditions first, then manager_confirm, then auto_approve.
  - auto_approve: All of: the employee corrects their own record (relation self), kind shift_time, change of 15 minutes or less, record_date is the submission day or the day before, period not locked, creates no new overtime, and a reason is given.
  - manager_confirm: Not an HR case, but not small enough to auto-approve: adds a missing clock-in or clock-out, changes more than 15 minutes and up to 2 hours, record older than the day before (up to 30 days), creates new overtime of up to 2 hours, no reason given, or submitted by the employee's direct manager.
  - hr_review: Any of: the payroll period is locked, the change is more than 2 hours, the absence type is changed (e.g. sick leave to annual leave), the change creates a rule breach (rest_after_change_h below 11, overtime above 2 h), record older than 30 days, or the request edits someone else's record and the requester is not their direct manager (relation other).

### Shift-swap validation (`workforce-time` / `shift_swap`)

Validate a shift swap between two employees: approve, reject for rest, qualification or hours, or send it to the manager.

Input: JSON swap request {"shift": {start, end, unit, requires}, "giver", "taker": {name, unit, qualifications, prev_end, next_start, week_hours_after, week_overtime_after_h}, "submitted"}. All times ISO local. Plain text is skipped. Required JSON fields: shift, taker.

- `decision` (main decision), choice: Validate the swap from the taker's point of view (the person who would work the shift). Rest: at least 11 hours from taker.prev_end to shift.start and from shift.end to taker.next_start. Hours: at most 48 hours in the week and at most 8 hours of weekly overtime after the swap. Exactly at a limit is allowed. If several options apply, return the first in this order: reject_rest, reject_qualification, reject_hours, needs_manager, approve.
  - reject_rest: The taker would have less than 11 hours of rest before or after the shift.
  - reject_qualification: The taker lacks at least one item listed in shift.requires.
  - reject_hours: After the swap the taker would exceed 48 hours in the week (week_hours_after > 48) or 8 hours of weekly overtime (week_overtime_after_h > 8).
  - needs_manager: No rule is broken, but the taker belongs to a different unit than the shift, or the request was submitted less than 24 hours before shift.start.
  - approve: Same unit, all required qualifications present, rest and hours within limits, submitted at least 24 hours before the shift.
