strom-research 1.13.2-beta.10 → 1.13.2-beta.12

package/assets/lang/cs.json

@@ -1982,15 +1982,15 @@
   "ui.arg.what-the-family-knows": "co rodina ví",
   "ui.error.story.no-source": "{id} v rodokmenu není",
   "ui.error.story.no-source.hint": "pozadí místa a doby se nejdřív zapíše jako pramen: strom source add … --kind book|newspaper|web",
-  "ui.consent.archive.pace": "Tempo stahování snímků z archivů, jejichž podmínky automatizaci omezují, po svolení „pomalu“: nejméně {seconds} s mezi dvěma snímky, nejvýš {n} za hodinu. Nastavit?",
+  "ui.consent.archive.pace": "Tempo stahování snímků z archivů, jejichž podmínky automatizaci omezují, po svolení „pomalu“: nejméně {seconds} s mezi dvěma snímky, nejvýš {n} požadavků na archiv za hodinu včetně katalogu. Nastavit?",
   "ui.archive.terms.known": "Podmínky: „{quote}“ ({terms})",
   "ui.archive.terms.connector": "Podmínky podle stahovače: {quote} ({terms})",
   "ui.archive.terms.none": "Podmínky archivu zatím nejsou známé (stahovač ještě nikdo nepotvrdil).",
   "ui.archive.terms.robots": "Jeho robots.txt: „{quote}“ ({terms}) – žádný automatický přístup jinak než přes prohlížeč člověka.",
   "ui.archive.terms.robots.none": "Jeho robots.txt nedovoluje automatický přístup ({terms}) – jen přes prohlížeč člověka.",
   "ui.archive.name": "{title} ({host})",
-  "ui.archive.ask.slow": "Povolit pomalé stahování snímků? Jeden snímek nejvýš za {seconds} s a nejvýš {n} za hodinu, jen snímky, které úkol potřebuje, nic dopředu. Bez svolení se snímky uloží ručně do připravené složky.",
-  "ui.archive.ask.browser": "Povolit stahování snímků přes prohlížeč na tomto počítači? Chrome s rozšířením Claude, tempo plánuje strom (jeden snímek nejvýš za {seconds} s, nejvýš {n} za hodinu); kontrolu, zda je u počítače člověk, projde člověk sám. Bez svolení se snímky uloží ručně.",
+  "ui.archive.ask.slow": "Povolit pomalé stahování snímků? Jeden snímek nejvýš za {seconds} s a nejvýš {n} požadavků na archiv za hodinu včetně katalogu, jen snímky, které úkol potřebuje, nic dopředu. Bez svolení se snímky uloží ručně do připravené složky.",
+  "ui.archive.ask.browser": "Povolit stahování snímků přes prohlížeč na tomto počítači? Chrome s rozšířením Claude, tempo plánuje strom (jeden snímek nejvýš za {seconds} s, nejvýš {n} požadavků na archiv za hodinu včetně katalogu); kontrolu, zda je u počítače člověk, projde člověk sám. Bez svolení se snímky uloží ručně.",
   "ui.archive.ask.change": "Platí pro tento archiv na tomto počítači; změnit jde kdykoli: strom allow archive {host}.",
   "ui.archive.btn.slow": "Povolit pomalu",
   "ui.archive.btn.browser": "Povolit přes prohlížeč",
@@ -2006,7 +2006,7 @@
   "ui.archive.window.browser": "Stahovat přes prohlížeč, jeden snímek za {seconds} s, jen co úkol potřebuje?",
   "ui.archive.window.change": "Změnit: nastavení → Archivy.",
   "ui.archive.choose": "{title} – jak získávat snímky?",
-  "ui.archive.way.slow": "Pomalu, lidským tempem (jeden snímek nejvýš za {seconds} s, nejvýš {n} za hodinu, jen co úkol potřebuje)",
+  "ui.archive.way.slow": "Pomalu, lidským tempem (jeden snímek nejvýš za {seconds} s, nejvýš {n} požadavků na archiv za hodinu včetně katalogu, jen co úkol potřebuje)",
   "ui.archive.way.browser": "Přes prohlížeč na tomto počítači (Chrome s rozšířením Claude; tempo plánuje strom)",
   "ui.archive.way.manual": "Jen ručně – snímky se uloží do připravené složky",
   "ui.archive.way.later": "Později – nic se nemění",
@@ -2048,7 +2048,7 @@
   "ui.archive.woken": "Úkoly {ids} se vracejí do fronty.",
   "ui.archive.inbox": "{id}: ve složce už jsou snímky ({n}) – výzkum je zaeviduje a úkol se vrátí sám.",
   "ui.archive.manual.tasks": "Úkoly {ids} dál čekají na snímky uložené ručně.",
-  "ui.archive.pace": "jeden snímek nejvýš za {seconds} s, nejvýš {n} za hodinu",
+  "ui.archive.pace": "jeden snímek nejvýš za {seconds} s, nejvýš {n} požadavků za hodinu včetně katalogu",
   "ui.archive.pace.line": "Tempo snímků pomalu: {pace} – změnit jde jen příkazem: strom allow host {host} --pace <s> --per-hour <n>, pro všechny archivy strom config set archive.pace \"<s> <n>\"",
   "ui.archive.allowed.line": "Platí: {level} – tady jen přísněji: snímky jen ručně.",
   "ui.archive.pace.service": "Tempo snímků: {pace} – změnit jde jen příkazem: strom allow host {host} --pace <s> --per-hour <n>",
@@ -2075,5 +2075,60 @@
   "ui.link.archive.none": "O tomto archivu tu není co rozhodnout. Nic se nestalo.",
   "ui.error.archive.permission": "stahování snímků z archivu {title} ({hosts}) čeká na rozhodnutí – podmínky archivu automatické stahování omezují; z archivu se nic nestahovalo",
   "ui.error.archive.permission.new": "stahování snímků z archivu {title} ({hosts}) čeká na rozhodnutí – čtení podmínek stahovačem zatím nikdo nepotvrdil; z archivu se nic nestahovalo",
