talos-code 0.0.1 → 0.1.0

package/vendor/harness-ui/src/research/recheck-history.mjs

@@ -0,0 +1,192 @@
+/*
+ * PORTO FEDELE di AVM/mobile/src/lib/research/researchRecheckHistory.ts (176 righe, 11/09/2026).
+ *
+ * ⛔⛔ TENUTA-NEL-TEMPO-01 — quanto vale OGGI un rapporto di ieri.
+ *
+ * ## Cosa dice la letteratura, e perché cambia il calcolo
+ *
+ * Il decadimento delle citazioni web ha DUE assi, e confonderli è l'errore
+ * standard: il *link rot* è l'indirizzo che muore, il *content drift* è la
+ * pagina che risponde ancora e non dice più ciò che era stato citato. Lo studio
+ * di riferimento (Zittrain et al., Harvard Law Review 127 — il lavoro da cui è
+ * nato Perma.cc) misura il secondo a mano, controllando se il link «produce
+ * ancora la fonte originale»: fra i link ancora VIVI, solo il **29,9%**
+ * conteneva davvero il materiale citato. L'emivita dei riferimenti web è
+ * stimata fra i ~5 e i ~14 anni a seconda del corpus, e la regola pratica è che
+ * i primi cinque anni una bibliografia li attraversa quasi intatta.
+ *
+ * ⇒ Da qui la scelta che conta: **la tenuta si conta sui PASSAGGI, non sulle
+ * pagine**. Una pagina «cambiata» che conserva tutte le frasi su cui il
+ * rapporto si appoggia non gli ha tolto niente, e contarla come una perdita
+ * farebbe scendere un numero che nella sostanza non è sceso. È la stessa
+ * domanda che quegli studi pongono a mano — noi la possiamo porre da soli
+ * perché il testo di allora ce l'abbiamo.
+ *
+ * ## ⛔ Il ricontrollo c'era già, e non si poteva rileggere
+ *
+ * Ogni ricontrollo scriveva il suo documento in Libreria — in prosa, per una
+ * persona. Bello da leggere e impossibile da confrontare: ricavare i numeri
+ * ripassando l'italiano stampato è esattamente il modo in cui una misura
+ * diventa un'invenzione.
+ *
+ * ⇒ Il documento resta identico per chi lo legge, e in fondo porta un blocco
+ * che si rilegge ESATTO. Blocco recintato in coda, non frontmatter: è il posto
+ * in cui il Markdown conserva i dati strutturati (lo stesso trattamento che
+ * riceve JSON-LD), mentre il frontmatter è per i metadati e passerebbe sopra
+ * all'intestazione che la persona legge.
+ */
+
+import { talosResearchRecheckStanding } from './recheck.mjs';
+
+/** @typedef {import('./recheck.mjs').TalosResearchRecheck} TalosResearchRecheck */
+
+const FENCE_OPEN = '```talos-research-recheck';
+const FENCE_CLOSE = '```';
+
+/**
+ * Una tappa della storia: un ricontrollo, con quanto reggeva quel giorno.
+ *
+ * @typedef {object} TalosResearchRecheckTappa
+ * @property {string} at
+ * @property {number} total
+ * @property {number} intact
+ * @property {number} changed
+ * @property {number} unreachable
+ * @property {number} passagesStanding
+ * @property {number} passagesLost
+ * @property {number | null} tenuta
+ *   Quanti passaggi citati reggono ancora, da 0 a 1 — `null` quando non ce
+ *   n'era nessuno da controllare.
+ *   ⛔ `null` e 0 sono due cose diverse: «non c'era niente da controllare» e
+ *   «non regge più niente». Un `null` letto come zero disegna un crollo che
+ *   non è mai avvenuto.
+ */
+
+/**
+ * La tappa col suo `runId`, come sta scritta nel documento.
+ *
+ * @typedef {TalosResearchRecheckTappa & {runId: string}} TalosResearchRecheckRecord
+ */
+
+/**
+ * La tappa, e quanto è cambiata rispetto a quella prima di lei.
+ *
+ * @typedef {TalosResearchRecheckTappa & {primo: boolean, delta: number | null}} TalosResearchRecheckPasso
+ */
+
+/**
+ * @param {string} runId
+ * @param {TalosResearchRecheck} recheck
+ * @returns {TalosResearchRecheckRecord}
+ */
+function tappaDi(runId, recheck) {
+  const standing = talosResearchRecheckStanding(recheck);
+  // ⛔ `standing` aggrega solo i passaggi PERSI: quelli che reggono stanno
+  //   sulle singole fonti e vanno sommati qui. Senza il totale, «3 persi» non
+  //   dice niente — tre su quattro e tre su trecento sono due rapporti diversi.
+  const reggono = recheck.sources.reduce((totale, fonte) => totale + fonte.passagesStanding, 0);
+  const passaggi = reggono + standing.passagesLost;
+
+  return {
+    runId,
+    at: recheck.at,
+    total: standing.total,
+    intact: standing.intact,
+    changed: standing.changed,
+    unreachable: standing.unreachable,
+    passagesStanding: reggono,
+    passagesLost: standing.passagesLost,
+    tenuta: passaggi > 0 ? reggono / passaggi : null,
+  };
+}
+
+/**
+ * Il blocco da appendere al documento del ricontrollo.
+ *
+ * ⛔ Porta il `runId`: il nome del file è la domanda, e due ricerche possono
+ * farsi la stessa domanda. Legare la storia al nome vorrebbe dire mescolare i
+ * ricontrolli di ricerche diverse e non accorgersene mai.
+ *
+ * @param {string} runId
+ * @param {TalosResearchRecheck} recheck
+ * @returns {string}
+ */
+export function talosResearchRecheckBlock(runId, recheck) {
+  return [FENCE_OPEN, JSON.stringify(tappaDi(runId, recheck)), FENCE_CLOSE].join('\n');
+}
+
+/**
+ * La tappa dentro un documento, o `null` se lì non c'è.
+ *
+ * ⛔ Un documento vecchio — scritto prima che il blocco esistesse — torna
+ * `null`, non un oggetto a zero. Uno zero finirebbe nella storia come un
+ * crollo, e sarebbe un crollo inventato dal nostro formato.
+ *
+ * @param {string | null | undefined} text
+ * @returns {TalosResearchRecheckRecord | null}
+ */
+export function talosResearchParseRecheckBlock(text) {
+  if (!text) return null;
+  const apre = text.indexOf(FENCE_OPEN);
+  if (apre < 0) return null;
+  const daCapo = text.indexOf('\n', apre);
+  if (daCapo < 0) return null;
+  const chiude = text.indexOf(FENCE_CLOSE, daCapo);
+  if (chiude < 0) return null;
+
+  try {
+    const letto = JSON.parse(text.slice(daCapo + 1, chiude).trim());
+    if (typeof letto.runId !== 'string' || typeof letto.at !== 'string') return null;
+    /** @param {string} chiave */
+    const numero = (chiave) => (typeof letto[chiave] === 'number' ? letto[chiave] : 0);
+    return {
+      runId: letto.runId,
+      at: letto.at,
+      total: numero('total'),
+      intact: numero('intact'),
+      changed: numero('changed'),
+      unreachable: numero('unreachable'),
+      passagesStanding: numero('passagesStanding'),
+      passagesLost: numero('passagesLost'),
+      tenuta: typeof letto.tenuta === 'number' ? letto.tenuta : null,
+    };
+  } catch {
+    // Un blocco rotto è un blocco che non c'è. Non si indovina.
+    return null;
+  }
+}
+
+/**
+ * La storia in ordine di tempo, con il salto da una tappa all'altra.
+ *
+ * ⛔ Il delta si calcola solo fra due tappe che hanno ENTRAMBE una tenuta: da
+ * `null` a 0,86 non è un guadagno dell'86%, è la prima misura.
+ *
+ * @param {readonly TalosResearchRecheckTappa[]} tappe
+ * @returns {readonly TalosResearchRecheckPasso[]}
+ */
+export function talosResearchRecheckStoria(tappe) {
+  const ordinate = [...tappe]
+    .filter((tappa) => Number.isFinite(Date.parse(tappa.at)))
+    .sort((a, b) => Date.parse(a.at) - Date.parse(b.at));
+
+  // Lo stesso istante due volte è lo stesso ricontrollo salvato due volte:
+  // due righe identiche nella storia sono rumore, non un secondo controllo.
+  /** @type {Set<string>} */
+  const viste = new Set();
+  const distinte = ordinate.filter((tappa) => {
+    if (viste.has(tappa.at)) return false;
+    viste.add(tappa.at);
+    return true;
+  });
+
+  return distinte.map((tappa, indice) => {
+    const prima = indice > 0 ? distinte[indice - 1] : null;
+    const confrontabile = prima !== null && prima.tenuta !== null && tappa.tenuta !== null;
+    return {
+      ...tappa,
+      primo: indice === 0,
+      delta: confrontabile ? tappa.tenuta - prima.tenuta : null,
+    };
+  });
+}

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

