strom-research 1.6.0 → 1.7.0

package/README.md

@@ -99,6 +99,12 @@ npm: `npm install -g strom-research@latest`.
   (`strom stats`), what is new (`strom recent`), what the agent does next
   (`strom plan`), one person's life with its
   records (`strom person card`), the ancestors as a tree (`strom pedigree`)
+- Hand the research to a relative in one small ZIP file (`strom pack`): the
+  family tree with its history, the images its records stand on and the
+  connectors — the pages only searched through the archive gives again. They
+  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`)
 
 **Safe by design**
 - What the agent may do alone is your choice: ask, auto (default) or full

package/assets/lang/cs.json

@@ -62,8 +62,8 @@
   "ui.menu.waitlist": "Co čeká na vás",
   "ui.menu.settings": "Nastavení: agent, samostatná práce, zprávy, archivy, kontrola",
   "ui.menu.doctor": "Kontrola instalace",
-  "ui.menu.trees": "Jiný rodokmen",
-  "ui.menu.newtree": "Založit rodokmen",
+  "ui.menu.trees": "Jiný rodokmen · poslat nebo přijmout",
+  "ui.menu.newtree": "Založit rodokmen · poslat nebo přijmout",
   "ui.menu.quit": "Konec",
   "ui.menu.bye": "Na shledanou. Příště stačí spustit: strom",
   "ui.run.how": "Kolik úkolů? (skončí dřív, když už nebude co dělat; 0 vrátí zpět)",
@@ -488,10 +488,13 @@
   "ui.sync.child.new": "{n}. {who}: dítě — {child}",
   "ui.sync.child.gone": "{n}. {who}: už to není jejich dítě — {child}",
   "ui.sync.person.gone": "{n}. už v něm není: {name}",
+  "ui.sync.place.coords": "{n}. {place}: poloha na mapě {from} → {at}",
+  "ui.sync.place.located": "{n}. {place}: poloha na mapě {at}",
   "ui.sync.do.add": "přidá se jako vodítko",
   "ui.sync.do.correct": "opraví vodítko výzkumu",
   "ui.sync.do.conflict": "rozpor k rozhodnutí (výzkum to má ze záznamu)",
   "ui.sync.do.user": "platí vaše úprava (údaj ze záznamu se stáhne s důvodem)",
+  "ui.sync.do.set": "výzkum převezme vaši polohu (žádný zápis ji nedokládá)",
   "ui.sync.do.pick": "jen když ho vyberete (--only)",
   "ui.sync.do.report": "nic se nemění — řekněte agentovi, co jste tím mysleli",
   "ui.sync.edits": "Vaše úpravy údajů doložených záznamem: {mode} (strom config set sync.edits conflict|user)",
@@ -805,5 +808,36 @@
   "ui.menu.failed": "Tohle se nepovedlo: {reason}",
   "ui.review.next.human": "Agent se do nich pustí v rozhovoru nebo při samostatné práci.",
   "ui.review.wake.human": "    pokud v něm chcete pokračovat, řekněte to agentovi v rozhovoru",
-  "ui.waiting.gone": "Tohle už na vás nečeká – agent se toho mezitím ujal."
+  "ui.waiting.gone": "Tohle už na vás nečeká – agent se toho mezitím ujal.",
+  "ui.trees.pack": "zabalit „{name}“ a poslat někomu (soubor ZIP)",
+  "ui.trees.unpack": "rodokmen, který vám někdo poslal (soubor ZIP)",
+  "ui.pack.which": "Které snímky přibalit?",
+  "ui.pack.opt.records": "ty, na kterých jsou zápisy – {mb} MB (prohledané stránky dá archiv znovu)",
+  "ui.pack.opt.all": "všechny – {mb} MB",
+  "ui.pack.done": "Zabaleno „{name}“: {file} ({mb} MB)",
+  "ui.pack.saved": "  rodokmen, jak byl naposledy uložený, i s historií",
+  "ui.pack.images": "  snímky: {n} ({mb} MB) – ty, na kterých jsou zápisy, a ty, které nikdo znovu nestáhne",
+  "ui.pack.images.all": "  snímky: všech {n} ({mb} MB)",
+  "ui.pack.left": "  vynechané snímky: {n} ({mb} MB) – prohledané stránky; až budou potřeba, strom je z archivu stáhne znovu",
+  "ui.pack.connectors": "  konektory: {list}",
+  "ui.pack.noconnector": "⚠ některé vynechané snímky přišly konektorem, který na tomto počítači není – nikdo by je znovu nestáhl: strom pack --all-images",
+  "ui.pack.missing": "⚠ snímky, které rodokmen uvádí, ale na tomto počítači nejsou: {n} – v balíčku chybí",
+  "ui.pack.send": "Soubor pošlete. Příjemce ho rozbalí a dvojklikem spustí Windows.cmd nebo macOS.command uvnitř: strom se nainstaluje, pokud chybí, a výzkum se otevře (kdo už strom má: strom unpack „<soubor>“).",
+  "ui.pack.readme.file": "JAK-NAVAZAT.txt",
+  "ui.pack.readme": "Výzkum „{name}“ – jak na něj navázat\n====================================\n\n1. Rozbalte celý soubor ZIP: ve Windows pravým tlačítkem – Extrahovat vše; na Macu dvojklikem.\n\n2. V rozbalené složce spusťte dvojklikem:\n     Windows:  Windows.cmd\n     macOS:    macOS.command  (poprvé pravým tlačítkem – Otevřít; když to macOS nedovolí:\n               Nastavení systému – Soukromí a zabezpečení – Přesto otevřít)\n     Linux:    v terminálu: bash Linux.sh\n   Nainstaluje Strom Research, pokud ještě není (oficiálním instalátorem), dá výzkum\n   na místo – rodokmen mezi vaše, snímky do vaší sdílené složky, všechno zkontroluje –,\n   převezme ho na váš počítač a otevře strom.\n\n3. Pokračujte: v nabídce stromu rozhovor s agentem.\n\nBez spouštěčů: nainstalujte strom sami\n   Windows (PowerShell):      {win}\n   macOS, Linux (Terminál):   {unix}\npak: strom unpack \"<tento soubor ZIP>\" (napište strom unpack a mezeru, přetáhněte soubor\ndo terminálu, Enter) – nebo v nabídce stromu: jiný rodokmen – rodokmen, který vám někdo poslal.\n\nSnímky, na kterých jsou zápisy, v balíčku jsou. Ostatní stránky knih (prohledané,\nnic se na nich nenašlo) kvůli velikosti ne – až budou potřeba, strom je stáhne\nz archivu znovu.\n",
+  "ui.unpack.file": "Přetáhněte sem soubor ZIP (nebo napište, kde je; 0 vrátí zpět):",
+  "ui.unpack.what": "„{name}“ (ze stromu {strom}, uloženo {date}) · snímky: {images}{connectors} → {root}",
+  "ui.unpack.ask": "Dát ho sem a převzít na tento počítač?",
+  "ui.unpack.done": "„{name}“ je tady: {root}",
+  "ui.unpack.images": "  snímky do sdílené složky: {n}{had}",
+  "ui.unpack.had": " (už tu byly: {n})",
+  "ui.unpack.connectors": "  konektory: {list}",
+  "ui.unpack.kept": "  konektor {name} tu už byl – zůstává váš",
+  "ui.unpack.left": "  prohledané stránky, které v něm nejsou: {n} – až budou potřeba, strom je stáhne z archivu",
+  "ui.unpack.adopted": "  převzato na tento počítač",
+  "ui.unpack.next": "Pokračujte: strom (nabídka) nebo strom chat.",
+  "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."
 }

package/assets/lang/de.json

@@ -62,8 +62,8 @@
   "ui.menu.waitlist": "Was auf Sie wartet",
   "ui.menu.settings": "Einstellungen: Agent, allein arbeiten, Nachrichten, Archive, Prüfung",
   "ui.menu.doctor": "Installation prüfen",
-  "ui.menu.trees": "Anderer Stammbaum",
-  "ui.menu.newtree": "Stammbaum anlegen",
+  "ui.menu.trees": "Anderer Stammbaum · einen schicken oder empfangen",
+  "ui.menu.newtree": "Stammbaum anlegen · einen schicken oder empfangen",
   "ui.menu.quit": "Beenden",
   "ui.menu.bye": "Auf Wiedersehen. Nächstes Mal genügt: strom",
   "ui.run.how": "Wie viele Aufgaben? (er hört früher auf, wenn es nichts mehr zu tun gibt; 0 geht zurück)",
@@ -488,10 +488,13 @@
   "ui.sync.child.new": "{n}. {who}: ein Kind — {child}",
   "ui.sync.child.gone": "{n}. {who}: nicht mehr ihr Kind — {child}",
   "ui.sync.person.gone": "{n}. nicht mehr darin: {name}",
+  "ui.sync.place.coords": "{n}. {place}: Lage auf der Karte {from} → {at}",
+  "ui.sync.place.located": "{n}. {place}: Lage auf der Karte {at}",
   "ui.sync.do.add": "als Hinweis übernommen",
   "ui.sync.do.correct": "berichtigt den Hinweis der Forschung",
   "ui.sync.do.conflict": "ein Widerspruch zum Entscheiden (die Forschung hat es aus einem Eintrag)",
   "ui.sync.do.user": "Ihre Änderung gilt (die Angabe aus dem Eintrag wird mit Grund zurückgezogen)",
+  "ui.sync.do.set": "die Forschung übernimmt Ihre Lage (kein Eintrag belegt sie)",
   "ui.sync.do.pick": "nur wenn Sie sie auswählen (--only)",
   "ui.sync.do.report": "nichts ändert sich — sagen Sie dem Agenten, was Sie meinten",
   "ui.sync.edits": "Ihre Änderungen an Angaben, die ein Eintrag belegt: {mode} (strom config set sync.edits conflict|user)",
@@ -805,5 +808,36 @@
   "ui.menu.failed": "Das ging nicht: {reason}",
   "ui.review.next.human": "Der Agent nimmt sie im Gespräch oder bei der Arbeit allein auf.",
   "ui.review.wake.human": "    wenn es weitergehen soll, sagen Sie es dem Agenten im Gespräch",
-  "ui.waiting.gone": "Das wartet nicht mehr auf Sie – der Agent hat es inzwischen übernommen."
+  "ui.waiting.gone": "Das wartet nicht mehr auf Sie – der Agent hat es inzwischen übernommen.",
+  "ui.trees.pack": "„{name}“ einpacken und jemandem schicken (eine ZIP-Datei)",
+  "ui.trees.unpack": "ein Stammbaum, den Ihnen jemand geschickt hat (eine ZIP-Datei)",
+  "ui.pack.which": "Welche Bilder kommen mit?",
+  "ui.pack.opt.records": "die, auf denen die Einträge stehen – {mb} MB (die durchgesehenen Seiten gibt das Archiv wieder)",
+  "ui.pack.opt.all": "alle – {mb} MB",
+  "ui.pack.done": "„{name}“ eingepackt: {file} ({mb} MB)",
+  "ui.pack.saved": "  der Stammbaum, wie er zuletzt gespeichert wurde, mit seiner Geschichte",
+  "ui.pack.images": "  Bilder: {n} ({mb} MB) – die, auf denen die Einträge stehen, und die, die niemand wieder laden kann",
+  "ui.pack.images.all": "  Bilder: alle {n} ({mb} MB)",
+  "ui.pack.left": "  weggelassen: {n} Bilder ({mb} MB) – durchgesehene Seiten; strom lädt sie aus dem Archiv wieder, wenn sie gebraucht werden",
+  "ui.pack.connectors": "  Konnektoren: {list}",
+  "ui.pack.noconnector": "⚠ einige weggelassene Bilder kamen über einen Konnektor, der auf diesem Computer fehlt – niemand könnte sie wieder laden: strom pack --all-images",
+  "ui.pack.missing": "⚠ {n} Bild(er), die der Stammbaum nennt, sind nicht auf diesem Computer – nicht im Paket",
+  "ui.pack.send": "Schicken Sie die Datei. Wer sie bekommt, packt sie aus und startet darin Windows.cmd oder macOS.command per Doppelklick: strom wird installiert, wo es fehlt, und die Forschung öffnet sich (mit strom schon: strom unpack „<die Datei>“).",
+  "ui.pack.readme.file": "SO-GEHT-ES-WEITER.txt",
+  "ui.pack.readme": "Die Forschung „{name}“ – so geht es weiter\n=========================================\n\n1. Packen Sie die ganze ZIP-Datei aus: unter Windows Rechtsklick – Alle extrahieren; auf dem Mac Doppelklick.\n\n2. Starten Sie im ausgepackten Ordner mit Doppelklick:\n     Windows:  Windows.cmd\n     macOS:    macOS.command  (beim ersten Mal Rechtsklick – Öffnen; wenn macOS es ablehnt:\n               Systemeinstellungen – Datenschutz & Sicherheit – Dennoch öffnen)\n     Linux:    im Terminal: bash Linux.sh\n   Es installiert Strom Research, wo es noch fehlt (der offizielle Installer), bringt die\n   Forschung an ihren Platz – den Stammbaum zu Ihren, die Bilder in Ihren gemeinsamen\n   Ordner, alles geprüft –, übernimmt sie auf Ihren Computer und öffnet strom.\n\n3. Weiter: im Menü von strom das Gespräch mit dem Agenten.\n\nOhne die Starter: installieren Sie strom selbst\n   Windows (PowerShell):      {win}\n   macOS, Linux (Terminal):   {unix}\ndann: strom unpack \"<diese ZIP-Datei>\" (strom unpack und ein Leerzeichen tippen, die Datei\nins Terminal ziehen, Enter) – oder im Menü von strom: ein anderer Stammbaum – ein Stammbaum, den Ihnen jemand geschickt hat.\n\nDie Bilder, auf denen die Einträge stehen, sind im Paket. Die anderen Seiten der Bücher\n(durchgesehen, nichts gefunden) wegen der Größe nicht – strom lädt sie aus dem Archiv\nwieder, wenn sie gebraucht werden.\n",
+  "ui.unpack.file": "Ziehen Sie die ZIP-Datei hierher (oder tippen Sie, wo sie liegt; 0 geht zurück):",
+  "ui.unpack.what": "„{name}“ (aus strom {strom}, gespeichert {date}): {images} Bild(er){connectors} → {root}",
+  "ui.unpack.ask": "Hierher legen und auf diesem Computer übernehmen?",
+  "ui.unpack.done": "„{name}“ ist da: {root}",
+  "ui.unpack.images": "  {n} Bild(er) in den gemeinsamen Ordner{had}",
+  "ui.unpack.had": " ({n} waren schon da)",
+  "ui.unpack.connectors": "  Konnektoren: {list}",
+  "ui.unpack.kept": "  Konnektor {name} war schon da – Ihrer bleibt",
+  "ui.unpack.left": "  {n} durchgesehene Seiten sind nicht darin: strom lädt sie aus dem Archiv, wenn sie gebraucht werden",
+  "ui.unpack.adopted": "  auf diesem Computer übernommen",
+  "ui.unpack.next": "Weiter: strom (das Menü) oder strom chat.",
+  "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."
 }

package/dist/cli/menu.js

@@ -25,7 +25,9 @@ import { liveWorkers, runsAtWork } from "../core/workers.js";
 import { askStromApp } from "./wizard.js";
 import { openForUser } from "../core/open.js";
 import { displayName } from "../core/people.js";
-import { agentReady, guarded, pause as partsPause, pickPerson, subMenu } from "./menu-parts.js";
+import { agentReady, droppedPaths, guarded, pause as partsPause, pickPerson, subMenu } from "./menu-parts.js";
+import { packPlan } from "../core/pack.js";
+import { expandHome } from "../core/paths.js";
 import { offerAgent } from "./fixes.js";
 import { addToResearch } from "./menu-research.js";
 import { waitingForYou } from "./menu-waiting.js";
@@ -423,6 +425,9 @@ async function pickTree(ctx, run, lang) {
     }
     const at = known.findIndex((k) => k.root === here);
     const options = [...known.map((k) => ({ label: `${k.name}  (${ctx.display(k.root)})` })), { label: ui(lang, "ui.trees.new") }];
+    // handing a research over: this one packed, one someone sent unpacked
+    const packAt = at >= 0 ? options.push({ label: ui(lang, "ui.trees.pack", { name: known[at].name }) }) - 1 : -1;
+    const unpackAt = options.push({ label: ui(lang, "ui.trees.unpack") }) - 1;
     const back = at >= 0 ? { back: ui(lang, "ui.back.stay", { name: known[at].name }) } : {};
     const i = await ctx.choose(ui(lang, "ui.trees.pick"), options, Math.max(0, at), back);
     if (i === undefined || i === at)
@@ -431,6 +436,28 @@ async function pickTree(ctx, run, lang) {
         await run(["trees", "use", known[i].root], true);
         return;
     }
+    if (i === packAt) {
+        const tree = Tree.open(known[at].root, ctx.env);
+        const shared = ctx.settings.shared().value;
+        const size = (all) => (packPlan(tree, shared, all).media.reduce((s, m) => s + m.size, 0) / 1e6).toFixed(0);
+        const which = await ctx.choose(ui(lang, "ui.pack.which"), [{ label: ui(lang, "ui.pack.opt.records", { mb: size(false) }) }, { label: ui(lang, "ui.pack.opt.all", { mb: size(true) }) }], 0, { back: ui(lang, "ui.browse.back") });
+        if (which === undefined)
+            return;
+        await run(["pack", "--tree", tree.root, ...(which === 1 ? ["--all-images"] : [])]);
+        await partsPause(ctx, lang);
+        return;
+    }
+    if (i === unpackAt) {
+        const answer = (await ctx.ask(ui(lang, "ui.unpack.file"))).trim();
+        if (!answer || answer === "0")
+            return;
+        const resolve = (p) => path.resolve(ctx.cwd, expandHome(p, ctx.env));
+        const dropped = droppedPaths(answer).map(resolve);
+        const file = dropped.length === 1 && fs.existsSync(dropped[0]) ? dropped[0] : resolve(answer);
+        await run(["unpack", file]);
+        await partsPause(ctx, lang);
+        return;
+    }
     const name = (await ctx.ask(ui(lang, "ui.tree.name.new"), ui(lang, "ui.tree.default"))).trim();
     if (name === "0")
         return;

package/dist/cli/ui.js

@@ -41,8 +41,8 @@ export const UI = {
     "ui.menu.waitlist": "What waits for you",
     "ui.menu.settings": "Settings: the agent, working alone, messages, archives, the check",
     "ui.menu.doctor": "Check the installation",
-    "ui.menu.trees": "Another family tree",
-    "ui.menu.newtree": "Create a family tree",
+    "ui.menu.trees": "Another family tree · send or receive one",
+    "ui.menu.newtree": "Create a family tree · send or receive one",
     "ui.menu.quit": "Quit",
     "ui.menu.bye": "See you next time. Start again with: strom",
     "ui.run.how": "How many tasks? (it stops earlier when there is nothing to do; 0 goes back)",
@@ -420,10 +420,13 @@ export const UI = {
     "ui.sync.child.new": "{n}. {who}: a child — {child}",
     "ui.sync.child.gone": "{n}. {who}: no longer their child — {child}",
     "ui.sync.person.gone": "{n}. no longer in it: {name}",
+    "ui.sync.place.coords": "{n}. {place}: on the map {from} → {at}",
+    "ui.sync.place.located": "{n}. {place}: on the map at {at}",
     "ui.sync.do.add": "added as a lead",
     "ui.sync.do.correct": "corrects the research's lead",
     "ui.sync.do.conflict": "a conflict for you to decide (the research has it from a record)",
     "ui.sync.do.user": "your edit wins (the record's fact withdrawn with the reason)",
+    "ui.sync.do.set": "the research takes your position (no record proves one)",
     "ui.sync.do.pick": "only when you pick it (--only)",
     "ui.sync.do.report": "nothing changes — tell the agent what you meant",
     "ui.sync.edits": "Your edits to facts a record proves: {mode} (strom config set sync.edits conflict|user)",
@@ -737,6 +740,37 @@ export const UI = {
     "ui.review.next.human": "The agent takes them up in a conversation or when it works alone.",
     "ui.review.wake.human": "    to go on with it, tell the agent in a conversation",
     "ui.waiting.gone": "This one no longer waits for you — the agent has taken it up meanwhile.",
+    "ui.trees.pack": "pack \"{name}\" to send to someone (a ZIP file)",
+    "ui.trees.unpack": "a family tree someone sent you (a ZIP file)",
+    "ui.pack.which": "Which images go along?",
+    "ui.pack.opt.records": "the ones its records stand on — {mb} MB (the pages searched through the archive gives again)",
+    "ui.pack.opt.all": "all of them — {mb} MB",
+    "ui.pack.done": "Packed \"{name}\": {file} ({mb} MB)",
+    "ui.pack.saved": "  the family tree as last saved, with its history",
+    "ui.pack.images": "  images: {n} ({mb} MB) — the ones its records stand on and the ones nobody can fetch again",
+    "ui.pack.images.all": "  images: all {n} ({mb} MB)",
+    "ui.pack.left": "  left out: {n} images ({mb} MB) — pages searched through; strom fetches them from the archive again when they are needed",
+    "ui.pack.connectors": "  connectors: {list}",
+    "ui.pack.noconnector": "⚠ some images left out came through a connector that is not on this computer — nobody could fetch them again: strom pack --all-images",
+    "ui.pack.missing": "⚠ {n} image(s) the family tree names are not on this computer — not in the package",
+    "ui.pack.send": "Send the file. The one who gets it unpacks it and double-clicks Windows.cmd or macOS.command inside: strom is installed where it is missing and the research opens (with strom already: strom unpack \"<the file>\").",
+    "ui.pack.readme.file": "HOW-TO-CONTINUE.txt",
+    "ui.pack.readme": "The research \"{name}\" - how to go on with it\n=============================================\n\n1. Unpack the whole ZIP file: on Windows right click it - Extract All; on a Mac double click it.\n\n2. In the unpacked folder start, by a double click:\n     Windows:  Windows.cmd\n     macOS:    macOS.command  (the first time: right click - Open; when macOS refuses:\n               System Settings - Privacy & Security - Open Anyway)\n     Linux:    in a terminal: bash Linux.sh\n   It installs Strom Research where it is not yet (the official installer), puts the\n   research in place - the family tree among yours, the images into your shared folder,\n   all of it checked - takes it over on your computer and opens strom.\n\n3. Go on: in strom's menu, the conversation with the agent.\n\nWithout the launchers: install strom yourself\n   Windows (PowerShell):      {win}\n   macOS, Linux (Terminal):   {unix}\nthen: strom unpack \"<this ZIP file>\" (type strom unpack and a space, drag the file into\nthe terminal, press Enter) - or in strom's menu: another family tree - a family tree someone sent you.\n\nThe images the records stand on are in the package. The other pages of the books\n(searched through, nothing found on them) are not, for size - strom fetches them from\nthe archive again when they are needed.\n",
+    "ui.unpack.file": "Drag the ZIP file here (or type where it is; 0 goes back):",
+    "ui.unpack.what": "\"{name}\" (sent from strom {strom}, saved {date}): {images} image(s){connectors} → {root}",
+    "ui.unpack.ask": "Put it here and take it over on this computer?",
+    "ui.unpack.done": "\"{name}\" is here: {root}",
+    "ui.unpack.images": "  {n} image(s) into the shared folder{had}",
+    "ui.unpack.had": " ({n} were here already)",
+    "ui.unpack.connectors": "  connectors: {list}",
+    "ui.unpack.kept": "  connector {name} was here already — yours stays",
+    "ui.unpack.left": "  {n} pages searched through are not in it: strom fetches them from the archive when they are needed",
+    "ui.unpack.adopted": "  taken over on this computer",
+    "ui.unpack.next": "Go on: strom (the menu) or strom chat.",
+    "ui.unpack.same": "this research is here already: {root}",
+    "ui.unpack.person": "only the person at the computer unpacks a research (it adds connectors)",
+    "ui.pack.launch.extract": "First unpack the whole ZIP file - on Windows: right click, Extract All - then start this again from the unpacked folder.",
+    "ui.pack.launch.failed": "Strom Research could not be installed. Install it by the line in HOW-TO-CONTINUE.txt and run this again.",
 };
 /** A text for the person, in their language. */
 export function ui(lang, key, values = {}) {

package/dist/commands/connectors.js

@@ -1094,14 +1094,16 @@ async function fetchWith(ctx, c, request, recordset) {
         });
     if (recordset && request.cmd === "fetch") {
         // what is registered already is not asked for again (a part of an image is not the image)
-        const have = new Set(tree.list("media").filter((m) => m.recordset === recordset && !m.part && m.image !== undefined).map((m) => m.image));
+        // …unless its file is not here (a research handed over without its images): fetched again, put back
+        const here = (m) => fs.existsSync(path.join(shared(ctx), m.file));
+        const have = new Set(tree.list("media").filter((m) => m.recordset === recordset && !m.part && m.image !== undefined && here(m)).map((m) => m.image));
         const asked = request.images;
         request.images = asked.filter((n) => !have.has(n));
         if (!request.images.length)
             return { text: `images ${runs(asked)} of ${recordset} are registered already — nothing fetched`, data: { added: [], again: asked } };
     }
     if (recordset && request.cmd === "part") {
-        const had = tree.list("media").find((m) => m.recordset === recordset && m.image === request.image && m.part && sameRegion(m.part, request.region));
+        const had = tree.list("media").find((m) => m.recordset === recordset && m.image === request.image && m.part && sameRegion(m.part, request.region) && fs.existsSync(path.join(shared(ctx), m.file)));
         if (had)
             return { text: `part ${regionText(request.region)} of image ${request.image} of ${recordset} is registered already: ${had.id} — nothing fetched`, data: { added: [], again: [had.id] } };
     }
@@ -1158,16 +1160,18 @@ async function fetchWith(ctx, c, request, recordset) {
             ? lines(`part ${regionText(m.part)} of image ${request.image} of ${recordset} fetched and registered: ${m.id}${m.width ? ` · ${m.width}×${m.height} px` : ""}${gain ? ` · ${gain.toFixed(1)}× the detail of the whole image` : ""} · ${took}`, gain !== undefined && gain < 1.2 ? "  no sharper than the whole image: the portal gives no more detail than that" : undefined, `look at it: strom media view ${recordset}:${request.image} --crop ${regionText(m.part)} (a view of the image uses the part by itself)`)
             : res.again.length && whole && res.again.includes(whole.id) && r.images.every((i) => isWhole(i.region))
                 ? lines(`the portal's sharpest of image ${request.image} is the whole scan, registered already: ${whole.id}${whole.width ? ` · ${whole.width}×${whole.height} px` : ""} — no part needed`, `look at it: strom media view ${recordset}:${request.image} --crop ${regionText(request.region)}`)