-  "ui.error.archive.permission.hint": "rozhodnout v menu strom (Co čeká), nebo v terminálu: strom allow archive {host} --way {ways}"
+  "ui.error.archive.permission.hint": "rozhodnout v menu strom (Co čeká), nebo v terminálu: strom allow archive {host} --way {ways}",
+  "ui.error.archive.rerouted": "{title}: odteď {way} – tento příkaz tou cestou ještě nešel",
+  "ui.error.archive.rerouted.hint": "spustit stejný příkaz znovu",
+  "ui.archive.level.robots.manual": "robots.txt nedovoluje automatický přístup a stahovač neumí jít přes prohlížeč – snímky jen ručně",
+  "ui.archive.level.browserOnly": "archiv pouští automatické nástroje jen přes prohlížeč člověka – snímky jen přes prohlížeč, se svolením",
+  "ui.archive.level.browserOnly.manual": "archiv pouští automatické nástroje jen přes prohlížeč člověka a stahovač to neumí – snímky jen ručně",
+  "ui.pace.text": "nejméně {seconds} s mezi dvěma požadavky, {cap}",
+  "ui.host.pace.own": "{host}: {pace} – vlastní tempo",
+  "ui.host.pace.service": "{host}: {pace} – zase tempo služby",
+  "ui.host.revoked": "{host}: svolení odvoláno – žádný stahovač se tam teď nedostane",
+  "ui.host.allowed": "{host}: automatický přístup povolen (strom consents)",
+  "ui.host.notallowed": "Nepovoleno – nic se nezměnilo.",
+  "ui.consents.on": "souhlasy: zapnuto – stahovač běží, až když ho člověk povolí, a stejně tak každý server archivu, ke kterému se připojí",
+  "ui.consents.off": "souhlasy: vypnuto – stahovače běží bez ptaní (tempo hlídá strom, jen ke svým serverům); kód, který jde mimo strom, potřebuje souhlas člověka · aby se strom ptal předem: strom config set connectors.consent on",
+  "ui.consents.connectors": "stahovače",
+  "ui.consents.connector": "{name}  {dir}  od {date}  servery {hosts}",
+  "ui.consents.none": "(žádné)",
+  "ui.consents.hosts": "servery (automatický přístup)",
+  "ui.consents.host.refused": "⛔ {reason} – znovu to strom zkusí až od {when}",
+  "ui.consents.host.refused.lifted": "⛔ {reason} – strom to znovu nezkusí, dokud to člověk nezruší: strom allow host {host} --unblock",
+  "ui.consents.host.recent": "požadavků za poslední hodinu: {n}",
+  "ui.consents.host.slowed": "zpomaleno ×{factor}",
+  "ui.consents.host.limit": "jeho limit vyčerpán do {when}",
+  "ui.consents.host.since": "povoleno od {date}",
+  "ui.consents.pace": "nejméně {seconds} s mezi dvěma požadavky, {cap}",
+  "ui.consents.pace.own": "{pace} (vlastní tempo)",
+  "ui.consents.archives": "archivy (co jejich podmínky stromu dovolují: dovoleno · omezeno · jen ručně · zakázáno; neznámé jako omezeno)",
+  "ui.consents.level.allowed": "dovoleno",
+  "ui.consents.level.restricted": "omezeno",
+  "ui.consents.level.manual": "jen ručně",
+  "ui.consents.level.forbidden": "zakázáno",
+  "ui.consents.level.unknown": "neznámé",
+  "ui.consents.archive.refused": "jeho server odmítl automatický přístup stromu (odpověď serveru, ne podmínky archivu) – zruší to jen člověk: strom allow host {host} --unblock",
+  "ui.consents.archive.browser": "jen přes prohlížeč člověka",
+  "ui.consents.archive.browser.robots": "jen přes prohlížeč člověka (jeho robots.txt)",
+  "ui.consents.archive.way": "svolení člověka: {way}",
+  "ui.consents.way.slow": "pomalu",
+  "ui.consents.way.browser": "přes prohlížeč",
+  "ui.consents.way.manual": "ručně",
+  "ui.consents.archive.ask": "snímky jen se svolením člověka",
+  "ui.consents.archive.pace.service": "tempo služby: {pace}",
+  "ui.consents.archive.pace.images": "snímky: {pace}",
+  "ui.consents.pending": "čeká na rozhodnutí člověka: {items}",
+  "ui.consents.pending.permission": "{title} (snímky)",
+  "ui.consents.pending.takeover": "úrovně archivů u {names} (strom allow archive --accept)",
+  "ui.consents.pending.milder": "{connector} uvádí pro {host} mírnější úroveň: {to}",
+  "ui.consents.pace.about": "tempo: na každý server jeden požadavek po druhém – tempo služby (uvádí ho její stahovač), jinak nejméně {seconds} s mezi požadavky; hodinový limit jen tam, kde ho stanoví služba nebo člověk; pomaleji, když server odpovídá pomalu, čekání, když řekne, že je jeho limit vyčerpán; jeho robots.txt se čte jednou denně (cesty, kam nástroje nepouští, se nežádají, jeho Crawl-delay je nejpomalejší tempo); odmítnutí zastaví stahování na den – odmítnutí klienta stromu, dokud ho člověk nezruší (strom allow host <host> --unblock) · vlastní tempo pro server: strom allow host <host> --pace <seconds> --per-hour <n>",
+  "ui.consents.logins": "uložená přihlášení (strom login): {names}",
+  "ui.consents.revoke": "vzít zpět: strom allow connector <name> --revoke · strom allow host <host> --revoke · strom allow archive <host> --revoke",
+  "ui.consents.reason.client": "odmítl automatický přístup stromu ({details})",
+  "ui.consents.reason.refused": "odmítl automatický přístup ({details})",
+  "ui.consents.reason.login": "odmítl přihlášení ({details})",
+  "ui.consents.reason.slow": "dvakrát požádal o zpomalení ({details})",
+  "ui.consents.reason.silent": "bez odpovědi ({details}; server neběží, nebo blokuje IP adresu tohoto počítače)",
+  "ui.consents.reason.browser.slow": "požádal prohlížeč o zpomalení ({details})",
+  "ui.consents.reason.browser": "odmítl prohlížeč ({details})"
 }

package/assets/lang/de.json

@@ -1982,15 +1982,15 @@
   "ui.arg.what-the-family-knows": "was die Familie weiß",
   "ui.error.story.no-source": "{id} gibt es im Stammbaum nicht",
   "ui.error.story.no-source.hint": "der Hintergrund von Ort und Zeit wird zuerst als Quelle erfasst: strom source add … --kind book|newspaper|web",
