strom-research 1.7.0 → 1.8.0

package/README.md

@@ -105,6 +105,9 @@ npm: `npm install -g strom-research@latest`.
   double-click the launcher inside (Windows, macOS, Linux): it installs strom
   where it is missing, puts the research in place and takes it over
   (`strom unpack`)
+- Take a family tree off the computer (`strom trees remove`): a backup offered
+  first, its name typed to confirm, then into the system's trash with the
+  images no other tree uses — never deleted for good
 
 **Safe by design**
 - What the agent may do alone is your choice: ask, auto (default) or full

package/assets/lang/cs.json

@@ -179,6 +179,7 @@
   "ui.run.stop.resets": " (obnoví se {at})",
   "ui.run.stop.auth": "agent není přihlášený – spusťte jednou {command} a přihlaste se",
   "ui.run.stop.failed": "agent selhal: {detail}",
+  "ui.run.finishing": "■ Ctrl-C: sezení {session} dostalo žádost skončit – agent zapíše, co našel, a sezení uzavře, pak běh skončí (další sezení nezačne). Dalším Ctrl-C ho zastavíte hned.",
   "ui.run.stopping": "■ zastavuji – sezení se zavře a jeho úkol se vrátí do fronty; dalším Ctrl-C skončíte hned",
   "ui.run.gone": "· {session} zavřeno – jeho běh se zastavil{back}",
   "ui.run.back": "; {task} je zpět ve frontě",
@@ -374,6 +375,7 @@
   "ui.menu.app.live": "Agent pracuje – můžete ho živě sledovat v aplikaci Strom: volba {key}.",
   "ui.app.open.now": "Až bude nainstalovaná: otevřít v ní výzkum?",
   "ui.run.follow": "Sledovat mezitím práci živě v aplikaci Strom?",
+  "ui.run.follow.later": "Aplikace Strom se otevře, až agent začne první sezení.",
   "ui.consent.host.pace": "Vlastní tempo pro {host}: nejméně {seconds} s mezi dvěma požadavky, {cap}. Příliš rychlé stahování zpomalí archiv všem a může vést k zablokování vaší IP adresy – nastavit?",
   "ui.pace.cap": "nejvýš {n} za hodinu",
   "ui.pace.nocap": "bez hodinového limitu",
@@ -582,6 +584,14 @@
   "ui.consent.gate.set": "Nechat podmínku „{name}“ rozhodovat, kdy agent pracující sám pokračuje?",
   "ui.consent.gate.unset": "Odebrat podmínku „{name}“ — agent pracující sám se jí už nebude ptát?",
   "ui.consent.gate.skip": "Nechat agenta pracovat samotného bez podmínky „{name}“?",
+  "ui.run.browser.always": "· prohlížeč (Claude in Chrome) v každém sezení, jak jste nastavili (agent.browser always) – bez ptaní pro {hosts}; musí běžet Chrome s rozšířením Claude",
+  "ui.consent.browser": "Dát agentovi nástroje prohlížeče (Claude in Chrome) v každém sezení výzkumu? Pracuje ve vašem Chromu – tam, kde jste přihlášení – na webech archivů výzkumu bez ptaní; v rozhovoru se u každého jiného webu zeptá.",
+  "ui.archives.agentbrowser": "Prohlížeč pro agenta (Claude in Chrome): {state}",
+  "ui.archives.agentbrowser.archives": "jen pro archivy přes prohlížeč",
+  "ui.archives.agentbrowser.always": "v každém sezení",
+  "ui.archives.agentbrowser.about": "V každém sezení může agent pracovat ve vašem Chromu – tam, kde jste přihlášení – takže mu můžete zadat cokoli přes prohlížeč. Na webech archivů výzkumu bez ptaní; v rozhovoru se u každého jiného webu zeptá, při samostatné práci jiné weby nepoužije. Musí běžet Chrome s rozšířením Claude.",
+  "ui.archives.agentbrowser.on": "Dát agentovi prohlížeč v každém sezení?",
+  "ui.archives.agentbrowser.off": "Vrátit prohlížeč jen pro archivy přes prohlížeč?",
   "ui.consent.remote": "Spouštět sezení Claude Code, která strom otevírá, se vzdáleným ovládáním (Remote Control), abyste je mohli sledovat a řídit z claude.ai nebo z aplikace Claude v telefonu?",
   "ui.consent.hook.on": "Nechat hook „{name}“, aby se dozvídal všechno, co se uloží do vašich výzkumů? Je to program na tomto počítači a udělá s tím, k čemu byl napsán.",
   "ui.consent.hook.off": "Přestat hooku „{name}“ hlásit, co se ukládá?",
@@ -614,6 +624,16 @@
   "ui.link.what.chat.person": "rozhovor s agentem ({agent}) o osobě {person}.",
   "ui.link.chat.say": "Podívejme se na osobu {person}: řekni mi krátce, co o ní výzkum ví, a zeptej se mě, co chci zjistit.",
   "ui.link.what.review.person": "prověřit znovu osobu {person}.",
+  "ui.link.what.direction.pause": "pozastavit směr „{name}“: jeho úkoly ({n}) počkají mimo frontu a nic nového se pro něj nenavrhne. Nic se nemaže.",
+  "ui.link.what.direction.done": "ukončit směr „{name}“: jeho úkoly ({n}) odejdou z fronty. Nic se nemaže, jde ho znovu spustit.",
+  "ui.link.what.direction.resume": "znovu spustit směr „{name}“: jeho úkoly ({n}) se vrátí do fronty a výzkum navrhne, co chybí.",
+  "ui.link.direction.none": "Směr {id} v tomto výzkumu není. Nic se nestalo.",
+  "ui.link.direction.cannot": "Směr „{name}“ už je {state}. Nic se nestalo.",
+  "ui.link.direction.why": "Proč? (pár slov, zůstane u směru; Enter: bez důvodu)",
+  "ui.link.what.chat.research": "rozhovor s agentem ({agent}) o směru „{name}“, jen jeho úkoly.",
+  "ui.link.chat.research.say": "Pojďme pracovat na směru „{name}“ ({id}), na jeho úkolech.",
+  "ui.link.what.finish": "požádat agenta {agent}, aby dokončil sezení {session} ({task}): zapíše, co našel, a sezení zavře; při samostatné práci další nezačne.",
+  "ui.link.finish.none": "Sezení {session} už neběží (mezitím skončilo). Nic se nestalo.",
   "ui.link.what.review.family": "prověřit znovu osobu {person} i s partnery a dětmi.",
   "ui.link.what.review.line": "prověřit znovu osobu {person} i s předky.",
   "ui.link.what.research.ancestors": "hledat předky osoby {person} (nový směr výzkumu).",
@@ -703,7 +723,7 @@
   "ui.research.knows": "Co o tom víte? Data, místa a rodinné historky agentovi pomohou (Enter: nic)",
   "ui.research.done": "✓ Výzkum „{name}“ je založený.",
   "ui.research.chat": "Začít na něm s agentem hned?",
-  "ui.research.say": "Založil(a) jsem nový výzkum „{name}“ – pojďme s ním začít.",
+  "ui.research.say": "Založil(a) jsem nový výzkum „{name}“ ({id}) – pojďme s ním začít, jeho úkoly.",
   "ui.settings.title": "Nastavení (na tomto počítači)",
   "ui.settings.wizard": "Jazyk, agent, model, co smí agent sám, příběhy… (průvodce nastavením)",
   "ui.settings.alone": "Samostatná práce agenta: {minutes} min na úkol · podmínka: {gate}",
@@ -750,6 +770,65 @@
   "ui.more.noagent": "Agent se do toho pustí, až bude na počítači (volba 1 v menu).",
   "ui.menu.noagent.chosen": "AI agent, kterého výzkum používá, na počítači není – volba 1 vybere jiného.",
   "task.answer": "Odpověď uživatele (na: {asked}): {answer}",
+  "who.run": "{agent} – samostatná práce",
+  "who.chat": "{agent} – rozhovor",
+  "log.person.add": "Nová osoba: {who}",
+  "log.person.name": "Zapsané jméno: {who}",
+  "log.person.edit": "Upraveno: {who}",
+  "log.person.cite": "Doklad k osobě {who}",
+  "log.person.retract": "Odvoláno: {who}",
+  "log.merge": "Sloučeno, byl to jeden: {who}",
+  "log.family.add": "Nová rodina: {who}",
+  "log.family.child": "Dítě rodiny {who}: {child}",
+  "log.family.edit": "Upravená rodina: {who}",
+  "log.family.cite": "Doklad k rodině {who}",
+  "log.event.add": "{who} – {fact}",
+  "log.event.edit": "Upřesněno: {who} – {fact}",
+  "log.event.cite": "Doklad k údaji: {who} – {fact}",
+  "log.event.retract": "Odvoláno: {who} – {fact}",
+  "log.source.add": "Záznam z pramene: {name}",
+  "log.source.edit": "Upravený záznam: {name}",
+  "log.search.found": "Hledáno, nalezeno: {name}",
+  "log.search.negative": "Hledáno, bez výsledku: {name}",
+  "log.search.partial": "Hledáno, nalezeno zčásti: {name}",
+  "log.search.inconclusive": "Hledáno, nejasné: {name}",
+  "log.recordset.add": "Nová kniha: {name}",
+  "log.recordset.edit": "Upravená kniha: {name}",
+  "log.recordset.calibrate": "V knize určeno, kde jsou které roky: {name}",
+  "log.media": "Nové snímky: {name} (obr. {images})",
+  "log.media.one": "Nový snímek: {name} (obr. {image})",
+  "log.media.loose": "Nové snímky: {n}",
+  "log.reading": "Pročteno: {name} (obr. {images})",
+  "log.task.add": "Nový úkol: {name}",
+  "log.task.done": "Hotovo: {name}",
+  "log.task.park": "Odloženo: {name}",
+  "log.task.drop": "Zahozeno: {name}",
+  "log.task.wait": "Čeká na vás: {name}",
+  "log.task.wake": "Zpět agentovi: {name}",
+  "log.task.edit": "Upravený úkol: {name}",
+  "log.session.start": "Agent začal: {name}",
+  "log.session.close": "Agent skončil: {name}",
+  "log.lesson.add": "Poznatek: {name}",
+  "log.hypothesis.add": "Hypotéza: {name}",
+  "log.hypothesis.argue": "Hypotéza zvážena: {name}",
+  "log.hypothesis.decide": "Hypotéza rozhodnuta: {name}",
+  "log.conflict.add": "Záznamy si odporují: {name}",
+  "log.conflict.resolve": "Rozpor vyřešen: {name}",
+  "log.place.add": "Nové místo: {name}",
+  "log.place.edit": "Upřesněné místo: {name}",
+  "log.repository.add": "Nový archiv: {name}",
+  "log.repository.edit": "Upravený archiv: {name}",
+  "log.story.set": "Vyprávění: {who}",
+  "log.story.approve": "Vyprávění schváleno: {who}",
+  "log.note.add": "Poznámka: {name}",
+  "log.input.add": "Materiál od rodiny: {name}",
+  "log.input.sync": "Převzatý rodokmen: {name}",
+  "log.input.done": "Materiál zpracován: {name}",
+  "log.research.add": "Nový směr výzkumu: {name}",
+  "log.research.edit": "Upravený směr výzkumu: {name}",
+  "log.research.pause": "Směr pozastaven: {name}",
+  "log.research.resume": "Směr znovu běží: {name}",
+  "log.research.done": "Směr ukončen: {name}",
   "ui.waiting.title": "Agent od vás potřebuje ({n}):",
   "ui.waiting.do": "Co udělat: {what}",
   "ui.waiting.ask": "agent vám to řekne v rozhovoru",
@@ -766,6 +845,20 @@
   "ui.intake.empty": "Není v tom nic, co by se dalo přidat.",
   "ui.intake.ours": "{path} je složka samotného stromu (výzkumu), ne rodinné podklady.",
   "ui.research.exists": "Takový výzkum už je: „{name}“ – agent v něm pokračuje.",
+  "ui.more.directions": "Směry výzkumu: pozastavit, ukončit nebo znovu spustit",
+  "ui.dirs.pick": "Který směr?",
+  "ui.dirs.item": "{name} – {state} · úkoly: {n}",
+  "ui.dirs.active": "běží",
+  "ui.dirs.paused": "pozastavený",
+  "ui.dirs.done": "ukončený",
+  "ui.dirs.what": "„{name}“:",
+  "ui.dirs.do.pause": "Pozastavit – jeho úkoly počkají, agent vezme jiné",
+  "ui.dirs.do.done": "Ukončit – jeho úkoly odejdou z fronty (nic se nemaže)",
+  "ui.dirs.do.resume": "Znovu spustit – jeho úkoly se vrátí do fronty",
+  "ui.dirs.paused.now": "⏸ „{name}“ je pozastavený: jeho úkoly ({n}) počkají, dokud ho tady znovu nespustíte.",
+  "ui.dirs.done.now": "■ „{name}“ je ukončený: jeho úkoly ({n}) jsou mimo frontu – nic se nesmazalo, tady ho jde znovu spustit.",
+  "ui.dirs.active.now": "▶ „{name}“ zase běží: jeho úkoly ({n}) jsou zpátky ve frontě.",
+  "ui.research.resume": "Takový výzkum už je, {state}: „{name}“. Spustit ho znovu?",
   "ui.alone.gate.bad": "Napište prosím počet bodů od 0 do 100 (třeba 10).",
   "ui.waiting.long": "Na odpověď sem je to dlouhé (nejvýš {n} znaků) – stačí odkaz nebo věta, zbytek řekněte agentovi v rozhovoru.",
   "ui.settings.remote.chats": "rozhovory ano, samostatná práce ne",
@@ -839,5 +932,27 @@
   "ui.unpack.same": "tento výzkum už tu je: {root}",
   "ui.unpack.person": "výzkum rozbaluje jen člověk u počítače (přidává konektory)",
   "ui.pack.launch.extract": "Nejdřív rozbalte celý soubor ZIP – ve Windows pravým tlačítkem: Extrahovat vše – a spusťte tohle znovu z rozbalené složky.",
-  "ui.pack.launch.failed": "Strom Research se nepodařilo nainstalovat. Nainstalujte ho řádkem z JAK-NAVAZAT.txt a spusťte tohle znovu."
+  "ui.pack.launch.failed": "Strom Research se nepodařilo nainstalovat. Nainstalujte ho řádkem z JAK-NAVAZAT.txt a spusťte tohle znovu.",
+  "ui.trees.remove": "odebrat rodokmen z tohoto počítače",
+  "ui.session.finish.done": "Sezení {session} (úkol {task}) dostalo žádost skončit: agent ji uvidí u svého dalšího příkazu strom, zapíše, co našel, a sezení uzavře.",
+  "ui.session.finish.none": "v tomto výzkumu teď žádné sezení neběží",
+  "ui.session.finish.which": "běží víc sezení ({sessions}) – napište, které",
+  "ui.session.finish.closed": "sezení {session} už je uzavřené",
+  "ui.remove.which": "Který rodokmen odebrat z tohoto počítače?",
+  "ui.remove.person": "rodokmen z počítače odebírá jen člověk u počítače",
+  "ui.remove.busy": "na rodokmenu „{name}“ se právě pracuje – odebrat ho jde, až práce skončí",
+  "ui.remove.what": "„{name}“ ({root}) · osoby: {persons}",
+  "ui.remove.backup": "Nejdřív ho zabalit jako zálohu, se všemi snímky ({mb} MB)? Kdykoli se vrátí přes strom unpack.",
+  "ui.remove.backup.done": "  záloha: {file}",
+  "ui.remove.images": "Poslat do koše i snímky, které žádný jiný rodokmen nepoužívá (snímky: {n}, {mb} MB)?",
+  "ui.remove.type": "Pro potvrzení napište název rodokmenu ({name}) – cokoli jiného nic neodebere:",
+  "ui.remove.cancelled": "Nic se neodebralo.",
+  "ui.remove.done": "„{name}“ je v koši.",
+  "ui.remove.live": "  aplikace Strom ho už živě nesleduje",
+  "ui.remove.images.done": "  jeho snímky v koši: {n} ({mb} MB)",
+  "ui.remove.images.folder": "{name} – snímky",
+  "ui.remove.backup.back": "  vrátí se ze zálohy: strom unpack „{file}“",
+  "ui.remove.trash.alone": "  vrátí se z koše systému, dokud ho nevysypete",
+  "ui.remove.next": "Teď pracujete s rodokmenem „{name}“ – jiný vyberete v nabídce pod Jiný rodokmen.",
+  "ui.remove.trash": "  nebo z koše systému, dokud ho nevysypete"
 }

package/assets/lang/de.json

@@ -179,6 +179,7 @@
   "ui.run.stop.resets": " (erneuert sich {at})",
   "ui.run.stop.auth": "der Agent ist nicht angemeldet – starten Sie einmal {command} und melden Sie sich an",
   "ui.run.stop.failed": "der Agent ist gescheitert: {detail}",
+  "ui.run.finishing": "■ Strg-C: Sitzung {session} ist gebeten aufzuhören – der Agent schreibt auf, was er gefunden hat, und schließt sie, dann endet der Lauf (keine nächste Sitzung). Noch einmal Strg-C stoppt ihn sofort.",
   "ui.run.stopping": "■ wird angehalten – die Sitzung wird geschlossen und ihre Aufgabe kehrt in die Warteschlange zurück; nochmals Strg-C beendet sofort",
   "ui.run.gone": "· {session} geschlossen – ihr Lauf war abgebrochen{back}",
   "ui.run.back": "; {task} ist zurück in der Warteschlange",
@@ -374,6 +375,7 @@
   "ui.menu.app.live": "Der Agent arbeitet – Sie können ihm in der Strom-App live zusehen: Auswahl {key}.",
   "ui.app.open.now": "Sobald sie installiert ist: die Forschung darin öffnen?",
   "ui.run.follow": "Die Arbeit währenddessen live in der Strom-App verfolgen?",
+  "ui.run.follow.later": "Die Strom-App öffnet sich, wenn der Agent seine erste Sitzung beginnt.",
   "ui.consent.host.pace": "Ihr eigenes Tempo für {host}: mindestens {seconds} s zwischen zwei Anfragen, {cap}. Zu schnelles Laden bremst das Archiv für alle und kann Ihre IP-Adresse sperren lassen – so einstellen?",
   "ui.pace.cap": "höchstens {n} pro Stunde",
   "ui.pace.nocap": "ohne Stundenlimit",
@@ -582,6 +584,14 @@
   "ui.consent.gate.set": "Die Bedingung „{name}“ entscheiden lassen, wann der allein arbeitende Agent weitermacht?",
   "ui.consent.gate.unset": "Die Bedingung „{name}“ entfernen — der allein arbeitende Agent fragt sie nicht mehr?",
   "ui.consent.gate.skip": "Den Agenten ohne die Bedingung „{name}“ allein arbeiten lassen?",
+  "ui.run.browser.always": "· der Browser (Claude in Chrome) in jeder Sitzung, wie Sie es eingestellt haben (agent.browser always) – ohne Nachfrage für {hosts}; Chrome mit der Claude-Erweiterung muss laufen",
+  "ui.consent.browser": "Dem Agenten in jeder Sitzung der Forschung Browser-Werkzeuge (Claude in Chrome) geben? Er arbeitet in Ihrem eigenen Chrome – wo Sie angemeldet sind – auf den Seiten der Archive der Forschung ohne Nachfrage; im Gespräch fragt er bei jeder anderen Seite.",
+  "ui.archives.agentbrowser": "Der Browser für den Agenten (Claude in Chrome): {state}",
+  "ui.archives.agentbrowser.archives": "nur für Archive über den Browser",
+  "ui.archives.agentbrowser.always": "in jeder Sitzung",
+  "ui.archives.agentbrowser.about": "In jeder Sitzung kann der Agent in Ihrem eigenen Chrome arbeiten – wo Sie angemeldet sind –, Sie können ihm also alles über den Browser auftragen. Die Seiten der Archive der Forschung ohne Nachfrage; im Gespräch fragt er bei jeder anderen Seite, allein arbeitend nutzt er keine andere. Chrome mit der Claude-Erweiterung muss laufen.",
+  "ui.archives.agentbrowser.on": "Dem Agenten den Browser in jeder Sitzung geben?",
+  "ui.archives.agentbrowser.off": "Zurück zum Browser nur für Archive über den Browser?",
   "ui.consent.remote": "Die Claude-Code-Sitzungen, die strom öffnet, mit Remote Control starten, damit Sie sie auf claude.ai oder in der Claude-App auf dem Telefon verfolgen und steuern können?",
   "ui.consent.hook.on": "Den Hook „{name}“ über alles informieren, was in Ihre Forschungen gespeichert wird? Er ist ein Programm auf diesem Computer und tut damit, wofür er geschrieben wurde.",
   "ui.consent.hook.off": "Dem Hook „{name}“ nicht mehr melden, was gespeichert wird?",
@@ -614,6 +624,16 @@
   "ui.link.what.chat.person": "ein Gespräch mit dem Agenten ({agent}) über {person}.",
   "ui.link.chat.say": "Schauen wir uns {person} an: Sag mir kurz, was die Forschung über diese Person weiß, und frag mich, was ich herausfinden möchte.",
   "ui.link.what.review.person": "{person} erneut prüfen.",
+  "ui.link.what.direction.pause": "die Richtung „{name}“ pausieren: ihre Aufgaben ({n}) warten außerhalb der Warteschlange, und es wird nichts Neues für sie vorgeschlagen. Nichts wird gelöscht.",
+  "ui.link.what.direction.done": "die Richtung „{name}“ beenden: ihre Aufgaben ({n}) verlassen die Warteschlange. Nichts wird gelöscht, sie kann wieder aufgenommen werden.",
+  "ui.link.what.direction.resume": "die Richtung „{name}“ wieder aufnehmen: ihre Aufgaben ({n}) kommen zurück in die Warteschlange, und die Forschung schlägt vor, was fehlt.",
+  "ui.link.direction.none": "Richtung {id} ist nicht in dieser Forschung. Es ist nichts geschehen.",
+  "ui.link.direction.cannot": "Die Richtung „{name}“ ist schon {state}. Es ist nichts geschehen.",
+  "ui.link.direction.why": "Warum? (ein paar Worte, bleiben bei der Richtung; Enter: ohne Grund)",
+  "ui.link.what.chat.research": "ein Gespräch mit dem Agenten ({agent}) über die Richtung „{name}“, nur ihre Aufgaben.",
+  "ui.link.chat.research.say": "Arbeiten wir an der Richtung „{name}“ ({id}), an ihren Aufgaben.",
+  "ui.link.what.finish": "{agent} bitten, die Sitzung {session} ({task}) abzuschließen: er schreibt auf, was er gefunden hat, und schließt die Sitzung; arbeitet er selbständig, beginnt er keine weitere.",
+  "ui.link.finish.none": "Die Sitzung {session} läuft nicht mehr (sie ist inzwischen beendet). Es ist nichts geschehen.",
   "ui.link.what.review.family": "{person} erneut prüfen, mit Partnern und Kindern.",
   "ui.link.what.review.line": "{person} erneut prüfen, mit den Vorfahren.",
   "ui.link.what.research.ancestors": "die Vorfahren von {person} suchen (eine neue Richtung der Forschung).",
@@ -703,7 +723,7 @@
   "ui.research.knows": "Was wissen Sie darüber? Daten, Orte und Familiengeschichten helfen dem Agenten (Enter: nichts)",
   "ui.research.done": "✓ Die Forschung „{name}“ ist angelegt.",
   "ui.research.chat": "Jetzt mit dem Agenten beginnen?",
-  "ui.research.say": "Ich habe eine neue Forschung angelegt, „{name}“ – fangen wir damit an.",
+  "ui.research.say": "Ich habe eine neue Forschung angelegt, „{name}“ ({id}) – fangen wir damit an, mit ihren Aufgaben.",
   "ui.settings.title": "Einstellungen (auf diesem Computer)",
   "ui.settings.wizard": "Sprache, Agent, Modell, was der Agent allein darf, Geschichten… (die Einrichtung)",
   "ui.settings.alone": "Der Agent allein: {minutes} Min. je Aufgabe · Bedingung: {gate}",
@@ -750,6 +770,65 @@
   "ui.more.noagent": "Der Agent nimmt es auf, sobald er auf dem Computer ist (Punkt 1 im Menü).",
   "ui.menu.noagent.chosen": "Der KI-Agent dieser Forschung ist nicht auf dem Computer – Punkt 1 wählt einen anderen.",
   "task.answer": "Antwort des Nutzers (auf: {asked}): {answer}",
+  "who.run": "{agent} – arbeitet selbständig",
+  "who.chat": "{agent} – Gespräch",
+  "log.person.add": "Neue Person: {who}",
+  "log.person.name": "Name eingetragen: {who}",
+  "log.person.edit": "Geändert: {who}",
+  "log.person.cite": "Ein Beleg für {who}",
+  "log.person.retract": "Zurückgezogen: {who}",
+  "log.merge": "Zusammengeführt, es war derselbe: {who}",
+  "log.family.add": "Neue Familie: {who}",
+  "log.family.child": "Ein Kind von {who}: {child}",
+  "log.family.edit": "Familie geändert: {who}",
+  "log.family.cite": "Ein Beleg für die Familie {who}",
+  "log.event.add": "{who} – {fact}",
+  "log.event.edit": "Präzisiert: {who} – {fact}",
+  "log.event.cite": "Ein Beleg für: {who} – {fact}",
+  "log.event.retract": "Zurückgezogen: {who} – {fact}",
+  "log.source.add": "Eintrag aus einer Quelle: {name}",
+  "log.source.edit": "Eintrag geändert: {name}",
+  "log.search.found": "Gesucht, gefunden: {name}",
+  "log.search.negative": "Gesucht, nichts gefunden: {name}",
+  "log.search.partial": "Gesucht, teilweise gefunden: {name}",
+  "log.search.inconclusive": "Gesucht, unklar: {name}",
+  "log.recordset.add": "Neues Buch: {name}",
+  "log.recordset.edit": "Buch geändert: {name}",
+  "log.recordset.calibrate": "Im Buch bestimmt, wo welche Jahre stehen: {name}",
+  "log.media": "Neue Bilder: {name} (Bilder {images})",
+  "log.media.one": "Neues Bild: {name} (Bild {image})",
+  "log.media.loose": "Neue Bilder: {n}",
+  "log.reading": "Durchgelesen: {name} (Bilder {images})",
+  "log.task.add": "Neue Aufgabe: {name}",
+  "log.task.done": "Erledigt: {name}",
+  "log.task.park": "Zurückgestellt: {name}",
+  "log.task.drop": "Verworfen: {name}",
+  "log.task.wait": "Wartet auf Sie: {name}",
+  "log.task.wake": "Zurück an den Agenten: {name}",
+  "log.task.edit": "Aufgabe geändert: {name}",
+  "log.session.start": "Der Agent beginnt: {name}",
+  "log.session.close": "Der Agent ist fertig: {name}",
+  "log.lesson.add": "Gelernt: {name}",
+  "log.hypothesis.add": "Eine Hypothese: {name}",
+  "log.hypothesis.argue": "Hypothese abgewogen: {name}",
+  "log.hypothesis.decide": "Hypothese entschieden: {name}",
+  "log.conflict.add": "Die Einträge widersprechen sich: {name}",
+  "log.conflict.resolve": "Widerspruch geklärt: {name}",
+  "log.place.add": "Neuer Ort: {name}",
+  "log.place.edit": "Ort präzisiert: {name}",
+  "log.repository.add": "Neues Archiv: {name}",
+  "log.repository.edit": "Archiv geändert: {name}",
+  "log.story.set": "Erzählung: {who}",
+  "log.story.approve": "Erzählung freigegeben: {who}",
+  "log.note.add": "Notiz: {name}",
+  "log.input.add": "Material der Familie: {name}",
+  "log.input.sync": "Stammbaum übernommen: {name}",
+  "log.input.done": "Material durchgearbeitet: {name}",
+  "log.research.add": "Neue Richtung der Forschung: {name}",
+  "log.research.edit": "Richtung geändert: {name}",
+  "log.research.pause": "Richtung pausiert: {name}",
+  "log.research.resume": "Richtung wieder aufgenommen: {name}",
+  "log.research.done": "Richtung beendet: {name}",
   "ui.waiting.title": "Der Agent braucht Sie ({n}):",
   "ui.waiting.do": "Was zu tun ist: {what}",
   "ui.waiting.ask": "der Agent sagt es Ihnen im Gespräch",
@@ -766,6 +845,20 @@
   "ui.intake.empty": "Darin ist nichts, was sich hinzufügen ließe.",
   "ui.intake.ours": "{path} ist ein Ordner von strom selbst (der Forschung), keine Unterlagen der Familie.",
   "ui.research.exists": "Diese Forschung gibt es schon: „{name}“ – der Agent arbeitet daran weiter.",
+  "ui.more.directions": "Die Richtungen der Forschung: pausieren, beenden oder wieder aufnehmen",
+  "ui.dirs.pick": "Welche Richtung?",
+  "ui.dirs.item": "{name} – {state} · Aufgaben: {n}",
+  "ui.dirs.active": "läuft",
+  "ui.dirs.paused": "pausiert",
+  "ui.dirs.done": "beendet",
+  "ui.dirs.what": "„{name}“:",
+  "ui.dirs.do.pause": "Pausieren – ihre Aufgaben warten, der Agent nimmt andere",
+  "ui.dirs.do.done": "Beenden – ihre Aufgaben verlassen die Warteschlange (nichts wird gelöscht)",
+  "ui.dirs.do.resume": "Wieder aufnehmen – ihre Aufgaben zurück in die Warteschlange",
+  "ui.dirs.paused.now": "⏸ „{name}“ ist pausiert: ihre Aufgaben ({n}) warten, bis Sie sie hier wieder aufnehmen.",
+  "ui.dirs.done.now": "■ „{name}“ ist beendet: ihre Aufgaben ({n}) sind aus der Warteschlange – nichts gelöscht, hier lässt sie sich wieder aufnehmen.",
+  "ui.dirs.active.now": "▶ „{name}“ läuft wieder: ihre Aufgaben ({n}) sind zurück in der Warteschlange.",
+  "ui.research.resume": "Diese Forschung gibt es schon, {state}: „{name}“. Wieder aufnehmen?",
   "ui.alone.gate.bad": "Bitte eine Zahl von Punkten zwischen 0 und 100 (z. B. 10).",
   "ui.waiting.long": "Das ist für eine Antwort hier zu lang (höchstens {n} Zeichen) – ein Link oder ein Satz; das Übrige sagen Sie dem Agenten im Gespräch.",
   "ui.settings.remote.chats": "Gespräche ja, allein arbeiten nein",
@@ -839,5 +932,27 @@
   "ui.unpack.same": "diese Forschung ist schon da: {root}",
   "ui.unpack.person": "eine Forschung packt nur die Person am Computer aus (sie fügt Konnektoren hinzu)",
   "ui.pack.launch.extract": "Packen Sie zuerst die ganze ZIP-Datei aus – unter Windows mit Rechtsklick: Alle extrahieren – und starten Sie dies dann im ausgepackten Ordner neu.",
-  "ui.pack.launch.failed": "Strom Research ließ sich nicht installieren. Installieren Sie es mit der Zeile aus SO-GEHT-ES-WEITER.txt und starten Sie dies neu."
+  "ui.pack.launch.failed": "Strom Research ließ sich nicht installieren. Installieren Sie es mit der Zeile aus SO-GEHT-ES-WEITER.txt und starten Sie dies neu.",
+  "ui.trees.remove": "einen Stammbaum von diesem Computer nehmen",
+  "ui.session.finish.done": "Sitzung {session} (Aufgabe {task}) ist gebeten, aufzuhören: ihr Agent sieht es bei seinem nächsten strom-Befehl, schreibt auf, was er gefunden hat, und schließt die Sitzung.",
+  "ui.session.finish.none": "in dieser Forschung läuft gerade keine Sitzung",
+  "ui.session.finish.which": "mehrere Sitzungen laufen ({sessions}) – sagen Sie, welche",
+  "ui.session.finish.closed": "Sitzung {session} ist schon geschlossen",
+  "ui.remove.which": "Welchen Stammbaum von diesem Computer nehmen?",
+  "ui.remove.person": "einen Stammbaum nimmt nur die Person am Computer herunter",
+  "ui.remove.busy": "an „{name}“ wird gerade gearbeitet – er kann weg, wenn die Arbeit vorbei ist",
+  "ui.remove.what": "„{name}“ ({root}) · Personen: {persons}",
+  "ui.remove.backup": "Zuerst als Sicherung einpacken, mit allen Bildern ({mb} MB)? Er kommt jederzeit mit strom unpack zurück.",
+  "ui.remove.backup.done": "  Sicherung: {file}",
+  "ui.remove.images": "Auch die Bilder, die kein anderer Stammbaum nutzt, in den Papierkorb ({n}, {mb} MB)?",
+  "ui.remove.type": "Zur Bestätigung tippen Sie den Namen des Stammbaums ({name}) – alles andere nimmt nichts weg:",
+  "ui.remove.cancelled": "Nichts wurde weggenommen.",
+  "ui.remove.done": "„{name}“ ist im Papierkorb.",
+  "ui.remove.live": "  die Strom-App verfolgt ihn nicht mehr live",
+  "ui.remove.images.done": "  seine Bilder im Papierkorb: {n} ({mb} MB)",
+  "ui.remove.images.folder": "{name} – Bilder",
+  "ui.remove.backup.back": "  er kommt aus der Sicherung zurück: strom unpack „{file}“",
+  "ui.remove.trash.alone": "  er kommt aus dem Papierkorb des Systems zurück, bis er geleert wird",
+  "ui.remove.next": "Jetzt arbeiten Sie an „{name}“ – einen anderen wählen Sie im Menü unter Anderer Stammbaum.",
+  "ui.remove.trash": "  oder aus dem Papierkorb des Systems, bis er geleert wird"
 }

package/assets/method/narrate.md

@@ -7,8 +7,12 @@ A story is written from the facts, for the family.
   unknown. Never fill gaps with plausible fiction.
 - Use the research language and plain words; explain old occupations and
   terms the reader will not know.
+- Format: paragraphs separated by a blank line; within them only "## "
+  subheadings, "- " bullet lines, **bold** and *italic* — the Strom app shows
+  anything else (links, tables, quotes, numbered lists) as plain text. The
+  title goes in --title, not as a "# " line in the text.
 - Write it to a file in notes/, then `strom story set P… --text @notes/story-P….md
-  --fact E… --fact E… --note "what is inferred"`: every fact it leans on goes
+  --title "…" --fact E… --fact E… --note "what is inferred"`: every fact it leans on goes
   in --fact. A couple's story goes on the family (F…).
 - It stays a draft; when the user says it is right: `strom story approve P…`
   (the Strom app asks them too).

package/assets/plugins/gates/claude-usage/gate.ts

@@ -87,7 +87,8 @@ const now = Date.now();
 const start = week.resets.getTime() - WEEK;
 const gone = Math.max(0, Math.min(100, ((now - start) / WEEK) * 100));
 const behind = gone - week.used;
-const v = { used: week.used, gone: Math.round(gone), behind: Math.round(behind), min };
+// shown rounded down: never "15 in hand (at least 15 needed)" for 14.6 — and gone − used stays what it says
+const v = { used: week.used, gone: Math.floor(gone), behind: Math.floor(behind), min };
 if (session && session.used >= 100) answer(1, say("session"), session.resets ? new Date(session.resets.getTime() + 60_000) : undefined);
 if (behind < min) {
   // when the week gone reaches usage + the number; past the reset, the new week's number

package/dist/agents/files.js

@@ -12,7 +12,7 @@ import { writeFileAtomic } from "../core/json.js";
 import { PROFILES, SELF_READING } from "./profiles.js";
 import { Settings } from "../core/config.js";
 import { configDir } from "../core/paths.js";
-import { treeBrowserConnectors } from "../core/connector.js";
+import { agentBrowser } from "../core/connector.js";
 import { CHROME_ALLOW, CHROME_DENY, chromeDomain } from "../core/browser.js";
 export const MARKER = "<!-- strom: generated above this line (strom agents sync); your own notes below are kept -->";
 function agentsMd(tree) {
@@ -152,8 +152,10 @@ function treeRules(tree, agent) {
     const claude = agent === "claude";
     const at = (abs) => (claude ? permissionPath(abs) : abs.replace(/\\/g, "/"));
     const keys = at(configDir(tree.env));
-    // Connectors of this tree whose images come through the user's browser: browser tools (Claude in Chrome), for their sites only.
-    const sites = claude ? [...new Set(treeBrowserConnectors(tree, shared).flatMap((c) => c.manifest.hosts.map(chromeDomain)))] : [];
+    // 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: [] };
+    const sites = [...new Set(web.hosts.map(chromeDomain))];
     const downloads = at(settings.downloads());
     // A rule for each of Claude Code's shells: Bash, and PowerShell (on Windows) — a Bash rule does not cover it. Grok has one.
     const shell = (cmd) => (claude ? [`Bash(${cmd})`, `PowerShell(${cmd})`] : [`Bash(${cmd})`]);
@@ -171,7 +173,7 @@ function treeRules(tree, agent) {
             ...(shared ? ["Read", "Edit"].map((t) => `${t}(${at(path.join(shared, "plugins", "connectors"))}/**)`) : []),
             "WebSearch",
             "WebFetch",
-            ...(sites.length ? [...CHROME_ALLOW, ...sites] : []),
+            ...(web.on ? [...CHROME_ALLOW, ...sites] : []),
         ],
         deny: [
             "Read(data/**)",

package/dist/cli/main.js

@@ -15,7 +15,7 @@ import { noticeStromApp } from "../core/stromapp.js";
 import { isNewer } from "../core/update.js";
 import { refreshGlobal } from "../agents/global.js";
 import { linkFiles, linkHandlerState, registerLinks } from "../core/links.js";
-import { clockLine } from "../core/clock.js";
+import { clockLine, FINISH_LINE, finishAsked } from "../core/clock.js";
 import { currentSession } from "../core/session.js";
 import { checkArgs, GroupOnly, parseOptions, resolveCommand, splitPassthrough } from "./execute.js";
 import "../commands/index.js";
@@ -194,9 +194,27 @@ export async function main(argv, io, env, cwd) {
         return code;
     }
 }
-/** Near the end of a session with a time limit (strom run), every command reminds the agent how long it has left. */
+/**
+ * Near the end of a session with a time limit (strom run), every command reminds the agent how long it has left;
+ * a session the user asked to finish (strom session finish) is told to write down and close, from its next command.
+ */
 function remind(io, ctx, command) {
-    const line = ctx && command !== "session close" ? clockLine(ctx.env) : undefined;
+    if (!ctx || command === "session close" || command === "session finish")
+        return;
+    const session = ctx.env.STROM_SESSION;
+    if (session) {
+        try {
+            const root = ctx.locateTree();
+            if (root && finishAsked(root, session)) {
+                io.stderr(FINISH_LINE + "\n");
+                return;
+            }
+        }
+        catch {
+            // no tree here: only the clock
+        }
+    }
+    const line = clockLine(ctx.env);
     if (!line)
         return;
     try {

package/dist/cli/menu-links.js

@@ -6,7 +6,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { outOfAnswers, translator } from "./menu-parts.js";
-import { offerChat } from "./menu-research.js";
+import { directionTasks, offerChat, setDirection } from "./menu-research.js";
 import { humanCost, humanDay, humanTask } from "./human.js";
 import { lines, truncate } from "./format.js";
 import { Tree } from "../core/tree.js";
@@ -55,6 +55,40 @@ export async function taskDo(ctx, run, lang, root, id, what) {
     out(ctx, t(`ui.link.task.${what}.done`));
     return true;
 }
+/** A direction of the research paused, ended (each with the person's reason, if they give one) or taken up again. */
+export async function directionDo(ctx, run, lang, root, id, what) {
+    const t = translator(lang);
+    const tree = Tree.open(root, ctx.env);
+    const r = tree.get(id);
+    if (!r || r.type !== "research")
+        return stop(ctx, t("ui.link.direction.none", { id }));
+    const state = what === "pause" ? "paused" : what === "resume" ? "active" : "done";
+    if (r.state === state)
+        return stop(ctx, state === "active" ? t("ui.research.exists", { name: r.name }) : t("ui.link.direction.cannot", { name: r.name, state: t(`ui.dirs.${state}`) }));
+    if (!(await asks(ctx, lang, root, t(`ui.link.what.direction.${what}`, { name: r.name, n: directionTasks(tree, r.id) }))))
+        return false;
+    let reason;
+    if (what !== "resume") {
+        reason = (await ctx.ask(t("ui.link.direction.why"))).trim();
+        if (reason === "0")
+            return false;
+    }
+    await setDirection(ctx, run, lang, root, r, what, reason || undefined);
+    return true;
+}
+/** A session at work asked to finish: its agent writes down what it found and closes it; a run starts no next one. */
+export async function finishSession(ctx, run, lang, root, id) {
+    const t = translator(lang);
+    const tree = Tree.open(root, ctx.env);
+    const s = tree.get(id);
+    if (!s || s.type !== "session" || s.state !== "open")
+        return stop(ctx, t("ui.link.finish.none", { session: id }));
+    const task = s.task ? tree.get(s.task) : undefined;
+    const agent = PROFILES[s.agent ?? ""]?.name ?? s.agent ?? "";
+    if (!(await asks(ctx, lang, root, t("ui.link.what.finish", { agent, session: s.id, task: task ? truncate(humanTask(tree, task.what, lang), 80) : "–" }))))
+        return false;
+    return (await run(["session", "finish", s.id])) === 0;
+}
 /** The agent's sessions, the latest first, and what this month's cost. */
 export function sessionsView(ctx, lang, root) {
     const t = translator(lang);

package/dist/cli/menu-research.js

@@ -6,6 +6,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { agentReady, droppedPaths, outOfAnswers, pause, pickPerson, subMenu, translator } from "./menu-parts.js";
 import { Tree } from "../core/tree.js";
+import { directionOf, scopes } from "../core/directions.js";
 import { displayName, lifespan } from "../core/people.js";
 import { DEATH_AFTER_YEARS, unprovenPeople } from "../core/review.js";
 import { planSync, readTreeFile, receivedSince } from "../core/sync.js";
@@ -26,10 +27,12 @@ export async function addToResearch(ctx, run, lang, root) {
             items.push({ key: "3", label: t("ui.menu.review"), act: async () => void (await reviewPerson(ctx, run, lang, root)) });
             items.push({ key: "4", label: t(noApp(ctx) ? "ui.more.sync.noapp" : "ui.more.sync"), act: async () => void (await syncTree(ctx, run, lang, root)) });
         }
+        if (tree.count("research") > 0)
+            items.push({ key: "5", label: t("ui.more.directions"), act: async () => void (await directions(ctx, run, lang, root)) });
         // only when there are some: the people no record of their own proves — last, it shows only sometimes
         const unproven = unprovenPeople(tree).filter((u) => !u.living).length;
         if (unproven)
-            items.push({ key: "5", label: t("ui.menu.unproven", { n: unproven }), act: async () => void (await reviewUnproven(ctx, run, lang, root)) });
+            items.push({ key: String(items.length + 1), label: t("ui.menu.unproven", { n: unproven }), act: async () => void (await reviewUnproven(ctx, run, lang, root)) });
         return { title: t("ui.more.title"), items };
     });
 }
@@ -175,6 +178,13 @@ export async function startDirection(ctx, run, lang, root, direction, who, name,
         : undefined;
     if (same)
         return void ctx.io.stdout(t("ui.research.exists", { name: same.name }) + "\n");
+    // …paused or ended: taken up again rather than made twice
+    const stopped = focus && direction !== "question" ? Tree.open(root, ctx.env).list("research").find((r) => r.focus === focus && r.direction === direction) : undefined;
+    if (stopped) {
+        if (await ctx.confirm(t("ui.research.resume", { name: stopped.name, state: t(`ui.dirs.${stopped.state}`) })))
+            await setDirection(ctx, run, lang, root, stopped, "resume");
+        return;
+    }
     const suggested = question ?? t(direction === "ancestors" ? "ui.research.title.ancestors" : "ui.research.title.descendants", { name });
     const title = (await ctx.ask(t("ui.research.title"), suggested)).trim();
     if (title === "0")
@@ -193,7 +203,36 @@ export async function startDirection(ctx, run, lang, root, direction, who, name,
     if (knows && knows !== "0")
         await run(["intake", `--text=${knows}`, "--research", made.id], true);
     ctx.io.stdout(t("ui.research.done", { name: made.name }) + "\n");
-    await offerChat(ctx, run, lang, root, t("ui.research.chat"), t("ui.research.say", { name: made.name }));
+    await offerChat(ctx, run, lang, root, t("ui.research.chat"), t("ui.research.say", { name: made.name, id: made.id }));
+}
+/** A direction's tasks not finished: open, at work, put aside or waiting for the user. */
+export function directionTasks(tree, research) {
+    const all = scopes(tree);
+    return tree.list("task").filter((x) => ["open", "doing", "parked", "waiting"].includes(x.state) && directionOf(tree, x, all) === research).length;
+}
+/** The directions of the research, each with how it goes and its tasks: one paused, ended or taken up again. */
+async function directions(ctx, run, lang, root) {
+    const t = translator(lang);
+    const tree = Tree.open(root, ctx.env);
+    const all = tree.list("research");
+    const label = (r) => t("ui.dirs.item", { name: r.name, state: t(`ui.dirs.${r.state}`), n: directionTasks(tree, r.id) });
+    const i = await ctx.choose(t("ui.dirs.pick"), all.map((r) => ({ label: label(r) })), all.length, { back: t("ui.browse.back") });
+    if (i === undefined)
+        return;
+    const r = all[i];
+    const acts = r.state === "active" ? ["pause", "done"] : r.state === "paused" ? ["resume", "done"] : ["resume"];
+    const a = await ctx.choose(t("ui.dirs.what", { name: r.name }), acts.map((x) => ({ label: t(`ui.dirs.do.${x}`) })), acts.length, { back: t("ui.browse.back") });
+    if (a === undefined)
+        return;
+    await setDirection(ctx, run, lang, root, r, acts[a]);
+}
+/** A direction paused, ended or taken up again (with the person's reason), and what that means for its tasks. */
+export async function setDirection(ctx, run, lang, root, r, act, reason) {
+    const t = translator(lang);
+    if ((await run(["research", act, r.id, ...(reason ? [`--reason=${reason}`] : [])], true)) !== 0)
+        return;
+    const state = act === "pause" ? "paused" : act === "resume" ? "active" : "done";
+    ctx.io.stdout(t(`ui.dirs.${state}.now`, { name: r.name, n: directionTasks(Tree.open(root, ctx.env), r.id) }) + "\n");
 }
 /** The person said no to the Strom app: it is not named. */
 const noApp = (ctx) => stromAppState(ctx.settings) === "no";

package/dist/cli/menu-settings.js

@@ -226,7 +226,9 @@ async function archives(ctx, run, lang, shared, root) {
         const saved = loadLogins(ctx.env);
         const connectors = listConnectors(shared);
         const consent = ctx.settings.connectorsConsent();
-        const agent = ctx.settings.agent(root ? Tree.open(root, ctx.env).config : undefined).value;
+        const treeConfig = root ? Tree.open(root, ctx.env).config : undefined;
+        const agent = ctx.settings.agent(treeConfig).value;
+        const always = ctx.settings.resolve("agent.browser", treeConfig)?.value === "always";
         const via = (c) => (c.manifest.policy.automation === "manual" ? "manual" : routeOf(ctx.env, c).via);
         // Each downloader on a line of its own: how its images come, and its login where it can use one.
         const lines = connectors.map((c) => {
@@ -260,6 +262,20 @@ async function archives(ctx, run, lang, shared, root) {
                         await run(["config", "set", "connectors.consent", consent ? "off" : "on"], true);
                 },
             },
+            // The browser for the agent in every session: Claude Code's alone, shown only when it does the research and is here.
+            ...(claudeHere(ctx, treeConfig)
+                ? [
+                    {
+                        key: "b",
+                        label: t("ui.archives.agentbrowser", { state: t(always ? "ui.archives.agentbrowser.always" : "ui.archives.agentbrowser.archives") }),
+                        act: async () => {
+                            out(t("ui.archives.agentbrowser.about"));
+                            if (await ctx.confirm(t(always ? "ui.archives.agentbrowser.off" : "ui.archives.agentbrowser.on"), false))
+                                await run(always ? ["config", "unset", "agent.browser"] : ["config", "set", "agent.browser", "always"], true);
+                        },
+                    },
+                ]
+                : []),
             ...switchable.map((c) => {
                 const next = via(c) === "browser" ? "direct" : "browser";
                 const name = c.manifest.title ?? c.name;