strom-research 1.18.0-beta.7 → 1.18.0-beta.8

package/CHANGELOG.cs.md

@@ -7,7 +7,7 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
 
 ## 1.18.0
 
-*Připravuje se: bety do 1.18.0-beta.7. Oddíl bude úplný s vydáním.*
+*Připravuje se: bety do 1.18.0-beta.8. Oddíl bude úplný s vydáním.*
 
 - **Fotky z telefonu nastojato.** Fotka otočená podle údaje EXIF se čte tak, jak se má dívat, nastojato; místa na ní
   vyznačená (výřezy, poloviny dvoustrany, uložená část) jsou místa obrázku, jak se ukazuje. Fotka sama zůstává, jak
@@ -22,6 +22,8 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
   vypadne — i příjmení, nikdy se nebere od otce ani z jiné rodiny —, co nejde přečíst, je označené; druhý čtenář
   může číst naslepo. Do stromu se z toho nic nezapíše samo. Dokument už přečtený to o sobě řekne, takže se omylem
   nečte podruhé. Dokument čtený znovu se ukazuje pod názvem svého souboru, nikdy pod kódem.
+  Dokument poslaný z aplikace Strom najde agenta stejně jako terminál — i nainstalovaného do vlastní složky, přes npm
+  nebo Homebrew — místo hlášení, že agent není nastavený.
 - **Fotky z telefonu.** `strom phone on`, které zapíná jen člověk, pustí k počítači telefon v domácí síti (Wi-Fi
   nebo kabel — nikdy mobilní síť ani VPN). Telefon se jednou spáruje přes QR kód; jeho stránka pak fotí nebo vybírá
   z galerie a posílá fotky celé do stromu výzkumu, s poznámkou a osobou, kterou ukazují — stejně jako „Přidat
@@ -32,7 +34,10 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
   údaji a jejich časem. Otevře strom, jehož QR kód ji spároval, a jde přidat na plochu jako ikona, která ji otevře
   bez nového párování. Co čeká a změny jdou na telefonu přečíst celé: text toho, co čeká, se neořezává, další položky
   nad prvních 20 se donačtou klepnutím a změna s víc řádky se rozbalí celá; Co čeká je poslední částí stránky. Změna
-  starší než dnešek má u času i datum (rok jen u loňských a starších).
+  starší než dnešek má u času i datum (rok jen u loňských a starších). Nálezy pod Teď ukazují, co výzkum našel od
+  posledního pohledu z telefonu (aspoň posledních 24 hodin, starší klepnutím) — nové osoby, prameny, nalezené, opravené
+  či nově doložené údaje, vyřešené rozpory — nové zvýrazněné; co přibude při otevřené stránce, ukáže jen počet
+  v názvu záložky a malý štítek.
 - **Souhlas v jednom jazyce.** Souhlas, který dává jen člověk (rozbalení výzkumu, odebrání stromu, odmítnuté okno),
   zazní celý v jazyce výzkumu, nic z něj nezůstane anglicky.
 - **Odmítnutá aktualizace.** Když se `strom update` odmítne, řekne, že se nic nenainstalovalo a která verze zůstává,

package/CHANGELOG.de.md

@@ -7,7 +7,7 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
 
 ## 1.18.0
 
-*In Vorbereitung: die Betas bis 1.18.0-beta.7. Der Abschnitt ist mit dem Release vollständig.*
+*In Vorbereitung: die Betas bis 1.18.0-beta.8. Der Abschnitt ist mit dem Release vollständig.*
 
 - **Handyfotos aufrecht.** Ein Foto, das nach seiner EXIF-Ausrichtung gedreht ist, wird gelesen, wie es gesehen
   werden soll, aufrecht; die darauf markierten Stellen (Ausschnitte, die Hälften einer Doppelseite, ein gespeicherter
@@ -23,7 +23,9 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
   weg — auch ein Nachname, nie vom Vater oder aus einer anderen Familie genommen —, Unleserliches wird markiert; ein
   zweiter Leser kann blind lesen. In den Stammbaum gelangt nichts von selbst. Ein schon gelesenes Dokument sagt es,
   so wird es nicht versehentlich ein zweites Mal gelesen. Ein erneut gelesenes Dokument wird unter dem Namen seiner
-  Datei gezeigt, nie unter einem Code.
+  Datei gezeigt, nie unter einem Code. Ein aus der Strom-App gesendetes Dokument findet den Agenten wie das Terminal —
+  auch einen in einem eigenen Ordner, über npm oder Homebrew installierten —, statt zu melden, es sei kein Agent
+  eingerichtet.
 - **Fotos vom Handy.** `strom phone on`, das nur ein Mensch einschaltet, lässt ein Handy im Heimnetz (WLAN oder
   Kabel — nie ein Mobilfunknetz oder ein VPN) zu diesem Computer. Das Handy wird einmal per QR-Code gekoppelt; seine
   Seite fotografiert dann oder wählt aus der Galerie und schickt die Fotos ganz in einen Stammbaum der Forschung, mit
@@ -37,7 +39,10 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
   das sie ohne neues Koppeln öffnet. Was wartet und die Änderungen lassen sich auf dem Handy ganz lesen: kein Text
   dessen, was wartet, wird gekürzt, mehr als die ersten 20 kommen auf Antippen, eine Änderung mit vielen Zeilen klappt
   ganz auf; Was wartet ist der letzte Teil der Seite. Eine Änderung vor heute hat bei der Uhrzeit auch ihr Datum (das
-  Jahr nur, wenn es nicht das laufende ist).
+  Jahr nur, wenn es nicht das laufende ist). Funde unter Jetzt zeigen, was die Forschung seit dem letzten Blick vom
+  Handy gefunden hat (mindestens die letzten 24 Stunden, ältere auf Antippen) — neue Personen, Quellen, gefundene,
+  korrigierte oder neu belegte Angaben, geklärte Widersprüche —, die neuen hervorgehoben; was bei offener Seite
+  hinzukommt, zeigt nur eine Zahl im Titel des Tabs und ein kleines Etikett.
 - **Eine Zustimmung in einer Sprache.** Eine Zustimmung, die nur ein Mensch gibt (eine Forschung entpacken, einen
   Stammbaum entfernen, ein abgelehntes Fenster), steht ganz in der Sprache der Forschung, nichts davon bleibt
   Englisch.

package/CHANGELOG.md

@@ -7,7 +7,7 @@ The changes of each version in short. The full notes and the install lines are o
 
 ## 1.18.0
 
-*In preparation: the betas up to 1.18.0-beta.7. The section is complete with the release.*
+*In preparation: the betas up to 1.18.0-beta.8. The section is complete with the release.*
 
 - **Phone photos upright.** A photo turned by its EXIF orientation is read as it is meant to be seen, upright; the
   places marked on it (excerpts, the halves of a spread, a cut-out part) are of the picture as it is shown. The
@@ -22,7 +22,8 @@ The changes of each version in short. The full notes and the install lines are o
   a name the document does not have is left out — a surname too, never taken from a father or another family —,
   what cannot be read is marked; a second reader can read it blind. Nothing of it enters the tree by itself. A
   document read already says so, so it is not read a second time by mistake. A document read again is shown under
-  the name of its file, never a code.
+  the name of its file, never a code. A document sent from the Strom app finds the agent as the terminal does — one
+  installed in a folder of its own, by npm or Homebrew too — instead of saying no agent is set up.
 - **Photos from a phone.** `strom phone on`, turned on by the person alone, lets a phone on the home network (Wi-Fi
   or a cable — never a mobile network or a VPN) reach this computer. The phone is paired once by its QR code; its
   page then takes photos or picks them from the gallery and sends them whole into a tree of the research, with a