-  "ui.consent.archive.pace": "Tempo für Bilder aus Archiven, deren Bedingungen die Automatisierung einschränken, nach der Erlaubnis „langsam“: mindestens {seconds} s zwischen zwei Bildern, höchstens {n} pro Stunde. So einstellen?",
+  "ui.consent.archive.pace": "Tempo für Bilder aus Archiven, deren Bedingungen die Automatisierung einschränken, nach der Erlaubnis „langsam“: mindestens {seconds} s zwischen zwei Bildern, höchstens {n} Anfragen an das Archiv pro Stunde, den Katalog mitgezählt. So einstellen?",
   "ui.archive.terms.known": "Bedingungen: „{quote}“ ({terms})",
   "ui.archive.terms.connector": "Bedingungen laut Downloader: {quote} ({terms})",
   "ui.archive.terms.none": "Die Bedingungen des Archivs sind noch nicht bekannt (der Downloader ist noch nicht bestätigt).",
   "ui.archive.terms.robots": "Seine robots.txt: „{quote}“ ({terms}) – kein automatischer Zugriff außer über den Browser eines Menschen.",
   "ui.archive.terms.robots.none": "Seine robots.txt erlaubt keinen automatischen Zugriff ({terms}) – nur über den Browser eines Menschen.",
   "ui.archive.name": "{title} ({host})",
-  "ui.archive.ask.slow": "Langsames Herunterladen der Bilder erlauben? Höchstens ein Bild alle {seconds} s und höchstens {n} pro Stunde, nur die Bilder, die eine Aufgabe braucht, nichts im Voraus. Ohne Erlaubnis werden die Bilder von Hand in einen vorbereiteten Ordner gespeichert.",
-  "ui.archive.ask.browser": "Herunterladen der Bilder über den Browser auf diesem Computer erlauben? Chrome mit der Claude-Erweiterung, das Tempo plant strom (höchstens ein Bild alle {seconds} s, höchstens {n} pro Stunde); eine Prüfung, ob ein Mensch da ist, besteht der Mensch selbst. Ohne Erlaubnis werden die Bilder von Hand gespeichert.",
+  "ui.archive.ask.slow": "Langsames Herunterladen der Bilder erlauben? Höchstens ein Bild alle {seconds} s und höchstens {n} Anfragen an das Archiv pro Stunde, den Katalog mitgezählt, nur die Bilder, die eine Aufgabe braucht, nichts im Voraus. Ohne Erlaubnis werden die Bilder von Hand in einen vorbereiteten Ordner gespeichert.",
+  "ui.archive.ask.browser": "Herunterladen der Bilder über den Browser auf diesem Computer erlauben? Chrome mit der Claude-Erweiterung, das Tempo plant strom (höchstens ein Bild alle {seconds} s, höchstens {n} Anfragen an das Archiv pro Stunde, den Katalog mitgezählt); eine Prüfung, ob ein Mensch da ist, besteht der Mensch selbst. Ohne Erlaubnis werden die Bilder von Hand gespeichert.",
   "ui.archive.ask.change": "Gilt für dieses Archiv auf diesem Computer; jederzeit zu ändern: strom allow archive {host}.",
   "ui.archive.btn.slow": "Langsam erlauben",
   "ui.archive.btn.browser": "Über den Browser erlauben",
@@ -2006,7 +2006,7 @@
   "ui.archive.window.browser": "Über den Browser herunterladen, ein Bild alle {seconds} s, nur was eine Aufgabe braucht?",
   "ui.archive.window.change": "Ändern: Einstellungen → Archive.",
   "ui.archive.choose": "{title} – wie sollen die Bilder kommen?",
-  "ui.archive.way.slow": "Langsam, im Tempo eines Menschen (höchstens ein Bild alle {seconds} s, höchstens {n} pro Stunde, nur was eine Aufgabe braucht)",
+  "ui.archive.way.slow": "Langsam, im Tempo eines Menschen (höchstens ein Bild alle {seconds} s, höchstens {n} Anfragen an das Archiv pro Stunde, den Katalog mitgezählt, nur was eine Aufgabe braucht)",
   "ui.archive.way.browser": "Über den Browser auf diesem Computer (Chrome mit der Claude-Erweiterung; das Tempo plant strom)",
   "ui.archive.way.manual": "Nur von Hand – die Bilder werden in einen vorbereiteten Ordner gespeichert",
   "ui.archive.way.later": "Später – nichts ändert sich",
@@ -2048,7 +2048,7 @@
   "ui.archive.woken": "Die Aufgaben {ids} kehren in die Warteschlange zurück.",
   "ui.archive.inbox": "{id}: Im Ordner liegen schon Bilder ({n}) – die Forschung erfasst sie, und die Aufgabe kommt von selbst zurück.",
   "ui.archive.manual.tasks": "Die Aufgaben {ids} warten weiter auf die von Hand gespeicherten Bilder.",
-  "ui.archive.pace": "höchstens ein Bild alle {seconds} s, höchstens {n} pro Stunde",
+  "ui.archive.pace": "höchstens ein Bild alle {seconds} s, höchstens {n} Anfragen pro Stunde, den Katalog mitgezählt",
   "ui.archive.pace.line": "Tempo der Bilder, langsam: {pace} – nur per Befehl zu ändern: strom allow host {host} --pace <s> --per-hour <n>, für alle Archive strom config set archive.pace \"<s> <n>\"",
   "ui.archive.allowed.line": "Es gilt: {level} – hier nur strenger: die Bilder nur von Hand.",
   "ui.archive.pace.service": "Tempo der Bilder: {pace} – nur per Befehl zu ändern: strom allow host {host} --pace <s> --per-hour <n>",
@@ -2075,5 +2075,60 @@
   "ui.link.archive.none": "Über dieses Archiv gibt es hier nichts zu entscheiden. Es ist nichts geschehen.",
   "ui.error.archive.permission": "das Herunterladen von Bildern aus dem Archiv {title} ({hosts}) wartet auf eine Entscheidung – seine Bedingungen schränken das automatische Herunterladen ein; beim Archiv wurde nichts angefragt",
   "ui.error.archive.permission.new": "das Herunterladen von Bildern aus dem Archiv {title} ({hosts}) wartet auf eine Entscheidung – die Lesart der Bedingungen durch den Downloader hat noch niemand bestätigt; beim Archiv wurde nichts angefragt",