@@ -0,0 +1,194 @@
+/*
+ * PORTO FEDELE di AVM/mobile/src/lib/research/researchRecheck.ts (176 righe, 11/09/2026).
+ *
+ * R12 — chiedere, più tardi, se le fonti dicono ancora quello che dicevano.
+ *
+ * Il motivo misurato per cui conta: **oltre il 75% dei contenuti web citati era
+ * cambiato entro tre anni**, e la raggiungibilità di una citazione scende
+ * dall'87% nei suoi primi cinque anni al 38% dopo dieci. Il link morto è la
+ * metà visibile; il link vivo che ora dice un'altra cosa è quello pericoloso,
+ * perché niente in lui sembra sbagliato.
+ *
+ * Nessun altro può fare questo controllo. Ogni prodotto di ricerca conserva
+ * URL, quindi il massimo che può dirti è se una richiesta riesce — e un soft
+ * 404 o una pagina riscritta in silenzio rispondono 200. Noi abbiamo tenuto il
+ * testo estratto, quindi la domanda che possiamo porre è quella che conta:
+ * *quello che abbiamo letto è ancora lì?*
+ *
+ * Due misure, di natura deliberatamente diversa:
+ *
+ *  - **Quanta parte del testo tenuto sopravvive**, come proporzione. Un'euristica,
+ *    e dichiarata tale. Usa il CONTENIMENTO invece di una somiglianza
+ *    simmetrica: una pagina che ha aggiunto tre paragrafi non ha perso niente
+ *    di ciò su cui ci appoggiavamo, e chiamarla «cambiata» griderebbe al lupo
+ *    su ogni sito vivo.
+ *  - **Se ogni passaggio citato è ancora ritrovabile**, esattamente, con lo
+ *    stesso controllo meccanico che usa R-4. Nessuna euristica, nessuna soglia,
+ *    nessuna opinione. È la risposta che decide se il rapporto regge ancora:
+ *    una pagina può essere riscritta da cima a fondo, e se le frasi che abbiamo
+ *    citato sono sopravvissute, le citazioni valgono quanto il giorno in cui
+ *    sono state fatte.
+ */
+
+import { talosResearchLocate } from './verification.mjs';
+
+/** @typedef {import('./report.mjs').TalosResearchReportRecord} TalosResearchReportRecord */
+
+/** @typedef {'intact' | 'changed' | 'unreachable'} TalosRecheckState */
+
+/** Quanta parte del testo tenuto deve sopravvivere perché una pagina conti come invariata. */
+const INTACT_AT = 0.95;
+
+/** Parole per shingle. Cinque è la misura consueta per il quasi-duplicato sulla prosa. */
+const SHINGLE = 5;
+
+/**
+ * @typedef {object} TalosResearchSourceRecheck
+ * @property {string} url
+ * @property {string} title
+ * @property {TalosRecheckState} state
+ * @property {number | null} survived 0…1 del testo tenuto ancora presente. Null quando la pagina non si è potuta leggere.
+ * @property {string | null} reason Perché non si è potuta leggere, quando è quella la risposta.
+ * @property {number} passagesStanding Passaggi citati ancora ritrovabili nella pagina di oggi.
+ * @property {number} passagesLost Passaggi citati che non ci sono più. Il numero che conta.
+ */
+
+/**
+ * @typedef {object} TalosResearchRecheck
+ * @property {string} at
+ * @property {readonly TalosResearchSourceRecheck[]} sources
+ */
+
+/**
+ * @param {string} text
+ * @returns {Set<string>}
+ */
+function shingles(text) {
+  const words = text.toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, ' ').split(/\s+/).filter(Boolean);
+  /** @type {Set<string>} */
+  const out = new Set();
+  for (let index = 0; index + SHINGLE <= words.length; index += 1) {
+    out.add(words.slice(index, index + SHINGLE).join(' '));
+  }
+  // Un testo troppo corto per gli shingle si confronta intero invece di essere
+  // dichiarato vuoto.
+  if (out.size === 0 && words.length > 0) out.add(words.join(' '));
+  return out;
+}
+
+/**
+ * Quanto di `kept` è ancora presente in `now`, da 0 a 1.
+ *
+ * Monodirezionale di proposito. La domanda non è «queste due pagine sono la
+ * stessa» — è «quello su cui ci appoggiavamo è ancora lì», e una pagina che è
+ * cresciuta non è una pagina che è cambiata sotto i nostri piedi.
+ *
+ * @param {string} kept
+ * @param {string} now
+ * @returns {number}
+ */
+export function talosResearchSurvival(kept, now) {
+  const before = shingles(kept);
+  if (before.size === 0) return 1;
+  const after = shingles(now);
+  let found = 0;
+  for (const piece of before) if (after.has(piece)) found += 1;
+  return found / before.size;
+}
+
+/**
+ * @typedef {object} TalosResearchRecheckDeps
+ * @property {(url: string) => Promise<{text: string} | null>} read Rilegge la pagina. Null o un lancio vogliono dire entrambi «non si è potuta leggere».
+ * @property {() => string} at
+ */
+
+/**
+ * Ricontrolla ogni fonte di un rapporto finito.
+ *
+ * IN SEQUENZA, come la verifica: questo gira su un telefono contro i server di
+ * altre persone, e una dozzina di richieste simultanee è il modo in cui una
+ * connessione domestica e un sito di notizie decidono entrambi che sei uno
+ * scraper.
+ *
+ * Una fonte che non si può leggere si registra, non si butta mai — e vale la
+ * pena dire perché questa non è una perdita: il testo estratto è ancora qui,
+ * quindi il dossier resta leggibile e citabile dopo che la pagina stessa è
+ * sparita. È tutta la ragione per cui il testo era stato tenuto.
+ *
+ * @param {TalosResearchRecheckDeps} deps
+ * @param {TalosResearchReportRecord} report
+ * @param {ReadonlyMap<string, string>} keptByUrl Il testo tenuto, per url — vive nei dossier, non nel rapporto.
+ * @returns {Promise<TalosResearchRecheck>}
+ */
+export async function talosResearchRecheckReport(deps, report, keptByUrl) {
+  /** @type {TalosResearchSourceRecheck[]} */
+  const sources = [];
+
+  for (const source of report.sources) {
+    const kept = keptByUrl.get(source.url) ?? '';
+    const quoted = report.claims
+      .filter((claim) => report.sources[claim.sourceIndex - 1]?.url === source.url)
+      .map((claim) => claim.passage)
+      .filter((passage) => passage.length > 0);
+
+    /** @type {{text: string} | null} */
+    let fresh = null;
+    /** @type {string | null} */
+    let reason = null;
+    try {
+      fresh = await deps.read(source.url);
+      if (!fresh) reason = 'unreadable';
+    } catch (failure) {
+      reason = failure instanceof Error ? failure.message : 'unreadable';
+    }
+
+    if (!fresh) {
+      sources.push({
+        url: source.url,
+        title: source.title,
+        state: 'unreachable',
+        survived: null,
+        reason,
+        // Non contati come persi: non riusciamo a vedere la pagina, che è una
+        // cosa diversa dall'aver guardato e non averli trovati.
+        passagesStanding: 0,
+        passagesLost: 0,
+      });
+      continue;
+    }
+
+    const survived = talosResearchSurvival(kept, fresh.text);
+    const standing = quoted.filter((passage) => talosResearchLocate(fresh.text, passage) !== null).length;
+
+    sources.push({
+      url: source.url,
+      title: source.title,
+      state: survived >= INTACT_AT ? 'intact' : 'changed',
+      survived,
+      reason: null,
+      passagesStanding: standing,
+      passagesLost: quoted.length - standing,
+    });
+  }
+
+  return { at: deps.at(), sources };
+}
+
+/**
+ * La riga che il lettore riceve per prima: cos'è successo al dossier da allora.
+ *
+ * @param {TalosResearchRecheck} recheck
+ * @returns {{total:number, intact:number, changed:number, unreachable:number, passagesLost:number}}
+ */
+export function talosResearchRecheckStanding(recheck) {
+  /** @param {TalosRecheckState} state */
+  const count = (state) => recheck.sources.filter((entry) => entry.state === state).length;
+  return {
+    total: recheck.sources.length,
+    intact: count('intact'),
+    changed: count('changed'),
+    unreachable: count('unreachable'),
+    // Citazioni che non risolvono più alle parole che citavano.
+    passagesLost: recheck.sources.reduce((total, entry) => total + entry.passagesLost, 0),
+  };
+}

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