@@ -35,7 +36,9 @@ The changes of each version in short. The full notes and the install lines are o
   the home screen as an icon that opens it without pairing again. What waits and the changes read whole on the phone:
   no text of what waits is cut, more of it than the first 20 comes on a tap, a change of many lines unfolds whole;
   What waits is the last part of the page. A change older than today has its date beside the time (the year only when
-  it is not this one).
+  it is not this one). Finds, under Now, say what the research found since the phone looked last (the last 24 hours
+  at least, older ones on a tap) — new people, sources, facts found, corrected or newly cited, conflicts resolved —
+  the new ones marked; something new while the page is open shows only as a count in the tab's title and a small label.
 - **A consent in one language.** A consent only a person gives (unpacking a research, removing a tree, a window said
   no to) is said whole in the research's language, nothing of it left in English.
 - **An update said no to.** When `strom update` is declined, it says nothing was installed and which version stays,

package/assets/lang/cs.json

@@ -1416,6 +1416,26 @@
   "ui.phone.page.log.lines": "{n, plural, one {a # další} few {a # další} other {a # dalších}}",
   "ui.phone.page.log.fold": "Sbalit",
   "ui.phone.page.log.none": "Zatím se nic neuložilo.",
+  "ui.phone.page.finds": "Nálezy",
+  "ui.phone.page.finds.since": "od {time}",
+  "ui.phone.page.finds.none": "Nic nového se nenašlo.",
+  "ui.phone.page.finds.older": "Ukázat starší nálezy",
+  "ui.phone.page.finds.loading": "Načítá se…",
+  "ui.phone.page.finds.cut": "{n, plural, one {a # další v Přehledu výzkumu na počítači} few {a # další v Přehledu výzkumu na počítači} other {a # dalších v Přehledu výzkumu na počítači}}",
+  "ui.phone.page.finds.sources": "Nové prameny",
+  "ui.phone.page.finds.resolved": "Vyřešeno",
+  "ui.phone.page.finds.kind.person": "Nově v rodokmenu",
+  "ui.phone.page.finds.kind.family": "Nová rodina v rodokmenu",
+  "ui.phone.page.finds.kind.name": "Jméno: {text}",
+  "ui.phone.page.finds.kind.child": "Dítě: {text}",
+  "ui.phone.page.finds.kind.fact": "{text}",
+  "ui.phone.page.finds.kind.fixed": "{text} · opraveno",
+  "ui.phone.page.finds.kind.cited": "{text} · nově doloženo",
+  "ui.phone.page.finds.kind.source": "{text}",
+  "ui.phone.page.finds.kind.conflict": "Rozpor: {text}",
+  "ui.phone.page.finds.kind.hypothesis": "Otázka: {text}",
+  "ui.phone.page.finds.newMark": "nové",
+  "ui.phone.page.finds.new": "{n, plural, one {# novinka ↓} few {# novinky ↓} other {# novinek ↓}}",
   "ui.settings.phone": "Propojení s telefonem (fotky z telefonu do výzkumu v místní síti): {state}",
   "ui.settings.phone.on": "zapnuto, spárované telefony: {n}",
   "ui.settings.phone.error": "zapnuto, nedostupné",

package/assets/lang/de.json

@@ -1416,6 +1416,26 @@
   "ui.phone.page.log.lines": "{n, plural, one {und # weitere} other {und # weitere}}",
   "ui.phone.page.log.fold": "Weniger zeigen",
   "ui.phone.page.log.none": "Noch nichts gespeichert.",
+  "ui.phone.page.finds": "Funde",
+  "ui.phone.page.finds.since": "seit {time}",
+  "ui.phone.page.finds.none": "Nichts Neues gefunden.",
+  "ui.phone.page.finds.older": "Ältere Funde zeigen",
+  "ui.phone.page.finds.loading": "Wird geladen…",
+  "ui.phone.page.finds.cut": "{n, plural, one {und # weiterer in der Forschungsübersicht am Computer} other {und # weitere in der Forschungsübersicht am Computer}}",
+  "ui.phone.page.finds.sources": "Neue Quellen",
+  "ui.phone.page.finds.resolved": "Geklärt",
+  "ui.phone.page.finds.kind.person": "Neu im Stammbaum",
+  "ui.phone.page.finds.kind.family": "Neue Familie im Stammbaum",
+  "ui.phone.page.finds.kind.name": "Name: {text}",
+  "ui.phone.page.finds.kind.child": "Kind: {text}",
+  "ui.phone.page.finds.kind.fact": "{text}",
+  "ui.phone.page.finds.kind.fixed": "{text} · korrigiert",
+  "ui.phone.page.finds.kind.cited": "{text} · neu belegt",
+  "ui.phone.page.finds.kind.source": "{text}",
+  "ui.phone.page.finds.kind.conflict": "Widerspruch: {text}",
+  "ui.phone.page.finds.kind.hypothesis": "Frage: {text}",
+  "ui.phone.page.finds.newMark": "neu",
+  "ui.phone.page.finds.new": "{n, plural, one {# neu ↓} other {# neu ↓}}",
   "ui.settings.phone": "Verbindung mit dem Telefon (Fotos vom Telefon in die Forschung im lokalen Netz): {state}",
   "ui.settings.phone.on": "an, gekoppelte Telefone: {n}",
   "ui.settings.phone.error": "an, nicht erreichbar",

package/assets/phone/index.html

@@ -40,6 +40,12 @@
     <button id="treeBtn" class="tree" type="button" aria-haspopup="dialog"><span id="treeName"></span><span class="caret" aria-hidden="true">▼</span></button>
     <div class="status"><span id="dot" class="dot"></span><span id="statusText"></span></div>
   </header>
+  <!-- something new while the page is open: a small label under the header (no sound, no vibration, no dialog); the
+       progress's label of changes above stacked under it, never over it -->
+  <div class="notes">
+    <div class="findnote" aria-live="polite"><button id="findPill" class="findpill" type="button" hidden></button></div>
+    <button id="newPill" class="newpill" type="button" hidden></button>
+  </div>
   <div id="goneBanner" class="banner" hidden><span id="goneText"></span><button id="goneClose" class="x" type="button">×</button></div>
   <section id="down" class="card down" hidden>
     <h2 id="downTitle"></h2>
@@ -50,7 +56,7 @@
     <p id="noTrees" class="quiet" hidden></p>
     <section id="pairedCard" class="card" hidden><h2 id="pairedTitle"></h2><p id="pairedText" class="quiet"></p></section>
     <section id="archiveCard" class="card" hidden><p id="archiveText" class="strong"></p><p id="archivePhotos" class="quiet"></p></section>