-  "ui.error.archive.permission.hint": "im Menü von strom entscheiden (Was wartet) oder im Terminal: strom allow archive {host} --way {ways}"
+  "ui.error.archive.permission.hint": "im Menü von strom entscheiden (Was wartet) oder im Terminal: strom allow archive {host} --way {ways}",
+  "ui.error.archive.rerouted": "{title}: ab jetzt {way} – dieser Befehl ging diesen Weg noch nicht",
+  "ui.error.archive.rerouted.hint": "denselben Befehl noch einmal starten",
+  "ui.archive.level.robots.manual": "die robots.txt erlaubt keinen automatischen Zugriff, und der Downloader kann nicht über den Browser gehen – Bilder nur von Hand",
+  "ui.archive.level.browserOnly": "das Archiv lässt automatische Werkzeuge nur über den Browser eines Menschen zu – Bilder nur über den Browser, mit Erlaubnis",
+  "ui.archive.level.browserOnly.manual": "das Archiv lässt automatische Werkzeuge nur über den Browser eines Menschen zu, und der Downloader kann das nicht – Bilder nur von Hand",
+  "ui.pace.text": "mindestens {seconds} s zwischen zwei Anfragen, {cap}",
+  "ui.host.pace.own": "{host}: {pace} – eigenes Tempo",
+  "ui.host.pace.service": "{host}: {pace} – wieder das Tempo des Dienstes",
+  "ui.host.revoked": "{host}: Zustimmung zurückgenommen – kein Downloader erreicht ihn jetzt",
+  "ui.host.allowed": "{host}: automatischer Zugriff erlaubt (strom consents)",
+  "ui.host.notallowed": "Nicht erlaubt – nichts geändert.",
+  "ui.consents.on": "Zustimmungen: an – ein Downloader läuft erst, wenn ein Mensch ihn erlaubt, und ebenso jeder Server eines Archivs, den er erreicht",
+  "ui.consents.off": "Zustimmungen: aus – Downloader laufen ohne Nachfrage (im Tempo von strom, nur zu ihren Servern); Code, der an strom vorbeigeht, braucht das Ja eines Menschen · um vorher gefragt zu werden: strom config set connectors.consent on",
+  "ui.consents.connectors": "Downloader",
+  "ui.consents.connector": "{name}  {dir}  seit {date}  Server {hosts}",
+  "ui.consents.none": "(keine)",
+  "ui.consents.hosts": "Server (automatischer Zugriff)",
+  "ui.consents.host.refused": "⛔ {reason} – strom versucht es erst wieder ab {when}",
+  "ui.consents.host.refused.lifted": "⛔ {reason} – strom versucht es nicht wieder, bis ein Mensch es aufhebt: strom allow host {host} --unblock",
+  "ui.consents.host.recent": "Anfragen in der letzten Stunde: {n}",
+  "ui.consents.host.slowed": "verlangsamt ×{factor}",
+  "ui.consents.host.limit": "sein Limit aufgebraucht bis {when}",
+  "ui.consents.host.since": "erlaubt seit {date}",
+  "ui.consents.pace": "mindestens {seconds} s zwischen zwei Anfragen, {cap}",
+  "ui.consents.pace.own": "{pace} (eigenes Tempo)",
+  "ui.consents.archives": "Archive (was ihre Bedingungen strom erlauben: erlaubt · eingeschränkt · nur von Hand · verboten; unbekannt wie eingeschränkt)",
+  "ui.consents.level.allowed": "erlaubt",
+  "ui.consents.level.restricted": "eingeschränkt",
+  "ui.consents.level.manual": "nur von Hand",
+  "ui.consents.level.forbidden": "verboten",
+  "ui.consents.level.unknown": "unbekannt",
+  "ui.consents.archive.refused": "sein Server hat den automatischen Zugriff von strom abgelehnt (die Antwort des Servers, nicht die Bedingungen des Archivs) – nur ein Mensch hebt das auf: strom allow host {host} --unblock",
+  "ui.consents.archive.browser": "nur über den Browser eines Menschen",
+  "ui.consents.archive.browser.robots": "nur über den Browser eines Menschen (seine robots.txt)",
+  "ui.consents.archive.way": "Erlaubnis des Menschen: {way}",
+  "ui.consents.way.slow": "langsam",
+  "ui.consents.way.browser": "über den Browser",
+  "ui.consents.way.manual": "von Hand",
+  "ui.consents.archive.ask": "Bilder nur mit Erlaubnis des Menschen",
+  "ui.consents.archive.pace.service": "Tempo des Dienstes: {pace}",
+  "ui.consents.archive.pace.images": "Bilder: {pace}",
+  "ui.consents.pending": "wartet auf die Entscheidung des Menschen: {items}",
+  "ui.consents.pending.permission": "{title} (Bilder)",
+  "ui.consents.pending.takeover": "die Stufen der Archive von {names} (strom allow archive --accept)",
+  "ui.consents.pending.milder": "{connector} gibt für {host} eine mildere Stufe an: {to}",
+  "ui.consents.pace.about": "Tempo: je Server eine Anfrage nach der anderen – das Tempo des Dienstes (sein Downloader nennt es), sonst mindestens {seconds} s Abstand; ein Stundenlimit nur, wo der Dienst oder ein Mensch eines setzt; langsamer, solange ein Server langsam antwortet, eine Pause, wenn er sein Limit für aufgebraucht erklärt; seine robots.txt einmal am Tag gelesen (die Pfade, die er Werkzeugen verwehrt, nicht angefragt, sein Crawl-delay das langsamste Tempo); eine Ablehnung hält einen Tag an – eine des Clients von strom, bis ein Mensch sie aufhebt (strom allow host <host> --unblock) · eigenes Tempo für einen Server: strom allow host <host> --pace <seconds> --per-hour <n>",
+  "ui.consents.logins": "gespeicherte Anmeldungen (strom login): {names}",
+  "ui.consents.revoke": "zurücknehmen: strom allow connector <name> --revoke · strom allow host <host> --revoke · strom allow archive <host> --revoke",
+  "ui.consents.reason.client": "hat den automatischen Zugriff von strom abgelehnt ({details})",
+  "ui.consents.reason.refused": "hat den automatischen Zugriff abgelehnt ({details})",
+  "ui.consents.reason.login": "hat die Anmeldung abgelehnt ({details})",
+  "ui.consents.reason.slow": "hat zweimal um ein langsameres Tempo gebeten ({details})",
+  "ui.consents.reason.silent": "keine Antwort ({details}; der Server ist nicht erreichbar oder sperrt die IP-Adresse dieses Computers)",
+  "ui.consents.reason.browser.slow": "hat den Browser um ein langsameres Tempo gebeten ({details})",
+  "ui.consents.reason.browser": "hat den Browser abgelehnt ({details})"
 }

package/assets/method/core.md

@@ -91,6 +91,21 @@ conclusion so the next researcher can follow it.
   the records decide it. You read no records here: what would
   decide a hypothesis is a task (`strom task add … --about H…`), not a search now.
 <!-- end -->
