talos-code 0.0.1 → 0.2.0

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

@@ -0,0 +1,111 @@
+import { talosResearchIsTerminal, talosResearchStepIdFor } from './run.mjs'
+
+/*
+ * PORTO FEDELE di AVM/mobile/src/lib/research/researchOutline.ts (85 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, senza duplicarne una riga.
+ *
+ * Il documento, prima che esista.
+ *
+ * La ricerca visiva del 2026-08-03 fa una domanda a cui nessun concorrente
+ * risponde: che cosa si disegna nel primo mezzo secondo, quando ancora non si
+ * sa niente? Di quel momento non ha trovato uno screenshot in nessuno dei
+ * cinque prodotti — le recensioni saltano dal piano allo stato popolato e il
+ * marketing taglia la transizione. Il che fa comodo, perché vuol dire che la
+ * risposta qui è nostra.
+ *
+ * E la risposta è che qualcosa lo sappiamo. Il piano è stato approvato prima
+ * che si spendesse un centesimo: i suoi rami SONO le sezioni che il rapporto
+ * avrà. Quindi la pagina si apre sulla forma del documento, con ogni sezione
+ * che dice dov'è — invece che su una rotella, o, come faceva fino a oggi, su
+ * niente del tutto.
+ *
+ * Tutto qui dentro è aritmetica sulla corsa. Niente disco, niente rete: il
+ * primo fotogramma non può essere in ritardo perché non c'è niente da aspettare.
+ */
+
+/**
+ * @import { TalosResearchRun, TalosResearchStepState } from './run.mjs'
+ */
+
+/**
+ * @typedef {object} TalosResearchSection
+ * @property {string} id
+ * @property {string} question
+ * @property {TalosResearchStepState} state
+ */
+
+/**
+ * Una sezione per ramo, nell'ordine del piano.
+ *
+ * Un ramo senza ancora un passo è `pending` invece che assente: al lettore si
+ * sta mostrando che cosa SUCCEDERÀ, e nascondere le parti non ancora partite
+ * farebbe sembrare che il documento cresca dal nulla.
+ *
+ * @param {TalosResearchRun} run
+ * @returns {readonly TalosResearchSection[]}
+ */
+export function talosResearchOutline(run) {
+    return run.plan.map((branch) => {
+        const step = run.steps.find((candidate) => candidate.id === talosResearchStepIdFor(branch.id, 'search'))
+        return { id: branch.id, question: branch.question, state: step?.state ?? 'pending' }
+    })
+}
+
+/**
+ * Quando una corsa finita è finita davvero.
+ *
+ * NON `updatedAt`, che viene timbrato da ogni evento che il giornale accetta —
+ * una rinomina compresa. Una ricerca conclusa in quattro minuti ieri e
+ * rinominata oggi leggerebbe «conclusa in 1 giorno», e la pagina starebbe
+ * citando il momento in cui le hai cambiato titolo come il momento in cui ha
+ * smesso di pensare.
+ *
+ * L'ultimo passo che riporta una fine è la fine vera. Una corsa annullata prima
+ * che un passo finisse non ne ha nessuno, e lì `updatedAt` è il meglio che c'è.
+ *
+ * @param {TalosResearchRun} run
+ * @returns {string}
+ */
+function endedAt(run) {
+    /** @type {string | null} */
+    let last = null
+    for (const step of run.steps) {
+        if (step.finishedAt && (last === null || step.finishedAt > last)) last = step.finishedAt
+    }
+    return last ?? run.updatedAt
+}
+
+/**
+ * Da quanto sta andando, in secondi.
+ *
+ * Dai tempi della corsa, mai da un cronometro fatto partire quando lo schermo
+ * si è montato: una ricerca la si guarda da più posti e sopravvive a tutti,
+ * quindi una durata posseduta da un componente ripartirebbe ogni volta che
+ * qualcuno guarda. Una corsa finita misura fino a quando è finita; una viva
+ * fino ad adesso.
+ *
+ * @param {TalosResearchRun} run
+ * @param {string} now
+ * @returns {number}
+ */
+export function talosResearchElapsedSeconds(run, now) {
+    const started = Date.parse(run.startedAt)
+    const until = Date.parse(talosResearchIsTerminal(run.status) ? endedAt(run) : now)
+    if (!Number.isFinite(started) || !Number.isFinite(until)) return 0
+    return Math.max(0, Math.round((until - started) / 1000))
+}
+
+/**
+ * `4 min 08 s`, oppure `38 s`. Tabellare, e mai un numero nudo di secondi oltre
+ * il minuto.
+ *
+ * @param {number} seconds
+ * @returns {string}
+ */
+export function talosResearchDuration(seconds) {
+    if (seconds < 60) return `${seconds} s`
+    const minutes = Math.floor(seconds / 60)
+    return `${minutes} min ${String(seconds % 60).padStart(2, '0')} s`
+}

