talos-code 0.0.1 → 0.1.0

package/vendor/harness-ui/src/research/narration.mjs

@@ -0,0 +1,181 @@
+import {
+    talosResearchIsResting,
+    talosResearchIsTerminal,
+    talosResearchWorkLeft,
+} from './run.mjs'
+import { talosResearchReportRefOf } from './card.mjs'
+
+/*
+ * PORTO FEDELE di AVM/mobile/src/lib/research/researchNarration.ts (150 righe, 11/09/2026).
+ *
+ * ⛔ `run.mjs` è il porto di `researchRun.ts` e lo cura un'altra sessione, in
+ * parallelo: qui se ne importa solo il nome concordato.
+ *
+ * Che cosa sta facendo la ricerca, detto in una frase.
+ *
+ * Owner 2026-08-03, sulla pagina com'era: «non c'è un progresso di quello che
+ * si sta facendo … dei termini molto tecnici». Aveva ragione, e la diagnosi è
+ * precisa: la pagina diceva QUANTO (`0/2`, `3 s`, `RACCOLGO`) e mai CHE COSA.
+ * Un contatore ha significato solo per chi già sa che cosa si sta contando; chi
+ * guarda vuole l'altra metà.
+ *
+ * Il materiale per la frase c'era già e non veniva usato. Il piano è stato
+ * approvato prima che si spendesse un centesimo, quindi ogni ramo porta la
+ * domanda a cui è andato a rispondere — il che vuol dire che «sto cercando le
+ * fonti su «chi la brevettò»» non è una parafrasi gentile dello stato, È lo
+ * stato, letto ad alta voce.
+ *
+ * Tutto qui dentro è aritmetica sulla corsa: niente disco, niente rete, nessun
+ * orologio proprio. La riga si può quindi disegnare nello stesso fotogramma del
+ * tocco.
+ */
+
+/**
+ * @import { TalosResearchRun, TalosResearchStep } from './run.mjs'
+ */
+
+/**
+ * @typedef {object} TalosResearchLine
+ * @property {string} key Una chiave i18n. Le parole vivono nelle traduzioni, mai qui.
+ * @property {Readonly<Record<string, string>>} params
+ */
+
+/** @type {Readonly<Record<string, string>>} */
+const NO_PARAMS = Object.freeze({})
+
+/**
+ * @param {string} key
+ * @param {Readonly<Record<string, string>>} [params]
+ * @returns {TalosResearchLine}
+ */
+function line(key, params = NO_PARAMS) {
+    return { key, params }
+}
+
+/**
+ * La domanda a cui un ramo è andato a rispondere — l'unico nome umano che un passo ha.
+ * @param {TalosResearchRun} run
+ * @param {string} branchId
+ * @returns {string | null}
+ */
+function branchQuestion(run, branchId) {
+    return run.plan.find((branch) => branch.id === branchId)?.question ?? null
+}
+
+/**
+ * Una frase per tutta la corsa.
+ *
+ * `driving` viene dal registro e non dal giornale, e i due sono davvero in
+ * disaccordo: una corsa uccisa insieme all'app legge ancora `collecting`, e
+ * dire «sto cercando» di una corsa che nessuno sta guidando è una bugia che la
+ * persona può stare a guardare per un'ora. Fermo è una frase sua, con il punto
+ * da cui ripartirebbe.
+ *
+ * @param {TalosResearchRun} run
+ * @param {boolean} driving
+ * @returns {TalosResearchLine}
+ */
+export function talosResearchNarration(run, driving) {
+    if (talosResearchIsTerminal(run.status)) {
+        if (run.status === 'cancelled') return line('research.cancelledHere')
+        if (run.status === 'failed') return line('research.say.failed')
+        /*
+         * «Conclusa» e «conclusa senza rapporto» sono lo stesso stato e due
+         * situazioni completamente diverse, e dire alla persona la prima quando
+         * era la seconda è costato ore il 2026-08-03: la corsa era finita, la
+         * pagina lo diceva, e nessuno ha pensato di chiedersi perché non ci
+         * fosse niente da leggere.
+         */
+        return talosResearchReportRefOf(run) ? line('research.say.done') : line('research.doneNoReport')
+    }
+
+    // Da dove ripartirebbe. Le corse terminali non devono niente, ed è per
+    // questo che si legge solo dopo il ramo terminale qui sopra.
+    const next = talosResearchWorkLeft(run)[0]?.question ?? null
+
+    /*
+     * Aver chiesto di fermarsi non è essersi fermati. Una pausa durante un
+     * passo già pagato lo lascia finire e depositare prima — «drain then
+     * checkpoint» — e lo scarto fra i due può essere un minuto in cui una
+     * persona guarda un pulsante che ha già premuto. Dire «in pausa» lì
+     * sarebbe la parola della pagina contro quella della rotella.
+     */
+    if (run.status === 'pause_requested') return line('research.say.pausing')
+    if (talosResearchIsResting(run.status)) {
+        return next ? line('research.say.pausedAt', { question: next }) : line('research.say.paused')
+    }
+    if (!driving) {
+        return next ? line('research.say.stoppedAt', { question: next }) : line('research.say.stopped')
+    }
+    if (run.plan.length === 0) return line('research.say.planning')
+
+    const running = run.steps.find((step) => step.state === 'running')
+    if (running) {
+        if (running.kind === 'synthesise') return line('research.say.writing')
+        if (running.kind === 'verify') return line('research.say.verifying')
+        const question = branchQuestion(run, running.branchId)
+        if (!question) return line('research.say.collecting')
+        return line(running.kind === 'read' ? 'research.say.reading' : 'research.say.searching', { question })
+    }
+
+    // Fra due passi il motore ha già deciso che cosa viene dopo, e lo scarto è
+    // di millisecondi. Dire che cosa sta per fare batte il tacere proprio nel
+    // fotogramma in cui è più probabile che una persona stia guardando.
+    return next ? line('research.say.searching', { question: next }) : line('research.say.writing')
+}
+
+/**
+ * @typedef {object} TalosResearchDoneNotice
+ * @property {string} title Le parole della persona, non tradotte — è la sua domanda.
+ * @property {TalosResearchLine} text
+ * @property {string} route La pagina di QUESTA ricerca. Una notifica che atterra
+ *   altrove ha speso l'attenzione dell'utente senza restituire niente.
+ */
+
+/**
+ * Che cosa annunciare quando una ricerca finisce, oppure niente.
+ *
+ * Una ricerca dura minuti: la persona la avvia, blocca il telefono, e fino a
+ * oggi niente le diceva che era finita. Doveva stare lì a guardarla — il che
+ * rende il lavoro in sottofondo senza valore.
+ *
+ * `cancelled` tace apposta. L'hanno fermata loro pochi secondi fa; dirgli che
+ * si è fermata è l'app che gli ripete la loro stessa azione, e ogni notifica
+ * così rende più facile scartare la prossima senza leggerla.
+ *
+ * @param {TalosResearchRun} run
+ * @returns {TalosResearchDoneNotice | null}
+ */
+export function talosResearchDoneNotice(run) {
+    if (!talosResearchIsTerminal(run.status)) return null
+    if (run.status === 'cancelled') return null
+    return {
+        title: run.title ?? run.question,
+        // Non guidata, e terminale: la stessa frase che mostra la pagina, che è
+        // il modo in cui la notifica e la pagina non possono finire in disaccordo.
+        text: talosResearchNarration(run, false),
+        route: `/research/${run.id}`,
+    }
+}
+
+/**
+ * Il nome di un passo, per il registro in fondo alla pagina.
+ *
+ * Il registro stampava `b1:search` e `synthesis`, che sono gli identificativi
+ * del motore — utili a esattamente un lettore, e li ha scritti lui. I nomi qui
+ * dicono a che cosa SERVIVA il passo, e la domanda del ramo rende ogni ricerca
+ * distinguibile dalla successiva senza un numero di serie.
+ *
+ * @param {TalosResearchRun} run
+ * @param {TalosResearchStep} step
+ * @returns {TalosResearchLine}
+ */
+export function talosResearchStepTitle(run, step) {
+    if (step.kind === 'synthesise') return line('research.stepTitle.write')
+    if (step.kind === 'verify') return line('research.stepTitle.verify')
+    const question = branchQuestion(run, step.branchId)
+    if (step.kind === 'read') {
+        return question ? line('research.stepTitle.read', { question }) : line('research.stepTitle.readPlain')
+    }
+    return question ? line('research.stepTitle.search', { question }) : line('research.stepTitle.searchPlain')
+}