+<!-- for link verify enrich locate connector -->
+- **Fetch only what you read**, as the archive allows (the brief's `archive`
+  line). An image known exactly from another source (an online reference, a
+  published edition): start with it. An archive that restricts automation (its
+  images slowly or through the browser, by the person's permission): sparing
+  and targeted — an index searched by halving (its middle image first, then the
+  half the name falls in; never batches from one end), only the images of the
+  name's letter fetched; a page number from the index turned into an image
+  number by one or two images, never a batch of ten; an entry: its image ±1
+  (it may run over a page). An archive that allows automation: batches as
+  usual (about ±5 around the target, an index in batches) — fewer turns.
+<!-- end -->
+- **What strom or the tree denies stays denied.** Never offer the user to
+  change your permissions or settings, strom's or the tree's, to get round it:
+  another way, or say what was refused.
 - **Stay within the task.** New questions become new tasks (`strom task add`,
   with where and done-when), not detours.
 <!-- for link verify enrich intake locate -->

package/dist/agents/files.js

@@ -14,6 +14,7 @@ import { isArchive } from "../core/mode.js";
 import { Settings } from "../core/config.js";
 import { agentAppUrl, appSite } from "../core/stromapp.js";
 import { configDir } from "../core/paths.js";
+import { within } from "../core/relocate.js";
 import { agentBrowser } from "../core/connector.js";
 import { CHROME_ALLOW, CHROME_DENY, chromeDomain } from "../core/browser.js";
 import { claudeScanReader, opencodeScanReader, SCAN_READER, scanReaderModel, treeReading } from "./scanreader.js";
@@ -68,6 +69,10 @@ the researcher; \`strom\` is your only way to read and change the research.
     either — check with \`strom net web --check <url>\`. Another way to the
     same records first; a task for the user (\`strom task wait T… --check
     <url> --on "…"\`) only if the source stays necessary.
+11. What strom or this tree denies you (a command, a site, a file) stays
+    denied: never offer the user to change your permissions or settings,
+    strom's or the tree's, to get round it — go another way, or say what was
+    refused.
 
 ## Working with the user
 
@@ -164,6 +169,43 @@ export function permissionPath(abs) {
     const win = /^([A-Za-z]):\/(.*)$/.exec(p);
     return win ? `//${win[1].toLowerCase()}/${win[2]}` : `/${p}`;
 }
+/** What strom keeps in its settings folder that no agent reads or edits: the seal keys, the person's settings,
+ * consents, permissions, logins. */
+const SETTINGS_KEPT = ["keys", "config.json", "consents.json", "archives.json", "logins.json", "agents-taught.json", "shortcut"];
+/**
+ * The parts of strom's settings folder kept from the agents, each with whether it is a folder. The whole folder —
+ * unless the research is in it (an isolated installation's home is "Strom research" inside it: a deny of the whole
+ * folder outweighs every allow and cuts the agent off its connectors, its inbox and the research itself). Then what
+ * strom keeps there always, and every other entry that holds none of the research's folders.
+ */
+export function settingsKeptFrom(dir, research, platform = process.platform) {
+    const keep = research.map((p) => path.resolve(p));
+    if (!keep.some((p) => within(p, dir, platform)))
+        return [{ path: dir, folder: true }];
+    let entries = [];
+    try {
+        entries = fs.readdirSync(dir);
+    }
+    catch {
+        // no settings folder yet: what strom will keep there
+    }
+    const names = [...new Set([...SETTINGS_KEPT, ...entries])].filter((n) => !keep.some((p) => within(p, path.join(dir, n), platform)));
+    return names.sort().map((n) => {
+        const p = path.join(dir, n);
+        let folder = n === "keys";
+        try {
+            folder = fs.statSync(p).isDirectory();
+        }
+        catch {
+            // not there yet: as strom makes it
+        }
+        return { path: p, folder };
+    });
+}
+/** The folders of the research the agent works in: its home, the shared folder, the tree. */
+function researchFolders(tree, settings) {
+    return [settings.home()?.value, settings.shared()?.value, tree.root].filter((p) => !!p);
+}
 /**
  * The tree's rules for Claude Code or Grok Build. Grok reads Claude Code's rules too, but an absolute
  * path in Claude Code's words ("//Users/x") is plain text to it: its own file gets the path as it is.
@@ -175,7 +217,7 @@ function treeRules(tree, agent) {
     const shared = settings.shared()?.value;
     const claude = agent === "claude";
     const at = (abs) => (claude ? permissionPath(abs) : abs.replace(/\\/g, "/"));
-    const keys = at(configDir(tree.env));
+    const kept = settingsKeptFrom(configDir(tree.env), researchFolders(tree, settings)).map((k) => (k.folder ? `${at(k.path)}/**` : at(k.path)));
     // Browser tools (Claude in Chrome): for the sites of the connectors fetching through the browser — or, agent.browser
     // always, of every archive of the research (anything else is asked in a conversation, not used in a run).
     const web = claude ? agentBrowser(tree, shared) : { on: false, hosts: [] };
@@ -217,9 +259,8 @@ function treeRules(tree, agent) {
             ...(shared ? [`Edit(${at(path.join(shared, "net"))}/**)`] : []),
             // A session ends with its turn: nothing wakes it up later (a live run waited for a wake-up that never came).
             ...(claude ? ["ScheduleWakeup", "CronCreate"] : []),
-            // The seal keys: an agent that could read them could forge the seal.
-            `Read(${keys}/**)`,
-            `Edit(${keys}/**)`,
+            // The seal keys: an agent that could read them could forge the seal; the person's settings, consents and logins.
+            ...kept.flatMap((k) => [`Read(${k})`, `Edit(${k})`]),
             // What the browser downloads is strom's to take over; the rest of the folder is the user's.
             `Read(${downloads}/**)`,
             ...(claude ? CHROME_DENY : []),
@@ -321,8 +362,8 @@ export function opencodeConfig(tree) {
                     [`${abs(path.join(shared, "net"))}/*`]: "deny",
                 }
                 : {}),
-            // the seal keys, and what the browser downloads (strom's to take over)
-            [`${abs(configDir(tree.env))}/*`]: "deny",
+            // the seal keys and the person's settings, and what the browser downloads (strom's to take over)
+            ...Object.fromEntries(settingsKeptFrom(configDir(tree.env), researchFolders(tree, settings)).map((k) => [k.folder ? `${abs(k.path)}/*` : abs(k.path), "deny"])),
             [`${abs(settings.downloads())}/*`]: "deny",
         },
         webfetch: "allow",

package/dist/brief/brief.js

@@ -736,6 +736,9 @@ function archiveLine(tree, b, repo, shared, installed, qs = []) {
             : ((q) => (q ? `the person's decision on its images waits since ${q.at.slice(0, 10)}` : "no decision of the person's yet: a fetch of its images asks them once, and the question then waits — never fetch there again until they decide"))(qs.find((x) => onHost(a.host, x.host))));
     else if (a.permission === "manual")
         parts.push("the person: images by hand only");
+    // a restricted archive's images, allowed slowly or through the browser: sparing (the method's "Fetch only what you read")
+    if ((a.level === "restricted" || a.level === "unknown") && (a.permission === "slow" || a.permission === "browser"))
+        parts.push("fetch sparingly: an index by halving, a page to its image by 1–2 images, an entry ±1");
     if (a.refused)
         parts.push(`${a.refused.host} refused strom's client — left alone ${a.refused.until && a.refused.until < REFUSED_FOREVER ? `until ${clock(a.refused.until)}` : "until the person lifts it"}; not through your web tools or a browser either`);
     else if (net) {

package/dist/cli/format.js

@@ -61,6 +61,10 @@ export function numberIn(lang, n, o = { maximumFractionDigits: 1 }) {
         return new Intl.NumberFormat("en", o).format(n);
     }
 }
+/** Seconds of a pace as a language writes them: 0,5 in Czech and German, 0.5 in English (no grouping: 3600, never 3,600). */
+export function secondsIn(lang, ms) {
+    return numberIn(lang, ms / 1000, { maximumFractionDigits: 2, useGrouping: false });
+}
 /** An argument as it is typed in a shell: quoted when it holds spaces or special characters. */
 export function shellArg(arg) {
     return /^[\p{L}\p{M}\p{N}._\/:@+-]+$/u.test(arg) ? arg : `"${arg.replace(/["\\$`]/g, "\\$&")}"`;