package/vendor/harness-ui/src/research/page-budget.mjs

@@ -0,0 +1,209 @@
+/*
+ * L6 — IL BUDGET DETERMINISTICO PER PAGINA.
+ *
+ * ## Il difetto che chiude
+ *
+ * Una pagina web è lunga quanto le pare. Il modello riceve tutto, e la finestra
+ * di contesto è la prima cosa che finisce: `naviga` nel kernel taglia già a
+ * 4.000 caratteri (`talosHarness.mjs:1296`, `uscitaUtile`) e la sintesi ne
+ * prende 4.000 in testa per fonte (`synthesis.mjs:59`). Nessuno dei due dice
+ * dove sia finito il resto, e la sintesi non guarda nemmeno la coda.
+ *
+ * ⛔ Il punto NON è tagliare — quello lo facciamo già. Il punto è che oggi il
+ * resto **sparisce**: non è da nessuna parte, quindi non si può né sfogliare né
+ * ri-verificare. Questo modulo separa tre cose che oggi sono una sola:
+ *
+ *   1. il testo INTERO, che si conserva (è il dossier: `collector.mjs`);
+ *   2. la FINESTRA, cioè quanto ne vede il modello adesso;
+ *   3. il RIFERIMENTO, cioè come arrivare al resto.
+ *
+ * ⛔ La (1) resta la fonte della verità per `talosResearchLocate`
+ * (`verification.mjs:201`): un passaggio citato si cerca nel testo intero, MAI
+ * nella finestra — altrimenti tagliare una pagina trasformerebbe una citazione
+ * vera in una citazione «non trovata», che è il verso peggiore in cui si possa
+ * sbagliare (una fonte onesta marcata come inventata).
+ *
+ * ## Perché 15.000, misurato invece che copiato
+ *
+ * Hermes v0.21 usa 15.000 caratteri per pagina, testa 75% / coda 25%, il resto
+ * su disco col percorso e la chiamata esatta per sfogliarlo, tetto 2 MB
+ * (`website/docs/user-guide/features/web-search.md:47-57` nel clone
+ * `%LOCALAPPDATA%\Temp\talos-competitor\hermes-agent-v21`, letto l'11/09/2026).
+ * Il numero è il loro, la ragione doveva essere nostra.
+ *
+ * MISURATO l'11/09/2026 su 430 pagine di documentazione vera (le `.md`/`.mdx`
+ * di `website/docs` dello stesso clone: sono pagine web pubblicate, non un
+ * campione inventato), con gli spazi compattati come fa il collettore:
+ *
+ *     mediana 10.688 · p75 15.752 · p90 27.983 · p95 43.899 · max 187.135
+ *
+ *     tetto      pagine intere        caratteri coperti
+ *     4.000       30/430  ( 7,0%)          26,1%
+ *     8.000      130/430  (30,2%)          47,9%
+ *     15.000     313/430  (72,8%)          69,4%
+ *     20.000     357/430  (83,0%)          76,3%
+ *     40.000     403/430  (93,7%)          89,3%
+ *
+ * ⇒ I 4.000 di oggi consegnano al modello il 26% dei caratteri e fanno arrivare
+ * intera UNA PAGINA SU QUATTORDICI: non è un budget, è un troncone. I 15.000 di
+ * Hermes cadono quasi esattamente sul 75° percentile (15.752): tre pagine su
+ * quattro arrivano intere e il taglio smette di essere la regola.
+ *
+ * ⛔ E la ragione per cui NON prendo i 20.000 del mobile (`collector.mjs:79`,
+ * `MAX_CHARS_PER_SOURCE`) è strutturale, non di gusto: quello è il tetto di ciò
+ * che si CONSERVA. Se il tetto mostrato fosse uguale a quello conservato, il
+ * riferimento «il resto è in …» punterebbe sempre a zero caratteri residui, e
+ * questo modulo sarebbe una bugia cortese. Il tetto mostrato deve stare
+ * STRETTAMENTE sotto quello conservato. 15.000 < 20.000.
+ *
+ * ## Perché testa 75% / coda 25%, al contrario di `uscitaUtile`
+ *
+ * `uscitaUtile` tiene un quarto in testa e tre quarti in coda, e ha ragione:
+ * misura l'uscita di una SUITE DI TEST, dove la diagnosi sta in fondo
+ * (`talosHarness.mjs:1282-1295`). Una pagina web è l'opposto — titolo, apertura
+ * e tesi stanno in cima, e la coda è note, footer, commenti. ⇒ stesso
+ * meccanismo, quote invertite, e la ragione scritta accanto a tutte e due.
+ *
+ * ## Deterministico, e la parola conta
+ *
+ * Nessun modello, nessuna sintesi, nessuna data, nessun `toLocaleString`: la
+ * stessa pagina produce la stessa identica finestra, byte per byte. Serve
+ * perché la cache del prompt dei fornitori funziona su PREFISSO ESATTO — «If
+ * your breakpoint is on content that changes every request, cache hits never
+ * occur» (platform.claude.com/docs/en/build-with-claude/prompt-caching, letta
+ * l'11/09/2026). Una finestra che cambia fra due giri identici brucia la cache
+ * di tutto ciò che le sta dopo.
+ */
+
+/**
+ * Quanti caratteri di una pagina vede il modello.
+ * Vedi la misura qui sopra: è il 75° percentile di 430 pagine vere.
+ */
+export const TALOS_RESEARCH_PAGE_BUDGET = 15_000;
+
+/** Quanta parte della finestra è la testa. Una pagina dice la sua tesi in cima. */
+export const TALOS_RESEARCH_HEAD_SHARE = 0.75;
+
+/**
+ * Quanto testo si CONSERVA di una pagina. Stesso tetto di Hermes (2 MB): oltre,
+ * un solo documento patologico si mangerebbe il dossier.
+ */
+export const TALOS_RESEARCH_KEPT_CAP = 2 * 1024 * 1024;
+
+/**
+ * @typedef {object} TalosResearchPageReference
+ * @property {string} percorso Dove il testo intero è stato depositato.
+ * @property {string} [chiamata]
+ *   La chiamata ESATTA per sfogliare il mezzo, se esiste davvero un attrezzo che
+ *   la accetta. ⛔ Non si inventa: oggi `leggi` non ha né offset né lunghezza
+ *   (`talosHarness.mjs:1446-1451`), quindi chi non può scriverne una vera non la
+ *   passa, e il marcatore tace invece di mentire.
+ */
+
+/**
+ * @typedef {object} TalosResearchPageWindow
+ * @property {string} window Ciò che il modello vede: testa + marcatore + coda.
+ * @property {number} total Caratteri della pagina intera.
+ * @property {number} shown Caratteri davvero mostrati (marcatore escluso).
+ * @property {number} omitted `total - shown`. Contato, mai stimato.
+ * @property {boolean} truncated
+ * @property {string | null} marker Il marcatore, per chi lo vuole altrove.
+ */
+
+/**
+ * Il taglio della testa, portato indietro fino a un confine di riga se ce n'è
+ * uno vicino — Hermes taglia «on markdown line boundaries», e mezza riga di
+ * markdown letta a metà è rumore. Se non c'è una riga si ripiega su uno spazio;
+ * se non c'è nemmeno quello (testo compattato, o una lingua senza spazi) si
+ * taglia netto: meglio un taglio netto che una regola che non si applica.
+ *
+ * @param {string} testo
+ * @param {number} tetto
+ * @returns {number}
+ */
+function tagliaInTesta(testo, tetto) {
+  if (tetto <= 0) return 0;
+  const finestra = testo.slice(0, tetto);
+  const riga = finestra.lastIndexOf('\n');
+  if (riga >= Math.floor(tetto * 0.8)) return riga;
+  const spazio = finestra.lastIndexOf(' ');
+  if (spazio >= tetto - 200) return spazio;
+  return tetto;
+}
+
+/**
+ * L'inizio della coda, portato AVANTI (mai indietro: allargherebbe la finestra
+ * oltre il tetto) fino al primo confine di riga vicino.
+ *
+ * @param {string} testo
+ * @param {number} tetto
+ * @returns {number}
+ */
+function tagliaInCoda(testo, tetto) {
+  if (tetto <= 0) return testo.length;
+  const da = testo.length - tetto;
+  const finestra = testo.slice(da);
+  const riga = finestra.indexOf('\n');
+  if (riga >= 0 && riga <= Math.floor(tetto * 0.2)) return da + riga + 1;
+  const spazio = finestra.indexOf(' ');
+  if (spazio >= 0 && spazio <= 200) return da + spazio + 1;
+  return da;
+}
+
+/**
+ * @param {number} valore
+ * @param {number} minimo
+ * @param {number} massimo
+ * @returns {number}
+ */
+function stretto(valore, minimo, massimo) {
+  if (!Number.isFinite(valore)) return minimo;
+  return Math.min(massimo, Math.max(minimo, valore));
+}
+
+/**
+ * La finestra che il modello vede, e il conto esatto di ciò che non vede.
+ *
+ * @param {string} testo
+ * @param {{cap?: number, headShare?: number, reference?: TalosResearchPageReference | null}} [opzioni]
+ * @returns {TalosResearchPageWindow}
+ */
+export function talosResearchPageBudget(testo, opzioni = {}) {
+  const pagina = typeof testo === 'string' ? testo : String(testo ?? '');
+  const tetto = Math.trunc(stretto(opzioni.cap ?? TALOS_RESEARCH_PAGE_BUDGET, 1, TALOS_RESEARCH_KEPT_CAP));
+  const quotaTesta = stretto(opzioni.headShare ?? TALOS_RESEARCH_HEAD_SHARE, 0, 1);
+  const riferimento = opzioni.reference ?? null;
+  const totali = pagina.length;
+
+  if (totali <= tetto) {
+    return { window: pagina, total: totali, shown: totali, omitted: 0, truncated: false, marker: null };
+  }
+
+  const tettoTesta = Math.round(tetto * quotaTesta);
+  const testa = pagina.slice(0, tagliaInTesta(pagina, tettoTesta));
+  const coda = pagina.slice(tagliaInCoda(pagina, tetto - tettoTesta));
+  const mostrati = testa.length + coda.length;
+  const tolti = totali - mostrati;
+
+  /*
+   * ⛔ D-10G, 10/09 — la lezione già pagata su questa stessa riga di codice: il
+   * marcatore di `uscitaUtile` diceva «l'elenco completo dei test» su QUALUNQUE
+   * troncamento, ed è stato visto dall'owner su una PAGINA WEB. Un marcatore che
+   * dice COSA ha tagliato mente appena il contenuto non è quello; questo dice
+   * solo QUANTO, e dove trovare il resto quando il resto ha davvero un posto.
+   */
+  const dove = riferimento?.percorso
+    ? `Il testo intero è in ${riferimento.percorso}.${riferimento.chiamata ? ` Per sfogliare il mezzo: ${riferimento.chiamata}` : ''}`
+    : 'Il testo intero è conservato nel dossier di questa ricerca.';
+
+  const marcatore = `… [visti ${mostrati} caratteri su ${totali}: ${testa.length} in testa, ${coda.length} in coda; ${tolti} tolti dal mezzo. ${dove}] …`;
+
+  return {
+    window: `${testa}\n\n${marcatore}\n\n${coda}`,
+    total: totali,
+    shown: mostrati,
+    omitted: tolti,
+    truncated: true,
+    marker: marcatore,
+  };
+}

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