package/vendor/harness-ui/src/research/open-cards.mjs

@@ -0,0 +1,131 @@
+/*
+ * PORTO FEDELE di AVM/mobile/src/lib/research/researchOpenCards.ts (112 righe, 11/09/2026).
+ *
+ * Le due schede che il rapporto tiene APERTE, e il pezzo da evidenziare.
+ *
+ * ## Perché aperte, e non dietro un tocco
+ *
+ * Il dissenso fra le fonti e l'affermazione che dice più di quanto la sua
+ * pagina sostenga sono le due cose che nessun concorrente mostra. Finiscono
+ * dietro un tocco solo se si dà per scontato che la persona vada a cercarle —
+ * ma chi legge un rapporto all'86% non ha motivo di aprire proprio quella riga,
+ * ed è esattamente quella che gli serve.
+ *
+ * ⇒ Il rapporto porta in superficie UNA contesa e UNA che eccede. Non tutte:
+ * una scheda ciascuna, come esempio leggibile, e l'elenco completo resta nella
+ * scheda «Affermazioni». Il mockup approvato disegna esattamente questo.
+ *
+ * ## Perché una scheda si può RIFIUTARE di mostrare
+ *
+ * Una contesa senza i passaggi contrari disegnerebbe due colonne di cui una
+ * vuota; una parziale senza il motivo direbbe «sostenuta solo in parte» e
+ * nient'altro — cioè quello che la riga dell'elenco già dice. In entrambi i
+ * casi la scheda occupa lo schermo e non aggiunge niente, e allora non si
+ * mostra. `null` è un esito, non un guasto.
+ */
+
+/**
+ * @typedef {import('./verification.mjs').TalosResearchChecks} TalosResearchChecks
+ * @typedef {import('./verification.mjs').TalosResearchSpan} TalosResearchSpan
+ */
+
+/**
+ * Un passaggio spezzato in tre, per evidenziare il pezzo che il giudice ha
+ * riconosciuto. `quote` vuota vuol dire «non si evidenzia niente»: il testo
+ * intero è in `before` e si stampa così com'è.
+ *
+ * @typedef {object} TalosResearchMarkedPassage
+ * @property {string} before
+ * @property {string} quote
+ * @property {string} after
+ */
+
+/**
+ * ⛔ Lo span è stato calcolato quando la pagina è stata letta, e il passaggio
+ * viene dal disco: sono due dati che possono essersi disallineati. Un indice
+ * fuori misura NON evidenzia il pezzo sbagliato — non evidenzia niente, e il
+ * passaggio si legge intero. Evidenziare a caso è peggio che non evidenziare,
+ * perché sposta la fiducia su una parola che nessuno ha giudicato.
+ *
+ * @param {string | null | undefined} passage
+ * @param {TalosResearchSpan | null | undefined} span
+ * @returns {TalosResearchMarkedPassage}
+ */
+export function talosResearchMarkedPassage(passage, span) {
+  const testo = passage ?? '';
+  const intero = { before: testo, quote: '', after: '' };
+  if (!span) return intero;
+
+  const { from, to } = span;
+  if (!Number.isInteger(from) || !Number.isInteger(to)) return intero;
+  if (from < 0 || to > testo.length || from >= to) return intero;
+
+  return { before: testo.slice(0, from), quote: testo.slice(from, to), after: testo.slice(to) };
+}
+
+/**
+ * Il minimo che serve per scegliere: il resto della scheda non lo decide questo file.
+ *
+ * @typedef {object} TalosResearchOpenClaim
+ * @property {string} text
+ * @property {string} passage
+ * @property {TalosResearchChecks} checks
+ */
+
+/**
+ * L'affermazione scelta e il suo posto nell'elenco, perché la scheda ci porti.
+ *
+ * @template T
+ * @typedef {object} TalosResearchOpenCard
+ * @property {T} claim
+ * @property {number} index
+ */
+
+/**
+ * @template {TalosResearchOpenClaim} T
+ * @param {readonly T[] | null | undefined} claims
+ * @param {(claim: T) => boolean} vale
+ * @returns {TalosResearchOpenCard<T> | null}
+ */
+function scegli(claims, vale) {
+  if (!claims) return null;
+  for (let index = 0; index < claims.length; index += 1) {
+    const claim = claims[index];
+    if (claim && vale(claim)) return { claim, index };
+  }
+  return null;
+}
+
+/**
+ * La prima contesa CHE HA I PASSAGGI CONTRARI.
+ *
+ * ⛔ `opposing` assente non vuol dire «non ce ne sono»: vuol dire «una verifica
+ * vecchia non li ha guardati». In entrambi i casi non c'è niente da affiancare,
+ * e la scheda non si apre.
+ *
+ * @template {TalosResearchOpenClaim} T
+ * @param {readonly T[] | null | undefined} claims
+ * @returns {TalosResearchOpenCard<T> | null}
+ */
+export function talosResearchContestedCard(claims) {
+  return scegli(claims, (claim) =>
+    claim.checks.claimSupported === 'contested'
+    && (claim.checks.opposing ?? []).some((contro) => Boolean(contro.passage?.trim())));
+}
+
+/**
+ * La prima che eccede la sua fonte, col motivo per cui la eccede.
+ *
+ * Senza motivo la scheda ripeterebbe la riga dell'elenco; il valore è la frase
+ * che dice DOVE l'affermazione va oltre, non il verdetto.
+ *
+ * @template {TalosResearchOpenClaim} T
+ * @param {readonly T[] | null | undefined} claims
+ * @returns {TalosResearchOpenCard<T> | null}
+ */
+export function talosResearchOverreachingCard(claims) {
+  return scegli(claims, (claim) =>
+    claim.checks.claimSupported === 'partial'
+    && Boolean(claim.checks.supportReason?.trim())
+    && Boolean(claim.passage?.trim()));
+}

