julianvolodia's picture
Super-squash branch 'main' using huggingface_hub
90264a9
Raw History Blame Contribute Delete
24.6 kB
"""Prompts (Polish) for DeepSeek. Layout: constant SYSTEM, then MATERIALS first in the user message (shared prefix
between author, blind solver and verifier calls -> DeepSeek context cache hits), then the task-specific part."""
SYS = ("Jesteś doświadczonym autorem i egzaminatorem zadań maturalnych CKE z historii (poziom rozszerzony) oraz "
"historykiem-redaktorem. Piszesz poprawną polszczyzną, w stylu arkuszy CKE. Fakty opierasz na dostarczonych "
"fragmentach polskiej Wikipedii (MATERIAŁY) i na ugruntowanej wiedzy podręcznikowej; nie wymyślasz faktów, dat, "
"nazw, cytatów ani źródeł. Odpowiadasz wyłącznie jednym obiektem JSON w podanym formacie (json).")
FRAG_RULES = ("Zasady tekstu źródłowego: wybierz jeden fragment [Pn] z MATERIAŁÓW i skopiuj z niego DOSŁOWNIE 1–4 "
"kolejne całe zdania (150–600 znaków). Możesz pominąć zdanie, jego część albo nawias, oznaczając "
"opuszczenie „[…]”; nawiasy z nazwami obcojęzycznymi, wymową lub datami życia usuń bez oznaczania; nie "
"zmieniaj, nie dopisuj i nie odmieniaj żadnego słowa – program porównuje cytat z artykułem znak po znaku. "
"Cytat ma być zrozumiały bez kontekstu (nie zaczynaj od „Z tego powodu”, „Ten”, „Jego”). Nie dodawaj podpisu „Tekst 1.” – program sam doda podpis z tytułem artykułu.")
WIKI_CHECK_RULES = ('"wiki_check" – ocena ORYGINAŁU względem MATERIAŁÓW: "status": "zgodne" (MATERIAŁY potwierdzają '
'kluczowe fakty), "konflikt" (MATERIAŁY przeczą treści, kluczowi lub dystraktorowi – w "dowody" podaj '
'dosłowny cytat, maks. 200 znaków), "brak_danych" (MATERIAŁY nie pozwalają tego sprawdzić); '
'"uwagi": 1–2 zdania.')
WIKI_CHECK_JSON = '"wiki_check": {"status": "zgodne", "uwagi": "…", "dowody": [{"id": "P1", "cytat": "…"}]}'
def materials(passages):
if not passages:
return "MATERIAŁY: brak fragmentów – korzystaj wyłącznie z ugruntowanej wiedzy podręcznikowej."
out = ["MATERIAŁY – fragmenty artykułów polskiej Wikipedii (CC BY-SA 4.0):"]
for i, p in enumerate(passages, 1):
tag = f" [element {p['element']})]" if p.get("element") else ""
out.append(f"[P{i}] „{p['title']}” – {p['section']}{tag}\n{p['text']}")
return "\n\n".join(out)
def msgs(passages, task):
return [{"role": "system", "content": SYS},
{"role": "user", "content": materials(passages) + "\n\n---\n" + task}]
# ---------------------------------------------------------------- stage 1: linking originals to Wikipedia
def link(r, essay_parts=None):
if r["task_type"] == "essay":
gk = r.get("grading_key") or {}
ow = "\n".join(f"{e.get('element', '')}: " + "; ".join((e.get("oczekiwana_wiedza") or [])[:6])
for e in gk.get("elementy", []))
task = (f"TEMAT WYPRACOWANIA (matura z historii, poziom rozszerzony):\n{r['question']}\n\n"
f"OCZEKIWANA WIEDZA (z klucza):\n{ow}\n\n"
"Wskaż artykuły polskiej Wikipedii potrzebne do sprawdzenia klucza i do argumentacji.\n"
"Zwróć json:\n"
'{"elementy": {"a": ["tytuł", "tytuł"], "b": ["…"], "c": ["…"]}, "zapytanie": "…", '
'"twierdzenia": ["…", "…"]}\n'
"- dla każdego elementu 1–3 dokładne tytuły haseł polskiej Wikipedii w formie nagłówka artykułu, "
"w mianowniku (np. „Unia lubelska”, „Bitwa pod Grunwaldem”, „Franciszek Ksawery Drucki-Lubecki”); "
"hasła szczegółowe (osoba, wydarzenie, traktat, instytucja) przed ogólnymi;\n"
"- \"zapytanie\": 3–6 słów kluczowych w formie podstawowej;\n"
"- \"twierdzenia\": 3–6 krótkich zdań faktograficznych z klucza do sprawdzenia w Wikipedii.")
else:
task = (f"ZADANIE (matura z historii, poziom rozszerzony):\n{r['question']}\n\nKLUCZ: {r['key_answer']}\n\n"
"Wskaż artykuły polskiej Wikipedii potrzebne do sprawdzenia treści zadania i klucza.\n"
"Zwróć json:\n"
'{"tytuly": ["…", "…"], "zapytanie": "…", "encja_odpowiedzi": null, "twierdzenia": ["…", "…"]}\n'
"- \"tytuly\": 1–3 dokładne tytuły haseł polskiej Wikipedii w formie nagłówka artykułu, w mianowniku "
"(np. „Unia lubelska”, „Bitwa pod Grunwaldem”, „Powstanie listopadowe”, „Franciszek Ksawery "
"Drucki-Lubecki”); hasła szczegółowe (osoba, wydarzenie, traktat, instytucja) przed ogólnymi;\n"
"- \"zapytanie\": 3–6 słów kluczowych w formie podstawowej;\n"
"- \"encja_odpowiedzi\": gdy zadanie każe podać/rozpoznać nazwę, postać, wydarzenie – tytuł hasła o "
"poprawnej odpowiedzi, w przeciwnym razie null;\n"
"- \"twierdzenia\": 2–5 krótkich zdań faktograficznych, które zadanie i klucz przyjmują za prawdziwe.")
return [{"role": "system", "content": SYS}, {"role": "user", "content": task}]
# ---------------------------------------------------------------- stage 3: variants of originals
def src_rule(parent_has_src, allow_new, kind):
if parent_has_src:
return ("Oryginał ma tekst źródłowy opracowany syntetycznie – zastąp go PRAWDZIWYM fragmentem z MATERIAŁÓW i "
"dostosuj do niego polecenie. Fragment nie może wprost podawać poprawnej odpowiedzi, chyba że polecenie "
"każe odczytać informację z tekstu. Gdy żaden fragment nie pasuje – \"zrodlo\": null i polecenie "
"oparte na własnej wiedzy." + (" W zadaniu porównawczym możesz dać dwa fragmenty („zrodlo” i "
"„zrodlo2”, każdy maks. 400 znaków)." if kind == "open_compare" else ""))
if allow_new:
return ("Oryginał nie ma tekstu źródłowego. Jeśli któryś fragment MATERIAŁÓW dobrze pasuje do polecenia, dodaj "
"go jako tekst źródłowy (polecenie zacznij wtedy od „Na podstawie tekstu i własnej wiedzy…”); "
"w przeciwnym razie \"zrodlo\": null.")
return "Oryginał nie ma tekstu źródłowego – wariant też go nie ma (\"zrodlo\": null)."
def variant_mcq(passages, r, correct_letter, correct_text, has_src):
task = (f"ZADANIE ORYGINALNE (zamknięte, jednokrotnego wyboru):\n{r['question']}\n"
f"Poprawna odpowiedź: {correct_letter}. {correct_text}\n\n"
"Napisz WARIANT tego zadania: ta sama wiedza i ta sama poprawna odpowiedź, inne sformułowanie.\n"
"1. Przeformułuj polecenie i trzon (inna składnia lub inny punkt wyjścia, co najmniej 40% innych słów). "
"Treści opcji A–D NIE zmieniaj i nie przepisuj – program zachowa je bez zmian i ustali nową kolejność; "
"trzon musi pasować gramatycznie i logicznie do tych samych opcji.\n"
f"2. {src_rule(has_src, False, 'mcq')}\n{FRAG_RULES}\n"
f"3. {WIKI_CHECK_RULES}\n"
"Zwróć json:\n"
'{"polecenie": "Dokończ zdanie. Wybierz właściwą odpowiedź spośród podanych.", "trzon": "…", '
'"zrodlo": {"id": "P2", "fragment": "…"}, ' + WIKI_CHECK_JSON + "}\n"
'("polecenie" może być pustym napisem, jeśli trzon jest pytaniem; "zrodlo": null, gdy bez tekstu).')
return msgs(passages, task)
def variant_tf(passages, r, has_src):
task = (f"ZADANIE ORYGINALNE (prawda/fałsz):\n{r['question']}\nKlucz: {r['key_answer']}\n\n"
"Napisz WARIANT: przeredaguj każde z trzech zdań (inna składnia i słownictwo), ZACHOWUJĄC jego wartość "
"logiczną i to, co sprawdza – zdanie prawdziwe pozostaje prawdziwe, fałszywe pozostaje fałszywe z tym samym "
"błędem merytorycznym. Nie zmieniaj faktów. Możesz przeredagować zdanie wprowadzające („wstep”). Kolejność "
"zdań ustali program – przy każdym zdaniu podaj jego numer w oryginale.\n"
f"{src_rule(has_src, False, 'tf')}\n{FRAG_RULES}\n{WIKI_CHECK_RULES}\n"
"Zwróć json:\n"
'{"wstep": "… albo pusty napis", "zdania": [{"nr": 1, "tekst": "…"}, {"nr": 2, "tekst": "…"}, '
'{"nr": 3, "tekst": "…"}], "zrodlo": null, ' + WIKI_CHECK_JSON + "}")
return msgs(passages, task)
def variant_open(passages, r, has_src, allow_new, identify):
p = r["max_points"]
task = (f"ZADANIE ORYGINALNE (otwarte, {r['task_type']}, {p} pkt):\n{r['question']}\n"
f"Zasady oceniania:\n{r['rubric']}\nPrzykładowe rozwiązanie: {r['key_answer']}\n\n"
"Napisz WARIANT: to samo zagadnienie, ta sama umiejętność i ta sama liczba punktów, inaczej sformułowane "
"polecenie (co najmniej 40% innych słów).\n"
f"- {src_rule(has_src, allow_new, r['task_type'])}\n{FRAG_RULES}\n"
+ ("- Polecenie każe podać/rozpoznać nazwę, postać lub wydarzenie: tekst źródłowy NIE może zawierać "
"odpowiedzi – zastąp ją w cytacie opuszczeniem „[…]”.\n" if identify else "") +
"- \"polecenie\": pełna treść polecenia (bez nagłówka „Zadanie N.” i bez tekstu źródłowego).\n"
"- \"klucz\": przykładowe poprawne rozwiązanie, zwięźle jak w kluczu CKE, uzupełnione o 1–2 konkretne "
"fakty z MATERIAŁÓW.\n"
f"- \"zasady\": zasady oceniania w stylu CKE: linie „{p} pkt – …”"
+ (", „1 pkt – …”" if p == 2 else "") + ", „0 pkt – odpowiedź niepełna lub błędna albo brak odpowiedzi.”\n"
f"- {WIKI_CHECK_RULES}\n"
"Zwróć json:\n"
'{"polecenie": "…", "zrodlo": {"id": "P1", "fragment": "…"}, "zrodlo2": null, "klucz": "…", '
'"zasady": "…", ' + WIKI_CHECK_JSON + "}")
return msgs(passages, task)
def variant_essay(passages, r, thesis, elements):
gk = r.get("grading_key") or {}
ow = "\n".join(f"{e.get('element', '')}: " + "; ".join((e.get("oczekiwana_wiedza") or [])[:8])
for e in gk.get("elementy", []))
task = (f"TEMAT WYPRACOWANIA (oryginał):\n{thesis}\nElementy:\n" + "\n".join(elements) +
f"\nOczekiwana wiedza (z klucza):\n{ow}\n\n"
"1. Przeformułuj TYLKO temat – ten sam problem i ta sama teza do oceny, inne sformułowanie (np. „Oceń, czy…”, "
"„Rozstrzygnij, czy…”, „Zweryfikuj tezę, że…”, inna perspektywa tezy); temat musi nadal pasować do "
"niezmienionych elementów a)–c).\n"
"2. Dla każdego elementu (a, b, c) podaj 2–3 fakty z MATERIAŁÓW przydatne w argumentacji, każdy z dosłownym "
"cytatem (maks. 200 znaków) i numerem fragmentu.\n"
"3. Sprawdź „oczekiwaną wiedzę” z klucza w MATERIAŁACH. " + WIKI_CHECK_RULES + "\n"
"Zwróć json:\n"
'{"temat": "…", "wiki_facts": [{"element": "a", "fakt": "…", "id": "P1", "cytat": "…"}], '
+ WIKI_CHECK_JSON + "}")
return msgs(passages, task)
# ---------------------------------------------------------------- verification
def blind(passages, question, kind):
fmt = '{"odpowiedz": "B"}' if kind == "mcq" else '{"odpowiedz": "1. P, 2. F, 3. P"}'
return msgs(passages, f"Rozwiąż zadanie maturalne z historii. Zwróć json: {fmt}\n\n{question}")
def verify_variant(passages, parent, var, fields_hint):
task = ("Jesteś recenzentem (historyk, egzaminator CKE). Oceń WARIANT zadania względem ORYGINAŁU i MATERIAŁÓW.\n\n"
f"ORYGINAŁ:\n{parent['question']}\nKlucz: {parent['key_answer']}\n\n"
f"WARIANT:\n{var['question']}\nKlucz: {var['key_answer']}\n"
+ (f"Zasady oceniania wariantu:\n{var['rubric']}\n" if parent["task_type"].startswith("open") else "") +
"\nSprawdź: (1) wariant sprawdza tę samą wiedzę i ma tę samą poprawną odpowiedź co oryginał (P/F: te same "
"wartości logiczne odpowiadających sobie zdań); (2) fakty w treści, kluczu i zasadach są poprawne; "
"(3) zadanie jest jednoznaczne (zamknięte: dokładnie jedna poprawna odpowiedź); (4) tekst źródłowy pasuje "
"do polecenia, a w zadaniach „podaj/rozpoznaj” nie zawiera odpowiedzi; (5) poprawna polszczyzna i styl CKE; "
"(6) wariant nie jest kosmetyczną kopią oryginału.\n"
"Klucz to przykładowe rozwiązanie: może zawierać dodatkowe poprawne fakty i przykłady – nie jest to błąd; "
"zgłaszaj tylko błędy merytoryczne, niezgodność klucza z poleceniem lub zasadami oceniania i "
"niejednoznaczność.\n"
'Zwróć json: {"problemy": ["…"], "decyzja": "ok", "poprawka": null}\n'
'"problemy": tylko rzeczywiste błędy (maks. 3, każdy do 30 słów), pusta lista gdy ich brak; '
'"decyzja": "ok" (bez zastrzeżeń), "popraw" (drobny błąd – wtedy "poprawka" zawiera poprawione pola: '
f"{fields_hint}), \"odrzuc\" (błąd merytoryczny lub niejednoznaczność, której nie da się łatwo naprawić).")
return msgs(passages, task)
def verify_essay_variant(passages, parent_thesis, var_thesis, elements):
task = ("Jesteś recenzentem (historyk, egzaminator CKE). Porównaj dwa sformułowania tematu wypracowania.\n"
f"TEMAT ORYGINALNY: {parent_thesis}\nNOWY TEMAT: {var_thesis}\nElementy (wspólne):\n" + "\n".join(elements) +
"\n\nSprawdź: (1) nowy temat stawia ten sam problem/tezę do oceny; (2) pasuje do elementów a)–c); "
"(3) jest poprawny merytorycznie i językowo, w stylu CKE; (4) nie jest kosmetyczną kopią.\n"
'Zwróć json: {"problemy": ["…"], "decyzja": "ok", "poprawka": null}\n'
'"problemy": tylko rzeczywiste błędy (maks. 3, każdy do 30 słów), pusta lista gdy ich brak; '
'"decyzja": "ok" | "popraw" (wtedy "poprawka": {"temat": "…"}) | "odrzuc".')
return msgs(passages, task)
# ---------------------------------------------------------------- stage 4: NEW tasks from the curriculum inventory
GEN_COMMON = ("Zasady:\n"
"- fakty wyłącznie potwierdzone w MATERIAŁACH albo ugruntowana wiedza podręcznikowa; nie wymyślaj dat, "
"nazw ani cytatów; unikaj spornych interpretacji jako jedynej poprawnej odpowiedzi;\n"
"- w polu \"fakty\" każdego zadania podaj 1–2 dosłowne cytaty (maks. 200 znaków) z MATERIAŁÓW, które "
"potwierdzają klucz (\"id\": numer fragmentu);\n"
"- zadanie z tekstem źródłowym ma pole \"zrodlo\" (dosłowny fragment) i polecenie odwołujące się do tekstu "
"(„Na podstawie tekstu i własnej wiedzy…”); tekst nie może wprost podawać odpowiedzi; zadanie bez tekstu "
"ma \"zrodlo\": null i nie odwołuje się do żadnego tekstu;\n"
"- bez odwołań do ilustracji, map i tabel; nie kopiuj zadań z arkuszy CKE; poprawna polszczyzna, styl CKE;\n"
"- każde zadanie dotyczy innego zagadnienia (także względem listy już wykorzystanych) i sprawdza wiedzę "
"na poziomie matury rozszerzonej: konkretne fakty, związki przyczynowo-skutkowe, chronologię, pojęcia – "
"nie oczywistości;\n"
"- \"wstep\" to tylko zdanie kontekstu (bez polecenia – polecenie „Oceń prawdziwość zdań…” doda program).\n")
def gen_closed(passages, req, specs, used):
spec = "\n".join(f"{i + 1}) {'wybór jednej odpowiedzi (mcq)' if s['typ'] == 'mcq' else 'prawda/fałsz (pf)'}, "
f"{'Z tekstem źródłowym' if s['src'] else 'bez tekstu źródłowego'}" for i, s in enumerate(specs))
task = (f"Wymaganie podstawy programowej {req['req']} (rozdział {req['chapter']} „{req['chapter_title']}”): "
f"{req['text']}\nZagadnienia pomocnicze: {'; '.join(req.get('issues', [])[:8])}\n"
+ (f"Już wykorzystane w tym wymaganiu (nie powtarzaj): {' | '.join(used[-15:])}\n" if used else "") +
f"\nNapisz {len(specs)} NOWYCH zadań zamkniętych w stylu CKE (matura z historii, poziom rozszerzony) "
f"sprawdzających to wymaganie, dokładnie w tej kolejności:\n{spec}\n\n" + GEN_COMMON +
"- mcq: \"polecenie\" w stylu CKE („Dokończ zdanie. Wybierz właściwą odpowiedź spośród podanych.” albo "
"„Wybierz właściwą odpowiedź spośród podanych.”), \"trzon\" = początek zdania albo pytanie; dokładnie jedna "
"poprawna odpowiedź i 3 wiarygodne, ale jednoznacznie błędne dystraktory z tej samej epoki; opcje zwięzłe, "
"o podobnej długości i budowie, pasujące gramatycznie do trzonu; bez „wszystkie/żadna z powyższych”; "
"program sam ustali kolejność opcji;\n"
"- pf: \"wstep\" (1 zdanie kontekstu albo pusty napis) i 3 zdania do oceny; co najmniej jedno prawdziwe i "
"jedno fałszywe; fałsz przez zmianę faktu (data, osoba, miejsce, skutek), a nie przez samo „nie”; przy "
"tekście źródłowym zdania NIE powtarzają tekstu – sprawdzają wiedzę związaną z tekstem (kontekst, skutki, "
"postaci, daty), której w cytacie nie ma;\n"
"- mcq z tekstem źródłowym: cytat opisuje tło lub okoliczności, a pytanie dotyczy tego, czego w cytacie NIE "
"ma (np. skutek, nazwa, data, postać) – poprawna odpowiedź nie może być zapisana w cytacie;\n"
f"{FRAG_RULES}\n"
"Zwróć json:\n"
'{"zadania": [{"typ": "mcq", "polecenie": "…", "trzon": "…", "poprawna": "…", "dystraktory": ["…", "…", '
'"…"], "zrodlo": null, "fakty": [{"id": "P1", "cytat": "…"}]}, {"typ": "pf", "wstep": "…", "zdania": '
'[{"tekst": "…", "prawda": true}, {"tekst": "…", "prawda": false}, {"tekst": "…", "prawda": true}], '
'"zrodlo": {"id": "P2", "fragment": "…"}, "fakty": [{"id": "P2", "cytat": "…"}]}]}')
return msgs(passages, task)
OPEN_DESC = {"open_explain": "wyjaśnij (przyczyny, skutki, znaczenie, mechanizm)",
"open_identify": "podaj/rozpoznaj (nazwa, postać, wydarzenie, pojęcie) z krótkim uzasadnieniem",
"open_compare": "porównaj (podobieństwo i/lub różnica)",
"open_argument": "sformułuj argument(y) za/przeciw tezie albo rozstrzygnij i uzasadnij",
"open_chronology": "uporządkuj chronologicznie albo przyporządkuj daty/okresy (z uzasadnieniem, gdy trzeba)"}
def gen_open(passages, req, specs, used):
spec = "\n".join(f"{i + 1}) {s['typ']} – {OPEN_DESC[s['typ']]}; {s['pkt']} pkt; "
+ ("z DWOMA tekstami źródłowymi (zrodlo i zrodlo2, każdy maks. 400 znaków)" if s['src'] == 2 else
"z tekstem źródłowym" if s['src'] else "bez tekstu źródłowego") for i, s in enumerate(specs))
task = (f"Wymaganie podstawy programowej {req['req']} (rozdział {req['chapter']} „{req['chapter_title']}”): "
f"{req['text']}\nZagadnienia pomocnicze: {'; '.join(req.get('issues', [])[:8])}\n"
+ (f"Już wykorzystane w tym wymaganiu (nie powtarzaj): {' | '.join(used[-15:])}\n" if used else "") +
f"\nNapisz {len(specs)} NOWYCH zadań otwartych w stylu CKE (matura z historii, poziom rozszerzony) "
f"sprawdzających to wymaganie, dokładnie w tej kolejności:\n{spec}\n\n" + GEN_COMMON +
"- \"polecenie\": pełna treść polecenia (bez nagłówka „Zadanie N.” i bez tekstu źródłowego); jednoznaczne, "
"możliwe do rozwiązania w kilku zdaniach;\n"
"- w zadaniach „podaj/rozpoznaj” tekst źródłowy nie może zawierać odpowiedzi – zastąp ją „[…]”;\n"
"- \"zasady\": zasady oceniania w stylu CKE: dla 1 pkt linie „1 pkt – …” i „0 pkt – odpowiedź niepełna "
"lub błędna albo brak odpowiedzi.”; dla 2 pkt linie „2 pkt – …”, „1 pkt – …”, „0 pkt – …”;\n"
"- \"klucz\": przykładowe poprawne rozwiązanie (zwięźle, jak w kluczu CKE; gdy możliwych jest kilka "
"odpowiedzi – podaj przykłady);\n"
f"{FRAG_RULES}\n"
"Zwróć json:\n"
'{"zadania": [{"typ": "open_explain", "punkty": 2, "zrodlo": {"id": "P1", "fragment": "…"}, "zrodlo2": '
'null, "polecenie": "…", "zasady": "2 pkt – …\\n1 pkt – …\\n0 pkt – odpowiedź niepełna lub błędna albo '
'brak odpowiedzi.", "klucz": "…", "fakty": [{"id": "P1", "cytat": "…"}]}]}')
return msgs(passages, task)
def gen_essay(passages, focus, angles, used, angle_desc):
ang = "\n".join(f"{i + 1}) ujęcie: {angle_desc[a]}" for i, a in enumerate(angles))
task = (f"Rozdział {focus['chapter']} „{focus['chapter_title']}”. Ognisko tematyczne: „{focus['focus']}”"
f" ({focus.get('period') or ''}).\n"
+ (f"Tematy już wykorzystane w tym ognisku (nie powtarzaj): {' | '.join(used[-10:])}\n" if used else "") +
f"\nNapisz {len(angles)} NOWE tematy wypracowań maturalnych (historia, poziom rozszerzony, styl CKE), "
f"każdy w innym ujęciu:\n{ang}\n\n"
"Każdy temat: teza lub problem do oceny („Oceń, czy…”, „Rozstrzygnij, czy…”, „Zweryfikuj tezę, że…”, "
"„Porównaj… i oceń…”), możliwy do rozstrzygnięcia na podstawie wiedzy licealnej, z trzema elementami "
"a), b), c) – rozłącznymi obszarami argumentacji (np. polityka, społeczeństwo, gospodarka, kultura albo "
"trzy etapy), każdy do rozwinięcia w 1–2 akapitach.\n"
"Klucz dla egzaminatora:\n"
"- \"mozliwe_stanowiska\": 2–3 stanowiska, które można uzasadnić;\n"
"- dla każdego elementu: \"oczekiwana_wiedza\" (5–8 konkretnych faktów: daty, postaci, wydarzenia, "
"pojęcia), \"przyklady_argumentow\" (2–3), \"fakty\" (1–3 dosłowne cytaty z MATERIAŁÓW, maks. 200 znaków, "
"z numerem fragmentu);\n"
"- \"typowe_bledy\": 3–5 typowych błędów merytorycznych (pomyłki dat, osób, pojęć, związków);\n"
"- \"podsumowanie\": 2–3 zdania – czego oczekuje egzaminator.\n"
"Fakty wyłącznie potwierdzone w MATERIAŁACH albo ugruntowana wiedza podręcznikowa; bez spornych "
"interpretacji podanych jako jedyna słuszna.\n"
"Zwróć json:\n"
'{"eseje": [{"temat": "…", "elementy": ["a) …", "b) …", "c) …"], "mozliwe_stanowiska": ["…", "…"], '
'"klucz": [{"element": "a", "oczekiwana_wiedza": ["…"], "przyklady_argumentow": ["…"], "fakty": '
'[{"id": "P1", "cytat": "…"}]}, {"element": "b", …}, {"element": "c", …}], "typowe_bledy": ["…"], '
'"podsumowanie": "…"}]}')
return msgs(passages, task)
def verify_new(passages, task_json, kind, fields_hint):
task = ("Jesteś recenzentem (historyk, egzaminator CKE). Oceń NOWE zadanie maturalne z historii (poziom "
f"rozszerzony, typ: {kind}) względem MATERIAŁÓW i wiedzy podręcznikowej.\n\n{task_json}\n\n"
"Sprawdź: (1) fakty w treści, kluczu i zasadach są poprawne; (2) zadanie jest jednoznaczne (zamknięte: "
"dokładnie jedna poprawna odpowiedź, dystraktory jednoznacznie błędne; P/F: każda ocena jednoznaczna); "
"(3) klucz i zasady oceniania pasują do polecenia i punktacji; (4) tekst źródłowy pasuje do polecenia i nie "
"podaje wprost odpowiedzi; (5) poprawna polszczyzna i styl CKE. Klucz to przykładowe rozwiązanie – "
"dodatkowe poprawne fakty w kluczu nie są błędem.\n"
'Zwróć json: {"problemy": ["…"], "decyzja": "ok", "poprawka": null}\n'
'"problemy": tylko rzeczywiste błędy (maks. 3, każdy do 30 słów), pusta lista gdy ich brak; '
'"decyzja": "ok" (bez zastrzeżeń), "popraw" (drobny błąd – wtedy "poprawka" zawiera poprawione pola: '
f"{fields_hint}), \"odrzuc\" (błąd merytoryczny lub niejednoznaczność, której nie da się łatwo naprawić).")
return msgs(passages, task)