@@ -0,0 +1,291 @@
+import { talosResearchSupportLabel } from './report.mjs'
+import { inlineInTestoSemplice, markdownInBlocchiReport, runsDiMarkdown } from './markdown-server.mjs'
+
+/*
+ * PORTO di AVM/mobile/src/lib/research/researchPdf.ts (246 righe, letto per intero il
+ * 12/09/2026 prima di scrivere una riga). ⛔ SOLA LETTURA sul mobile: qui non si tocca.
+ *
+ * ⛔⛔ EXPORT — una ricerca che diventa un PDF, in TRE TONI.
+ *
+ * Owner 2026-08-03 (mobile): «quando clicchi per generare il pdf appare un popup che ti fa
+ * scegliere il "tono" del pdf tra 3 template». Owner 12/09/2026 (desktop): «la ricerca
+ * approfondita deve avere una suite di esportazioni COMPLETA».
+ *
+ * I tre sono documenti DIVERSI, non tre tavolozze sullo stesso testo. Un cambio di colore
+ * travestito da scelta è una domanda posta a vuoto: chi la riceve deve fermarsi a pensare, e
+ * qualunque cosa risponda ottiene la stessa cosa.
+ *
+ *   `report`  — a chi deve leggerlo tutto: copertina, sintesi, ogni affermazione col suo
+ *               verdetto e il passaggio, poi le fonti.
+ *   `brief`   — a chi ha due minuti: la risposta, cosa regge, cosa NON regge. Niente
+ *               passaggi, niente elenco fonti.
+ *   `dossier` — a chi deve controllare: affermazione, verdetto, fonte, in tabella. Nessuna
+ *               prosa. È quello che gli altri non hanno.
+ *
+ * ⛔ Il modulo è PURO di proposito, come il suo originale: il documento si prova senza
+ *   pdfmake, senza rete e senza telefono. Chi lo trasforma in byte è `esportazioni.mjs`, che
+ *   passa questo `TalosReportInput` a `generateTalosDocument({format:'pdf', report})` — cioè
+ *   allo STESSO impaginatore (`document-report.mjs`) che usa `document_create`. Un secondo
+ *   impaginatore sarebbe un secondo aspetto per gli stessi documenti.
+ *
+ * ════════════════════════════════════════════════════════════════════════════════════════
+ * ⛔⛔⛔ L'UNICA DIVERGENZA DAL MOBILE, E NON È UNO STILE: `sourceIndex` È 1-BASED.
+ * ════════════════════════════════════════════════════════════════════════════════════════
+ *
+ * `researchPdf.ts` fa `report.sources[claim.sourceIndex]`. Ogni altro lettore dello stesso
+ * record — su mobile E qui — fa `sources[claim.sourceIndex - 1]`:
+ *   · `researchReport.ts:128` / `report.mjs` (la prosa del rapporto)
+ *   · `researchRecheck.ts:114`, `researchSynthesis.ts:254`, `researchVerification.ts:397,422`
+ * ⇒ Il PDF del mobile attribuisce ogni affermazione alla fonte SEGUENTE, e l'ultima a «—».
+ *   Il suo test non lo vede perché la sua fixture numera le fonti da 0, cioè con una
+ *   convenzione che nessun motore produce.
+ * ⛔ Portarlo «fedele» qui avrebbe importato il difetto su un record scritto da `report.mjs`,
+ *   che è 1-based per costruzione. Qui si usa `- 1`, e il test lo morde con un record vero.
+ *   ⛔ Il difetto resta APERTO sul mobile: non ho ownership lì, si segnala e non si corregge.
+ *
+ * ═════════════════════════════════════════════════════════════════════════════════════
+ * ⛔⛔ LA SECONDA DIVERGENZA, 12/09: IL MARKDOWN SI RENDE.
+ * ═════════════════════════════════════════════════════════════════════════════════════
+ *
+ * `researchPdf.ts` mette la sintesi in un blocco solo (`{t:'p', x: report.summary}`) e il
+ * testo di ogni affermazione dentro un titolo, così com'è. Ma quel testo lo scrive un modello,
+ * e un modello scrive **Markdown**: nel PDF di una ricerca vera (L8, 12/09) uscivano
+ * `## Executive Summary` e `**Key Components:**` LETTERALI, come nell'HTML.
+ * ⇒ Qui la sintesi passa da `markdownInBlocchiReport` (titoli, elenchi, tabelle veri) e il
+ *   testo delle affermazioni da `runsDiMarkdown` / `inlineInTestoSemplice`.
+ * ⛔ Il PASSAGGIO no, mai: è la PROVA, cioè il testo com'è nella fonte. Renderlo vorrebbe dire
+ *   modificare l'unica cosa che il rapporto conserva perché non sia modificabile.
+ */
+
+/**
+ * @import { TalosResearchReportRecord } from './report.mjs'
+ */
+
+export const TALOS_RESEARCH_PDF_TONES = Object.freeze(['report', 'brief', 'dossier'])
+
+/** Il tono di partenza: quello completo, che non lascia fuori niente. */
+export const TALOS_RESEARCH_PDF_DEFAULT_TONE = 'report'
+
+/** @param {{checks?:object}} claim */
+function verdetto(claim) {
+    return talosResearchSupportLabel(claim?.checks ?? {})
+}
+
+/**
+ * Il nome della fonte di un'affermazione. ⛔ `sourceIndex` è 1-BASED (vedi la testa del file).
+ * @param {TalosResearchReportRecord} report
+ * @param {number} numero
+ * @returns {string}
+ */
+function fonteDi(report, numero) {
+    const source = report.sources[Number(numero) - 1]
+    if (!source) return '—'
+    // Il titolo se c'è, altrimenti il dominio: un URL intero in una cella di tabella la
+    // sfonda, e nessuno lo legge comunque.
+    if (String(source.title ?? '').trim().length > 0) return source.title
+    /*
+     * ⛔ L'host INTERO (`altro.example.org`), non il dominio registrabile: il porto del mobile fa
+     *   `new URL(url).hostname`, e qui era partita una scorciatoia verso
+     *   `talosResearchRegistrableHost` di `independence.mjs` — che torna l'eTLD+1
+     *   (`example.org`). Quella funzione esiste per decidere se due fonti sono INDIPENDENTI, cioè
+     *   per accorpare i sottodomini apposta: usarla per un'etichetta farebbe leggere due fonti
+     *   diverse come la stessa. Trovato dal test, non ragionandoci sopra.
+     */
+    try {
+        return new URL(source.url).hostname || String(source.url ?? '—')
+    } catch {
+        return String(source.url ?? '—')
+    }
+}
+
+/**
+ * Quante reggono, quante a metà, quante smentite, quante mai verificate.
+ * @param {TalosResearchReportRecord} report
+ * @returns {{supported:number, partial:number, contradicted:number, unverified:number}}
+ */
+export function talosResearchPdfTally(report) {
+    const tally = { supported: 0, partial: 0, contradicted: 0, unverified: 0 }
+    for (const claim of report.claims ?? []) {
+        switch (claim?.checks?.claimSupported) {
+            case 'yes': tally.supported += 1; break
+            case 'partial': tally.partial += 1; break
+            case 'no': tally.contradicted += 1; break
+            default: tally.unverified += 1
+        }
+    }
+    return tally
+}
+
+/**
+ * La riga che dice come è stato giudicato, o che NON lo è stato.
+ *
+ * «Nessun giudice indipendente era disponibile» e «tutte le citazioni hanno fallito il
+ * controllo meccanico» sono due fatti diversi, e il record li tiene separati apposta. Un PDF
+ * che tace su questo consegna un verdetto senza dire chi l'ha dato.
+ */
+function nota(report) {
+    return {
+        t: 'note',
+        x: report.judge
+            ? `Le affermazioni sono state giudicate da ${report.judge}, confrontandole con il passaggio della fonte.`
+            : 'Nessun giudice indipendente era disponibile: i verdetti vengono dal solo controllo meccanico della citazione.',
+    }
+}
+
+function copertina(report, options) {
+    const titolo = String(options.title ?? '').trim()
+    return {
+        t: 'cover',
+        title: titolo || report.question,
+        subtitle: titolo ? report.question : 'Ricerca approfondita TALOS',
+        ...(options.date ? { date: options.date } : {}),
+    }
+}
+
+function bilancio(report) {
+    const tally = talosResearchPdfTally(report)
+    return {
+        t: 'kpi',
+        items: [
+            { l: 'Sostenute', v: String(tally.supported) },
+            { l: 'In parte', v: String(tally.partial) },
+            { l: 'Smentite', v: String(tally.contradicted) },
+            { l: 'Non verificate', v: String(tally.unverified) },
+        ],
+    }
+}
+
+function rapportoCompleto(report, options) {
+    const blocks = [
+        copertina(report, options),
+        { t: 'h', lvl: 1, x: 'In breve' },
+        ...markdownInBlocchiReport(report.summary, { livelloMinimo: 2 }),
+        bilancio(report),
+        nota(report),
+        { t: 'pb' },
+        { t: 'h', lvl: 1, x: 'Le affermazioni, una per una' },
+    ]
+    report.claims.forEach((claim, index) => {
+        blocks.push({ t: 'h', lvl: 3, x: `${index + 1}. ${inlineInTestoSemplice(claim.text)}` })
+        blocks.push({ t: 'p', x: `Verdetto: ${verdetto(claim)} — fonte: ${fonteDi(report, claim.sourceIndex)}` })
+        // Il passaggio è la prova. Senza, «sostenuta» è una parola che chiede fiducia invece
+        // di darla.
+        if (String(claim.passage ?? '').trim().length > 0) blocks.push({ t: 'note', x: `«${claim.passage}»` })
+    })
+    if (report.sources.length > 0) {
+        blocks.push({ t: 'pb' }, { t: 'h', lvl: 1, x: 'Le fonti' })
+        blocks.push({
+            t: 'table',
+            head: ['#', 'Titolo', 'Indirizzo', 'Come'],
+            align: ['r', 'l', 'l', 'l'],
+            rows: report.sources.map((source, index) => [
+                String(index + 1),
+                source.title || '—',
+                source.url,
+                source.obtained === 'page' ? 'pagina letta' : 'solo estratto',
+            ]),
+        })
+    }
+    return blocks
+}
+
+function sintesi(report, options) {
+    const tally = talosResearchPdfTally(report)
+    const regge = report.claims.filter((claim) => claim?.checks?.claimSupported === 'yes')
+    const nonRegge = report.claims.filter((claim) => (
+        claim?.checks?.claimSupported === 'no' || claim?.checks?.claimSupported === 'partial'
+    ))
+    /*
+     * Niente copertina, e non è una svista.
+     *
+     * Misurato sul OnePlus Pad 3 (2026-08-04): con la copertina la sintesi usciva di DUE
+     * pagine — il blocco `cover` ha 140 punti di margine in cima e da solo si mangia la prima.
+     * La riga nel popup promette «una pagina», e una promessa che il documento non mantiene è
+     * peggio della promessa assente.
+     */
+    const titolo = String(options.title ?? '').trim()
+    const blocks = [
+        { t: 'h', lvl: 1, x: titolo || report.question },
+        ...(titolo ? [{ t: 'note', x: report.question }] : []),
+        ...markdownInBlocchiReport(report.summary, { livelloMinimo: 3 }),
+        bilancio(report),
+    ]
+    if (regge.length > 0) {
+        blocks.push({ t: 'h', lvl: 2, x: 'Quello che regge' })
+        // Quattro, non tutte: una sintesi che riporta trenta punti non è una sintesi, è il
+        // rapporto senza le prove.
+        blocks.push({ t: 'list', items: regge.slice(0, 4).map((claim) => runsDiMarkdown(claim.text)) })
+    }
+    if (nonRegge.length > 0) {
+        blocks.push({ t: 'h', lvl: 2, x: 'Quello che NON regge' })
+        blocks.push({
+            t: 'list',
+            items: nonRegge.slice(0, 4).map((claim) => `${inlineInTestoSemplice(claim.text)} — ${verdetto(claim)}`),
+        })
+    }
+    if (tally.unverified > 0) {
+        blocks.push({
+            t: 'note',
+            x: `${tally.unverified} affermazioni non è stato possibile verificarle: la fonte non è stata riaperta o il passaggio non c'era.`,
+        })
+    }
+    blocks.push(nota(report))
+    return blocks
+}
+
+function dossier(report, options) {
+    return [
+        copertina(report, options),
+        { t: 'h', lvl: 1, x: 'Affermazioni e prove' },
+        nota(report),
+        {
+            t: 'table',
+            head: ['#', 'Affermazione', 'Verdetto', 'Fonte'],
+            align: ['r', 'l', 'l', 'l'],
+            rows: report.claims.map((claim, index) => [
+                String(index + 1),
+                runsDiMarkdown(claim.text),
+                verdetto(claim),
+                fonteDi(report, claim.sourceIndex),
+            ]),
+        },
+        {
+            t: 'chart',
+            kind: 'pie',
+            labels: ['Sostenute', 'In parte', 'Smentite', 'Non verificate'],
+            series: [{ data: Object.values(talosResearchPdfTally(report)) }],
+        },
+    ]
+}
+
+/**
+ * Il documento, nel tono chiesto.
+ *
+ * Un rapporto senza affermazioni non è un errore — una ricerca può finire senza che nessuna
+ * citazione regga — ma un PDF di sole intestazioni vuote non lo dice a nessuno. Quindi si dice.
+ *
+ * @param {TalosResearchReportRecord} report
+ * @param {'report'|'brief'|'dossier'} tone
+ * @param {{date?:string, title?:string|null}} [options]
+ * @returns {{theme:string, footer:object, blocks:object[]}}
+ */
+export function talosResearchPdfSpec(report, tone, options = {}) {
+    const blocks = (report.claims?.length ?? 0) === 0
+        ? [
+            copertina(report, options),
+            ...markdownInBlocchiReport(report.summary, { livelloMinimo: 2 }),
+            { t: 'note', x: 'Questa ricerca non ha prodotto affermazioni verificabili.' },
+        ]
+        : tone === 'brief'
+            ? sintesi(report, options)
+            : tone === 'dossier'
+                ? dossier(report, options)
+                : rapportoCompleto(report, options)
+
+    return {
+        // Il dossier vive di tabelle larghe; gli altri due si leggono.
+        theme: tone === 'dossier' ? 'plain' : 'report',
+        footer: { text: 'TALOS · ricerca approfondita', pageNo: true },
+        blocks,
+    }
+}