matematicsolutions/awesome-matematic-skills-pl / fundament-weryfikacyjny/skills/citation-grounding-pl
citation-grounding-pl
VerifiedMechaniczny weryfikator cytatu dla tekstów prawnych po polsku z GRADIENTEM weryfikacji (ISTNIENIE / TREŚĆ / FRAGMENT) - sprawdza string-matchem, czy każdy cytat z orzeczenia, ustawy, umowy lub pisma faktycznie istnieje w dokumencie źródłowym, czy sygnatura jest realna i czy parafraza oddaje stanowisko sądu, zamiast wierzyć modelowi "na oko". Przeciwdziała halucynacjom modelu (w tym problemowi "prawdziwy-cytat-fałszywa-teza"), RODO-safe (działa lokalnie), spina się z saos-orzecznictwo i eu-sparql-search. Używaj gdy: weryfikacja cytatów w opinii prawnej / memo / piśmie procesowym, sprawdzenie czy AI nie zmyśliło fragmentu wyroku, przepisu lub sygnatury, czy parafraza nie przekręca holdingu, kontrola cytatu przed wysłaniem deliverable do klienta, audyt grounding outputu LLM, "sprawdź czy ten cytat jest prawdziwy", "zweryfikuj cytaty", "czy ten fragment wyroku istnieje", "grounding", "anti-halucynacja", "citation check", "czy AI to zmyśliło", "czy SN to naprawdę orzekł".
| File | Kind | Size |
|---|---|---|
| CHANGELOG.md | markdown | 13.9 KB |
| LICENSE | other | 11.1 KB |
| SKILL.md | skill md | 25.2 KB |
| references/drabinka-zrodel-pl.md | markdown | 3.3 KB |
| references/gradient-weryfikacji.md | markdown | 4.6 KB |
| references/szkielet-weryfikatora-domenowego/README.md | markdown | 4.7 KB |
| references/szkielet-weryfikatora-domenowego/SKILL.template.md | markdown | 2.9 KB |
| scripts/ground-citations.mjs | script | 38.3 KB |
| scripts/porownanie-slow.mjs | script | 16.7 KB |
| scripts/test-grounding.mjs | script | 31.9 KB |
scripts/ground-citations.mjs
View on GitHub#!/usr/bin/env node
// citation-grounding-pl v3.0 - mechaniczny weryfikator cytatu z GRADIENTEM weryfikacji (zero-dep ESM).
// Usage: node ground-citations.mjs <task.json>
//
// Gradient (adaptacja Existence/Content/Paragraph z jeannesulzer/international-criminal-tribunals-skills, CC BY 4.0):
// ISTNIENIE (0) - kotwica (sygnatura/CELEX, data, organ) jest realna i zgadza sie z deklaracja.
// TRESC (1) - zrodlo CO DO ISTOTY zawiera to, co twierdzi output (parafraza / stanowisko sadu).
// FRAGMENT (2) - doslowny cytat / pinpoint akapitu istnieje w zrodle (czysty string-match - rdzen v1).
//
// claim_type ustawia WYMAGANY poziom; skrypt liczy OSIAGNIETY poziom i kalibruje.
// Rdzen mechaniczny pozostaje uczciwy: TRESC zwraca WYMAGA_OSADU (obecnosc terminow to warunek konieczny,
// nie wystarczajacy) - substancje potwierdza czlowiek / paraphrase-judge, jak w kaskadzie PATRON.
//
// task.json: { "items": [ { id, source_id, claim_type?, claim_text?, quote?, source_text?, anchor?, anchor_resolved? } ] }
import { readFileSync } from "node:fs";
import { pathToFileURL } from "node:url";
import { porownajSlowa, tokeny as tokenySlow, twardy } from "./porownanie-slow.mjs";
// --- Normalizacja: JEDEN DOM reguly ------------------------------------------
// Tablica prawdy (kontrakt): doc-intel-contract-pl/contract/normalizacja.cases.json
// Ten sam kontrakt realizuje `evidence.py` po stronie Pythona; oba testy czytaja
// TEN plik, nie swoje kopie.
//
// Do 2026-08-30 kazda strona miala wlasna implementacje i wlasne luki. Tutejsza
// gubila SZESC z osmiu znakow, ktore polski PDF wstawia naprawde: U+2011 w
// sygnaturach akt, U+00AD w justowanych akapitach, U+2212, U+200B, U+2026 oraz
// wejscie zapisane w NFD. Skutek byl gorszy niz przeoczenie: falszywy czerwony
// na poziomie FRAGMENT, czyli "cytatu nie ma w zrodle" o cytacie, ktory tam
// jest - zarzut halucynacji postawiony przez blad normalizacji.
const QUOTE_CHAR = /^[„“”‟«»‹›‘’‚‛`´']$/;
const DASH_CHAR = /^[‐‑‒–—―−⁃-]$/;
// Niewidzialne w PDF (zerowa szerokosc, BOM, word joiner) i miekki dywiz - kasowane (DROP).
// Przeniesienie wyrazu: kreska (miekki dywiz WLICZONY) + opcjonalne spacje +
// lamanie linii. U+00AD renderuje sie wylacznie na lamaniu, wiec TAM znaczy
// przeniesienie; poza lamaniem jest kasowany jak reszta niewidzialnych.
// JS nie ma casefold; ostre s trzeba zlozyc jawnie (nazwiska i adresy w aktach).
const HYPHENS = new Set(["-", "", "‐", "‑", "‒", "–", "—", "―", "−", "⁃", "-"]);
const DROP = new Set(["", "", "", "", "", ""]);
const COMBINING = /\p{M}/u;
const POZIOM = { ISTNIENIE: 0, TRESC: 1, FRAGMENT: 2 };
const POZIOM_NAZWA = ["ISTNIENIE", "TRESC", "FRAGMENT"];
// claim_type -> wymagany poziom weryfikacji
const WYMAGANY_POZIOM = {
cytat_doslowny: POZIOM.FRAGMENT, // cytat w cudzyslowie
teza_pinpoint: POZIOM.FRAGMENT, // "jak w pkt 15 uzasadnienia..." bez cudzyslowu
stanowisko_sadu: POZIOM.TRESC, // parafraza holdingu: "SN przyjal, ze..."
parafraza: POZIOM.TRESC,
fakt_proceduralny: POZIOM.ISTNIENIE, // data, sklad, rozstrzygniecie
powolanie: POZIOM.ISTNIENIE, // sama sygnatura jako autorytet: "por. II CSK 123/19"
quote: POZIOM.FRAGMENT, // alias wsteczny (v1)
};
// Polskie stopwords - do ekstrakcji terminow nosnych przy poziomie TRESC.
const STOPWORDS = new Set(
("a aby albo ale ani az bez bo by byc byl byla bylo byly co czy dla do gdy gdyz i ich ile im " +
"iz ja jak jako je jednak jego jej jest jesli juz ktore ktory ktora ktorych ktorym lub ma " +
"majac mi mial mnie moze na nad nam nas nawet nie nim niz o od oraz po pod ponad poniewaz " +
"przed przez przy sa sie tak takze tam te tego tej temu ten to tych tym u w we wiec za ze " +
"zeby ze az nr poz art").split(" ")
);
// Fold polskich diakrytykow - dopasowanie frazy szablonowej musi lapac tez tekst ASCII
// (OCR, transliteracja, degradacja kodowania), a lista fraz jest pisana z diakrytykami.
const DIAKRYTYKI = { "ą": "a", "ć": "c", "ę": "e", "ł": "l", "ń": "n", "ó": "o", "ś": "s", "ź": "z", "ż": "z" };
function fold(s) {
return s.replace(/[ąćęłńóśźż]/g, (ch) => DIAKRYTYKI[ch]);
}
// --- Dyskonto jezyka szablonowego (poziom TRESC) ---
// Frazy-wytrychy polskiego jezyka prawnego wystepuja w niemal kazdym akcie/umowie, wiec ich
// obecnosc w zrodle NIE jest dowodem, ze zrodlo mowi to, co twierdzi output. Termin nosny
// pochodzacy WYLACZNIE z frazy szablonowej liczy sie 0.5 zamiast 1.0 do pokrycia (wazonego).
// Wzorzec COMMON_LEGAL_PHRASES z AnttiHero/lavern (Apache-2.0); lista PL i kod od zera.
const BOILERPLATE_FRAZY = [
"z zastrzeżeniem",
"w szczególności",
"nie ponosi odpowiedzialności",
"ponosi odpowiedzialność",
"chyba że umowa stanowi inaczej",
"chyba że strony postanowiły inaczej",
"o którym mowa",
"o której mowa",
"o których mowa",
"stosuje się odpowiednio",
"pod rygorem nieważności",
"na zasadach określonych",
"zgodnie z postanowieniami",
"mając na uwadze",
"w rozumieniu przepisów",
"wchodzi w życie",
"traci moc",
"w drodze rozporządzenia",
"z uwzględnieniem",
"w zakresie nieuregulowanym",
"postanowienia niniejszej umowy",
"strony zgodnie postanawiają",
"zasady współżycia społecznego",
"należyta staranność",
"należytej staranności",
].map((f) => fold(normalize(f)));
// Tokeny nosne (>=4 znaki, nie-stopword) pochodzace z fraz szablonowych obecnych w twierdzeniu.
// Zwraca tokeny w formie FOLDED - porownuj przez fold(t).
function boilerplateTokens(normClaim) {
const foldedClaim = fold(normClaim);
const toks = new Set();
for (const fraza of BOILERPLATE_FRAZY) {
if (!foldedClaim.includes(fraza)) continue;
for (const t of fraza.split(" ")) {
if (t.length >= 4 && !STOPWORDS.has(t)) toks.add(t);
}
}
return toks;
}
// --- Zbieznosc fragmentu (poziom TRESC, sygnal pomocniczy) ---
// Trigram-Jaccard twierdzenia z najlepszym oknem zrodla. Lapie przypadek "terminy obecne, ale
// rozproszone po dokumencie" - zrodlo zawiera slowa twierdzenia, lecz zaden zwarty fragment
// nie odpowiada tezie (wariant "prawdziwe slowa, falszywa teza" na poziomie tresci).
// Wzorzec citation-content-matcher z chrisryugj/korean-law-mcp (MIT): tam bigramy znakowe dla
// koreanskiego (1 znak = sylaba); dla polskiego alfabetu lacinskiego odpowiednikiem informacyjnym
// jest TRIGRAM (bigram lacinski nakladal sie przypadkowo w kazdym tekscie prawniczym - zmierzone
// na fixture: bigram scatter 0.33 vs trigram scatter 0.15 przy parafrazie 0.45-0.78). Kod i progi
// od zera; u nas to wylacznie SYGNAL (uwaga dla czlowieka), nigdy samodzielna blokada.
const PROG_ZBIEZNOSC_NISKA = 0.2; // ponizej = terminy rozproszone, brak zwartego fragmentu
function trigramy(s) {
const out = new Set();
for (let i = 0; i <= s.length - 3; i++) {
const g = s.slice(i, i + 3);
if (!g.includes(" ")) out.add(g);
}
return out;
}
function jaccardZbiorow(a, b) {
if (a.size === 0 || b.size === 0) return 0;
let wspolne = 0;
for (const x of a) if (b.has(x)) wspolne++;
return wspolne / (a.size + b.size - wspolne);
}
// Maksymalny trigram-Jaccard twierdzenia z oknem zrodla dlugosci ~twierdzenia (krok 1/3 okna).
function zbieznoscFragmentu(normClaim, src) {
const cb = trigramy(normClaim);
if (cb.size === 0) return null;
const L = Math.max(normClaim.length, 60);
if (src.length <= L) return jaccardZbiorow(cb, trigramy(src));
const step = Math.max(20, Math.floor(L / 3));
let best = 0;
for (let i = 0; i <= src.length - Math.floor(L / 2); i += step) {
const j = jaccardZbiorow(cb, trigramy(src.slice(i, i + L)));
if (j > best) best = j;
if (best >= 0.95) break;
}
return best;
}
// Realizuje kontrakt z tablicy prawdy (patrz komentarz przy QUOTE_CHAR).
// Kolejnosc krokow jest czescia kontraktu: przeniesienie wyrazu MUSI byc
// rozpoznane, zanim skasujemy miekki dywiz.
//
// v2.5: normalizacja Z MAPA POZYCJI - port `normalize_with_map` z evidence.py.
// Do v2.4 `offset` byl liczony w tekscie ZNORMALIZOWANYM (male litery, zwiniete
// spacje, sklejone przeniesienia), wiec wskazywal inne miejsce niz cytat w
// oryginale - pinpoint, ktory nie trafia. Teraz znak znormalizowany o indeksie k
// powstal ze znakow [start[k], end[k]) oryginalu (indeksy JS, jednostki UTF-16).
// `normalize` jest nakladka na te funkcje: jeden dom reguly, jedna tablica prawdy.
function mapChar(ch) {
if (DROP.has(ch)) return "";
if (QUOTE_CHAR.test(ch)) return '"';
if (DASH_CHAR.test(ch)) return "-";
if (ch === "…") return "...";
if (ch === "ß" || ch === "ẞ") return "ss";
return ch;
}
function normalizeWithMap(s) {
const text = s == null ? "" : String(s);
let norm = "";
const start = [], end = [];
const n = text.length;
let i = 0;
let pendingSpace = -1; // zwijanie bialych znakow: pozycja pierwszego z serii
const emit = (chars, a, b) => {
for (const c of chars) {
for (let u = 0; u < c.length; u++) { norm += c[u]; start.push(a); end.push(b); }
}
};
while (i < n) {
// 1) grupa: punkt kodowy + nastepujace znaki laczace -> NFC (wejscie NFD)
let j = i + (text.codePointAt(i) > 0xffff ? 2 : 1);
while (j < n && COMBINING.test(String.fromCodePoint(text.codePointAt(j)))) {
j += text.codePointAt(j) > 0xffff ? 2 : 1;
}
const group = text.slice(i, j).normalize("NFC");
// 2) przeniesienie wyrazu: kreska + (spacje/taby) + lamanie linii -> kasuj cale, BEZ spacji
if (group.length === 1 && HYPHENS.has(group)) {
let k = j;
while (k < n && (text[k] === " " || text[k] === "\t")) k++;
if (k < n && (text[k] === "\r" || text[k] === "\n")) {
while (k < n && /[\r\n \t]/.test(text[k])) k++;
pendingSpace = -1;
i = k;
continue;
}
}
let piece = "";
for (const ch of group) piece += mapChar(ch);
if (piece === "") { i = j; continue; }
// 3) biale znaki (\s obejmuje NBSP): jedna spacja, wiodace i koncowe pomijamy
if (/^\s+$/.test(piece)) {
if (norm.length > 0 && pendingSpace === -1) pendingSpace = i;
i = j;
continue;
}
if (pendingSpace !== -1) { emit(" ", pendingSpace, pendingSpace + 1); pendingSpace = -1; }
// 4) male litery - rozszerzenie dlugosci dopuszczone, wszystkie znaki wskazuja te sama grupe
emit(piece.toLowerCase(), i, j);
i = j;
}
return { norm, start, end };
}
function normalize(s) {
if (s == null) return "";
return normalizeWithMap(s).norm;
}
// Zakres [a, b) tekstu znormalizowanego -> zakres w ORYGINALE.
function naOryginal(mapa, a, b) {
if (a < 0 || b <= a || b > mapa.start.length) return null;
return { start: mapa.start[a], end: mapa.end[b - 1] };
}
// Doslowny fragment zrodla do wgladu czlowieka (wzorzec: cytat przypiety do miejsca).
const FRAGMENT_MAX = 400;
function fragmentZrodla(tekst, zakres) {
if (!zakres) return null;
const f = tekst.slice(zakres.start, zakres.end);
return f.length > FRAGMENT_MAX ? f.slice(0, FRAGMENT_MAX) + " [...ucieto]" : f;
}
// "II CSK 123/19" -> "ii csk 123/19" (do porownania kotwic; tnie kropki i nadmiar spacji)
function normSig(s) {
return normalize(s).replace(/[.,;]/g, "").replace(/\s+/g, " ").trim();
}
// Rozwiniecie skrotow organow - "SN" i "Sad Najwyzszy" to ta sama instytucja.
const SKROTY_ORGANOW = [
[/\bsn\b/g, "sąd najwyższy"],
[/\bnsa\b/g, "naczelny sąd administracyjny"],
[/\bwsa\b/g, "wojewódzki sąd administracyjny"],
[/\btk\b/g, "trybunał konstytucyjny"],
[/\btsue\b/g, "trybunał sprawiedliwości unii europejskiej"],
[/\bkio\b/g, "krajowa izba odwoławcza"],
[/\bsokik\b/g, "sąd ochrony konkurencji i konsumentów"],
[/\bp?uodo\b/g, "urzędu ochrony danych osobowych"], // "Prezes UODO" -> forma dopełniaczowa
[/\buoku?ik\b/g, "urzędu ochrony konkurencji i konsumentów"],
[/\bkrs\b/g, "krajowy rejestr sądowy"],
[/\bsa\b/g, "sąd apelacyjny"],
[/\bso\b/g, "sąd okręgowy"],
[/\bsr\b/g, "sąd rejonowy"],
[/\bso\b/g, "sąd okręgowy"],
];
function normOrgan(s) {
let t = normalize(s);
for (const [re, full] of SKROTY_ORGANOW) t = t.replace(re, full);
return t.replace(/\s+/g, " ").trim();
}
// Czy wszystkie tokeny krotszego organu wystepuja w dluzszym (po rozwinieciu skrotow)?
function organZgodny(a, b) {
const ta = new Set(normOrgan(a).split(" ").filter(Boolean));
const tb = new Set(normOrgan(b).split(" ").filter(Boolean));
const [maly, duzy] = ta.size <= tb.size ? [ta, tb] : [tb, ta];
for (const t of maly) if (!duzy.has(t)) return false;
return true;
}
// --- STRONY sprawy: guard "prawdziwy cytat, falszywa teza" na poziomie kotwicy ---
// Gdy sygnatura sie zgadza, ale STRONY zadeklarowane rozjezdzaja sie ze stronami rozwiazanego
// zrodla, to sygnal, ze realny cytat/sygnature doczepiono do INNEJ sprawy. Miara: nakladanie
// zbiorow tokenow nosnych nazw stron (Jaccard) - wzorzec _is_name_mismatch z
// john-walkoe/courtlistener_citations_mcp (MIT); kod, stop-lista PL/EU i progi napisane od zera.
const STRONY_STOP = new Set(
("v vs versus przeciwko przeciw p-ko pko ko oraz inni innych innymi innym inn " +
"spolka spolki spolke z o oo sp s sa akcyjna akcyjnej ograniczona ograniczonej " +
"odpowiedzialnoscia odpowiedzialnosci komandytowa komandytowo komandytowej jawna cywilna sc " +
"przedsiebiorstwo panstwowe fundacja stowarzyszenie zaklad zaklady grupa " +
"we sprawie the of and co ltd inc corp gmbh ag srl bv nv plc se sarl spa oy ab as").split(" ")
);
const STRONY_PROG_ZGODNE = 0.5; // Jaccard >= => strony zgodne (rozne formy tej samej nazwy)
const STRONY_PROG_ROZBIEZNE = 0.3; // Jaccard < => strony rozbiezne (wzor progu z courtlistener)
// Tokeny nosne nazwy strony: normalizacja + odsianie form prawnych/spojnikow + czystych liczb.
function partyTokens(s) {
if (s == null) return [];
const joined = Array.isArray(s) ? s.join(" ") : String(s);
return [...new Set(
normalize(joined)
.replace(/["'.,;:()\[\]/»«§-]/g, " ")
.split(" ")
.map((t) => t.replace(/[^a-ząćęłńóśźż0-9]/g, ""))
.filter((t) => t.length >= 2 && !STRONY_STOP.has(t) && !/^\d+$/.test(t))
)];
}
// Nakladanie zbiorow tokenow stron (Jaccard). overlap=null gdy ktoras strona bez tokenow nosnych.
function stronyOverlap(a, b) {
const ta = new Set(partyTokens(a));
const tb = new Set(partyTokens(b));
if (ta.size === 0 || tb.size === 0) {
return { overlap: null, wspolne: [], tylkoZadeklarowane: [...ta], tylkoZnalezione: [...tb], minSize: Math.min(ta.size, tb.size) };
}
const wspolne = [...ta].filter((t) => tb.has(t));
const union = new Set([...ta, ...tb]).size;
return {
overlap: wspolne.length / union,
wspolne,
tylkoZadeklarowane: [...ta].filter((t) => !tb.has(t)),
tylkoZnalezione: [...tb].filter((t) => !ta.has(t)),
minSize: Math.min(ta.size, tb.size),
};
}
// Data do postaci YYYY-MM-DD jesli sie da; inaczej znormalizowany string.
function normDate(s) {
if (s == null) return "";
const t = String(s).trim();
const iso = t.match(/(\d{4})-(\d{2})-(\d{2})/);
if (iso) return `${iso[1]}-${iso[2]}-${iso[3]}`;
const pl = t.match(/(\d{1,2})[.\s]+(\d{1,2})[.\s]+(\d{4})/);
if (pl) return `${pl[3]}-${String(pl[2]).padStart(2, "0")}-${String(pl[1]).padStart(2, "0")}`;
return normalize(t);
}
function splitGaps(normQuote) {
return normQuote
.split(/\s*(?:\[\s*\.\.\.\s*\]|\.\.\.)\s*/)
.map((seg) => seg.trim())
.filter((seg) => seg.length > 0);
}
function editDistance(a, b) {
const m = a.length, n = b.length;
if (Math.abs(m - n) > 40) return Math.max(m, n);
const dp = Array.from({ length: m + 1 }, (_, i) => i);
for (let j = 1; j <= n; j++) {
let prev = dp[0];
dp[0] = j;
for (let i = 1; i <= m; i++) {
const tmp = dp[i];
dp[i] = Math.min(dp[i] + 1, dp[i - 1] + 1, prev + (a[i - 1] === b[j - 1] ? 0 : 1));
prev = tmp;
}
}
return dp[m];
}
function bestApprox(segment, source) {
const L = segment.length;
if (L === 0 || source.length < L) return { dist: L, at: -1 };
let best = { dist: Infinity, at: -1 };
const step = L > 200 ? 5 : 1;
for (let i = 0; i + L <= source.length; i += step) {
const window = source.slice(i, i + L);
const d = editDistance(segment, window);
if (d < best.dist) best = { dist: d, at: i };
if (d === 0) break;
}
return best;
}
// --- POZIOM FRAGMENT: string-match cytatu (rdzen v1) ---
// `mapa` = normalizeWithMap(source_text): zakresy wracaja w ORYGINALE, nie w tekscie znormalizowanym.
// v3: najpierw porownanie NA SLOWACH (porownanie-slow.mjs). Rozstrzyga ono wszystko, co da sie rozstrzygnac
// slowami: zmieniona tresc i istotne opuszczenie to twarda odmowa, typografia nie jest roznica. Dopasowanie
// znakowe ponizej zostaje dla cytatow krotszych niz 3 slowa i dla przypadkow, w ktorych slowa sie nie
// skladaja (np. tekst z OCR posklejany albo porozbijany inaczej niz w cytacie).
function sprawdzFragment(quote, mapa) {
const src = mapa.norm;
const normQuote = normalize(quote);
const slowa = porownajSlowa(normQuote, src);
const naOrg = (z) => naOryginal(mapa, z.a, z.b);
if (slowa.stan === "DOKLADNY" || slowa.stan === "DOKLADNY_Z_OPUSZCZENIEM") {
const zakres = naOrg(slowa.zakres);
return { dopasowanie: "dokladne", offset: zakres.start, zakres, segmenty: slowa.segmenty.map(naOrg),
...(slowa.opuszczone ? { opuszczone: slowa.opuszczone, opuszczono_slow: slowa.opuszczono_slow } : {}),
...(slowa.odnosniki_pominiete ? { odnosniki_pominiete: slowa.odnosniki_pominiete } : {}),
...(slowa.wtracenia ? { wtracenia: slowa.wtracenia } : {}) };
}
if (slowa.stan === "ROZJAZD") {
return { dopasowanie: slowa.tylko_diakrytyki ? "diakrytyki" : "zmieniona_tresc", offset: -1, roznice: slowa.roznice,
twardy: slowa.twardy, zakres: slowa.zakres ? naOrg(slowa.zakres) : null };
}
if (slowa.stan === "OPUSZCZENIE_ISTOTNE" || slowa.stan === "OPUSZCZENIE_ZA_SZEROKIE") {
return { dopasowanie: slowa.stan === "OPUSZCZENIE_ISTOTNE" ? "opuszczenie_istotne" : "opuszczenie_za_szerokie", offset: -1,
opuszczone: slowa.opuszczone || [], opuszczone_istotne: slowa.opuszczone_istotne || [], opuszczono_slow: slowa.opuszczono_slow,
zakres: slowa.zakres ? naOrg(slowa.zakres) : null };
}
if (slowa.stan === "WTRACENIE_ISTOTNE") {
return { dopasowanie: "wtracenie_istotne", offset: -1, wtracenia: slowa.wtracenia, wtracenia_istotne: slowa.wtracenia_istotne };
}
// Cytat z opuszczeniem, ktorego segment jest za krotki, NIE wraca do dopasowania znakowego: tam "A [...] B"
// przechodzilo jako dokladne bez wzgledu na to, co wycieto.
const segments = splitGaps(normQuote.replace(/\(\s*\.\.\.\s*\)/g, "[...]"));
if (segments.length > 1) return { dopasowanie: "opuszczenie_niesprawdzalne", offset: -1, powod: slowa.powod || "segmentow cytatu nie da sie umiejscowic w zrodle" };
if (segments.length === 0) return { dopasowanie: "brak", offset: -1 };
// Cytat z co najmniej 3 slow, ktorego slow nie da sie odnalezc w zrodle, to BRAK. Dopasowanie znakowe z progiem
// 15% robilo z niego "drobne roznice" takze wtedy, gdy zmieniono liczbe (pomiar 2026-11-18).
if (slowa.stan !== "ZA_KROTKI") return { dopasowanie: "brak", offset: -1, detail: [] };
// Cytat krotszy niz 3 slowa: dopasowanie znakowe, ale z liczba w cytacie tylko DOKLADNE ("art. 57" przy
// zrodlowym "art. 56" to jedna litera roznicy i inny przepis).
// To samo dla slowa twardego (spojnik, przeczenie): "wniosek i" przy zrodlowym "wniosek lub" to nie literowka.
const krotkiZLiczba = /\p{N}/u.test(normQuote);
const krotkiTwardy = krotkiZLiczba || tokenySlow(normQuote).some((x) => twardy(x.t));
// Dopasowanie znakowe na GRANICACH slow: "art. 5" nie moze trafic w srodek "art. 56".
const naGranicy = (seg, od) => {
for (let idx = src.indexOf(seg, od); idx !== -1; idx = src.indexOf(seg, idx + 1)) {
const przed = idx > 0 ? src[idx - 1] : " ", po = idx + seg.length < src.length ? src[idx + seg.length] : " ";
if (!/[\p{L}\p{N}]/u.test(przed) && !/[\p{L}\p{N}]/u.test(po)) return idx;
}
return -1;
};
let cursor = 0, exact = true;
const zakresy = [];
for (const seg of segments) {
const idx = naGranicy(seg, cursor);
if (idx === -1) { exact = false; break; }
zakresy.push(naOryginal(mapa, idx, idx + seg.length));
cursor = idx + seg.length;
}
if (exact) {
const zakres = { start: zakresy[0].start, end: zakresy[zakresy.length - 1].end };
return { dopasowanie: "dokladne", offset: zakres.start, zakres, segmenty: zakresy };
}
let worstRatio = 0, detail = [];
for (const seg of segments) {
const { dist, at } = bestApprox(seg, src);
const ratio = seg.length > 0 ? dist / seg.length : 1;
worstRatio = Math.max(worstRatio, ratio);
detail.push({ seg: seg.slice(0, 60), dist, zakres: at >= 0 ? naOryginal(mapa, at, Math.min(at + seg.length, src.length)) : null });
}
if (krotkiTwardy) return { dopasowanie: "krotki_niezgodny", offset: -1, detail };
if (worstRatio <= 0.15) return { dopasowanie: "przyblizone", offset: -1, detail };
return { dopasowanie: "brak", offset: -1, detail };
}
// --- POZIOM TRESC: obecnosc terminow nosnych twierdzenia w zrodle (warunek konieczny) ---
// v2.3: pokrycie WAZONE (termin szablonowy liczy sie 0.5) + pokrycie surowe + zbieznosc fragmentu.
function sprawdzTresc(claimText, src) {
const normClaim = normalize(claimText);
const terms = [...new Set(
normClaim
.replace(/[".,;:()\[\]»«]/g, " ")
.split(" ")
.filter((t) => t.length >= 4 && !STOPWORDS.has(t))
)];
if (terms.length === 0) return { pokrycie: 0, pokrycieSurowe: 0, obecne: [], brakujace: [], boilerplate: [], zbieznosc: null };
const boiler = boilerplateTokens(normClaim);
// Dopasowanie po RDZENIU (prefiks) - polska deklinacja: "Warszawie"~"Warszawa", "spółki"~"spółka".
// Termin obecny, gdy zrodlo zawiera jego prefiks dlugosci max(4, len-3) (ucina do 3 znakow koncowki).
const obecny = (t) => {
if (src.includes(t)) return true;
const pref = t.slice(0, Math.max(4, t.length - 3));
return pref.length >= 4 && src.includes(pref);
};
const obecne = [], brakujace = [];
let licznikWazony = 0;
for (const t of terms) {
if (obecny(t)) { obecne.push(t); licznikWazony += boiler.has(fold(t)) ? 0.5 : 1; }
else brakujace.push(t);
}
return {
pokrycie: licznikWazony / terms.length, // wazone: szablon nie zawyza dowodu
pokrycieSurowe: obecne.length / terms.length,
obecne, brakujace, liczbaTerminow: terms.length,
boilerplate: obecne.filter((t) => boiler.has(fold(t))),
zbieznosc: zbieznoscFragmentu(normClaim, src),
};
}
// --- POZIOM ISTNIENIE: zgodnosc kotwicy zadeklarowanej z rozwiazana (SAOS/EUR-Lex dostarcza agent) ---
function sprawdzIstnienie(anchor, resolved) {
if (!resolved) return { stan: anchor ? "nierozwiazana" : "brak_kotwicy", roznice: [], uwagi: [] };
// TOZSAMOSC (twarda): sygnatura + data. Rozbieznosc = mozliwe falszerstwo.
const roznice = [];
const porTwarde = (klucz, fn) => {
const a = anchor && anchor[klucz] != null ? fn(anchor[klucz]) : "";
const b = resolved[klucz] != null ? fn(resolved[klucz]) : "";
if (a && b && a !== b) roznice.push({ pole: klucz, zadeklarowano: a, znaleziono: b });
};
porTwarde("sygnatura", normSig);
porTwarde("data", normDate);
// ORGAN (miekki): tylko potwierdzenie. Niezgodnosc = uwaga, NIE blokada - tozsamosc niesie sygnatura.
const uwagi = [];
const oa = anchor && anchor.organ != null ? anchor.organ : "";
const ob = resolved.organ != null ? resolved.organ : "";
if (oa && ob && !organZgodny(oa, ob)) {
uwagi.push({ pole: "organ", zadeklarowano: normOrgan(oa), znaleziono: normOrgan(ob), uwaga: "niezgodnosc organu (miekka) - sprawdz, ale tozsamosc niesie sygnatura" });
}
// STRONY (kalibrowane): rozbieznosc = twarda roznica (mozliwy "prawdziwy cytat, falszywa teza");
// czesciowa zgodnosc = miekka uwaga (mozliwa rozna forma nazwy tej samej strony).
const sa = anchor && (anchor.strony ?? anchor.parties);
const sb = resolved.strony ?? resolved.parties;
const ov = stronyOverlap(sa, sb);
if (ov.overlap != null) {
const overlapPct = Math.round(ov.overlap * 100) / 100;
if (ov.overlap < STRONY_PROG_ROZBIEZNE && ov.minSize >= 2) {
roznice.push({
pole: "strony", zadeklarowano: partyTokens(sa).join(" "), znaleziono: partyTokens(sb).join(" "),
overlap: overlapPct, wspolne: ov.wspolne,
uwaga: "strony sprawy rozbiezne z rozwiazanym zrodlem - mozliwy 'prawdziwy cytat, falszywa teza' (sygnatura/cytat realne, ale dotycza innej sprawy)",
});
} else if (ov.overlap < STRONY_PROG_ZGODNE) {
uwagi.push({
pole: "strony", zadeklarowano: partyTokens(sa).join(" "), znaleziono: partyTokens(sb).join(" "),
overlap: overlapPct, uwaga: "czesciowa zgodnosc stron - sprawdz, czy to ta sama sprawa (mozliwa rozna forma nazwy)",
});
}
}
return { stan: roznice.length === 0 ? "potwierdzona" : "rozbiezna", roznice, uwagi };
}
// `normalize` wystawiony, zeby bramka konformancji mogla go zmierzyc przeciw
// wspolnej tablicy prawdy. Regula bez sposobu zmierzenia nie trzyma.
export { stronyOverlap, partyTokens, zbieznoscFragmentu, boilerplateTokens, normalize, normalizeWithMap };
export function verify(item) {
const claimType = item.claim_type || (item.quote ? "cytat_doslowny" : "powolanie");
// required_level: jawny override poziomu - pozwala domenie zadeklarowac wlasne claim_type
// (np. KRS: fakt_rejestrowy/numer_krs) bez wpisywania jej slownika do silnika. Backward-compat.
let wymagany;
if (item.required_level && POZIOM[item.required_level] != null) {
wymagany = POZIOM[item.required_level];
} else {
wymagany = WYMAGANY_POZIOM[claimType] ?? POZIOM.FRAGMENT;
}
const out = { id: item.id, source_id: item.source_id, claim_type: claimType, wymagany_poziom: POZIOM_NAZWA[wymagany] };
const oryginal = item.source_text == null ? "" : String(item.source_text);
const mapa = normalizeWithMap(oryginal);
const maTekst = mapa.norm.length > 0;
const src = mapa.norm;
// 1. ISTNIENIE
const ist = sprawdzIstnienie(item.anchor, item.anchor_resolved);
let poziomIstnienia = -1; // -1 brak, 0 domniemane, 0.5 potwierdzone (>= ISTNIENIE)
if (ist.stan === "potwierdzona") poziomIstnienia = POZIOM.ISTNIENIE;
else if (ist.stan === "rozbiezna") poziomIstnienia = -1; // rozbieznosc kotwicy = sygnal falszerstwa
else if (maTekst) poziomIstnienia = POZIOM.ISTNIENIE; // domniemane na podstawie obecnosci tekstu
const istnienieDomniemane = ist.stan !== "potwierdzona" && maTekst;
// 2. FRAGMENT (gdy jest cytat)
let frag = null;
if (item.quote && maTekst) frag = sprawdzFragment(item.quote, mapa);
// 3. TRESC (gdy jest twierdzenie/parafraza i tekst)
let tresc = null;
const claimText = item.claim_text || item.quote;
if (claimText && maTekst) tresc = sprawdzTresc(claimText, src);
// OSIAGNIETY poziom
let osiagniety = istnienieDomniemane || poziomIstnienia >= 0 ? POZIOM.ISTNIENIE : -1;
if (ist.stan === "rozbiezna") osiagniety = -1;
if (tresc && tresc.pokrycie >= 0.7) osiagniety = Math.max(osiagniety, POZIOM.TRESC);
if (frag && frag.dopasowanie === "dokladne") osiagniety = Math.max(osiagniety, POZIOM.FRAGMENT);
if (frag && (frag.dopasowanie === "przyblizone" || frag.dopasowanie === "diakrytyki")) osiagniety = Math.max(osiagniety, POZIOM.TRESC);
out.osiagniety_poziom = osiagniety >= 0 ? POZIOM_NAZWA[osiagniety] : "BRAK";
// --- DECYZJA ---
// Rozbiezna kotwica - twardy czerwony niezaleznie od reszty.
if (ist.stan === "rozbiezna") {
out.status = "NIEZWERYFIKOWANY";
const poleStrony = ist.roznice.some((r) => r.pole === "strony");
out.note = poleStrony
? "rozbieznosc stron sprawy z rozwiazanym zrodlem - mozliwy 'prawdziwy cytat, falszywa teza' (BLOKADA)"
: "rozbieznosc kotwicy (sygnatura/data) - mozliwe falszerstwo zrodla";
out.detail = ist.roznice;
return out;
}
// Brak zrodla tam, gdzie potrzebne (TRESC/FRAGMENT wymagaja tekstu).
if (wymagany >= POZIOM.TRESC && !maTekst) {
out.status = "BRAK_ZRODLA";
out.note = "nie dostarczono tekstu zrodlowego do weryfikacji tresci/fragmentu";
return out;
}
if (wymagany === POZIOM.FRAGMENT) {
if (frag && frag.dopasowanie === "dokladne") {
// offset/zakres w ORYGINALNYM source_text (indeksy JS, UTF-16), koniec wylaczny.
out.status = "ZWERYFIKOWANY"; out.offset = frag.offset; out.zakres = frag.zakres;
if (frag.segmenty.length > 1) out.segmenty = frag.segmenty;
out.fragment_zrodla = fragmentZrodla(oryginal, frag.zakres);
// v3: cytat z opuszczeniem jest zgodny co do slowa, ale czlowiek ma ZOBACZYC, co wycieto.
if (frag.opuszczone) {
out.opuszczone = frag.opuszczone; out.opuszczono_slow = frag.opuszczono_slow;
out.note = `slowa zgodne; cytat pomija ${frag.opuszczono_slow} slow zrodla - sprawdz, czy wyciecie nie zmienia sensu: ` +
frag.opuszczone.map((x) => `"${x}"`).join(", ");
}
if (frag.odnosniki_pominiete) out.odnosniki_pominiete = frag.odnosniki_pominiete;
if (frag.wtracenia) {
out.wtracenia = frag.wtracenia;
out.note = (out.note ? out.note + "; " : "") + "cytat zawiera wtracenie cytujacego w nawiasie kwadratowym (pominiete przy porownaniu): " +
frag.wtracenia.map((x) => `"${x}"`).join(", ");
}
return out;
}
// v3: zmieniona tresc i istotne opuszczenie to twarda odmowa z NAZWANA roznica - nie "drobne roznice".
if (frag && frag.dopasowanie === "zmieniona_tresc") {
out.status = "NIEZWERYFIKOWANY"; out.powod_kod = "zmieniona_tresc"; out.roznice = frag.roznice;
const pary = frag.roznice.map((r) => `"${r.cytat || "(brak)"}" zamiast "${r.zrodlo || "(brak)"}"`).join("; ");
out.note = `cytat rozni sie od zrodla co do slowa: ${pary}` + (frag.twardy ? " - roznica dotyczy liczby, przeczenia albo spojnika (BLOKADA)" : " (BLOKADA)");
if (frag.zakres) out.fragment_zrodla = fragmentZrodla(oryginal, frag.zakres);
return out;
}
if (frag && (frag.dopasowanie === "opuszczenie_istotne" || frag.dopasowanie === "opuszczenie_za_szerokie" || frag.dopasowanie === "opuszczenie_niesprawdzalne")) {
out.status = "NIEZWERYFIKOWANY"; out.powod_kod = frag.dopasowanie;
if (frag.opuszczone) out.opuszczone = frag.opuszczone;
if (frag.opuszczone_istotne) out.opuszczone_istotne = frag.opuszczone_istotne;
out.note = frag.dopasowanie === "opuszczenie_istotne"
? `cytat wycina ze zrodla slowa, ktore moga zmieniac sens (${frag.opuszczone_istotne.join(", ")}): ` + frag.opuszczone.map((x) => `"${x}"`).join(", ") + " (BLOKADA)"
: frag.dopasowanie === "opuszczenie_za_szerokie"
? `segmenty cytatu stoja w zrodle ponad 40 slow od siebie (${frag.opuszczono_slow}) - to dwa rozne miejsca, nie jeden cytat (BLOKADA)`
: `cytatu z opuszczeniem nie da sie sprawdzic: ${frag.powod} (BLOKADA)`;
if (frag.zakres) out.fragment_zrodla = fragmentZrodla(oryginal, frag.zakres);
return out;
}
if (frag && frag.dopasowanie === "wtracenie_istotne") {
out.status = "NIEZWERYFIKOWANY"; out.powod_kod = "wtracenie_istotne";
out.wtracenia = frag.wtracenia; out.wtracenia_istotne = frag.wtracenia_istotne;
out.note = `cytat dopisuje w nawiasie kwadratowym slowo, ktore zmienia sens (${frag.wtracenia_istotne.join(", ")}) - to nie objasnienie, tylko zmiana tresci (BLOKADA)`;
return out;
}
if (frag && frag.dopasowanie === "krotki_niezgodny") {
out.status = "NIEZWERYFIKOWANY"; out.powod_kod = "krotki_cytat_niezgodny";
out.note = "cytat krotszy niz 3 slowa z liczba, przeczeniem albo spojnikiem nie stoi w zrodle doslownie (BLOKADA)";
out.detail = frag.detail;
out.fragmenty_zrodla = frag.detail.map((d) => fragmentZrodla(oryginal, d.zakres));
return out;
}
if (frag && frag.dopasowanie === "diakrytyki") {
out.status = "ZMODYFIKOWANY"; out.powod_kod = "diakrytyki"; out.roznice = frag.roznice;
out.note = "slowa roznia sie wylacznie znakami diakrytycznymi (typowy slad OCR albo klawiatury): " +
frag.roznice.map((r) => `"${r.cytat}" / "${r.zrodlo}"`).join("; ");
if (frag.zakres) out.fragment_zrodla = fragmentZrodla(oryginal, frag.zakres);
return out;
}
if (frag && frag.dopasowanie === "przyblizone") {
out.status = "ZMODYFIKOWANY"; out.powod_kod = "znaki";
out.note = "roznice na poziomie znakow, ktorych porownanie na slowach nie rozstrzyga (cytat krotszy niz 3 slowa albo slowa inaczej posklejane niz w zrodle) - porownaj z fragmentem zrodla";
out.detail = frag.detail;
// Najblizsze miejsce w zrodle dla kazdego segmentu - czlowiek porownuje z cytatem.
out.fragmenty_zrodla = frag.detail.map((d) => fragmentZrodla(oryginal, d.zakres));
return out;
}
// cytat nieznaleziony - ale czy dokument w ogole mowi o rzeczy (TRESC)?
// v2.3: prog na pokryciu WAZONYM - obecnosc samych fraz szablonowych nie ratuje
// brakujacego cytatu doslownego (lekcja lavern: boilerplate nie jest dowodem).
if (tresc && tresc.pokrycie >= 0.7) {
out.status = "KALIBRACJA";
out.note = "doslowny cytat nieznaleziony, ale zrodlo dotyczy tematu (poziom TRESC). Zloagodz do parafrazy LUB oznacz pinpoint jako prowizoryczny.";
out.detail = { brakujace_terminy: tresc.brakujace, zbieznosc_fragmentu: tresc.zbieznosc };
return out;
}
out.status = "NIEZWERYFIKOWANY";
out.note = tresc && tresc.pokrycieSurowe >= 0.7
? "brak cytatu; terminy obecne w zrodle to glownie jezyk szablonowy (pokrycie wazone " +
`${Math.round(tresc.pokrycie * 100)}%, surowe ${Math.round(tresc.pokrycieSurowe * 100)}%) - potencjalna halucynacja, BLOKADA`
: "brak cytatu i brak pokrycia terminow - potencjalna halucynacja, BLOKADA";
out.detail = frag ? frag.detail : { powod: "brak tekstu/quote" };
// detail z FRAGMENT to TABLICA segmentow - rozsmarowana spreadem dawala klucze "0", "1".
if (tresc) {
const baza = Array.isArray(out.detail) ? { segmenty: out.detail } : (out.detail || {});
out.detail = { ...baza, terminy_szablonowe: tresc.boilerplate, zbieznosc_fragmentu: tresc.zbieznosc };
}
return out;
}
if (wymagany === POZIOM.TRESC) {
if (!tresc) { out.status = "BRAK_ZRODLA"; out.note = "brak claim_text/quote lub tekstu zrodla"; return out; }
if (tresc.pokrycie >= 0.7) {
out.status = "WYMAGA_OSADU";
out.note = `terminy nosne obecne (${Math.round(tresc.pokrycie * 100)}%) - substancje potwierdza czlowiek/paraphrase-judge`;
// Sygnal zbieznosci (v2.3): terminy obecne, ale zaden zwarty fragment zrodla nie odpowiada
// twierdzeniu - podwyzszone ryzyko "prawdziwe slowa, falszywa teza". Uwaga, nie blokada.
if (tresc.zbieznosc != null && tresc.zbieznosc < PROG_ZBIEZNOSC_NISKA) {
out.note += `; UWAGA: terminy rozproszone po zrodle (zbieznosc fragmentu ${Math.round(tresc.zbieznosc * 100)}%) - brak zwartego fragmentu odpowiadajacego twierdzeniu`;
}
out.detail = { pokrycie: tresc.pokrycie, pokrycie_surowe: tresc.pokrycieSurowe, brakujace_terminy: tresc.brakujace, terminy_szablonowe: tresc.boilerplate, zbieznosc_fragmentu: tresc.zbieznosc };
return out;
}
// v2.3: pokrycie surowe wysokie, ale wazone ponizej progu = dowod glownie szablonowy.
// Miekko (czlowiek osadza), bo wszystkie terminy SA w zrodle - to nie klasyczna halucynacja.
if (tresc.pokrycieSurowe >= 0.7) {
out.status = "WYMAGA_OSADU";
out.note = `terminy obecne, ale pokrycie w przewazajacej mierze jezykiem szablonowym (wazone ${Math.round(tresc.pokrycie * 100)}%, surowe ${Math.round(tresc.pokrycieSurowe * 100)}%) - podwyzszona ostroznosc, substancje potwierdza czlowiek`;
out.detail = { pokrycie: tresc.pokrycie, pokrycie_surowe: tresc.pokrycieSurowe, terminy_szablonowe: tresc.boilerplate, brakujace_terminy: tresc.brakujace, zbieznosc_fragmentu: tresc.zbieznosc };
return out;
}
out.status = "NIEZWERYFIKOWANY";
out.note = `zrodlo nie zawiera terminow nosnych twierdzenia (pokrycie ${Math.round(tresc.pokrycie * 100)}%) - potencjalna halucynacja`;
out.detail = { pokrycie: tresc.pokrycie, brakujace_terminy: tresc.brakujace, obecne_terminy: tresc.obecne };
return out;
}
// wymagany === ISTNIENIE
if (ist.stan === "potwierdzona") {
out.status = "ZWERYFIKOWANY";
out.note = "kotwica (sygnatura+data) potwierdzona w rozwiazanym zrodle";
if (ist.uwagi && ist.uwagi.length) { out.status = "WYMAGA_OSADU"; out.note = "tozsamosc potwierdzona, ale organ niezgodny - sprawdz"; out.uwagi = ist.uwagi; }
return out;
}
if (istnienieDomniemane) {
out.status = "WYMAGA_OSADU";
out.note = "istnienie DOMNIEMANE (jest tekst, brak rozwiazanej kotwicy) - rozwiaz sygnature przez saos-orzecznictwo / eu-sparql przy wysokiej stawce";
return out;
}
out.status = "BRAK_ZRODLA";
out.note = "kotwica nierozwiazana i brak tekstu zrodla - rozwiaz sygnature lub dostarcz dokument";
return out;
}
function main() {
const path = process.argv[2];
if (!path) {
console.error("Usage: node ground-citations.mjs <task.json>");
process.exit(2);
}
const task = JSON.parse(readFileSync(path, "utf8").replace(/^/, ""));
const items = Array.isArray(task.items) ? task.items : [];
const results = items.map(verify);
const liczba = (s) => results.filter((r) => r.status === s).length;
const summary = {
total: results.length,
zweryfikowane: liczba("ZWERYFIKOWANY"),
zmodyfikowane: liczba("ZMODYFIKOWANY"),
wymaga_osadu: liczba("WYMAGA_OSADU"),
kalibracja: liczba("KALIBRACJA"),
niezweryfikowane: liczba("NIEZWERYFIKOWANY"),
brak_zrodla: liczba("BRAK_ZRODLA"),
// v3: z ilu "niezweryfikowanych" wynika zmiana tresci albo opuszczenie (podzbior, nie osobna pula)
zmieniona_tresc: results.filter((r) => r.powod_kod === "zmieniona_tresc").length,
opuszczenie: results.filter((r) => String(r.powod_kod || "").startsWith("opuszczenie")).length,
};
// BLOKADA twarda: halucynacja lub brak zrodla. KALIBRACJA/WYMAGA_OSADU = decyzja czlowieka (miekka).
// Pusta lista to tez BLOKADA: zero sprawdzonych cytatow nie jest dowodem, ze cytaty sa dobre.
const pusta = results.length === 0;
const blokada = pusta || summary.niezweryfikowane > 0 || summary.brak_zrodla > 0;
const wymaga_decyzji = summary.kalibracja > 0 || summary.wymaga_osadu > 0;
const powod = pusta
? (Array.isArray(task.items) ? "pusta lista cytatow (items: []) - nic nie zweryfikowano" : "brak pola items w zadaniu - nic nie zweryfikowano")
: undefined;
console.log(JSON.stringify({ summary, blokada, ...(powod ? { powod } : {}), wymaga_decyzji, results }, null, 2));
process.exit(blokada ? 1 : 0);
}
// Uruchom main() tylko jako CLI; przy imporcie (testy) silnik pozostaje biblioteka.
const argvPath = process.argv[1] ? pathToFileURL(process.argv[1]).href : "";
if (import.meta.url === argvPath) main();
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the work | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixes | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation code | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| skill-creatoranthropics/skillsCreate new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |