strom-research 1.20.0 → 1.21.0-beta.1

package/CHANGELOG.cs.md

@@ -5,6 +5,17 @@
 Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou na
 [GitHub Releases](https://github.com/ACiDekCZ/strom-research/releases) (anglicky).
 
+## 1.21.0
+
+*Připravuje se: bety do 1.21.0-beta.1. Oddíl bude úplný s vydáním.*
+
+- **„Čeká“ říká, co aplikace Strom neukazuje.** Řádek v menu a `strom plan` řekne, kolik z čekajícího je jen tady
+  v terminálu a kolik čeká na odpověď; zbytek je číslo, které ukazuje aplikace Strom, takže se obě shodují.
+- **„Co čeká“ dává vlastní věci terminálu na začátek.** Co ukazuje jen terminál (rozpor vlastní úpravy, odeslání
+  z aplikace, otázka ke čtení skenů), je pod „Jen tady v terminálu“, zbytek pod „I v aplikaci Strom“.
+- **`strom input assign`, `hide` a `unskip` řeknou, co se změnilo**, v jazyce výzkumu: každý soubor, každý
+  uvolněný nebo nový úkol, lidi jménem a jak změnu vrátit. Jejich JSON zůstává stejný.
+
 ## 1.20.0
 
 *25. 10. 2026 · patří k aplikaci Strom 3.16.0.*

package/CHANGELOG.de.md

@@ -5,6 +5,19 @@
 Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Installationszeilen stehen bei
 [GitHub Releases](https://github.com/ACiDekCZ/strom-research/releases) (auf Englisch).
 
+## 1.21.0
+
+*In Vorbereitung: die Betas bis 1.21.0-beta.1. Der Abschnitt ist mit dem Release vollständig.*
+
+- **„Wartet“ sagt, was die Strom-App nicht zeigt.** Die Zeile im Menü und `strom plan` sagt, wie viel des Wartenden
+  nur hier im Terminal ist und wie viel auf Antwort wartet; der Rest ist die Zahl, die die Strom-App zeigt, sodass
+  beide übereinstimmen.
+- **„Was wartet“ stellt das Eigene des Terminals voran.** Was nur das Terminal zeigt (ein Widerspruch einer eigenen
+  Änderung, eine Sendung der App, eine Frage zum Lesen von Scans), steht unter „Nur hier im Terminal“, der Rest unter
+  „Auch in der Strom-App“.
+- **`strom input assign`, `hide` und `unskip` sagen, was sich geändert hat**, in der Sprache der Forschung: jede
+  Datei, jede freigegebene oder neue Aufgabe, Personen mit Namen und wie es rückgängig geht. Ihr JSON bleibt gleich.
+
 ## 1.20.0
 
 *25.10.2026 · gehört zur Strom-App 3.16.0.*

package/CHANGELOG.md

@@ -5,6 +5,19 @@ English · [Čeština](CHANGELOG.cs.md) · [Deutsch](CHANGELOG.de.md)
 The changes of each version in short. The full notes and the install lines are on
 [GitHub Releases](https://github.com/ACiDekCZ/strom-research/releases).
 
+## 1.21.0
+
+*In preparation: the betas up to 1.21.0-beta.1. The section is complete with the release.*
+
+- **"Waiting" says what the Strom app does not show.** The line in the menu and `strom plan` says how many of the
+  waiting things are only here in the terminal and how many wait for a reply; the rest is the number the Strom app
+  shows, so the two agree.
+- **"What waits" puts the terminal's own first.** What only the terminal shows (a conflict of an own edit, a send of
+  the app, a question about the reading of scans) is listed under "Only here in the terminal", the rest under
+  "Also in the Strom app".
+- **`strom input assign`, `hide` and `unskip` say what changed** in the research's language: each file, each task
+  let go of or made, people by name, and how to take it back. Their JSON stays the same.
+
 ## 1.20.0
 
 *2026-10-25 · goes with the Strom app 3.16.0.*

package/assets/lang/cs.json

@@ -90,6 +90,9 @@
   "ui.menu.title": "Strom výzkum {version}",
   "ui.menu.tree": "Rodokmen: {name} · osob: {persons}",
   "ui.menu.waiting": "Čeká: {count}",
+  "ui.waiting.split.reply": "{n, plural, one {# čeká} few {# čekají} other {# čeká}} na odpověď",
+  "ui.waiting.split.here": "{n} jen tady v terminálu",
+  "ui.waiting.split": "{n} (z toho {parts})",
   "ui.menu.working": "Agent právě pracuje samostatně.",
   "ui.menu.chat": "Pokračovat ve výzkumu s agentem",
   "ui.menu.start": "Začít výzkum s agentem",
@@ -448,6 +451,8 @@
   "ui.wait.how1": "snímky patří do schránky (inbox), pro každou knihu vlastní složka, každý pojmenovaný číslem snímku, jak ho počítá prohlížeč",
   "ui.wait.how2": "(9.jpg; přiblížená část: 9a.jpg) – další běh je zaregistruje a úkol se sám vrátí do fronty",
   "ui.wait.todo.n": "k vyřízení {n}",
+  "ui.wait.app.head": "I v aplikaci Strom · {n}",
+  "ui.wait.only.head": "Jen tady v terminálu (v aplikaci Strom nejsou) · {n}",
   "ui.wait.sent.n": "čeká na odpověď {n}",
   "ui.wait.sent.title": "Čeká na odpověď",
   "ui.wait.filter": "filtr: {section}",
@@ -1633,7 +1638,7 @@
   "ui.plan.images": " (nejdřív potřebuje snímky)",
   "ui.plan.more": "… a další úkoly: {n}",
   "ui.plan.stories": "Potom vyprávění: {n} ({names})",
-  "ui.plan.waiting": "Čeká: {n} (v menu: Co čeká)",
+  "ui.plan.waiting": "Čeká: {count} · v menu: Co čeká",
   "ui.plan.none": "Fronta je prázdná – nové úkoly agent navrhne po dalším sezení, nebo mu jde v rozhovoru říct, co hledat.",
   "ui.plan.steer": "Pořadí se mění v rozhovoru s agentem: stačí mu říct, co má přednost.",
   "ui.plan.session": "sezení z {day}",
@@ -1869,6 +1874,24 @@
   "ui.intake.scans.archive": "Ve složce {folder} {n, plural, one {je # obrázek. Uložit ho do Archivu Stromu jako rodinný dokument?} few {jsou # obrázky. Uložit je do Archivu Stromu jako rodinné dokumenty?} other {je # obrázků. Uložit je do Archivu Stromu jako rodinné dokumenty?}}",
   "ui.intake.book.archive": "{folder}: neuloženo.",
   "ui.intake.known": "Tyhle podklady už ve výzkumu jsou – nic nepřibylo.",
+  "ui.input.assign.add": "{id} – nově patří k: {who}",
+  "ui.input.assign.remove": "{id} – už nepatří k: {who}",
+  "ui.input.batch.add": "dávka {name} – nově patří k: {who}",
+  "ui.input.batch.remove": "dávka {name} – už nepatří k: {who}",
+  "ui.input.task.of": "úkol {task} – nově se týká i: {who}",
+  "ui.input.assign.kept": "{id}: {who} zůstává – patří k celé dávce (odebrat z dávky: strom input assign --batch {batch} --remove {person})",
+  "ui.input.assign.none": "Nic ke změně.",
+  "ui.input.hidden": "{id} skryto",
+  "ui.input.why.unrelated": "nic z rodiny",
+  "ui.input.why.duplicate": "totéž jako jiný soubor",
+  "ui.input.task.without": "úkol {task} – bez {files} (skryto)",
+  "ui.input.task.dropped": "úkol {task} zrušen – jeho soubory jsou skryté ({files})",
+  "ui.input.hide.back": "zobrazit znovu: strom input unskip {ids}",
+  "ui.input.hide.none": "Už skryto – nic se nezměnilo.",
+  "ui.input.shown.new": "{id} znovu zobrazeno (čeká na roztřídění)",
+  "ui.input.shown.processed": "{id} znovu zobrazeno (zpracováno)",
+  "ui.input.task.gather": "úkol {task}: {what}",
+  "ui.input.unskip.none": "Nic skrytého – nic se nezměnilo.",
   "ui.intake.done": "✓ Přidáno do výzkumu: {n}. Agent to projde při další práci.",
   "ui.intake.done.archive": "✓ Uloženo do Archivu Stromu: {n}.",
   "ui.intake.done.waiting": "✓ Uloženo do výzkumu: {n}. Agent to projde, až bude na počítači.",

package/assets/lang/de.json

@@ -90,6 +90,9 @@
   "ui.menu.title": "Strom Ahnenforschung {version}",
   "ui.menu.tree": "Stammbaum: {name} · Personen: {persons}",
   "ui.menu.waiting": "Wartet: {count}",
+  "ui.waiting.split.reply": "{n, plural, one {# wartet} other {# warten}} auf Antwort",
+  "ui.waiting.split.here": "{n} nur hier im Terminal",
+  "ui.waiting.split": "{n} (davon {parts})",
   "ui.menu.working": "Der Agent arbeitet gerade selbstständig.",
   "ui.menu.chat": "Die Forschung mit dem Agenten fortsetzen",
   "ui.menu.start": "Die Forschung mit dem Agenten beginnen",
@@ -448,6 +451,8 @@
   "ui.wait.how1": "Scans kommen in den Eingang (inbox), ein Ordner pro Buch, jeder benannt nach der Bildnummer, wie der Viewer sie zählt",
   "ui.wait.how2": "(9.jpg; ein vergrößerter Ausschnitt: 9a.jpg) – der nächste Lauf registriert sie und die Aufgabe kehrt von selbst zurück",
   "ui.wait.todo.n": "zu erledigen {n}",
+  "ui.wait.app.head": "Auch in der Strom-App · {n}",
+  "ui.wait.only.head": "Nur hier im Terminal (nicht in der Strom-App) · {n}",
   "ui.wait.sent.n": "wartet auf Antwort {n}",
   "ui.wait.sent.title": "Wartet auf Antwort",
   "ui.wait.filter": "Filter: {section}",
@@ -1633,7 +1638,7 @@
   "ui.plan.images": " (braucht zuerst die Scans)",
   "ui.plan.more": "… und {n, plural, one {# weitere Aufgabe} other {# weitere Aufgaben}}",
   "ui.plan.stories": "Danach die Geschichten: {n} ({names})",
-  "ui.plan.waiting": "Wartet: {n} (im Menü: Was wartet)",
+  "ui.plan.waiting": "Wartet: {count} · im Menü: Was wartet",
   "ui.plan.none": "Die Warteschlange ist leer – neue Aufgaben schlägt der Agent nach der nächsten Sitzung vor, oder ihm im Gespräch sagen, was er suchen soll.",
   "ui.plan.steer": "Die Reihenfolge ändert sich im Gespräch mit dem Agenten: ihm sagen, was Vorrang hat.",
   "ui.plan.session": "Sitzung vom {day}",
@@ -1869,6 +1874,24 @@
   "ui.intake.scans.archive": "Im Ordner {folder} {n, plural, one {ist # Bild. Als Familiendokument im Strom-Archiv speichern?} other {sind # Bilder. Als Familiendokumente im Strom-Archiv speichern?}}",
   "ui.intake.book.archive": "{folder}: nicht gespeichert.",
   "ui.intake.known": "Diese Unterlagen sind schon in der Forschung – nichts hinzugefügt.",
+  "ui.input.assign.add": "{id} – gehört jetzt auch zu: {who}",
+  "ui.input.assign.remove": "{id} – gehört nicht mehr zu: {who}",
+  "ui.input.batch.add": "Stapel {name} – gehört jetzt auch zu: {who}",
+  "ui.input.batch.remove": "Stapel {name} – gehört nicht mehr zu: {who}",
+  "ui.input.task.of": "Aufgabe {task} – betrifft jetzt auch: {who}",
+  "ui.input.assign.kept": "{id}: {who} bleibt – gehört zum ganzen Stapel (vom Stapel entfernen: strom input assign --batch {batch} --remove {person})",
+  "ui.input.assign.none": "Nichts zu ändern.",
+  "ui.input.hidden": "{id} ausgeblendet",
+  "ui.input.why.unrelated": "nichts von der Familie",
+  "ui.input.why.duplicate": "dasselbe wie eine andere Datei",
+  "ui.input.task.without": "Aufgabe {task} – ohne {files} (ausgeblendet)",
+  "ui.input.task.dropped": "Aufgabe {task} aufgegeben – ihre Dateien sind ausgeblendet ({files})",
+  "ui.input.hide.back": "wieder zeigen: strom input unskip {ids}",
+  "ui.input.hide.none": "Bereits ausgeblendet – nichts geändert.",
+  "ui.input.shown.new": "{id} wieder sichtbar (wartet auf Sortierung)",
+  "ui.input.shown.processed": "{id} wieder sichtbar (verarbeitet)",
+  "ui.input.task.gather": "Aufgabe {task}: {what}",
+  "ui.input.unskip.none": "Nichts ausgeblendet – nichts geändert.",
   "ui.intake.done": "✓ Zur Forschung hinzugefügt: {n}. Der Agent sieht es bei der nächsten Arbeit durch.",
   "ui.intake.done.archive": "✓ Im Strom-Archiv gespeichert: {n}.",
   "ui.intake.done.waiting": "✓ In der Forschung aufbewahrt: {n}. Der Agent sieht es durch, sobald er auf diesem Computer ist.",

package/dist/cli/menu-waiting.js

@@ -3,7 +3,9 @@
 // an office, one message to the family. What is to do apart from what waits for a reply from outside (sent).
 //
 //   the overview  the places of what is to do, a page of 15 at a time (next, previous, a range, all), filtered by
-//                 section, "?" for what waits for a reply; a number opens a place — a place of one thing that thing
+//                 section, "?" for what waits for a reply; a number opens a place — a place of one thing that thing;
+//                 what the Strom app does not show (core/waiting.ts terminalOnly) first, under a heading of its own,
+//                 the app's after it under theirs
 //   a place       its things, then for all of them at once: the request texts joined, sent, a conversation
 //   a thing       what it is and waits for, then only what makes sense for its kind: the archive or the site, the
 //                 folder for images saved by hand, the request's text, sent (or back among what is to do), an answer
@@ -26,7 +28,7 @@ import { claimOf, isEditConflict, sideText } from "../core/conflicts.js";
 import { openForUser } from "../core/open.js";
 import { isArchive } from "../core/mode.js";
 import { listConnectors } from "../core/connector.js";
-import { requestFile, requestTexts, waitingFor } from "../core/waiting.js";
+import { inApp, requestFile, requestTexts, waitingFor } from "../core/waiting.js";
 import { SENDABLE } from "../core/waitkind.js";
 /** A person for the person reading: "Jan Novák (*1905) [P0001]". */
 const label = (p) => `${displayName(p)}${lifespan(p) ? ` (${lifespan(p)})` : ""} [${p.id}]`;
@@ -87,16 +89,25 @@ function short(tree, lang, w) {
 }
 const sentAtOf = (w) => String(w.item.sentAt ?? w.item.at);
 /** The places of a list, in its order (the items of one place stand together). */
-function placesOf(items) {
+function placesOf(items, only = false) {
     const by = new Map();
     for (const w of items) {
         let p = by.get(w.item.group.key);
         if (!p)
-            by.set(w.item.group.key, (p = { key: w.item.group.key, name: w.item.group.name, items: [] }));
+            by.set(w.item.group.key, (p = { key: w.item.group.key, name: w.item.group.name, items: [], only }));
         p.items.push(w);
     }
     return [...by.values()];
 }
+/**
+ * The places of the overview: when something is only here in the terminal, its places first, apart from those the
+ * Strom app shows too (a place with both — an archive's milder question beside its tasks — in each part with its own);
+ * else the places as they come.
+ */
+function overviewPlaces(items) {
+    const here = items.filter((w) => !inApp(w));
+    return here.length ? [...placesOf(here, true), ...placesOf(items.filter(inApp))] : placesOf(items);
+}
 /** A place's line on the overview: the thing itself when it is one, else what is there by kind. */
 function placeDetail(t, lang, tree, p, phase) {
     const one = p.items.length === 1 ? truncate(short(tree, lang, p.items[0]), 60) : undefined;
@@ -144,7 +155,9 @@ export async function waitingForYou(ctx, run, lang, root) {
             counts.set(w.item.section, (counts.get(w.item.section) ?? 0) + 1);
         if (filter && !counts.get(filter))
             filter = undefined;
-        const places = placesOf(filter ? here.filter((w) => w.item.section === filter) : here);
+        const places = overviewPlaces(filter ? here.filter((w) => w.item.section === filter) : here);
+        // the part only here in the terminal and the part the Strom app shows too, each with its heading
+        const split = places.some((p) => p.only);
         const pages = Math.max(1, Math.ceil(places.length / PAGE));
         page = Math.min(page, pages - 1);
         const [from, to] = view === "all" ? [0, places.length] : view ? [view.from, Math.min(view.to, places.length)] : [page * PAGE, Math.min(places.length, (page + 1) * PAGE)];
@@ -166,6 +179,10 @@ export async function waitingForYou(ctx, run, lang, root) {
         const width = Math.max(0, ...names.map((n) => [...n].length));
         for (const [k, p] of shown.entries()) {
             const name = names[k];
+            if (split && (k === 0 || shown[k - 1].only !== p.only)) {
+                const n = places.filter((x) => x.only === p.only).reduce((a, x) => a + x.items.length, 0);
+                screen.push(`  ${t(p.only ? "ui.wait.only.head" : "ui.wait.app.head", { n })}`);
+            }
             screen.push(`${String(from + k + 1).padStart(2)}  ${name}${" ".repeat(width - [...name].length)}   ${placeDetail(t, lang, tree, p, phase)}`);
         }
         // what can be typed here, only what does something now
@@ -247,7 +264,7 @@ export async function waitingForYou(ctx, run, lang, root) {
             if (/^\d+$/u.test(a) && Number(a) >= 1 && Number(a) <= places.length) {
                 const p = places[Number(a) - 1];
                 // a place of one: that thing at once
-                await guarded(ctx, lang, async () => (p.items.length === 1 ? thing(ctx, run, lang, root, p.items[0]) : place(ctx, run, lang, root, p.key, phase, filter)));
+                await guarded(ctx, lang, async () => (p.items.length === 1 ? thing(ctx, run, lang, root, p.items[0]) : place(ctx, run, lang, root, p.key, phase, filter, split ? p.only : undefined)));
                 break;
             }
             out(controlLine);
@@ -255,14 +272,14 @@ export async function waitingForYou(ctx, run, lang, root) {
     }
 }
 /** One place: its things, then for all of them at once — the request texts joined, sent, a conversation. */
-async function place(ctx, run, lang, root, key, phase, filter) {
+async function place(ctx, run, lang, root, key, phase, filter, only) {
     const t = translator(lang);
     const out = (line = "") => ctx.io.stdout(line + "\n");
     for (;;) {
         if (outOfAnswers(ctx))
             return;
         const tree = Tree.open(root, ctx.env);
-        const items = waitingHere(ctx, tree).filter((w) => w.item.group.key === key && w.item.phase === phase && (!filter || w.item.section === filter));
+        const items = waitingHere(ctx, tree).filter((w) => w.item.group.key === key && w.item.phase === phase && (!filter || w.item.section === filter) && (only === undefined || only === !inApp(w)));
         if (!items.length)
             return;
         const name = items[0].item.group.name;

package/dist/cli/menu.js

@@ -43,6 +43,7 @@ import { pathOf, startAgain } from "../core/userpath.js";
 import { offerAgent } from "./fixes.js";
 import { addToResearch } from "./menu-research.js";
 import { waitingForYou, waitingHere } from "./menu-waiting.js";
+import { waitingLine } from "../core/waiting.js";
 import { permissionWaitingLines } from "../core/archiveasks.js";
 import { settingsMenu } from "./menu-settings.js";
 import { mainPerson } from "../core/kin.js";
@@ -177,7 +178,8 @@ export async function runMenu(ctx, run) {
             }
             // what waits for the person: the same list What waits shows (each thing once — a task that waits for an archive's
             // decision is one of its question's)
-            const waiting = waitingHere(ctx, tree).length;
+            const waits = waitingHere(ctx, tree);
+            const waiting = waits.length;
             const started = tree.list("research").length > 0;
             out(t("ui.menu.tree", { name: tree.config.name, persons: tree.countLive("person") }));
             // No agent yet (none installed, or not the one chosen): the research waits for it — kept as an archive meanwhile,
@@ -201,8 +203,9 @@ export async function runMenu(ctx, run) {
                     out();
                 }
             }
+            // what of it the Strom app does not show (only here in the terminal) said, so its number and the app's agree
             if (waiting)
-                out(t("ui.menu.waiting", { count: waiting }));
+                out(waitingLine(lang, waits));
             // an archive's images wait for the person's decision: one line, only until it is answered
             // (since when, and the tasks that stand on it, once it waits long or holds up much)
             for (const line of permissionWaitingLines(tree, lang))

package/dist/cli/ui.js

@@ -63,6 +63,9 @@ export const UI = {
     "ui.menu.title": "Strom research {version}",
     "ui.menu.tree": "Family tree: {name} · people: {persons}",
     "ui.menu.waiting": "Waiting: {count}",
+    "ui.waiting.split": "{n} (of these {parts})",
+    "ui.waiting.split.here": "{n} only here in the terminal",
+    "ui.waiting.split.reply": "{n} waiting for a reply",
     "ui.menu.working": "The agent is working on its own right now.",
     "ui.menu.chat": "Continue the research with the agent",
     "ui.menu.start": "Start the research with the agent",
@@ -425,6 +428,8 @@ export const UI = {
     "ui.wait.how1": "scans go into the inbox, a folder per book, each named by its image number as the viewer counts it",
     "ui.wait.how2": "(9.jpg; a zoomed-in part of it: 9a.jpg) — the next run registers them and the task comes back by itself",
     "ui.wait.todo.n": "to do {n}",
+    "ui.wait.only.head": "Only here in the terminal (not in the Strom app) · {n}",
+    "ui.wait.app.head": "Also in the Strom app · {n}",
     "ui.wait.sent.n": "waiting for a reply {n}",
     "ui.wait.sent.title": "Waiting for a reply",
     "ui.wait.filter": "filter: {section}",
@@ -1622,7 +1627,7 @@ export const UI = {
     "ui.plan.images": " (needs the scans first)",
     "ui.plan.more": "… and {n, plural, one {# more task} other {# more tasks}}",
     "ui.plan.stories": "Then the stories: {n} ({names})",
-    "ui.plan.waiting": "Waiting: {n} (in the menu: What waits)",
+    "ui.plan.waiting": "Waiting: {count} · in the menu: What waits",
     "ui.plan.none": "Nothing in the queue — the agent proposes new tasks after its next session, or tell it in a conversation what to look for.",
     "ui.plan.steer": "To change the order, tell the agent in a conversation what comes first.",
     "ui.plan.session": "the session of {day}",
@@ -1858,6 +1863,24 @@ export const UI = {
     "ui.intake.scans.archive": "The folder {folder} holds {n, plural, one {# image. Save it to the Strom archive as a family document?} other {# images. Save them to the Strom archive as family documents?}}",
     "ui.intake.book.archive": "{folder}: not saved.",
     "ui.intake.known": "This material is in the research already — nothing added.",
+    "ui.input.assign.add": "{id} – now also of: {who}",
+    "ui.input.assign.remove": "{id} – no longer of: {who}",
+    "ui.input.batch.add": "batch {name} – now also of: {who}",
+    "ui.input.batch.remove": "batch {name} – no longer of: {who}",
+    "ui.input.task.of": "task {task} – now also about: {who}",
+    "ui.input.assign.kept": "{id}: {who} stays – the whole batch is of them (off the batch: strom input assign --batch {batch} --remove {person})",
+    "ui.input.assign.none": "Nothing to change.",
+    "ui.input.hidden": "{id} hidden",
+    "ui.input.why.unrelated": "nothing of the family",
+    "ui.input.why.duplicate": "the same as another file",
+    "ui.input.task.without": "task {task} – without {files} (hidden)",
+    "ui.input.task.dropped": "task {task} dropped – its files are hidden ({files})",
+    "ui.input.hide.back": "to show again: strom input unskip {ids}",
+    "ui.input.hide.none": "Hidden already – nothing changed.",
+    "ui.input.shown.new": "{id} shown again (waits to be sorted)",
+    "ui.input.shown.processed": "{id} shown again (processed)",
+    "ui.input.task.gather": "task {task}: {what}",
+    "ui.input.unskip.none": "Nothing hidden – nothing changed.",
     "ui.intake.done": "✓ Added to the research: {n}. The agent goes through it in its next work.",
     "ui.intake.done.archive": "✓ Saved to the Strom archive: {n}.",
     "ui.intake.done.waiting": "✓ Kept in the research: {n}. The agent goes through it once it is on this computer.",

package/dist/commands/browse.js

@@ -17,7 +17,9 @@ import { lacksImages } from "../core/queue.js";
 import { forStory } from "../core/stories.js";
 import { isArchive } from "../core/mode.js";
 import { actsAsArchive, stateOf } from "../core/state.js";
-import { rankedQueue, waitingForUser } from "./tasks.js";
+import { rankedQueue } from "./tasks.js";
+import { waitingHere } from "../cli/menu-waiting.js";
+import { waitingLine } from "../core/waiting.js";
 import { readTuneLog } from "../core/tune.js";
 import { calibrationLabel } from "../core/viewsizes.js";
 /** A change strom made by itself in the reading of scans, as a person reads it in strom recent. */
@@ -205,7 +207,9 @@ register({
         // the stories, with the searches beyond the registers before them
         const work = queue.filter((t) => !forStory(t));
         const stories = queue.filter(forStory);
-        const waiting = waitingForUser(tree).length;
+        // what waits for the person: the menu's What waits, what of it is only here in the terminal said (core/waiting.ts)
+        const waits = waitingHere(ctx, tree);
+        const waiting = waits.length;
         const shown = work.slice(0, count);
         let n = 0;
         const rows = shown.map((t) => [
@@ -225,7 +229,7 @@ register({
                 out.push(ui(lang, "ui.plan.stories", { n: stories.length, names: storyNames.join(", ") }));
         }
         if (waiting)
-            out.push(ui(lang, "ui.plan.waiting", { n: waiting }));
+            out.push(waitingLine(lang, waits, "ui.plan.waiting"));
         if (queue.length)
             out.push("", ui(lang, "ui.plan.steer"));
         const item = (t) => ({ id: t.id, what: humanTask(tree, t.what, lang), level: t.level, state: t.state, needsImages: lacksImages(tree, t) });

package/dist/commands/intake.js

@@ -14,7 +14,7 @@ import { collectFiles, fileSha256, inputPath, MAX_IN_TREE, mimeOf, storeShared }
 import { create, normId, requireRecord, update } from "../core/records.js";
 import { phrase } from "../core/phrases.js";
 import { addMarriedNames, importedTree, importGedcom, importStromJson, isStromJson, marriedNamesPlan, undoMarriedNames } from "../core/import.js";
-import { gedcomName, likelyDuplicates } from "../core/people.js";
+import { displayName, gedcomName, likelyDuplicates } from "../core/people.js";
 import { decodeText, safeFolderName } from "../core/text.js";
 import { amendInput, checkOriginalMeta } from "../core/originals.js";
 import { batchStatus, closeBatch, listBatches, readBatch } from "../core/batches.js";
@@ -61,6 +61,69 @@ function idsGiven(ctx, args, opts) {
     return ids;
 }
 /** The research the inputs are for: the one named, else the only active one. */
+/** A person for the person reading, as the material names them: "Jan Novák [P0002]" (an ID the research lacks as given). */
+function whoOf(tree, ids) {
+    return ids
+        .map((id) => {
+        const p = tree.get(id);
+        return p ? `${displayName(p)} [${p.id}]` : id;
+    })
+        .join(", ");
+}
+/** The tasks' files before a write: what a task let go of is said by its files (strom input hide). */
+function filesOfTasks(tree) {
+    return new Map(tree.list("task").map((t) => [t.id, t.where.filter((w) => /^I\d/u.test(w))]));
+}
+/**
+ * What strom input assign|hide|unskip changed, in the research language (the person reads it — the menu, the Strom
+ * app's bridge, an agent too): each file, each task, each batch, from what this write logged and how the records are
+ * now. The history keeps its own words.
+ */
+function materialLines(tree, before, batch) {
+    const lang = tree.lang;
+    const out = [];
+    for (const o of tree.written) {
+        const [id, ...rest] = o.targets;
+        if (o.op === "input.assign" && id) {
+            const i = tree.get(id);
+            const now = new Set([...(i?.persons ?? []), ...(i?.sorted?.persons ?? [])]);
+            const add = rest.filter((p) => now.has(p));
+            const remove = rest.filter((p) => !now.has(p));
+            if (add.length)
+                out.push(ui(lang, "ui.input.assign.add", { id, who: whoOf(tree, add) }));
+            if (remove.length)
+                out.push(ui(lang, "ui.input.assign.remove", { id, who: whoOf(tree, remove) }));
+        }
+        else if (o.op === "batch.assign" && batch) {
+            const b = readBatch(tree.root, batch);
+            const now = new Set(b?.persons ?? []);
+            const name = b?.name ?? batch;
+            const add = o.targets.filter((p) => now.has(p));
+            const remove = o.targets.filter((p) => !now.has(p));
+            if (add.length)
+                out.push(ui(lang, "ui.input.batch.add", { name, who: whoOf(tree, add) }));
+            if (remove.length)
+                out.push(ui(lang, "ui.input.batch.remove", { name, who: whoOf(tree, remove) }));
+        }
+        else if (o.op === "task.edit" && id && rest.length)
+            out.push(ui(lang, "ui.input.task.of", { task: id, who: whoOf(tree, rest) }));
+        else if (o.op === "task.edit" && id) {
+            const t = tree.get(id);
+            const files = (before.get(id) ?? []).filter((f) => !t?.where.includes(f));
+            if (files.length)
+                out.push(ui(lang, "ui.input.task.without", { task: id, files: files.join(", ") }));
+        }
+        else if (o.op === "task.drop" && id)
+            out.push(ui(lang, "ui.input.task.dropped", { task: id, files: (before.get(id) ?? []).join(", ") }));
+        else if (o.op === "input.hide" && id) {
+            const why = tree.get(id)?.hidden?.reason;
+            out.push(`${ui(lang, "ui.input.hidden", { id })}${why ? ` (${ui(lang, `ui.input.why.${why}`)})` : ""}`);
+        }
+        else if (o.op === "input.unskip" && id)
+            out.push(ui(lang, tree.get(id)?.state === "processed" ? "ui.input.shown.processed" : "ui.input.shown.new", { id }));
+    }
+    return out;
+}
 function researchFor(tree, named) {
     if (typeof named === "string")
         return requireRecord(tree, named, "research").id;
@@ -340,8 +403,10 @@ register({
     run(ctx, { args, opts }) {
         const tree = ctx.tree();
         const ids = idsGiven(ctx, args, opts);
+        const before = filesOfTasks(tree);
         const got = tree.withTreeLock(() => unhideMaterial(tree, ids));
-        return { text: got.changed.length ? lines(...tree.written.map((o) => o.summary)) : "nothing skipped: nothing changed", data: got };
+        const tasks = got.tasks.map((id) => ui(tree.lang, "ui.input.task.gather", { task: id, what: tree.get(id)?.what ?? "" }));
+        return { text: got.changed.length ? lines(...materialLines(tree, before), ...tasks) : ui(tree.lang, "ui.input.unskip.none"), data: got };
     },
 }, {
     path: ["input", "hide"],
@@ -364,8 +429,12 @@ register({
         if (why !== undefined && !HIDE_REASONS.includes(why))
             throw new UsageError(`--why: ${HIDE_REASONS.join(" or ")}`, { code: "material.body", params: { why: why.slice(0, 40) } });
         const ids = idsGiven(ctx, args, opts);
+        const before = filesOfTasks(tree);
         const got = tree.withTreeLock(() => hideMaterial(tree, ids, { reason: why, by: fileBy(tree, ctx.env) }));
-        return { text: got.changed.length ? lines(...tree.written.map((o) => o.summary), `show again: strom input unskip ${got.changed.length > 3 ? "…" : got.changed.join(" ")}`) : "hidden already: nothing changed", data: got };
+        return {
+            text: got.changed.length ? lines(...materialLines(tree, before), ui(tree.lang, "ui.input.hide.back", { ids: got.changed.length > 3 ? "…" : got.changed.join(" ") })) : ui(tree.lang, "ui.input.hide.none"),
+            data: got,
+        };
     },
 }, {
     path: ["input", "assign"],
@@ -393,7 +462,7 @@ register({
             throw new UsageError("give the files or --batch, not both", { code: "material.body" });
         const got = tree.withTreeLock(() => assignMaterial(tree, { ...(batch ? { batch } : { files: idsGiven(ctx, args, opts) }), add: people(opts.add), remove: people(opts.remove) }));
         return {
-            text: lines(got.changed.length ? lines(...tree.written.map((o) => o.summary)) : "nothing to change", ...got.kept.map((k) => `${k.id}: ${k.person} stays — the whole batch is theirs (strom input assign --batch ${k.batch} --remove ${k.person})`)),
+            text: lines(got.changed.length ? lines(...materialLines(tree, new Map(), got.batch)) : ui(tree.lang, "ui.input.assign.none"), ...got.kept.map((k) => ui(tree.lang, "ui.input.assign.kept", { id: k.id, who: whoOf(tree, [k.person]), batch: k.batch, person: k.person }))),
             data: got,
         };
     },

package/dist/core/tree.js

@@ -29,7 +29,7 @@ export const TREE_FILE = "strom.json";
 export const SEAL_FOREIGN = "seal.foreign";
 // 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.20.0";
+export const VERSION = "1.21.0-beta.1";
 const GITIGNORE = `# Strom Research — local state and large files are not versioned
 .strom/
 /media/

package/dist/core/waiting.js

@@ -1,7 +1,8 @@
 // What waits for the person, in one ordered list: the tasks that wait for them, the questions about archives, the new
 // versions of approved stories — and, for the terminal, the trees the Strom app sent and the questions about the reading
 // of scans. The bridge sends it to the Strom app (/status `waiting`, the app's spec ZADANI_VYZKUM_menu-ceka.md); the
-// menu's What waits reads the same. Computed, nothing written.
+// menu's What waits reads the same — the terminal's own marked `terminalOnly` (TERMINAL_ONLY), so the menu says what
+// of its count the app does not show (waitingSplit, waitingLine). Computed, nothing written.
 //
 // Each item: its kind (core/waitkind.ts for a task), the section the app shows it in, the place where it is dealt with
 // (its group), todo or sent, its order; for a task its priority, the site, the request's text, whom, the folder for
@@ -66,6 +67,35 @@ function actionsOf(kind, phase, note) {
                 : [];
     return all.filter((a) => ACTIONS_OFFERED.includes(a));
 }
+/**
+ * The options that add what only the terminal shows (the menu's What waits): the bridge never asks for them, so the
+ * Strom app never shows them. Each item they add is marked `terminalOnly`; a new kind of the terminal's own goes here.
+ */
+export const TERMINAL_ONLY = ["sends", "tune", "conflicts", "milder"];
+/** Whether the Strom app shows a thing that waits too (its /status `waiting`): everything but the terminal's own. */
+export function inApp(w) {
+    return !w.terminalOnly;
+}
+/**
+ * How many things wait, split as the Strom app counts them: all of them (the menu's count), those shown only in the
+ * terminal, those in the app that wait for a reply (sent — the app counts only what is to do), and what is to do in
+ * the app (its number: all − only here − sent).
+ */
+export function waitingSplit(items) {
+    const here = items.filter((w) => !inApp(w)).length;
+    const sent = items.filter((w) => inApp(w) && w.item.phase === "sent").length;
+    return { all: items.length, here, sent, app: items.length - here - sent };
+}
+/**
+ * The line "Waiting: N" for the person: what of it is only here in the terminal and what waits for a reply, each said
+ * on its own — the rest is the app's number; as it was only when neither is there (N is the app's number then).
+ */
+export function waitingLine(lang, items, key = "ui.menu.waiting") {
+    const s = waitingSplit(items);
+    const parts = [...(s.here ? [ui(lang, "ui.waiting.split.here", { n: s.here })] : []), ...(s.sent ? [ui(lang, "ui.waiting.split.reply", { n: s.sent })] : [])];
+    const count = parts.length ? ui(lang, "ui.waiting.split", { n: s.all, parts: parts.join(", ") }) : String(s.all);
+    return ui(lang, key, { count });
+}
 /** An address a person may open: http(s) only. */
 function webUrl(u) {
     return u && /^https?:\/\//iu.test(u) && URL.canParse(u) ? u : undefined;
@@ -256,7 +286,7 @@ export function waitingFor(tree, o = {}) {
         for (const q of questions.filter((p) => p.kind === "milder" && p.host && p.connector)) {
             const title = q.title ?? q.connector;
             const what = ui(lang, "ui.archive.milder.item", { title, host: q.host, to: levelWords(lang, q.to ?? "allowed"), from: levelWords(lang, q.from ?? "restricted") });
-            out.push({ question: q, item: { id: q.key, what, on: "", at: q.at, kind: "milder", section: "decide", group: archiveGroup(tree, q.host, title), phase: "todo", actions: [], host: q.host, connector: q.connector } });
+            out.push({ question: q, terminalOnly: true, item: { id: q.key, what, on: "", at: q.at, kind: "milder", section: "decide", group: archiveGroup(tree, q.host, title), phase: "todo", actions: [], host: q.host, connector: q.connector } });
         }
     // a new version of an approved story: whose (a couple's: person and partner), since when
     if (o.stories !== false)
@@ -291,6 +321,7 @@ export function waitingFor(tree, o = {}) {
         for (const r of receivedPending(tree.root))
             out.push({
                 send: r,
+                terminalOnly: true,
                 item: {
                     id: r.intake,
                     what: ui(lang, "ui.waiting.sent", { day: humanDay(r.at, lang), time: r.at.slice(11, 16), n: r.changes }),
@@ -308,6 +339,7 @@ export function waitingFor(tree, o = {}) {
         for (const c of conflictsToDecide(tree))
             out.push({
                 conflict: c,
+                terminalOnly: true,
                 item: { id: c.id, what: conflictTitle(tree, c), on: "", at: c.created, kind: "conflict", section: "decide", group: { key: "conflicts", name: phrase(lang, "wait.group.conflicts"), kind: "other" }, phase: "todo", actions: [] },
             });
     // the questions about the reading of scans only a person answers
@@ -315,6 +347,7 @@ export function waitingFor(tree, o = {}) {
         for (const q of tuneQuestions(tree, o.tune).due)
             out.push({
                 tune: q,
+                terminalOnly: true,
                 item: { id: q.id, what: q.text, on: q.why, at: q.asked, kind: "tune", section: "decide", group: { key: "tune", name: phrase(lang, "wait.group.tune"), kind: "other" }, phase: "todo", actions: [] },
             });
     // one place, one name: the first said of it (an archive's question names it as the research knows the archive; its

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strom-research",
-  "version": "1.20.0",
+  "version": "1.21.0-beta.1",
   "description": "Genealogical research toolkit for AI coding agents",
   "type": "module",
   "bin": {
@@ -57,5 +57,8 @@
   "devDependencies": {
     "@types/node": "^22.20.4",
     "typescript": "^7.0.2"
+  },
+  "publishConfig": {
+    "tag": "beta"
   }
 }