@@ -0,0 +1,203 @@
+import { talosResearchVerifiedStanding } from './verification.mjs'
+
+/*
+ * PORTO FEDELE di AVM/mobile/src/lib/research/researchReport.ts (175 righe, 11/09/2026).
+ *
+ * ⛔ `verification.mjs` (porto di `researchVerification.ts`) lo cura un'altra
+ * sessione, in parallelo: qui se ne importa solo il nome concordato, senza
+ * duplicarne una riga.
+ *
+ * ⛔⛔ Questo è il pezzo che il cancello di consegna userà (disegno §6.5): il
+ * record recintato ` ```talos-research-report ` deve scriversi e rileggersi
+ * IDENTICO al mobile. Ogni carattere del recinto, l'ordine dei campi del
+ * record e il `null` invece di un recupero parziale sono parte del contratto,
+ * non stile.
+ *
+ * Il rapporto, scritto una volta per due lettori — e che porta il proprio verdetto.
+ *
+ * Stessa decisione del dossier, per la stessa ragione: prosa per una persona,
+ * un record recintato per il processo, scritti entrambi da un oggetto solo così
+ * che non possano divergere. Quello che cambia è CHE COSA tiene il record. Ogni
+ * affermazione porta il suo passaggio, dove quel passaggio sta nel testo tenuto
+ * della fonte, il verdetto, e il nome del giudice che l'ha dato.
+ *
+ * È la scommessa strutturale di questa fase. Verificare mentre si scrive lo
+ * sanno fare tutti; poi la verifica evapora, e un mese dopo il lettore ha un
+ * rapporto e nessun modo di chiedere come sia stato controllato. Siccome noi
+ * teniamo il passaggio E il verdetto E il giudice, il controllo è un artefatto:
+ * si può rileggere, rifare con un giudice diverso, e confrontare con quello che
+ * diceva la prima volta. Un prodotto che conserva gli URL non può farlo a
+ * nessun prezzo, perché la prova che ha controllato non c'è più.
+ *
+ * La prosa è stratificata dall'alto — risposta, poi affermazioni, poi fonti —
+ * perché 5.000 parole in una colonna su un telefono sono un muro, e perché la
+ * stratificazione deve sopravvivere alla lettura come semplice file Markdown
+ * fuori dall'app.
+ */
+
+/**
+ * @import { TalosResearchSource } from './collector.mjs'
+ * @import { TalosResearchChecks, TalosResearchVerifiedClaim } from './verification.mjs'
+ */
+
+/**
+ * @typedef {object} TalosResearchReportSourceRecord
+ * @property {string} url
+ * @property {string} title
+ * @property {string | null} publishedAt
+ * @property {'page' | 'snippet'} obtained
+ */
+
+/**
+ * @typedef {object} TalosResearchReportClaimRecord
+ * @property {string} text
+ * @property {number} sourceIndex
+ * @property {string} passage Il passaggio com'è nella fonte. Vuoto quando non ci è mai stato trovato.
+ * @property {TalosResearchChecks} checks
+ */
+
+/**
+ * @typedef {object} TalosResearchReportRecord
+ * @property {1} version
+ * @property {string} question
+ * @property {string} summary
+ * @property {string | null} judge Chi era disponibile a giudicare questa corsa,
+ *   o `null` se nessuno lo era. Registrato qui invece che dedotto dalle
+ *   affermazioni, perché sono due fatti diversi e dedurre l'uno dall'altro dice
+ *   una bugia in un caso vero: una corsa con un giudice perfettamente buono le
+ *   cui citazioni abbiano tutte fallito il controllo meccanico non ha nemmeno
+ *   un giudice per affermazione, e si leggerebbe come «nessun giudice
+ *   indipendente era disponibile». Mai verificato e mai avuto bisogno di
+ *   verifica non devono sembrare la stessa cosa.
+ * @property {readonly TalosResearchReportClaimRecord[]} claims
+ * @property {readonly TalosResearchReportSourceRecord[]} sources
+ */
+
+const FENCE_OPEN = '```talos-research-report'
+const FENCE_CLOSE = '```'
+
+/**
+ * Come si legge un verdetto per una persona. Parole, non simboli: questo file
+ * viene letto anche fuori dall'app.
+ *
+ * @param {TalosResearchChecks} checks
+ * @returns {string}
+ */
+export function talosResearchSupportLabel(checks) {
+    switch (checks.claimSupported) {
+        case 'yes': return 'sostenuta dalla fonte'
+        case 'partial': return 'sostenuta solo in parte'
+        case 'no': return 'NON sostenuta dalla fonte'
+        // ⛔ CONTESA-01: la parola dice anche PERCHÉ, se no «contesa» da sola
+        // si legge come una sfumatura di «parziale», che è ciò che non è.
+        case 'contested': return 'contesa — le fonti non concordano'
+        default: return 'non verificata'
+    }
+}
+
+/**
+ * @param {{
+ *   question: string,
+ *   summary: string,
+ *   judge: string | null,
+ *   claims: readonly TalosResearchVerifiedClaim[],
+ *   sources: readonly TalosResearchSource[],
+ * }} input
+ * @returns {string}
+ */
+export function talosResearchReportDocument(input) {
+    const standing = talosResearchVerifiedStanding(input.claims)
+
+    /** @type {TalosResearchReportRecord} */
+    const record = {
+        version: 1,
+        question: input.question,
+        summary: input.summary,
+        judge: input.judge,
+        claims: input.claims.map((entry) => ({
+            text: entry.claim.text,
+            sourceIndex: entry.claim.sourceIndex,
+            passage: entry.passage,
+            checks: entry.checks,
+        })),
+        sources: input.sources.map((source) => ({
+            url: source.url,
+            title: source.title,
+            publishedAt: source.publishedAt,
+            obtained: source.obtained,
+        })),
+    }
+
+    const verdictLine = [
+        `Affermazioni: ${standing.total}`,
+        `sostenute: ${standing.supported}`,
+        `in parte: ${standing.partial}`,
+        `non sostenute: ${standing.unsupported}`,
+        `non verificate: ${standing.unchecked}`,
+    ].join(' · ')
+
+    const prose = [
+        `# ${input.question}`,
+        '',
+        input.summary,
+        '',
+        verdictLine,
+        input.judge
+            ? `Verifica eseguita da: ${input.judge} — mai dal modello che ha scritto il rapporto.`
+            : 'Verifica non eseguita: nessun giudice indipendente era disponibile.',
+        '',
+        '## Le affermazioni',
+        ...input.claims.map((entry, index) => {
+            const source = input.sources[entry.claim.sourceIndex - 1]
+            return [
+                '',
+                `### ${index + 1}. ${entry.claim.text}`,
+                `Esito: ${talosResearchSupportLabel(entry.checks)}${entry.checks.supportReason ? ` — ${entry.checks.supportReason}` : ''}`,
+                entry.passage
+                    ? `\n> ${entry.passage}`
+                    : `\n> (il passaggio citato non è nel testo della fonte: "${entry.claim.quote}")`,
+                '',
+                source
+                    ? `Fonte: ${source.title} — ${source.url}${source.obtained === 'snippet' ? ' (solo estratto dal motore di ricerca)' : ''}`
+                    : 'Fonte: citata ma mai raccolta.',
+            ].join('\n')
+        }),
+        '',
+        `## Fonti (${input.sources.length})`,
+        ...input.sources.map((source, index) => [
+            `${index + 1}. ${source.title} — ${source.url}`,
+            `   ${source.publishedAt ? `data dichiarata: ${source.publishedAt}` : 'data non dichiarata'}`,
+            `   ${source.obtained === 'page' ? 'pagina letta' : 'solo estratto dal motore di ricerca'}`,
+        ].join('\n')),
+    ].join('\n')
+
+    return `${prose}\n\n${FENCE_OPEN}\n${JSON.stringify(record)}\n${FENCE_CLOSE}\n`
+}
+
+/**
+ * Rilegge un rapporto, o ammette di non poterlo fare.
+ *
+ * `null` invece di un recupero parziale, per la ragione che attraversa tutta
+ * questa fase: un rapporto letto a metà mostrerebbe verdetti accanto ad
+ * affermazioni a cui non appartengono, e un segno di verifica sbagliato è
+ * peggio di nessuno.
+ *
+ * @param {string} document
+ * @returns {TalosResearchReportRecord | null}
+ */
+export function talosResearchParseReport(document) {
+    const start = document.indexOf(FENCE_OPEN)
+    if (start < 0) return null
+    const from = start + FENCE_OPEN.length
+    const end = document.indexOf(FENCE_CLOSE, from)
+    if (end < 0) return null
+
+    try {
+        /** @type {TalosResearchReportRecord} */
+        const parsed = JSON.parse(document.slice(from, end))
+        if (parsed?.version !== 1 || !Array.isArray(parsed.claims) || !Array.isArray(parsed.sources)) return null
+        return { ...parsed, judge: parsed.judge ?? null }
+    } catch {
+        return null
+    }
+}