package/dist/cli/menu-archives.js

@@ -4,19 +4,21 @@
 // menu is the person's own terminal: each choice runs the ordinary command (strom allow archive …), 0 goes back with
 // nothing changed, and the current state is the suggested answer. Tasks that waited for the archive's images go back
 // to the queue once they may come — unless the images are in their folder already (saved by hand meanwhile).
+import { ui } from "./ui.js";
+import { secondsIn } from "./format.js";
 import { claudeHere, pause, subMenu, translator } from "./menu-parts.js";
 import { humanDay } from "./human.js";
 import { Tree } from "../core/tree.js";
 import { isArchive } from "../core/mode.js";
-import { bareHost, listConnectors, routeOf } from "../core/connector.js";
+import { bareHost, listConnectors, routeOf, routesOf } from "../core/connector.js";
 import { claimOf, loadArchives, rank } from "../core/terms.js";
 import { archiveQuestions, connectorFor, levelWords, tasksStanding, tasksWaitingOn, termsText, waysOffered, wokenLines } from "../core/archiveasks.js";
 import { wakeForArchive } from "../core/archivewait.js";
 import { archivesOverview, levelsOf, paceFor } from "../commands/archives.js";
 /** A pace in the person's words: "one image at most every 10 s, at most 120 an hour". */