-    <!-- what the research does now, what waits, the last 24 hours and the progress: to look at alone (nothing here
+    <!-- what the research does now, what it found, the last 24 hours, the progress and what waits: to look at alone (nothing here
          answers, starts or decides anything) -->
     <div id="overview" hidden>
       <section id="nowCard" class="card">
@@ -58,6 +64,14 @@
         <ul id="nowLines" class="lines"></ul>
         <div id="nowIdle" hidden><p class="idle-row"><span class="ring" aria-hidden="true"></span><span id="nowIdleText"></span></p><p id="nowIdleLast" class="quiet small"></p></div>
       </section>
+      <!-- what the research found since this phone looked last (the last 24 hours at least), the new ones marked -->
+      <section id="findsCard" class="card">
+        <h2 class="cap"><span id="findsTitle"></span> <span id="findsSince" class="since-label"></span></h2>
+        <p id="findsNone" class="quiet" hidden></p>
+        <ul id="findsList" class="finds"></ul>
+        <p id="findsCut" class="quiet small" hidden></p>
+        <p class="morerow"><button id="findsOlder" class="linkbtn" type="button" hidden></button></p>
+      </section>
       <section id="dayCard" class="card" hidden>
         <h2 id="dayTitle" class="cap"></h2>
         <div class="day">
@@ -91,7 +105,6 @@
       <p><button id="homeClose" class="btn outline small" type="button"></button></p>
     </section>
   </div>
-  <button id="newPill" class="newpill" type="button" hidden></button>
   <button id="strip" class="strip" type="button" hidden><span class="strip-bar"><span id="stripFill"></span></span><span id="stripText"></span></button>
   <footer class="bar">
     <button id="photoBtn" class="btn primary" type="button"></button>

package/assets/phone/phone.css

@@ -82,6 +82,25 @@ button{font:inherit;color:inherit}
 .morerow{margin:6px 0 0}
 .morerow .linkbtn{padding:10px 0;min-height:44px;text-align:left}
 .morerow .linkbtn:disabled{color:var(--text-faint);text-decoration:none;cursor:default}
+.finds li{padding:8px 0;border-top:1px solid var(--divider)}
+.finds li:first-child{border-top:0;padding-top:0}
+.finds .head{display:flex;align-items:baseline;gap:8px}
+.finds .who{flex:1;min-width:0;font-size:15px;font-weight:600;overflow-wrap:anywhere}
+.finds time{flex:none;overflow-wrap:normal;font-size:12.5px;color:var(--text-faint);font-variant-numeric:tabular-nums}
+.finds p{margin:2px 0 0;font-size:14px;color:var(--text-light);overflow-wrap:anywhere}
+.finds p.new{color:var(--text)}
+.finds .nd{display:inline-block;width:7px;height:7px;border-radius:50%;background:var(--accent);margin-right:6px;vertical-align:middle}
+.finds li.new{background:var(--primary-soft);border-radius:8px;margin:0 -8px;padding:8px;border-top-color:transparent}
+.since-label{text-transform:none;letter-spacing:0;font-weight:400;color:var(--text-faint)}
+#findsCard.none{display:flex;align-items:baseline;gap:12px;flex-wrap:wrap}
+#findsCard.none .cap,#findsCard.none p{margin:0}
+#findsCut{margin:10px 0 0}
+#findsCard,#waitCard{scroll-margin-top:calc(80px + env(safe-area-inset-top))}
+/* the labels of something new: one sticky column under the header, the finds' first, the progress's under it (never
+   one over the other); of no height itself, so nothing under it is covered but the labels */
+.notes{position:sticky;top:calc(65px + env(safe-area-inset-top));z-index:5;height:0;display:flex;flex-direction:column;align-items:center}
+.findnote{display:flex;justify-content:center}
+.findpill{margin-top:8px;border:1px solid var(--border);border-radius:999px;background:var(--surface);color:var(--primary-dark);padding:0 14px;min-height:32px;font-size:13px;font-weight:600;cursor:pointer;box-shadow:0 1px 4px rgba(20,16,8,.15)}
 .day{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:8px}
 .day b{display:block;font-size:20px;font-weight:600;font-variant-numeric:tabular-nums}
 .day span{font-size:12.5px;color:var(--text-light)}
@@ -92,7 +111,7 @@ button{font:inherit;color:inherit}
 .log .more{font-size:13px;color:var(--text-faint)}
 .log .unfold{display:block;background:none;border:0;padding:6px 0;margin:0;min-height:32px;font:inherit;font-size:13px;color:var(--primary);text-align:left;cursor:pointer}
 .log li.fresh{background:var(--primary-soft)}
-.newpill{position:fixed;top:calc(72px + env(safe-area-inset-top));left:50%;transform:translateX(-50%);z-index:7;border:0;border-radius:999px;background:var(--primary);color:var(--on-primary);padding:0 16px;min-height:36px;font-size:13px;font-weight:600;cursor:pointer;box-shadow:0 2px 8px rgba(20,16,8,.25)}
+.newpill{flex:none;margin-top:8px;border:0;border-radius:999px;background:var(--primary);color:var(--on-primary);padding:0 16px;min-height:36px;font-size:13px;font-weight:600;cursor:pointer;box-shadow:0 2px 8px rgba(20,16,8,.25)}
 
 /* the bar below: two buttons, the photos waiting above them */
 .bar{position:fixed;left:0;right:0;bottom:0;z-index:6;display:flex;gap:10px;padding:12px 16px max(12px,env(safe-area-inset-bottom));background:var(--bg);max-width:560px;margin:0 auto}

package/assets/phone/phone.js

@@ -168,6 +168,12 @@
     logLatest: "",
     waitLoaded: null, // more of what waits, asked for on a tap: {tree, of (what the overview gave then), n, items}
     waitBusy: false,
+    finds: null, // what the research found: {tree, key, since, groups, cut, earlier}
+    findsWin: {}, // the window of each tree: {since, base (what came after it is marked new)}
+    findsBusy: false,
+    seenMem: {}, // the last look at the finds of each tree, where the browser keeps nothing
+    waitBase: {}, // how much waited for each tree when it was looked at last
+    dwell: { finds: 0, wait: 0 }, // seconds each part has been in sight
     newCount: 0, // changes added above while scrolled down
     returning: false, // the page looked at again: the first answer after it awaited
   };
@@ -264,6 +270,7 @@
         S.shown = r.body.shown || null;
         if (S.shown && S.shown.latest && (S.logTree !== S.tree || S.logLatest !== S.shown.latest)) void loadLog(S.tree, S.shown.latest);
         keepWait();