package/vendor/harness-ui/src/research/opposing.mjs

@@ -0,0 +1,305 @@
+/*
+ * PORTO FEDELE di AVM/mobile/src/lib/research/researchOpposing.ts (279 righe, 11/09/2026).
+ *
+ * ⛔⛔ CONTESA-02 — cercare chi dice il CONTRARIO.
+ *
+ * ## Il difetto misurato sul Pad il 2026-08-20
+ *
+ * Il rapporto su GGUF scriveva, in chiaro, «le fonti… non specificano però
+ * formalmente un maintainer unico»: una divergenza, in prosa. La barra sopra
+ * diceva **7 su 7 sostenute · 0 contese**. `talosResearchContestedVerdict`
+ * esisteva coi suoi test, e **non lo chiamava nessuno**: la contesa non poteva
+ * entrare nei dati, quindi né la barra né la scheda potevano mostrarla mai.
+ *
+ * ## Perché serve un secondo giro, e perché costa poco
+ *
+ * Il giudice risponde su UNA coppia (affermazione, passaggio). Per sapere se
+ * qualcun altro dice il contrario bisogna dargli l'altro passaggio: è una
+ * domanda in più, non c'è scorciatoia. Il costo si tiene basso scegliendo
+ * **un solo candidato** per affermazione, e solo quando ne esiste uno che
+ * parla davvero dello stesso argomento.
+ *
+ * ⛔ E si chiede solo sulle affermazioni già SOSTENUTE (o in parte): la contesa
+ * è disaccordo, e il disaccordo esiste solo se prima c'era un accordo. Su una
+ * già smentita una fonte contraria non è un conflitto, è la stessa cosa detta
+ * due volte.
+ *
+ * ## Perché la scelta è lessicale e non semantica
+ *
+ * Un modello che sceglie il candidato è un secondo giudizio pagato per
+ * decidere cosa far giudicare, e sposta il risultato prima ancora di
+ * misurarlo. La sovrapposizione di parole è cieca, gratis e ripetibile: non
+ * decide chi ha ragione, decide soltanto **di cosa si sta parlando**. Il
+ * verdetto resta al giudice.
+ */
+
+/** @typedef {import('./collector.mjs').TalosResearchSource} TalosResearchSource */
+
+/** Le parole che portano significato: le corte le ha ogni frase. */
+const CORTA = 4;
+/** Sotto due parole in comune non si sta parlando della stessa cosa. */
+const SOGLIA = 2;
+/**
+ * ⛔⛔ Sopra questa soglia i due passaggi sono LA STESSA FRASE.
+ *
+ * MISURATO sul Pad il 2026-08-20, prima contesa vera trovata dal giudice:
+ * «Dice di sì» e «Dice di no» portavano il testo IDENTICO, parola per
+ * parola, da due siti che si ricopiano. Il giudice aveva risposto «sì,
+ * contraddice» a una frase uguale a quella che aveva appena approvato.
+ *
+ * ⇒ Due siti che riportano la stessa frase sono un'ECO, non un disaccordo —
+ * ed è la stessa distinzione che il rapporto fa già sulle fonti
+ * indipendenti. Una contesa inventata è peggio di una contesa non trovata:
+ * toglie forza a quelle vere.
+ */
+const ECO = 0.9;
+
+/**
+ * ⛔ Sotto questo numero di parole di contenuto il rapporto non dice niente:
+ * due frasi corte con due parole in comune non sono la stessa frase.
+ */
+const PAVIMENTO = 4;
+
+/** Un passaggio più lungo di così non è una citazione, è una pagina. */
+const MASSIMO = 400;
+
+/**
+ * ⛔⛔ Una TABELLA SROTOLATA non è una frase, e non si manda al giudice.
+ *
+ * FOTOGRAFATO sul Pad il 2026-08-20: come passaggio contrario è arrivato
+ * l'infobox di una pagina, estratto senza spazi fra le celle —
+ * «…0x46Developed byGeorgi Gerganov and communityInitial releaseAugust 22,
+ * 2023…». Il giudice ha risposto «sì, contraddice» a un blocco che in realtà
+ * CONFERMAVA la data: gli era stata data spazzatura, e ha risposto lo stesso.
+ *
+ * Il segno è preciso: una minuscola attaccata a una maiuscola è il punto in
+ * cui due celle si sono toccate. La prosa non lo fa quasi mai — una volta
+ * capita («iPhone», un nome proprio); tre volte in una frase sola è una
+ * tabella.
+ *
+ * ⛔ E si scarta PRIMA di pagare il giudice: una risposta comprata su un
+ * testo illeggibile costa uguale e vale meno di niente, perché entra nel
+ * rapporto come se fosse una verifica.
+ */
+const INCOLLATE = /\p{Ll}\p{Lu}/gu;
+const MAX_INCOLLATE = 3;
+
+/**
+ * @param {string} frase
+ * @returns {boolean}
+ */
+function tabellaSrotolata(frase) {
+  return (frase.match(INCOLLATE)?.length ?? 0) >= MAX_INCOLLATE;
+}
+
+/**
+ * Quanto questa frase è la stessa cosa del passaggio già approvato.
+ *
+ * ⛔⛔ Il confronto è nel VERSO PIÙ CORTO, e la prima versione lo faceva in uno
+ * solo — quello comodo.
+ *
+ * FOTOGRAFATO sul Pad il 2026-08-20, seconda contesa: «Dice di sì» portava
+ * «Sviluppato da Georgi Gerganov e dal team del progetto llama.cpp come
+ * evoluzione del precedente GGML», e «Dice di no» portava LA STESSA FRASE più
+ * un paragrafo di contorno. Guardando solo quanta parte della frase contraria
+ * è nel passaggio a favore, il contorno abbassava il rapporto e l'eco passava.
+ *
+ * ⇒ Si divide per il PIÙ CORTO dei due: se uno contiene l'altro, sono la
+ * stessa affermazione con più cornice, in qualunque verso stia la cornice. Il
+ * pavimento a quattro parole evita che due frasi brevissime con due parole in
+ * comune si dichiarino identiche.
+ *
+ * @param {string} frase
+ * @param {Set<string>} sostiene
+ * @returns {boolean}
+ */
+function eco(frase, sostiene) {
+  if (sostiene.size === 0) return false;
+  const sue = contenuto(frase);
+  if (sue.size === 0) return false;
+  let comuni = 0;
+  for (const parola of sue) if (sostiene.has(parola)) comuni += 1;
+  const piuCorto = Math.max(PAVIMENTO, Math.min(sue.size, sostiene.size));
+  return comuni / piuCorto >= ECO;
+}
+
+/**
+ * @param {string} testo
+ * @returns {Set<string>}
+ */
+function contenuto(testo) {
+  const parole = testo
+    .toLowerCase()
+    .replace(/[^\p{L}\p{N}\s]/gu, ' ')
+    .split(/\s+/)
+    .filter((parola) => parola.length >= CORTA);
+  return new Set(parole);
+}
+
+/**
+ * Le frasi di un testo, tagliate anche dove la punteggiatura non arriva.
+ *
+ * ⛔ Un muro di testo senza punti diventerebbe UNA frase lunga quanto la
+ * pagina, e mandarla al giudice sarebbe mandargli la pagina intera: la domanda
+ * diventerebbe «questa fonte dice il contrario», che non è verificabile.
+ *
+ * @param {string} testo
+ * @returns {string[]}
+ */
+function frasi(testo) {
+  /** @type {string[]} */
+  const out = [];
+  for (const pezzo of testo.split(/(?<=[.!?])\s+/)) {
+    const pulito = pezzo.trim();
+    if (!pulito) continue;
+    if (pulito.length <= MASSIMO) { out.push(pulito); continue; }
+
+    // ⛔ Il taglio cade sull'ULTIMO SPAZIO, non al carattere esatto.
+    //   FOTOGRAFATO sul Pad il 2026-08-20: un passaggio finiva con
+    //   «distributing quantized large lang» — mezza parola. Al giudice
+    //   arrivava una frase mutilata, e alla persona pure.
+    let da = 0;
+    while (da < pulito.length) {
+      let a = Math.min(da + MASSIMO, pulito.length);
+      if (a < pulito.length) {
+        const spazio = pulito.lastIndexOf(String.fromCharCode(32), a);
+        if (spazio > da) a = spazio;
+      }
+      const fetta = pulito.slice(da, a).trim();
+      if (fetta) out.push(fetta);
+      da = a;
+    }
+  }
+  return out;
+}
+
+/**
+ * Una fonte diversa da quella citata, e la sua frase più pertinente.
+ *
+ * @typedef {object} TalosResearchOpposingCandidate
+ * @property {number} sourceIndex L'indice nella lista delle fonti raccolte, contando da zero.
+ * @property {string} url
+ * @property {string} title
+ * @property {string} passage
+ * @property {{from:number, to:number}} span
+ * @property {number} overlap Quante parole di contenuto ha in comune con l'affermazione.
+ */
+
+/**
+ * La frase, in un'altra fonte, che parla più da vicino di questa affermazione.
+ *
+ * ⛔ `null` quando nessuna arriva alla soglia: chiedere al giudice di
+ * confrontare l'affermazione con un paragrafo che non c'entra produce un «no,
+ * non lo contraddice» che sembra una verifica e non lo è — e costa comunque.
+ *
+ * ⛔ E la fonte già citata è esclusa: il giudice l'ha appena letta. Riproporgli
+ * la stessa pagina significherebbe farsi contraddire da chi ha appena detto di
+ * sì, e chiamare «contesa» un disaccordo con sé stesso.
+ *
+ * @param {string} claimText
+ * @param {number} citedIndex
+ * @param {readonly TalosResearchSource[]} sources
+ * @param {string} [citedPassage=''] Il passaggio che sostiene l'affermazione: chi lo ripete non lo nega.
+ * @returns {TalosResearchOpposingCandidate | null}
+ */
+export function talosResearchOpposingCandidate(claimText, citedIndex, sources, citedPassage = '') {
+  const parole = contenuto(claimText);
+  if (parole.size === 0) return null;
+  const sostiene = contenuto(citedPassage);
+
+  /** @type {TalosResearchOpposingCandidate | null} */
+  let migliore = null;
+
+  for (let indice = 0; indice < sources.length; indice += 1) {
+    if (indice === citedIndex) continue;
+    const fonte = sources[indice];
+    if (!fonte?.text) continue;
+
+    let scorso = 0;
+    for (const frase of frasi(fonte.text)) {
+      // La posizione si cerca a partire da dove siamo arrivati: la stessa
+      // frase può comparire due volte, e la seconda non sta dove sta la
+      // prima.
+      const da = fonte.text.indexOf(frase, scorso);
+      if (da >= 0) scorso = da + frase.length;
+
+      let overlap = 0;
+      for (const parola of contenuto(frase)) if (parole.has(parola)) overlap += 1;
+      if (overlap < SOGLIA) continue;
+      if (migliore && overlap <= migliore.overlap) continue;
+      // ⛔ Prima ancora dell'eco: se non è prosa, non è un passaggio.
+      if (tabellaSrotolata(frase)) continue;
+      // ⛔ L'eco si scarta QUI, prima di pagare il giudice: chiedergli se
+      //   una frase contraddice sé stessa è comprare una risposta a una
+      //   domanda senza senso.
+      if (eco(frase, sostiene)) continue;
+
+      migliore = {
+        sourceIndex: indice,
+        url: fonte.url,
+        title: fonte.title,
+        passage: frase,
+        span: da >= 0 ? { from: da, to: da + frase.length } : { from: 0, to: 0 },
+        overlap,
+      };
+    }
+  }
+
+  return migliore;
+}
+
+/**
+ * La domanda al giudice, e non è la stessa di prima.
+ *
+ * ⛔ Non «sostiene l'affermazione?» ma «la CONTRADDICE?». Sembra la stessa
+ * domanda al negativo e non lo è: un passaggio che non sostiene un'affermazione
+ * quasi sempre non dice niente al riguardo, e leggere quel silenzio come una
+ * smentita farebbe apparire contese ovunque. La contesa deve essere DETTA dalla
+ * fonte.
+ *
+ * @param {string} claim
+ * @param {string} passage
+ * @returns {string}
+ */
+export function talosResearchOpposingPrompt(claim, passage) {
+  return [
+    'Passaggio, copiato da UN’ALTRA fonte:',
+    '"""',
+    passage,
+    '"""',
+    '',
+    'Affermazione:',
+    claim,
+    '',
+    'Questo passaggio CONTRADDICE l’affermazione?',
+    'Contraddire vuol dire dire il contrario, non tacere: se il passaggio',
+    'semplicemente non parla dell’affermazione, la risposta è NO.',
+    'Non usare altro: né quello che sai, né quello che ti sembra probabile.',
+    '',
+    // ⛔ Nessun menu con le barre: un modello lo ricopia invece di
+    //   sceglierne una voce. Vedi la nota sulla domanda del primo giro.
+    'Rispondi con UNA riga sola. Comincia con SI oppure con NO,',
+    'poi un trattino e il motivo, massimo quindici parole.',
+    '',
+    'Esempio di risposta: NO — il passaggio non parla di questo.',
+  ].join('\n');
+}
+
+/**
+ * Legge la riga del giudice: contraddice, sì o no.
+ *
+ * ⛔ Nel dubbio è NO. Una risposta illeggibile letta come «sì» marcherebbe
+ * contesa un'affermazione che nessuno ha smentito, e una contesa inventata è
+ * peggio di una contesa non trovata: toglie forza a quelle vere.
+ *
+ * @param {string} risposta
+ * @returns {boolean}
+ */
+export function talosResearchParseOpposingVerdict(risposta) {
+  const riga = risposta.trim().toLowerCase();
+  if (!riga) return false;
+  // Si guarda solo la PRIMA parola: un motivo che contiene «no» dentro una
+  // frase («non c'è dubbio che sia il contrario») non deve ribaltare l'esito.
+  const prima = riga.split(/[^\p{L}]+/u).filter(Boolean)[0];
+  return prima === 'si' || prima === 'sì' || prima === 'yes';
+}