-export function paceWords(t, p) {
+export function paceWords(lang, p) {
     const n = p.perHour === null || !Number.isFinite(p.perHour) ? "∞" : p.perHour;
-    return t("ui.archive.pace", { seconds: p.minIntervalMs / 1000, n });
+    return ui(lang, "ui.archive.pace", { seconds: secondsIn(lang, p.minIntervalMs), n });
 }
 function connectorsHere(ctx) {
     return listConnectors(ctx.settings.shared()?.value, ctx.env);
@@ -115,15 +117,15 @@ export async function decideArchive(ctx, run, lang, root, host, q) {
     const allowed = a?.level === "allowed";
     if (allowed) {
         out(`    ${t("ui.archive.allowed.line", { level: levelWords(lang, "allowed") })}`);
-        out(`    ${t("ui.archive.pace.service", { pace: paceWords(t, archivesOverview(ctx).find((r) => r.host === host && r.connector === c.name)?.pace ?? slow), host })}`);
+        out(`    ${t("ui.archive.pace.service", { pace: paceWords(lang, archivesOverview(ctx).find((r) => r.host === host && r.connector === c.name)?.pace ?? slow), host })}`);
     }
     else
-        out(`    ${t("ui.archive.pace.line", { pace: paceWords(t, slow), host })}`);
+        out(`    ${t("ui.archive.pace.line", { pace: paceWords(lang, slow), host })}`);
     const ways = allowed ? ["manual"] : waysOffered(c, claudeHere(ctx, tree?.config), q?.way, !!(a?.browserOnly ?? q?.browserOnly));
     const now = a?.permission;
     const choices = ways.map((w) => ({
         way: w,
-        label: t(w === "slow" ? "ui.archive.way.slow" : w === "browser" ? "ui.archive.way.browser" : "ui.archive.way.manual", { seconds: slow.minIntervalMs / 1000, n: Number.isFinite(slow.perHour) ? slow.perHour : "∞" }),
+        label: t(w === "slow" ? "ui.archive.way.slow" : w === "browser" ? "ui.archive.way.browser" : "ui.archive.way.manual", { seconds: secondsIn(lang, slow.minIntervalMs), n: Number.isFinite(slow.perHour) ? slow.perHour : "∞" }),
     }));
     if (now)
         choices.push({ label: t("ui.archive.way.revoke") });
@@ -216,6 +218,15 @@ async function decideMilder(ctx, run, lang, q, title) {
     if ((await run(["allow", "archive", c.name, i === 0 ? "--accept" : "--keep"], true)) === 0)
         out(t(i === 0 ? "ui.archive.milder.accepted" : "ui.archive.milder.kept", { title }));
 }
+/** An archive only a person's browser goes to, in the person's words: through the browser, or by hand where the downloader cannot. */
+function onlyBrowser(t, c, robots) {
+    const browser = routesOf(c).includes("browser");
+    return t(robots ? (browser ? "ui.archive.level.robots" : "ui.archive.level.robots.manual") : browser ? "ui.archive.level.browserOnly" : "ui.archive.level.browserOnly.manual");
+}
+/** Does only a person's browser go to an archive of this downloader (its robots.txt, strom's known terms)? Its line says how. */
+export function browserOnlyHere(ctx, c) {
+    return archivesOverview(ctx).some((r) => r.connector === c.name && r.browserOnly && r.level !== "manual" && r.level !== "forbidden");
+}
 /** What holds for a downloader's archive, on its line in the settings: its level, the person's way and since when, the pace. */
 export function archiveState(ctx, lang, c) {
     const t = translator(lang);
@@ -226,8 +237,11 @@ export function archiveState(ctx, lang, c) {
         const rec = store[r.host];
         const level = r.level;
         const closed = level === "manual" || level === "forbidden";
-        const way = !closed && r.way ? t("ui.archives.state.way", { way: t(`ui.archive.is.${r.way}`), date: rec?.at ? humanDay(rec.at, lang) : "–" }) : levelWords(lang, level, !!r.robots, r.from);
-        const pace = !closed && r.way !== "manual" && (level === "allowed" || r.way) ? `; ${paceWords(t, r.pace)}` : "";
+        // only a person's browser goes to the archive (its robots.txt, strom's known terms): said so — through the browser
+        // where the downloader can go that way, else by hand only; never "directly" (that is not the way here)
+        const only = !closed && !r.way && r.browserOnly ? onlyBrowser(t, c, !!r.robots) : undefined;
+        const way = only ?? (!closed && r.way ? t("ui.archives.state.way", { way: t(`ui.archive.is.${r.way}`), date: rec?.at ? humanDay(rec.at, lang) : "–" }) : levelWords(lang, level, !!r.robots, r.from));
+        const pace = !closed && r.way !== "manual" && (level === "allowed" || r.way) ? `; ${paceWords(lang, r.pace)}` : "";
         return `${rows.length > 1 ? `${r.host}: ` : ""}${way}${pace}`;
     })
         .join(" · ");

package/dist/cli/menu-settings.js

@@ -22,7 +22,7 @@ import { chooseMode } from "./menu-mode.js";
 import { agentsHere } from "../core/apps.js";
 import { mb, tidyPlan, TIDY_SAID } from "../core/tidy.js";
 import { calibrationOffer, viewSizesFor } from "../core/viewsizes.js";
-import { archivePermissions, archiveState } from "./menu-archives.js";
+import { archivePermissions, archiveState, browserOnlyHere } from "./menu-archives.js";
 export async function settingsMenu(ctx, run, lang, root, newer) {
     const t = translator(lang);
     return subMenu(ctx, lang, () => {
@@ -346,7 +346,9 @@ async function archives(ctx, run, lang, shared, root) {
             const login = !c.manifest.login ? "" : `; ${saved[c.name] ? t("ui.archives.login.saved", { date: saved[c.name].at.slice(0, 10) }) : t("ui.archives.login.none")}`;
             // what its archive's terms let it do here, the person's decision and since when, the pace (read only: the commands change it)
             const state = archiveState(ctx, lang, c);
-            return `  • ${c.manifest.title ?? c.name} — ${t(`ui.archives.via.${via(c)}`)}${login}${state ? `; ${state}` : ""}`;
+            // an archive only a person's browser goes to: its state says the way (never "directly", a route it cannot take there)
+            const how = browserOnlyHere(ctx, c) && state ? "" : t(`ui.archives.via.${via(c)}`);
+            return `  • ${c.manifest.title ?? c.name} — ${[how, login.replace(/^; /, ""), state].filter(Boolean).join("; ")}`;
         });
         // Through the browser: only Claude Code can, with the Claude in Chrome extension — said as it is here.
         const browser = connectors.filter((c) => via(c) === "browser");

package/dist/cli/ui.js

@@ -1782,15 +1782,15 @@ export const UI = {
     "ui.conflict.tasks-open": "still open about {id}: {tasks} \u2014 close them: strom task done {first} --result \"\u2026\"",
     "ui.error.story.no-source": "{id} is not in the family tree",
     "ui.error.story.no-source.hint": "the background of place and time is recorded first: strom source add \u2026 --kind book|newspaper|web",
-    "ui.consent.archive.pace": "The pace for the images of archives whose terms restrict automated access, once allowed slowly: at least {seconds} s between two images, at most {n} an hour. Set it so?",
+    "ui.consent.archive.pace": "The pace for the images of archives whose terms restrict automated access, once allowed slowly: at least {seconds} s between two images, at most {n} requests to the archive an hour, its catalogue counted too. Set it so?",
     "ui.archive.terms.known": "Terms: “{quote}” ({terms})",
     "ui.archive.terms.connector": "Terms as its downloader reads them: {quote} ({terms})",
     "ui.archive.terms.none": "The archive's terms are not known yet (nobody has confirmed its downloader).",
     "ui.archive.terms.robots": "Its robots.txt: “{quote}” ({terms}) – no automated access other than through a person's browser.",
     "ui.archive.terms.robots.none": "Its robots.txt allows no automated access ({terms}) – only through a person's browser.",
     "ui.archive.name": "{title} ({host})",
-    "ui.archive.ask.slow": "Allow slow downloading of its images? At most one image every {seconds} s and at most {n} an hour, only the images a task needs, nothing in advance. Without permission the images are saved by hand into a folder made ready for them.",
-    "ui.archive.ask.browser": "Allow downloading its images through the browser on this computer? Chrome with the Claude extension; strom plans the pace (at most one image every {seconds} s, at most {n} an hour); a check whether a person is there is passed by the person, never by strom. Without permission the images are saved by hand.",
+    "ui.archive.ask.slow": "Allow slow downloading of its images? At most one image every {seconds} s and at most {n} requests to the archive an hour, its catalogue counted too, only the images a task needs, nothing in advance. Without permission the images are saved by hand into a folder made ready for them.",
+    "ui.archive.ask.browser": "Allow downloading its images through the browser on this computer? Chrome with the Claude extension; strom plans the pace (at most one image every {seconds} s, at most {n} requests to the archive an hour, its catalogue counted too); a check whether a person is there is passed by the person, never by strom. Without permission the images are saved by hand.",
     "ui.archive.ask.change": "For this archive on this computer; to be changed at any time: strom allow archive {host}.",
     "ui.archive.btn.slow": "Allow slowly",
     "ui.archive.btn.browser": "Allow through the browser",
@@ -1806,7 +1806,7 @@ export const UI = {
     "ui.archive.window.browser": "Download through the browser, one image every {seconds} s, only what a task needs?",
     "ui.archive.window.change": "To change: settings → Archives.",
     "ui.archive.choose": "{title} – how to get its images?",
-    "ui.archive.way.slow": "Slowly, at a person's pace (one image at most every {seconds} s, at most {n} an hour, only what a task needs)",
+    "ui.archive.way.slow": "Slowly, at a person's pace (one image at most every {seconds} s, at most {n} requests to the archive an hour, its catalogue counted too, only what a task needs)",
     "ui.archive.way.browser": "Through the browser on this computer (Chrome with the Claude extension; strom plans the pace)",
     "ui.archive.way.manual": "By hand only – the images are saved into a folder made ready",
     "ui.archive.way.later": "Later – nothing changes",
@@ -1848,7 +1848,7 @@ export const UI = {
     "ui.archive.woken": "Tasks {ids} go back to the queue.",
     "ui.archive.inbox": "{id}: images already in its folder ({n}) \u2013 the research registers them and the task comes back by itself.",
     "ui.archive.manual.tasks": "Tasks {ids} keep waiting for the images saved by hand.",
-    "ui.archive.pace": "one image at most every {seconds} s, at most {n} an hour",
+    "ui.archive.pace": "one image at most every {seconds} s, at most {n} requests an hour, the catalogue too",
     "ui.archive.pace.line": "Pace of its images, slowly: {pace} \u2013 changed only by a command: strom allow host {host} --pace <s> --per-hour <n>, for every archive strom config set archive.pace \"<s> <n>\"",
     "ui.archive.allowed.line": "What holds: {level} – here only stricter: its images by hand.",
     "ui.archive.pace.service": "Pace of its images: {pace} – changed only by a command: strom allow host {host} --pace <s> --per-hour <n>",
@@ -1876,6 +1876,61 @@ export const UI = {
     "ui.error.archive.permission": "downloading images from {title} ({hosts}) waits for a decision \u2013 its terms restrict automated downloading; nothing was asked of the archive",
     "ui.error.archive.permission.new": "downloading images from {title} ({hosts}) waits for a decision \u2013 nobody has confirmed its downloader's reading of the terms yet; nothing was asked of the archive",
     "ui.error.archive.permission.hint": "to be decided in strom's menu (What waits), or in a terminal: strom allow archive {host} --way {ways}",
+    "ui.error.archive.rerouted": "{title}: {way} from now on – this command did not go that way yet",
+    "ui.error.archive.rerouted.hint": "run the same command again",
+    "ui.archive.level.robots.manual": "its robots.txt allows no automated access and the downloader cannot go through the browser – images by hand only",
+    "ui.archive.level.browserOnly": "the archive lets automated tools in only through a person's browser – images only through the browser, with permission",
+    "ui.archive.level.browserOnly.manual": "the archive lets automated tools in only through a person's browser and the downloader cannot go that way – images by hand only",
+    "ui.pace.text": "at least {seconds} s between two requests, {cap}",
+    "ui.host.pace.own": "{host}: {pace} – its own pace",
+    "ui.host.pace.service": "{host}: {pace} – the service's pace again",
+    "ui.host.revoked": "{host}: consent taken back – no downloader reaches it now",
+    "ui.host.allowed": "{host}: automated access allowed (strom consents)",
+    "ui.host.notallowed": "Not allowed – nothing changed.",
+    "ui.consents.on": "consents: on — a connector runs only once the person allows it, and each archive host it contacts",
+    "ui.consents.off": "consents: off — connectors run without asking (paced by strom, only to their hosts); code that goes round strom needs the person's yes · to be asked first: strom config set connectors.consent on",
+    "ui.consents.connectors": "connectors",
+    "ui.consents.connector": "{name}  {dir}  since {date}  hosts {hosts}",
+    "ui.consents.none": "(none)",
+    "ui.consents.hosts": "hosts (automated access)",
+    "ui.consents.host.refused": "⛔ {reason} — strom tries again only from {when}",
+    "ui.consents.host.refused.lifted": "⛔ {reason} — strom will not try again until the person lifts it: strom allow host {host} --unblock",
+    "ui.consents.host.recent": "{n} request(s) in the last hour",
+    "ui.consents.host.slowed": "slowed ×{factor}",
+    "ui.consents.host.limit": "its limit used up until {when}",
+    "ui.consents.host.since": "allowed since {date}",
+    "ui.consents.pace": "at least {seconds} s apart, {cap}",
+    "ui.consents.pace.own": "{pace} (the person's own)",
+    "ui.consents.archives": "archives (what their terms let strom do: allowed · restricted · manual · forbidden; unknown as restricted)",
+    "ui.consents.level.allowed": "allowed",
+    "ui.consents.level.restricted": "restricted",
+    "ui.consents.level.manual": "manual",
+    "ui.consents.level.forbidden": "forbidden",
+    "ui.consents.level.unknown": "unknown",
+    "ui.consents.archive.refused": "its server refused strom's automated access (the server's answer, not the archive's terms) — only the person lifts it: strom allow host {host} --unblock",
+    "ui.consents.archive.browser": "only through a person's browser",
+    "ui.consents.archive.browser.robots": "only through a person's browser (its robots.txt)",
+    "ui.consents.archive.way": "the user's permission: {way}",
+    "ui.consents.way.slow": "slow",
+    "ui.consents.way.browser": "browser",
+    "ui.consents.way.manual": "manual",
+    "ui.consents.archive.ask": "images only with the user's permission",
+    "ui.consents.archive.pace.service": "the service's pace {pace}",
+    "ui.consents.archive.pace.images": "images {pace}",
+    "ui.consents.pending": "waiting for the user's word: {items}",
+    "ui.consents.pending.permission": "{title} (images)",
+    "ui.consents.pending.takeover": "the archives' levels of {names} (strom allow archive --accept)",
+    "ui.consents.pending.milder": "{connector} gives {host} a milder level: {to}",
+    "ui.consents.pace.about": "pace: one request at a time per host — the service's pace (its connector says it), else ≥{seconds} s apart; an hourly cap only where the service or the person sets one; slower while a host answers slowly, a wait when it says its limit is used up; its robots.txt read once a day (the paths it keeps tools off not asked, its Crawl-delay the slowest pace); a refusal stops for a day — one of strom's client until the person lifts it (strom allow host <host> --unblock) · the person's own for a host: strom allow host <host> --pace <seconds> --per-hour <n>",
+    "ui.consents.logins": "logins saved (strom login): {names}",
+    "ui.consents.revoke": "take back: strom allow connector <name> --revoke · strom allow host <host> --revoke · strom allow archive <host> --revoke",
+    "ui.consents.reason.client": "refused strom's automated access ({details})",
+    "ui.consents.reason.refused": "refused automated access ({details})",
+    "ui.consents.reason.login": "refused the login ({details})",
+    "ui.consents.reason.slow": "asked twice to slow down ({details})",
+    "ui.consents.reason.silent": "no answer ({details}; the server is down, or it blocks this computer's IP address)",
+    "ui.consents.reason.browser.slow": "asked the browser to slow down ({details})",
+    "ui.consents.reason.browser": "refused the browser ({details})",
 };
 /** A text for the person, in their language. */
 export function ui(lang, key, values = {}) {