+        wantFinds();
       } else {
         S.shown = null;
         setTimeout(() => void refresh(), 0);
@@ -637,6 +644,7 @@
   };
 
   const render = () => {
+    notice();
     if (S.view === "unpaired") return renderUnpaired();
     if (S.view !== "main") return;
     renderHeader();
@@ -707,7 +715,7 @@
     $("overview").hidden = !tree || !o;
     if (!tree || !o) return;
     const archive = !!tree.archive;
-    $("nowCard").hidden = $("waitCard").hidden = archive;
+    $("nowCard").hidden = $("waitCard").hidden = $("findsCard").hidden = archive;
     const lines = Array.isArray(o.now) ? o.now : [];
     if (!archive && changed("now", [lines, o.lastWorked, new Date().toDateString()])) {
       $("nowTitle").textContent = lines.length > 1 ? t("now.lines", { n: lines.length }) : t("now");
@@ -732,6 +740,7 @@
       if (o.lastWorked) $("nowIdleLast").textContent = t("now.idleLast", { when: whenOf(o.lastWorked) });
     }
     if (!archive) drawWait();
+    if (!archive) drawFinds();
     $("dayCard").hidden = !o.day;
     if (o.day && changed("day", o.day)) {
       const plus = (n) => (n > 0 ? "+" : "") + count(n);
@@ -778,6 +787,170 @@
     $("waitWhere").hidden = !w.n;
   };
 
+  // ── the finds: since this phone looked last (its browser keeps when, for each tree), the last 24 hours at least ──
+  const DAY_MS = 86_400_000;
+  // a look longer ago than this: the last 24 hours (older ones on a tap), all of them new
+  const LONG_MS = 7 * DAY_MS;
+  const seenKey = (tree) => `strom.phone.seen.${tree}`;
+  const later = (a, b) => (a > b ? a : b);
+  const seenOf = (tree) => {
+    const v = later(store.get(seenKey(tree)) || "", S.seenMem[tree] || "");
+    return Number.isFinite(Date.parse(v)) ? v : "";
+  };
+  // the window of a tree, set as it is opened: from its last look, the last 24 hours at least; no look known: the last
+  // 24 hours, none of them new (what comes after the first answer is)
+  const findsWindow = (tree, now = Date.now()) => {
+    let w = S.findsWin[tree];
+    if (!w) {
+      const seen = seenOf(tree);
+      const day = new Date(now - DAY_MS).toISOString();
+      w = S.findsWin[tree] = { since: seen && now - Date.parse(seen) < LONG_MS && seen < day ? seen : day, base: seen };
+    }
+    return w;
+  };
+  const newest = (groups) => groups.reduce((m, g) => later(m, String(g.at || "")), "");
+  const isNew = (at) => {
+    const w = S.findsWin[S.tree];
+    return !!w && !!w.base && at > w.base;
+  };
+  // asked when the tree's newest change or the window is another
+  let findsAsking = null;
+  const loadFinds = (tree, latest) =>
+    (findsAsking ??= (async () => {
+      const w = findsWindow(tree);
+      const key = `${tree}|${latest}|${w.since}`;
+      // a fact said in the page's language (its name and date as the rest of the line)
+      const r = await ask(`/phone/finds?tree=${encodeURIComponent(tree)}&since=${encodeURIComponent(w.since)}&lang=${encodeURIComponent(LANG)}`);
+      findsAsking = null;
+      S.findsBusy = false;
+      const ok = r.status === 200 && Array.isArray(r.body.groups);
+      if (ok && tree === S.tree) {
+        if (!w.base) w.base = newest(r.body.groups) || w.since;
+        S.finds = { tree, key, since: typeof r.body.since === "string" ? r.body.since : w.since, groups: r.body.groups, cut: Number(r.body.cut) || 0, earlier: typeof r.body.earlier === "string" ? r.body.earlier : "" };
+      }
+      drawFinds();
+      notice();
+      // another tree, a newer change or another window meanwhile: asked again for it (a failure: at the next answer)
+      if (ok || tree !== S.tree) wantFinds();
+    })());
+  const wantFinds = () => {
+    const tree = treeById(S.tree);
+    if (!tree || tree.archive || !S.shown || !S.shown.latest) return;
+    const w = findsWindow(S.tree);
+    if (!S.finds || S.finds.key !== `${S.tree}|${S.shown.latest}|${w.since}`) void loadFinds(S.tree, S.shown.latest);
+  };
+  const drawFind = (g) => {
+    const li = el("li");
+    const head = el("div", "head");
+    head.append(el("span", "who", g.kind === "sources" ? t("finds.sources") : g.kind === "resolved" ? t("finds.resolved") : String(g.title || "")));
+    const time = el("time", "", logTime(Date.parse(g.at)));
+    time.dateTime = g.at;
+    head.append(time);
+    li.append(head);
+    for (const l of Array.isArray(g.lines) ? g.lines : []) {
+      const p = el("p");
+      if (isNew(l.at)) {
+        p.className = "new";
+        li.className = "new";
+        const dot = el("span", "nd");
+        dot.setAttribute("aria-hidden", "true");
+        p.append(dot, el("span", "vh", `${t("finds.newMark")}: `));
+      }
+      p.append(el("span", "", t(`finds.kind.${l.kind}`, { text: l.text })));
+      li.append(p);
+    }
+    return li;
+  };
+  const drawFinds = () => {
+    const tree = treeById(S.tree);
+    if (!tree || tree.archive) return;
+    const f = S.finds && S.finds.tree === S.tree ? S.finds : null;
+    const w = S.findsWin[S.tree];
+    if (!changed("finds", [f && [f.groups, f.cut, f.earlier, f.since], w && w.base, S.findsBusy, !!(S.shown && S.shown.latest), new Date().toDateString()])) return;
+    const groups = f ? f.groups : [];
+    $("findsTitle").textContent = t("finds");
+    $("findsSince").textContent = f ? t("finds.since", { time: logTime(Date.parse(f.since)) }) : "";
+    $("findsCard").classList.toggle("none", !groups.length);
+    // nothing saved yet, or nothing found in the window: a short line
+    $("findsNone").hidden = groups.length > 0 || (!f && !!(S.shown && S.shown.latest));
+    $("findsNone").textContent = t("finds.none");
+    $("findsList").replaceChildren(...groups.map(drawFind));
+    $("findsList").hidden = !groups.length;
+    $("findsCut").hidden = !(f && f.cut);
+    if (f && f.cut) $("findsCut").textContent = t("finds.cut", { n: f.cut });
+    $("findsOlder").hidden = !(f && f.earlier);
+    $("findsOlder").disabled = S.findsBusy;
+    $("findsOlder").textContent = S.findsBusy ? t("finds.loading") : t("finds.older");
+  };
+  // older finds: a day before the newest of them (the server looks a month back at most)
+  const olderFinds = () => {
+    const f = S.finds && S.finds.tree === S.tree ? S.finds : null;
+    const w = S.findsWin[S.tree];
+    if (!f || !f.earlier || !w || S.findsBusy) return;
+    w.since = new Date(Date.parse(f.earlier) - DAY_MS).toISOString();
+    S.findsBusy = true;
+    drawFinds();
+    wantFinds();
+  };
+
+  // ── something new while the page is open: its count in the tab's title and a small label (no sound, no vibration,
+  // no dialog, no notification); gone once the part it is in has been in sight a while ──
+  const BASE_TITLE = document.title;
+  const unseen = () => {
+    const tree = treeById(S.tree);
+    if (!tree || tree.archive || S.view !== "main") return { finds: 0, wait: 0 };
+    const f = S.finds && S.finds.tree === S.tree ? S.finds : null;
+    const w = S.findsWin[S.tree];
+    const ref = later(seenOf(S.tree), (w && w.base) || "");
+    const finds = f && ref ? f.groups.reduce((n, g) => n + (Array.isArray(g.lines) ? g.lines : []).filter((l) => l.at > ref).length, 0) : 0;
+    const n = S.shown && S.shown.waiting ? Number(S.shown.waiting.n) || 0 : 0;
+    const base = S.waitBase[S.tree];
+    return { finds, wait: base === undefined ? 0 : Math.max(0, n - base) };
+  };
+  const notice = () => {
+    // what waits: counted from what waited as the tree was opened (fewer since: from those)
+    const n = S.shown && S.shown.waiting && S.view === "main" ? Number(S.shown.waiting.n) || 0 : null;
+    if (n !== null && (S.waitBase[S.tree] === undefined || n < S.waitBase[S.tree])) S.waitBase[S.tree] = n;
+    const u = unseen();
+    const all = u.finds + u.wait;
+    const title = all ? `(${count(all)}) ${BASE_TITLE}` : BASE_TITLE;
+    if (document.title !== title) document.title = title;
+    $("findPill").hidden = !all;
+    const text = all ? t("finds.new", { n: all }) : "";
+    if (all && $("findPill").textContent !== text) $("findPill").textContent = text;
+  };
+  // in sight: on the screen, the page in front, no sheet over it
+  const inView = (e) => {
+    const r = e.getBoundingClientRect();
+    return r.height > 0 && r.bottom > 0 && r.top < (window.innerHeight || 0);
+  };
+  const DWELL_S = 2;
+  // called every second: what has been in sight DWELL_S seconds is seen (the finds by their newest, what waits by its count)
+  const looked = () => {
+    const tree = S.tree;
+    const showing = S.view === "main" && document.visibilityState !== "hidden" && !S.sheet && $("switcher").hidden;
+    const f = S.finds && S.finds.tree === tree ? S.finds : null;
+    S.dwell.finds = showing && f && f.groups.length && inView($("findsCard")) ? S.dwell.finds + 1 : 0;
+    S.dwell.wait = showing && S.shown && S.shown.waiting && inView($("waitCard")) ? S.dwell.wait + 1 : 0;
+    let moved = false;
+    if (S.dwell.finds >= DWELL_S) {
+      const at = newest(f.groups);
+      if (at && at > seenOf(tree)) {
+        S.seenMem[tree] = at;
+        store.set(seenKey(tree), at);
+        moved = true;
+      }
+    }
+    if (S.dwell.wait >= DWELL_S) {
+      const n = Number(S.shown.waiting.n) || 0;
+      if (S.waitBase[tree] !== n) {
+        S.waitBase[tree] = n;
+        moved = true;
+      }
+    }
+    if (moved) notice();
+  };
+
   // the progress: the changes drawn kept by their id, a new one put on top (lit for 6 s); scrolled down, what is under
   // the finger stays where it is and a pill says how many came above
   const logItems = new Map();
@@ -1067,6 +1240,9 @@
     if (S.tree !== id) {
       S.shown = null;
       S.waitLoaded = null;
+      S.finds = null;
+      S.findsBusy = false;
+      S.dwell = { finds: 0, wait: 0 };
       S.logTree = "";
       for (const li of logItems.values()) li.remove();
       logItems.clear();
@@ -1281,6 +1457,12 @@
     homeTimer = setTimeout(homeOff, Math.max(0, Date.parse(r.body.expiresAt) - Date.now()));
   };
   $("homeClose").onclick = homeOff;
+  $("findsOlder").onclick = olderFinds;
+  // to the finds (only what waits is new: to that)
+  $("findPill").onclick = () => {
+    const u = unseen();
+    $(u.finds || !u.wait ? "findsCard" : "waitCard").scrollIntoView({ block: "start", behavior: "smooth" });
+  };
   $("newPill").onclick = () => {
     S.newCount = 0;
     window.scrollTo({ top: 0, behavior: "smooth" });
@@ -1302,6 +1484,7 @@
     if (S.view === "main") {
       renderHeader();
       restampLog();
+      looked();
       if (ticks % 10 === 0 && document.visibilityState !== "hidden") void refresh();
     } else if (S.view === "unpaired" && ticks % 10 === 0) void whoami().then((w) => w === "paired" && void refresh());
   }, 1000);