-                : res.again.length
-                    ? lines(`that part is registered already: ${res.again.join(" ")}`, ...res.clashes.map((x) => `⚠ ${x}`))
-                    : "no part fetched";
+                : res.restored.length
+                    ? `part ${regionText(request.region)} of image ${request.image} of ${recordset} fetched again and put back (its file was not here; the same scan): ${res.restored.join(" ")} · ${took}`
+                    : res.again.length
+                        ? lines(`that part is registered already: ${res.again.join(" ")}`, ...res.clashes.map((x) => `⚠ ${x}`))
+                        : "no part fetched";
         data = { ...data, added: res.added.map((x) => ({ id: x.id, image: x.image, part: x.part })), again: res.again };
     }
     else if (recordset && r.images.length) {
         const res = registerImages(tree, shared(ctx), r.images.map((i) => ({ file: i.file, image: i.n, url: i.url, from: from(i.file), fetched })), recordset);
         const nums = res.added.map((m) => m.image).filter((n) => n !== undefined);
-        text = lines(`${res.added.length} image(s) of ${recordset}${nums.length ? ` (images ${Math.min(...nums)}–${Math.max(...nums)})` : ""} fetched and registered · ${took}`, res.again.length ? `${res.again.length} already registered` : undefined, ...res.clashes.slice(0, 10).map((x) => `⚠ ${x}`), res.woken.length ? `back in the queue (they waited for these images): ${res.woken.join(" ")}` : undefined);
-        data = { ...data, added: res.added.map((m) => ({ id: m.id, image: m.image })), again: res.again, woken: res.woken, clashes: res.clashes };
+        text = lines(res.added.length || !res.restored.length ? `${res.added.length} image(s) of ${recordset}${nums.length ? ` (images ${Math.min(...nums)}–${Math.max(...nums)})` : ""} fetched and registered · ${took}` : undefined, res.restored.length ? `${res.restored.length} image(s) of ${recordset} fetched again and put back (their file was not here; the same scan): ${res.restored.slice(0, 5).join(" ")}${res.restored.length > 5 ? " …" : ""} · ${took}` : undefined, res.again.length ? `${res.again.length} already registered` : undefined, ...res.clashes.slice(0, 10).map((x) => `⚠ ${x}`), res.woken.length ? `back in the queue (they waited for these images): ${res.woken.join(" ")}` : undefined);
+        data = { ...data, added: res.added.map((m) => ({ id: m.id, image: m.image })), again: res.again, restored: res.restored, woken: res.woken, clashes: res.clashes };
         fs.rmSync(workDir, { recursive: true, force: true });
     }
     else if (r.images.length) {
@@ -1307,7 +1311,7 @@ async function takeOver(ctx, c, result) {
         if (plan.recordset) {
             const res = registerImages(tree, shared(ctx), mine.map((t) => ({ file: t.file, image: t.item.n, url: t.item.url, from: `connector ${c.name} · your browser · ${path.basename(t.file)}`, part: t.item.region, fetched })), plan.recordset);
             added.push(...res.added.map((m) => ({ id: m.id, ...(m.image !== undefined ? { image: m.image } : {}) })));
-            again.push(...res.again);
+            again.push(...res.again, ...res.restored);
             notes.push(...res.clashes);
             woken.push(...res.woken);
             for (const t of mine)

package/dist/commands/index.js

@@ -5,6 +5,7 @@ import "./trees.js";
 import "./research.js";
 import "./intake.js";
 import "./sync.js";
+import "./pack.js";
 import "./tasks.js";
 import "./people.js";
 import "./batch.js";

package/dist/commands/media.js

@@ -26,12 +26,20 @@ export function registerImages(tree, shared, items, recordset) {
     const known = new Map(tree.list("media").filter((m) => !m.retracted).map((m) => [m.sha, m]));
     const added = [];
     const again = [];
+    const restored = [];
     const clashes = [];
     const copies = [];
     tree.withTreeLock(() => {
         for (const it of items) {
             const sha = fileSha256(it.file);
             const k = known.get(sha);
+            if (k && !tree.dryRun && !fs.existsSync(path.join(shared, k.file))) {
+                // its file is not here (a research handed over without its images): the same scan, put back where it was
+                fs.mkdirSync(path.dirname(path.join(shared, k.file)), { recursive: true });
+                fs.copyFileSync(it.file, path.join(shared, k.file));
+                restored.push(k.id);
+                continue;
+            }
             if (k) {
                 again.push(k.id);
                 // the same scan as another image: a portal serving another book's images, or a file given the wrong number
@@ -85,7 +93,7 @@ export function registerImages(tree, shared, items, recordset) {
             });
             woken.push(t.id);
         }
-    return { added, again, woken, clashes, copies };
+    return { added, again, restored, woken, clashes, copies };
 }
 function sharedDir(ctx) {
     return ctx.settings.shared().value;
@@ -264,7 +272,7 @@ register({
                     hint: "rename the files by the image number the viewer shows (9.jpg), or --image <n> for one file",
                 });
         }
-        const { added, again, woken, clashes, copies } = registerImages(tree, shared, items, recordset);
+        const { added, again, restored, woken, clashes, copies } = registerImages(tree, shared, items, recordset);
         if (opts.inbox && !tree.dryRun) {
             for (const f of files)
                 fs.rmSync(f, { force: true }); // now in the store
@@ -275,7 +283,7 @@ register({
         const nums = added.map((m) => m.image).filter((n) => n !== undefined);
         const text = lines(added.length
             ? `${added.length} image(s) registered: ${added[0].id}${added.length > 1 ? `–${added.at(-1).id}` : ""}${recordset ? ` of ${recordset}` : ""}${nums.length ? ` (images ${runs(nums)})` : ""}`
-            : "no new images", again.length ? `${again.length} already registered (same content): ${again.slice(0, 5).join(" ")}${again.length > 5 ? " …" : ""}` : undefined, ...clashes.slice(0, 10).map((c) => `⚠ ${c}`), ...copies.slice(0, 10), copies.length > 10 ? `… and ${copies.length - 10} more images with a sharper copy` : undefined, woken.length ? `back in the queue (they waited for these images): ${woken.join(" ")}` : undefined, tree.dryRun ? "(dry run — nothing written)" : undefined, added[0] ? `\nlook at one: strom media view ${recordset && added[0].image !== undefined ? `${recordset}:${added[0].image}` : added[0].id} --grid` : undefined);
+            : restored.length ? undefined : "no new images", restored.length ? `${restored.length} image(s) put back (their file was not here; the same scan): ${restored.slice(0, 5).join(" ")}${restored.length > 5 ? " …" : ""}` : undefined, again.length ? `${again.length} already registered (same content): ${again.slice(0, 5).join(" ")}${again.length > 5 ? " …" : ""}` : undefined, ...clashes.slice(0, 10).map((c) => `⚠ ${c}`), ...copies.slice(0, 10), copies.length > 10 ? `… and ${copies.length - 10} more images with a sharper copy` : undefined, woken.length ? `back in the queue (they waited for these images): ${woken.join(" ")}` : undefined, tree.dryRun ? "(dry run — nothing written)" : undefined, added[0] ? `\nlook at one: strom media view ${recordset && added[0].image !== undefined ? `${recordset}:${added[0].image}` : added[0].id} --grid` : undefined);
         return { text, data: { added: added.map((m) => ({ id: m.id, image: m.image })), again, woken, clashes, copies } };
     },
 }, {

package/dist/commands/pack.js

@@ -0,0 +1,131 @@
+// pack · unpack — a research handed to someone else as one ZIP file.
+import fs from "node:fs";
+import path from "node:path";
+import { register } from "../cli/registry.js";
+import { lines } from "../cli/format.js";
+import { ui } from "../cli/ui.js";
+import { NeedsConsentError, UsageError } from "../core/errors.js";
+import { findPack, freeRoot, INSTALL_UNIX, INSTALL_WINDOWS, packPlan, unpack, writePack } from "../core/pack.js";
+import { desktopDir, userHome } from "../core/paths.js";
+import { safeFolderName } from "../core/text.js";
+import { Tree } from "../core/tree.js";
+import { syncAgentFiles } from "../agents/files.js";
+import { setupWizard } from "../cli/wizard.js";
+import { isAgent } from "../core/which.js";
+import { ensureShared } from "./setup.js";
+const mb = (bytes) => (bytes / 1e6 < 10 ? (bytes / 1e6).toFixed(1) : Math.round(bytes / 1e6).toString());
+register({
+    path: ["pack"],
+    summary: "Pack the research into one ZIP file for someone to go on with it (the tree, the images its records stand on, the connectors)",
+    group: "research",
+    tree: true,
+    description: "The family tree as it was last saved, with its history; the images its records stand on, the images nobody can\n" +
+        "fetch again (saved by hand, the family's material) and the connectors that fetched the others. The pages only\n" +
+        "searched through are left out — the archive gives the same scan again (strom fetch puts it back, checked);\n" +
+        "--all-images takes them too. Logins, settings and seal keys never go along. The one who gets it: strom unpack.",
+    options: [
+        { name: "out", type: "string", value: "<file.zip>", description: "where to write it (default: the desktop, named after the tree and the day)" },
+        { name: "all-images", type: "boolean", description: "every image, the pages searched through too" },
+    ],
+    examples: ["strom pack", "strom pack --all-images", 'strom pack --out "~/Novákovi.zip"'],
+    run(ctx, { opts }) {
+        const tree = ctx.tree();
+        const shared = ctx.settings.shared().value;
+        const lang = ctx.uiLang();
+        const all = Boolean(opts["all-images"]);
+        const day = new Date().toISOString().slice(0, 10);
+        const base = `${safeFolderName(tree.config.name) || "tree"} ${day}`;
+        let out;
+        if (opts.out)
+            out = ctx.resolvePath(String(opts.out));
+        else {
+            const desk = desktopDir(ctx.env);
+            const dir = fs.existsSync(desk) ? desk : userHome(ctx.env);
+            out = path.join(dir, `${base}.zip`);
+            for (let n = 2; fs.existsSync(out); n++)
+                out = path.join(dir, `${base} (${n}).zip`);
+        }
+        if (!out.toLowerCase().endsWith(".zip"))
+            out += ".zip";
+        if (fs.existsSync(out))
+            throw new UsageError(`${ctx.display(out)} is there already`, { hint: "another --out, or without it" });
+        if (ctx.dryRun) {
+            const plan = packPlan(tree, shared, all);
+            const bytes = plan.media.reduce((s, m) => s + m.size, 0);
+            return { text: `dry run: would pack "${tree.config.name}" with ${plan.media.length} image(s) (${mb(bytes)} MB) into ${ctx.display(out)} — nothing written`, data: { out, plan } };
+        }
+        const readme = {
+            name: ui(tree.config.lang, "ui.pack.readme.file"),
+            text: ui(tree.config.lang, "ui.pack.readme", { name: tree.config.name, win: INSTALL_WINDOWS, unix: INSTALL_UNIX }),
+        };
+        const say = { extract: ui(tree.config.lang, "ui.pack.launch.extract"), failed: ui(tree.config.lang, "ui.pack.launch.failed") };
+        const r = writePack(tree, shared, out, { all, readme, say });
+        const took = r.plan.media.reduce((s, m) => s + m.size, 0);
+        const text = lines(ui(lang, "ui.pack.done", { name: tree.config.name, file: ctx.display(r.file), mb: mb(r.bytes) }), ui(lang, "ui.pack.saved"), ui(lang, all ? "ui.pack.images.all" : "ui.pack.images", { n: r.plan.media.length, mb: mb(took) }), r.plan.left.count ? ui(lang, "ui.pack.left", { n: r.plan.left.count, mb: mb(r.plan.left.bytes) }) : undefined, r.plan.connectors.length ? ui(lang, "ui.pack.connectors", { list: r.plan.connectors.join(", ") }) : undefined, r.plan.left.count && r.plan.left.connectors ? ui(lang, "ui.pack.noconnector") : undefined, r.plan.missing.length ? ui(lang, "ui.pack.missing", { n: r.plan.missing.length }) : undefined, "", ui(lang, "ui.pack.send"));
+        return { text, data: { file: r.file, bytes: r.bytes, manifest: r.manifest, missing: r.plan.missing } };
+    },
+});
+register({
+    path: ["unpack"],
+    summary: "Put a research someone packed for you in place and take it over on this computer (the person runs this)",
+    group: "research",
+    description: "The ZIP file of strom pack, or the folder it was unpacked into. The tree goes among the trees (a free name), its\n" +
+        "images into the shared folder (each checked against its SHA-256), its connectors into the plugins where there is\n" +
+        "none of that name (yours stays); the tree is checked whole and taken over on this computer. It adds connectors:\n" +
+        "only the person at the computer runs it — never an agent.",
+    args: [{ name: "file", description: "the ZIP file (or the folder it was unpacked into)", required: true }],
+    examples: ['strom unpack "~/Downloads/Novákovi 2026-09-29.zip"'],
+    async run(ctx, { args }) {
+        const lang = ctx.uiLang();
+        const src = ctx.resolvePath(args[0]);
+        if (!ctx.interactive)
+            throw new NeedsConsentError([{ key: "unpack", kind: "consent", question: ui(lang, "ui.unpack.person"), set: `strom unpack "${src}"` }]);
+        // someone new to strom (a launcher of the package installed it just now): the setup wizard first
+        if (!ctx.settings.home() && !isAgent(ctx.env)) {
+            await setupWizard(ctx);
+            ctx.settings.reload();
+        }
+        await ctx.requireHome();
+        const treesDir = ctx.settings.trees().value;
+        const shared = ctx.settings.shared().value;
+        const pack = findPack(src);
+        try {
+            const m = pack.manifest;
+            const same = ctx.knownTrees().find((t) => {
+                try {
+                    return JSON.parse(fs.readFileSync(path.join(t.root, "strom.json"), "utf8")).id === m.tree.id;
+                }
+                catch {
+                    return false;
+                }
+            });
+            if (same)
+                throw new UsageError(ui(lang, "ui.unpack.same", { root: ctx.display(same.root) }), { hint: `strom trees use "${same.root}"` });
+            const target = freeRoot(treesDir, m.tree.name);
+            ctx.io.stdout(ui(lang, "ui.unpack.what", {
+                name: m.tree.name,
+                strom: m.strom,
+                date: m.created.slice(0, 10),
+                images: m.media.length,
+                connectors: m.connectors.length ? ` · ${m.connectors.join(", ")}` : "",
+                root: ctx.display(target),
+            }) + "\n");
+            if (!(await ctx.confirm(ui(lang, "ui.unpack.ask"), true)))
+                return { text: "", data: { unpacked: false } };
+            ensureShared(shared);
+            const r = unpack(pack, treesDir, shared, ctx.env);
+            // the tree's own instructions and permissions, for this computer's folders
+            const tree = Tree.open(r.root, ctx.env);
+            const files = syncAgentFiles(tree);
+            tree.withTreeLock(() => tree.commit(`Agent instructions: ${files.join(", ")}`, files));
+            ctx.settings.config.currentTree = r.root;
+            ctx.settings.save();
+            const text = lines(ui(lang, "ui.unpack.done", { name: r.name, root: ctx.display(r.root) }), r.images || r.imagesHad ? ui(lang, "ui.unpack.images", { n: r.images, had: r.imagesHad ? ui(lang, "ui.unpack.had", { n: r.imagesHad }) : "" }) : undefined, r.connectors.length ? ui(lang, "ui.unpack.connectors", { list: r.connectors.join(", ") }) : undefined, ...r.connectorsKept.map((c) => ui(lang, "ui.unpack.kept", { name: c })), m.left.count ? ui(lang, "ui.unpack.left", { n: m.left.count }) : undefined, r.adopted ? ui(lang, "ui.unpack.adopted") : undefined, "", ui(lang, "ui.unpack.next"));
+            return { text, data: { unpacked: true, ...r } };
+        }
+        finally {
+            if (pack.tmp)
+                fs.rmSync(pack.tmp, { recursive: true, force: true });
+        }
+    },
+});

package/dist/commands/session.js

@@ -613,6 +613,8 @@ register({
                 // Close what the agent left open, record the metrics, export, commit.
                 const after = Tree.open(root, runEnv);
                 let s = after.get(session.id);
+                // strom worked for the agent when it closed the session itself or recorded something
+                const ranStrom = s.state !== "open" || sessionWrites(after, s.id) > 0;
                 if (s.state === "open")
                     s = closeSession(after, s, {
                         summary: result.outcome === "stopped" ? phrase(after.lang, "session.user") : phrase(after.lang, "session.agent", { outcome: result.outcome }),
@@ -656,7 +658,9 @@ register({
                     break;
                 }
                 // An agent that may not run strom can do nothing: stop, do not burn session after session.
-                if (result.denied?.some((d) => /^Bash: (\S*\/)?strom\b/.test(d))) {
+                // A refused command that only starts with strom (strom … && sed …, a loop) is no such thing
+                // when strom worked for it otherwise.
+                if (!ranStrom && result.denied?.some((d) => /^Bash: (\S*\/)?strom\b/.test(d))) {
                     stopCode = "denied";
                     break;
                 }

package/dist/commands/sync.js

@@ -21,6 +21,8 @@ function factText(f, lang) {
         return "—";
     return [f.value, humanDate(f.date, lang), humanPlace(f.place, undefined, lang)].filter(Boolean).join(", ") || "—";
 }
+/** A position on the map as a map shows it: degrees, six decimals at most. */
+const point = (p) => `${+p.lat.toFixed(6)}, ${+p.lon.toFixed(6)}`;
 /** One change as the user reads it, with what strom does with it. */
 function changeLine(tree, c, incoming, lang) {
     const name = (key) => {
@@ -44,8 +46,12 @@ function changeLine(tree, c, incoming, lang) {
         text: truncate(c.text ?? "", 120),
         child: name(c.child),
         kids: c.kind === "family.new" && c.text ? ` + ${c.text.split(" ").filter(Boolean).map(name).join(", ")}` : "",
+        place: c.place?.name ?? "",
+        at: c.place ? point(c.place) : "",
+        from: c.place?.was ? point(c.place.was) : "",
     };
-    return `${ui(lang, `ui.sync.${c.kind}`, v)} → ${ui(lang, `ui.sync.do.${c.action}`)}`;
+    const key = c.kind === "place.coords" && !c.place?.was ? "ui.sync.place.located" : `ui.sync.${c.kind}`;
+    return `${ui(lang, key, v)} → ${ui(lang, `ui.sync.do.${c.action}`)}`;
 }
 function planText(tree, plan, incoming, file, lang, edits) {
     const shown = file.includes(" ") ? `"${file}"` : file;