package/dist/cli/main.js

@@ -23,6 +23,7 @@ import { fireHooks, HOOK_INTERFACE } from "../core/hooks.js";
 import { prependPath } from "../runners/runner.js";
 import { shimDir } from "../commands/session.js";
 import { isAgent } from "../core/which.js";
+import { completePath, pathToRemember } from "../core/userpath.js";
 import { appUrlShown, noticeStromApp } from "../core/stromapp.js";
 import { lastChannelOf, pendingTransition, updateChannel, whatsNewUrl } from "../core/update.js";
 import { backupBefore, backupSaid } from "./backups.js";
@@ -220,6 +221,22 @@ export async function main(argv, io, env, cwd) {
             .map((x) => `${x[0].toUpperCase()}${x.slice(1).padStart(4, "0")}`);
         ran = ctx;
         command = def.path.join(" ");
+        // The PATH of the person's terminal remembered (never an agent's, a hook's, one strom started); a strom the system
+        // started (a link from the Strom app, the bridge, the phone's server) gets what of it is missing — and so do the
+        // agents and readers it starts (core/userpath.ts)
+        if (io.tty && !isAgent(env) && env.STROM_SPAWNED !== "1" && v.hook !== true && ctx.settings.home()) {
+            const remember = pathToRemember(env, ctx.settings.config.terminalPath);
+            if (remember) {
+                try {
+                    ctx.settings.config.terminalPath = remember;
+                    ctx.settings.save();
+                }
+                catch {
+                    // remembered next time
+                }
+            }
+        }
+        completePath(env, ctx.settings.config.terminalPath);
         // a person's own pace for a host taken as given until a command to an archive finds settings not the person's
         netTrust.ownPace = true;
         // the person's own settings folder (another than their default one, outside an agent): listed as theirs, so that an

package/dist/cli/ui.js

@@ -1317,6 +1317,26 @@ export const UI = {
     "ui.phone.page.log.lines": "{n, plural, one {and # more} other {and # more}}",
     "ui.phone.page.log.fold": "Show less",
     "ui.phone.page.log.none": "Nothing saved yet.",
+    "ui.phone.page.finds": "Finds",
+    "ui.phone.page.finds.since": "since {time}",
+    "ui.phone.page.finds.none": "Nothing new found.",
+    "ui.phone.page.finds.older": "Show older finds",
+    "ui.phone.page.finds.loading": "Loading…",
+    "ui.phone.page.finds.cut": "{n, plural, one {and # more in the Research overview on the computer} other {and # more in the Research overview on the computer}}",
+    "ui.phone.page.finds.sources": "New sources",
+    "ui.phone.page.finds.resolved": "Resolved",
+    "ui.phone.page.finds.kind.person": "New in the tree",
+    "ui.phone.page.finds.kind.family": "New family in the tree",
+    "ui.phone.page.finds.kind.name": "Name: {text}",
+    "ui.phone.page.finds.kind.child": "Child: {text}",
+    "ui.phone.page.finds.kind.fact": "{text}",
+    "ui.phone.page.finds.kind.fixed": "{text} · corrected",
+    "ui.phone.page.finds.kind.cited": "{text} · newly cited",
+    "ui.phone.page.finds.kind.source": "{text}",
+    "ui.phone.page.finds.kind.conflict": "Conflict: {text}",
+    "ui.phone.page.finds.kind.hypothesis": "Question: {text}",
+    "ui.phone.page.finds.newMark": "new",
+    "ui.phone.page.finds.new": "{n, plural, one {# new ↓} other {# new ↓}}",
     "ui.settings.phone": "Phone connection (photos from a phone into the research on the local network): {state}",
     "ui.settings.phone.on": "on, paired phones: {n}",
     "ui.settings.phone.error": "on, unreachable",

package/dist/core/changelog.js

@@ -144,6 +144,15 @@ function kindOf(op) {
         return "story";
     return "other";
 }
+/** A fact of a person or a family as a person reads it ("narození: 3. 4. 1842, Sloup"); undefined when it is not there. */
+export function factSaid(tree, owner, eventId, lang) {
+    const e = (owner ? tree.get(owner) : undefined)?.events.find((x) => x.id === eventId);
+    if (!e)
+        return undefined;
+    const f = cardFact(tree, e);
+    const what = [f.value, humanDate(f.date, lang), humanPlace(f.place, f.house, lang)].filter(Boolean).join(", ");
+    return `${eventName(f.kind, lang, f.label)}${what ? `: ${what}` : ""}`;
+}
 /** Lines of what a commit saved, in the research language, each with what it is about; its subject when it logged no operation. */
 export function changeLines(tree, ops, subject, lang, was) {
     const get = (id) => (id ? tree.get(id) : undefined);
@@ -198,14 +207,7 @@ export function changeLines(tree, ops, subject, lang, was) {
                 return r.id;
         }
     };
-    const fact = (owner, eventId, at = tree) => {
-        const e = (owner ? at.get(owner) : undefined)?.events.find((x) => x.id === eventId);
-        if (!e)
-            return undefined;
-        const f = cardFact(at, e);
-        const what = [f.value, humanDate(f.date, lang), humanPlace(f.place, f.house, lang)].filter(Boolean).join(", ");
-        return `${eventName(f.kind, lang, f.label)}${what ? `: ${what}` : ""}`;
-    };
+    const fact = (owner, eventId, at = tree) => factSaid(at, owner, eventId, lang);
     /** A fact as an operation's summary names it, its record gone since ("+E0274 BIRT P0076 MAR 1776 [probable]"). */
     const factOf = (summary) => {
         const m = /^\+E\d+ (\S+) \S+(?: (.+?))? \[\p{L}+\]$/u.exec(summary);

package/dist/core/live-read.js

@@ -21,7 +21,7 @@ import { readableTypes } from "./readable.js";
 import { makeView } from "./views.js";
 import { inputPath } from "./media.js";
 import { sandboxOf } from "./sandbox.js";
-import { AGENTS, which } from "./which.js";
+import { AGENTS, findAgent } from "./which.js";
 import { assetPath } from "./assets.js";
 import { EXIT } from "./errors.js";
 import { forApp, refusal } from "./receive.js";
@@ -281,7 +281,7 @@ function notReady(tree, settings, env, seen, now) {
     const agent = settings.agent(tree.config).value;
     // (the agents' table of core, not the runners': a runner's module reaches the bridge, and so would come round to itself)
     const known = AGENTS.find((a) => a.id === agent);
-    if (agent !== "script" && (!known || !which(known.command, env)))
+    if (agent !== "script" && (!known || !findAgent(known.command, env)))
         return { why: "agent.none" };
     if (!READ_TESTED.includes(agent))
         return { why: "agent.untested" };

package/dist/core/phone-finds.js

@@ -0,0 +1,273 @@
+// What the research found, for a paired phone's page (strom phone): its Finds since the person last looked. A find is
+// what an agent of the research wrote of the family — never the person's own edits (the Strom app, the terminal) and
+// never the research's upkeep:
+//
+//   a new person (person.add, person.import) · a name of a person found (person.name) · a new family, a child found in
+//   one (family.add, family.import, family.child) · a fact found, corrected or newly cited (event.add, event.edit,
+//   event.cite — not a citation taken off or put back by an undo) · a new source (source.add) · a conflict resolved
+//   (conflict.resolve) · a hypothesis decided (hypothesis.decide — not abandoned)
+//
+// Tasks, sessions, images, readings, notes, places, settings, stories and what waits are none. Read from the logs of
+// each day (data/ops/<yyyy-mm>/<dd>/…, never written again once committed), never from git: an agent at work makes a
+// thousand commits a day. Each log is read once and only its finds kept; the answer is kept for the head and the
+// window asked, so the page asking again and again reads nothing new. Records gone since (taken back, merged into
+// another) say nothing; each text by the records as they are now, cleaned for the phone (forPhone).
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import { Tree } from "./tree.js";
+import { actsAsArchive } from "./state.js";
+import { runGit } from "./git.js";
+import { factSaid } from "./changelog.js";
+import { conflictTitle, displayName, lifespan } from "./people.js";
+import { ownerName } from "./overview.js";
+import { forPhone } from "./phone-watch.js";
+/** The window when the page asks for none: the last 24 hours. */
+export const FINDS_HOURS = 24;
+/** How far back the page may ask, and how far back a find before the window is looked for. */
+export const FINDS_BACK_DAYS = 31;
+/** At most so many groups in one answer (the newest); the rest counted. */
+export const FINDS_GROUPS = 100;
+const FIND_OPS = new Set(["person.add", "person.import", "person.name", "family.add", "family.import", "family.child", "event.add", "event.edit", "event.cite", "source.add", "conflict.resolve", "hypothesis.decide"]);
+/** The finds of one log as they were read, by its size (a log of a commit is never written again). */
+const logsRead = new Map();
+/** The answers kept, by the tree, its head and the window (a few: two phones may ask for two windows). */
+const kept = new Map();
+const KEPT = 16;
+/** Is it a find: an agent's (or a session's), of a kind that is one, not an undo. */
+function isFind(o) {
+    if (!FIND_OPS.has(o.op) || o.by === "user")
+        return false;
+    if (/^\S+ cites no more /u.test(o.summary) || (o.op === "event.cite" && /^\S+ cites \S+(?:, \S+)* again: /u.test(o.summary)))
+        return false;
+    if (o.op === "hypothesis.decide" && / abandoned/u.test(o.summary))
+        return false;
+    return true;
+}
+function findsOfLog(file) {
+    let size;
+    try {
+        size = fs.statSync(file).size;
+    }
+    catch {
+        return [];
+    }
+    const held = logsRead.get(file);
+    if (held && held.size === size)
+        return held.ops;
+    const ops = [];
+    let text = "";
+    try {
+        text = fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return [];
+    }
+    for (const line of text.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const o = JSON.parse(line);
+            if (o && typeof o.op === "string" && typeof o.at === "string" && Array.isArray(o.targets) && isFind(o))
+                ops.push(o);
+        }
+        catch {
+            // a line being written this moment: read whole the next time (the size differs)
+        }
+    }
+    logsRead.set(file, { size, ops });
+    return ops;
+}
+function list(dir) {
+    try {
+        return fs.readdirSync(dir).sort();
+    }
+    catch {
+        return [];
+    }
+}
+/** The logs of each day from `from` (a day, yyyy-mm-dd) on, oldest first; the older logs of a month or a session aside. */
+function logsFrom(dataDir, from) {
+    const dir = path.join(dataDir, "ops");
+    const out = [];
+    for (const month of list(dir).filter((n) => /^\d{4}-\d{2}$/u.test(n) && n >= from.slice(0, 7)))
+        for (const day of list(path.join(dir, month)).filter((n) => /^\d{2}$/u.test(n) && `${month}-${n}` >= from))
+            for (const f of list(path.join(dir, month, day)))
+                if (f.endsWith(".jsonl"))
+                    out.push(path.join(dir, month, day, f));
+    return out;
+}
+const hashed = (s) => crypto.createHash("sha256").update(s).digest("hex").slice(0, 12);
+/**
+ * The finds of operations, grouped, newest group first; each line once (a fact found and cited: found). A fact is said
+ * in `lang` (the page's: its name and its date as the rest of its line; the research language when none).
+ */
+export function findGroups(tree, ops, lang = tree.lang) {
+    const groups = new Map();
+    // a fact said once, by what happened to it first in the window; a person or family new in it: no line for its names
+    const facts = new Map();
+    const fresh = new Set();
+    const live = (id) => {
+        const r = id ? tree.get(id) : undefined;
+        if (!r || (r.type !== "person" && r.type !== "family"))
+            return undefined;
+        return r.retracted || r.mergedInto ? undefined : r;
+    };
+    const group = (key, make) => {
+        let g = groups.get(key);
+        if (!g) {
+            const made = make();
+            if (!made)
+                return undefined;
+            g = { key: hashed(`${tree.config.id}:${key}`), ...made, at: "", lines: [] };
+            groups.set(key, g);
+        }
+        return g;
+    };
+    const ofRecord = (r) => group(r.id, () => {
+        if (r.type === "person") {
+            const span = lifespan(r);
+            const title = forPhone(`${displayName(r)}${span ? ` (${span})` : ""}`);
+            return title ? { kind: "person", title } : undefined;
+        }
+        const title = forPhone(ownerName(tree, r.id));
+        return title ? { kind: "family", title } : undefined;
+    });
+    const add = (g, line) => {
+        if (!g || g.lines.some((l) => l.kind === line.kind && l.text === line.text))
+            return;
+        g.lines.push(line);
+        if (line.at > g.at)
+            g.at = line.at;
+    };
+    for (const o of [...ops].sort((a, b) => a.at.localeCompare(b.at))) {
+        const [first, second] = o.targets;
+        const at = o.at;
+        switch (o.op) {
+            case "person.add":
+            case "person.import":
+            case "family.add":
+            case "family.import": {
+                const r = live(first);
+                if (!r)
+                    break;
+                fresh.add(r.id);
+                add(ofRecord(r), { kind: r.type === "person" ? "person" : "family", text: "", at });
+                break;
+            }
+            case "person.name": {
+                const r = live(first);
+                const m = /^\S+ name (.+?)(?: \([\w-]+\))?(?: ← \S+)?$/u.exec(o.summary);
+                const name = m ? forPhone(m[1].replace(/\//gu, " ").replace(/\s+/gu, " ").trim()) : "";
+                if (r && name && !fresh.has(r.id))
+                    add(ofRecord(r), { kind: "name", text: name, at });
+                break;
+            }
+            case "family.child": {
+                const r = live(first);
+                const child = live(second ?? /\+child (P\d+)/u.exec(o.summary)?.[1]);
+                if (!r || !child || child.type !== "person")
+                    break;
+                const span = lifespan(child);
+                const text = forPhone(`${displayName(child)}${span ? ` (${span})` : ""}`);
+                if (text)
+                    add(ofRecord(r), { kind: "child", text, at });
+                break;
+            }
+            case "event.add":
+            case "event.edit":
+            case "event.cite": {
+                const r = live(first);
+                const id = second ?? /^\+?(E\d+) /u.exec(o.summary)?.[1];
+                const e = r?.events.find((x) => x.id === id);
+                if (!r || !e || e.retracted)
+                    break;
+                const said = forPhone(factSaid(tree, r.id, e.id, lang) ?? "");
+                if (!said)
+                    break;
+                // a line of its own on the phone: its first letter as a sentence's
+                const text = said.charAt(0).toLocaleUpperCase(lang) + said.slice(1);
+                const kind = o.op === "event.add" ? "fact" : o.op === "event.edit" ? "fixed" : "cited";
+                const was = facts.get(`${r.id}:${e.id}`);
+                if (was) {
+                    // said already: as it is now, at its newest moment
+                    was.text = text;
+                    was.at = at;
+                    const g = ofRecord(r);
+                    if (g && at > g.at)
+                        g.at = at;
+                    break;
+                }
+                const line = { kind, text, at };
+                facts.set(`${r.id}:${e.id}`, line);
+                add(ofRecord(r), line);
+                break;
+            }
+            case "source.add": {
+                const s = first ? tree.get(first) : undefined;
+                const text = s && s.type === "source" && !s.retracted ? forPhone(s.title) : "";
+                if (text)
+                    add(group("sources", () => ({ kind: "sources" })), { kind: "source", text, at });
+                break;
+            }
+            case "conflict.resolve": {
+                const c = first ? tree.get(first) : undefined;
+                const text = c && c.type === "conflict" && c.state === "resolved" ? forPhone(conflictTitle(tree, c)) : "";
+                if (text)
+                    add(group("resolved", () => ({ kind: "resolved" })), { kind: "conflict", text, at });
+                break;
+            }
+            case "hypothesis.decide": {
+                const h = first ? tree.get(first) : undefined;
+                const text = h && h.type === "hypothesis" && h.state === "decided" ? forPhone(h.question) : "";
+                if (text)
+                    add(group("resolved", () => ({ kind: "resolved" })), { kind: "hypothesis", text, at });
+                break;
+            }
+        }
+    }
+    return [...groups.values()].filter((g) => g.lines.length).sort((a, b) => b.at.localeCompare(a.at));
+}
+function head(root) {
+    const r = runGit(root, ["rev-parse", "HEAD"]);
+    return r.status === 0 ? r.stdout.trim() : "";
+}
+/**
+ * The finds of a tree since `since` (an ISO moment; none or not one: the last FINDS_HOURS; at most FINDS_BACK_DAYS
+ * back), newest first, and the newest find before them; a fact said in `lang`, the page's (a language code; none or not
+ * one: the research language). Kept for the head, the window and the language: asked again with none of them changed,
+ * nothing is read. An archive: none.
+ */
+export function treeFinds(root, env, since, now = Date.now(), lang) {
+    const said = lang && /^[a-z]{2,3}$/u.test(lang) ? lang : undefined;
+    const floor = now - FINDS_BACK_DAYS * 86_400_000;
+    const asked = since ? Date.parse(since) : NaN;
+    const from = new Date(Number.isFinite(asked) ? Math.min(now, Math.max(floor, asked)) : now - FINDS_HOURS * 3_600_000).toISOString();
+    const h = head(root);
+    // the day moves the floor of what is looked for before the window
+    const key = `${root}|${h}|${from}|${new Date(floor).toISOString().slice(0, 10)}|${said ?? ""}`;
+    const was = kept.get(key);
+    if (was)
+        return was;
+    const tree = Tree.open(root, env);
+    let value = { since: from, groups: [] };
+    if (!actsAsArchive(tree)) {
+        const dataDir = path.join(root, "data");
+        const ops = logsFrom(dataDir, new Date(floor).toISOString().slice(0, 10)).flatMap(findsOfLog);
+        const inWindow = ops.filter((o) => o.at >= from);
+        const groups = findGroups(tree, inWindow, said ?? tree.lang);
+        // the newest find before the window that still says something (a record gone since says nothing)
+        let earlier;
+        const before = ops.filter((o) => o.at < from && o.at >= new Date(floor).toISOString()).sort((a, b) => b.at.localeCompare(a.at));
+        for (let i = 0; i < before.length && !earlier; i += 50)
+            earlier = findGroups(tree, before.slice(i, i + 50))[0]?.at;
+        value = { since: from, groups: groups.slice(0, FINDS_GROUPS), ...(groups.length > FINDS_GROUPS ? { cut: groups.length - FINDS_GROUPS } : {}), ...(earlier ? { earlier } : {}) };
+    }
+    kept.set(key, value);
+    for (const old of kept.keys()) {
+        if (kept.size <= KEPT)
+            break;
+        kept.delete(old);
+    }
+    return value;
+}

package/dist/core/phone-send.js

@@ -9,6 +9,8 @@
 //                                  rest?}], more}), at most 20; rest: the lines of a change past the 3 shown
 //   GET  /phone/waiting?tree=&from=&limit=   more of what waits than the state gives ({n, items: [{what, on?}]}), of the
 //                                  same list, at most 200 at once
+//   GET  /phone/finds?tree=&since=   what the research found since then (phone-finds.ts: {since, groups: [{key, kind,
+//                                  title?, at, lines: [{kind, text, at}]}], cut?, earlier?}), at most 31 days back
 //   GET  /phone/people?tree=&q=    up to 8 people of the tree matching q (2 letters at least; case, accents and NFD
 //                                  aside): {id, name, birth, death, place}
 //   GET  /phone/media/<sha256>?tree=   is that content in the research already ({known: false} or {known, kind})
@@ -32,6 +34,7 @@ import { waysHere } from "./readable.js";
 import { birthEvent, deathEvent, displayName, findPersons } from "./people.js";
 import { yearLabel } from "./gdate.js";
 import { foldText } from "./text.js";
+import { treeFinds } from "./phone-finds.js";
 import { LOG_PHONE, WAITING_ASKED, WAITING_SHOWN, treeLog, treeMarks, treeOverview, treeWaiting } from "./phone-watch.js";
 /** How often the batches of a phone are looked at, and the parts of uploads cut short. */
 const INCOMING_EVERY_MS = 60 * 60_000;
@@ -130,6 +133,17 @@ export function phoneSend(env, note) {
                 const limit = Math.min(LOG_PHONE, Math.max(1, Number.parseInt(url.searchParams.get("limit") ?? "", 10) || LOG_PHONE));
                 reply(200, treeLog(t.root, env, limit));
             };
+        if (req.method === "GET" && p === "/phone/finds")
+            return () => {
+                if (foreign())
+                    return refuse(403, refusal("only the phone's page asks", "phone.origin"));
+                req.resume();
+                const t = treeOf();
+                if (!t)
+                    return gone();
+                // a fact said in the page's language (its name and date as the rest of the line)
+                reply(200, { ...treeFinds(t.root, env, url.searchParams.get("since") ?? undefined, Date.now(), url.searchParams.get("lang") ?? undefined) });
+            };
         if (req.method === "GET" && p === "/phone/waiting")
             return () => {
                 if (foreign())

package/dist/core/phone-watch.js

@@ -34,6 +34,10 @@ const ALONE = String.raw `(?<![\p{L}\p{M}\p{N}])`;
 const ENDS = String.raw `(?![\p{L}\p{M}\p{N}])`;
 const ONE_ID = String.raw `${ALONE}(?:D\d{14}-[0-9a-f]{4}|[${[...new Set(Object.values(ALL_PREFIXES))].join("")}]\d{4,})${ENDS}`;
 const IDS = new RegExp(String.raw `${ONE_ID}(?:(?:\s*[,;/&+–—-]\s*|\s+(?:\p{L}\p{M}*){1,4}\s+)${ONE_ID})*(?:\s*,?\s*(?:…|\.{3}))?`, "gu");
+// an ID written short in square brackets ("[I103]", "[P12, F3]"): a capital or two of any script and a number — never a
+// year ("[1842]"), a word ("[sic]") or what has a space or a small letter in it ("[fol. 3]", "[č. 12]")
+const SHORT_ID = String.raw `\p{Lu}\p{M}*(?:\p{Lu}\p{M}*)?\p{Nd}+`;
+const BRACKET_IDS = new RegExp(String.raw `\[\s*${SHORT_ID}(?:\s*[,;/&+–—-]\s*${SHORT_ID})*\s*\]`, "gu");
 // a link, with its scheme or www.: its site alone
 const LINK = /(?<![\p{L}\p{M}\p{N}.@])(?:(?:https?|ftp):\/\/|www\.)[^\s<>"„“”«»]+/giu;
 // a path: of Windows (C:\…, C:/…, \\server\…), the home's (~/…), absolute (/Users/…), in the research (notes/…, data/…),
@@ -86,6 +90,7 @@ export function forPhone(text) {
         return `${siteOf(core)}${tail}`;
     })
         .replace(PATHS, (m) => peeled(m).tail)
+        .replace(BRACKET_IDS, "")
         .replace(IDS, "")
         .replace(/\s+/gu, " ");
     for (let before = ""; before !== s;) {

package/dist/core/tree.js

@@ -27,7 +27,7 @@ import { lastBackup } from "./backup.js";
 export const TREE_FILE = "strom.json";
 // between releases the candidate being made (a bridge run from the sources says what it is: the Strom app goes by it);
 // at a release the release's own (package.json)
-export const VERSION = "1.18.0-beta.7";
+export const VERSION = "1.18.0-beta.8";
 const GITIGNORE = `# Strom Research — local state and large files are not versioned
 .strom/
 /media/

package/dist/core/userpath.js

@@ -0,0 +1,57 @@
+// The PATH of the person's terminal, for a strom started without it.
+//
+// A strom the system starts — a link from the Strom app through the applet (macOS: do shell script), the bridge and
+// the phone's server it starts, a login item — gets the system's bare PATH (/usr/bin:/bin:/usr/sbin:/sbin), not the
+// one the person's shell profile builds: the agent in ~/.local/bin, Node of an agent installed by npm, are not on it
+// (found on Mac: "Read the document" from the app said no agent is set up). strom remembers the PATH of the last
+// strom the person ran in a terminal, and every strom puts what of it, and of the folders the agents' installers use,
+// is missing at the end of its own PATH — never before it: what the process was given comes first (the strom of a
+// research's .strom/bin before the person's own). The person's shell is never run to ask (a profile may print,
+// ask, take long — or be fish's).
+import path from "node:path";
+import { agentBinDirs } from "./install.js";
+/** The PATH of this environment (Windows: Path in a copy of it). */
+export function pathOf(env) {
+    return env.PATH ?? env.Path ?? "";
+}
+/**
+ * The PATH to remember from a strom the person runs in a terminal (not an agent's, not one strom started), or
+ * undefined: none to remember, or the one remembered already.
+ */
+export function pathToRemember(env, remembered) {
+    const now = pathOf(env);
+    if (!now.trim() || now === remembered)
+        return undefined;
+    return now;
+}
+/** The PATH with what is missing of the remembered one and of the agents' folders at its end; undefined: nothing missing. */
+export function fullerPath(env, remembered, platform = process.platform) {
+    const now = pathOf(env);
+    const delimiter = platform === "win32" ? ";" : ":";
+    const key = (dir) => {
+        const d = dir.replace(/[\\/]+$/, "") || dir;
+        return platform === "win32" ? d.replace(/\//g, "\\").toLowerCase() : d;
+    };
+    const dirs = now.split(delimiter).filter(Boolean);
+    const have = new Set(dirs.map(key));
+    const more = [];
+    for (const dir of [...(remembered ?? "").split(delimiter), ...agentBinDirs(env, platform)]) {
+        if (!dir || !(platform === "win32" ? path.win32 : path.posix).isAbsolute(dir) || have.has(key(dir)))
+            continue;
+        have.add(key(dir));
+        more.push(dir);
+    }
+    return more.length ? [...dirs, ...more].join(delimiter) : undefined;
+}
+/** The environment given the fuller PATH (in place: what this strom starts gets it too). Whether it changed. */
+export function completePath(env, remembered, platform = process.platform) {
+    const fuller = fullerPath(env, remembered, platform);
+    if (fuller === undefined)
+        return false;
+    // (a copy of Windows' environment keeps the name Path; the process's own takes either)
+    if (platform === "win32" && env.PATH === undefined && env.Path !== undefined)
+        env.Path = fuller;
+    else
+        env.PATH = fuller;
+    return true;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strom-research",
-  "version": "1.18.0-beta.7",
+  "version": "1.18.0-beta.8",
   "description": "Genealogical research toolkit for AI coding agents",
   "type": "module",
   "bin": {