strom-research 1.0.0 → 1.1.0

package/assets/method/reading.md

@@ -31,8 +31,10 @@ Look at as few pixels as the question needs, and write down what you saw at once
   occupations, godparents, witnesses, midwife, remarks in the margin.
 - **Report image by image, as you go**: the image and page, what was found (or
   nothing), what was illegible and where, the hand, how sure each name is.
-- **Cite the image**: `strom source add … --media B0001:57 --locator "pag. 112,
-  2nd entry"`; a searched range goes in `strom search add … --pages 40-69`.
+- **Cite the image, and where the entry is on it**: `strom source add …
+  --clip B0001:57@0.05,0.40,0.45,0.18 --locator "pag. 112, 2nd entry"` — the
+  crop you read it in, as its view prints it; a searched range goes in
+  `strom search add … --pages 40-69`.
 - Page ↔ image: `strom recordset calibrate B0001 --point 57=112` (measured on
   the image, never guessed); then `strom media view B0001 --page 112` works.
 - **No images here yet:** a connector for that archive

package/assets/method/recording.md

@@ -4,7 +4,7 @@ Record a found entry in one batch: write the lines to a file in notes/, run
 `strom batch --file notes/<file> --dry-run`, fix what it reports, then run it
 without --dry-run. `#name` labels what a line creates, `@name` uses it later.
 
-    source add "Baptism of Jan Novák 1885" --kind baptism --recordset B0001 --media B0001:57 --locator "pag. 112, entry 2" --language la --information primary --transcript @notes/entry.txt #s
+    source add "Baptism of Jan Novák 1885" --kind baptism --recordset B0001 --clip B0001:57@0.05,0.40,0.45,0.18 --locator "pag. 112, entry 2" --language la --information primary --transcript @notes/entry.txt #s
     event add P0001 CHR --date "25 JUN 1885" --place "Týnec" --house 13 --cite @s --quote "baptizatus est" --with "godparent:Marie Dvořáková" --with "midwife:Anna Nová" --with "officiant:P. Josef Kříž" --status proven
     cite E0001 @s --quote "natus 24. Junii" --status proven
     name add P0002 "Marie /Svobodová/" --kind birth --cite @s --quote "Maria filia Josephi Svoboda"
@@ -12,6 +12,15 @@ without --dry-run. `#name` labels what a line creates, `@name` uses it later.
     family add --partner @josef --child P0002 --cite @s --information secondary
     search add "Baptism of Jan Novák" --recordset B0001 --years 1884-1886 --pages 55-60 --method page-by-page --result found --found @s
 
+- `--clip` is where the entry is on its image: the crop you read it in — the
+  view of it prints the option to copy (`the source of an entry read here:
+  --clip …`); an entry over a page break gets two. It cites the image too, and
+  the Strom app shows the entry cut out of the scan next to its words. Every
+  entry read from a scan gets it when it is recorded — you have the entry in
+  front of you; strom reminds you of one without it (source add, task done).
+- `--transcript` is the entry's words as they stand in it — its own language,
+  spelling and abbreviations, line by line, unread letters `[?]`; the Strom app
+  shows them next to the entry's image. Every entry read gets them.
 - A fact already in the tree gets the citation (`cite E…`), not a second fact —
   and what the record adds to it: `event edit E… --age husband:27 --age wife:17
   --house 21 --with "witness:…" --with "officiant:…"` (filling in needs no reason).

package/assets/plugins/connectors/DISCOVERY.md

@@ -24,8 +24,12 @@ strom runs the connector; you never run it yourself, you test it with
       only finds books and gives their links (`"can": ["find", "list"]`), and
       the user downloads by hand into the inbox.
     - `"unknown"`: you could not find out. Say so; the user decides.
-  - `pace`: slower than strom's default when the terms or robots.txt ask for
-    it, e.g. `{"minIntervalMs": 5000}` for a crawl-delay of 5.
+  - `pace`: the service's own, when it states one — slower when the terms
+    or robots.txt ask for it (`{"minIntervalMs": 5000}` for a crawl-delay of
+    5), faster when its documentation allows it (an API, an image server:
+    `{"minIntervalMs": 500, "source": "<where it says so>"}`), its hourly cap
+    when it has one (`"perHour"`). Never make one up: without it strom keeps
+    its own pause and follows what the server answers.
 - **Never get round a technical measure**: logins you do not have, captchas,
   or tokens meant to stop scripts. Tiles are how many viewers show big images;
   they are a measure against downloading only when the terms or the portal

package/assets/plugins/connectors/README.md

@@ -7,8 +7,13 @@ work folder by itself: it asks strom, which paces every request, keeps to the
 connector's hosts, writes the files and checks that an image is an image.
 
 This page is the whole contract. It is **version 1 and it does not change**:
-a connector written for it keeps working. (A different contract would get a
-new number, and strom would still run version 1.)
+a connector written for it keeps working. It only grows — optional fields,
+new capabilities, new routes:
+- an older strom leaves out what it does not know yet (`strom connector show`
+  says so) and runs the rest;
+- a different contract would get a new number, and strom would still run
+  version 1. A connector written for a newer version than strom runs asks for
+  `strom update`.
 
 ## The folder
 
@@ -78,11 +83,18 @@ starts with `.` or `_` are ignored (`_old-version/`).
     - `unknown`.
   - `terms` (a URL), `termsSummary`, `robots` and `officialExport`: shown to
     the user when they decide.
-  - `pace` (optional): slower than strom's default, never faster.
-    - `minIntervalMs`: time between two requests to a host. The default and
-      the minimum is 2000.
-    - `perHour`: requests to a host in an hour. The default and the maximum is
-      400.
+  - `pace` (optional): the service's own pace, where it states one — its
+    terms, robots.txt (a crawl-delay), the documentation of its API or
+    image server. Nothing made up: without it strom keeps its default.
+    - `minIntervalMs`: time between two requests to a host. The default is
+      2000; less only with `source`, and never below 250.
+    - `perHour`: requests to a host in an hour, where the service has such a
+      cap. The default is none.
+    - `source`: where the service says so (a URL, or a sentence).
+
+    The user may set their own pace for a host
+    (`strom allow host <host> --pace <seconds> --per-hour <n>`); it comes
+    first.
 - `login` (optional): the portal gives more to users who log in, and the
   connector can use the user's own account.
   - `about`: what an account gives, in a sentence the user reads.
@@ -217,16 +229,21 @@ The answer is one line on stdin:
   - `refused`: the archive said no (401 or 403), or asked twice to slow down
     (429);
   - `blocked`: the archive refused earlier and is left alone for now;
-  - `cap`: the hourly cap is reached;
+  - `cap`: the hourly cap of the service (or the user's) is reached, or the
+    server says its limit is used up for longer than strom waits;
   - `silent`: no answer. The server is down, or it blocks this IP;
   - `http`: the server keeps failing, or the request is not valid;
   - `too-big`: text over 5 MB (ask with `save`);
   - `login`: a request with a login value (section 4) that strom will not send.
 
 strom answers requests one at a time, in order, and paces them:
-- at least 2 s apart for each host, and at most 400 an hour;
+- at the service's pace for each host (the connector's `pace`), else at
+  least 2 s apart; an hourly cap only where the service or the user sets one;
+- longer apart while a host answers slowly (the pause is at least as long as
+  its answers take, counted from the answer);
 - shared by everything on this computer;
-- it waits by itself when an archive asks it to (Retry-After).
+- it waits by itself when an archive asks it to (Retry-After), or says its
+  limit is used up (RateLimit headers).
 
 ### 4. The user's login
 

package/dist/agents/files.js

@@ -11,7 +11,7 @@ import { writeFileAtomic } from "../core/json.js";
 import { PROFILES, SELF_READING } from "./profiles.js";
 import { Settings } from "../core/config.js";
 import { configDir } from "../core/paths.js";
-import { browserConnectors } from "../core/connector.js";
+import { treeBrowserConnectors } from "../core/connector.js";
 import { CHROME_ALLOW, CHROME_DENY, chromeDomain } from "../core/browser.js";
 export const MARKER = "<!-- strom: generated above this line (strom agents sync); your own notes below are kept -->";
 function agentsMd(tree) {
@@ -75,30 +75,37 @@ they ask.
   archive — a few minutes; it then fetches only the images we need, slowly").
 - **Stories of their ancestors**: on by default — once records tell a life,
   strom proposes a task to write it for the family book in the Strom app
-  (the method: a story rests on recorded facts only). When the research
-  starts, tell them in a sentence and that they may say no (\`strom\` shows
-  whether they chose; \`strom config set stories no\`). A story stays a draft
-  until they approve it.
+  (the method: a story rests on recorded facts only). When \`strom\` says to
+  tell them (it does once, not in every conversation), say it in a sentence
+  and that they may say no (\`strom config set stories no\`). A story stays a
+  draft until they approve it.
+- **One person looked at again** ("check grandpa František", "find more
+  about her", after a new model): \`strom review <whom>\` — strom proposes
+  the work as tasks (what the tree already says of them elsewhere, entries to
+  read whole, facts to check); tell them how many and what a session costs,
+  and they choose: here with you, or the agent alone.
 - **What waits for them** (\`strom\` shows it): tell them plainly what to do
   and where, one thing at a time.
 - **Results and the Strom app**: \`output/tree-strom.ged\` is the family tree
   for the Strom app (https://stromapp.info) — strom's companion: a free family
   tree app, no account, their data stay on their computer; it shows the tree,
-  the sources, a map, a family book. When they want to see the results (or
-  once, when the first ones are there), suggest it gently, in a sentence or
-  two: best installed as an app from the browser, from
+  the sources, a map, a family book. When they want to see the results, or
+  when \`strom\` says to offer it (it does once, not in every conversation),
+  suggest it gently, in a sentence or two: best installed as an app from the browser, from
   https://stromapp.info/run/ — \`strom app install\` opens it there and says
   where to click; it works offline then; \`strom app\` opens it, with this
   research when the app can take it — run by you, the app then follows the
   research live, what you record shows there by itself (else in the app:
-  Import, and this file). \`strom\` says which, in its results line. A program they already use is fine too:
+  Import, and this file) — each register entry with its image, cut out of its
+  scan. \`strom\` says which, in its results line. A program they already use is fine too:
   \`output/tree.ged\`. If they do not want it, do not bring it up again.
 - **The tree in this conversation, app or not**: they can simply ask you —
   about anyone in the tree, a family, a line, what is proven and by which
   record, what is still missing. Answer from strom (\`strom person show\`,
   \`family show\`, \`research show\`, \`find\`, \`source show\`, \`story show\`,
   \`gaps\`, \`frontier\`) in plain words: names, dates, places and the record
-  behind each fact, no IDs. Tell them once that they can ask like this.
+  behind each fact, no IDs. When \`strom\` says to (once), tell them they can
+  ask like this.
 
 ${SELF_READING}
 ${MARKER}
@@ -131,15 +138,17 @@ export function claudeSettings(tree) {
     const settings = new Settings(tree.env, {});
     const shared = settings.shared()?.value;
     const keys = permissionPath(configDir(tree.env));
-    // Connectors whose images come through the user's browser: browser tools, for their sites only.
-    const browser = browserConnectors(tree.env, shared);
+    // Connectors of this tree whose images come through the user's browser: browser tools, for their sites only.
+    const browser = treeBrowserConnectors(tree, shared);
     const sites = [...new Set(browser.flatMap((c) => c.manifest.hosts.map(chromeDomain)))];
     const downloads = permissionPath(settings.downloads());
     const lead = settings.models("claude", tree.config).lead;
+    // A rule for each of Claude Code's shells: Bash, and PowerShell (on Windows) — a Bash rule does not cover it.
+    const shell = (cmd) => [`Bash(${cmd})`, `PowerShell(${cmd})`];
     return {
         permissions: {
             allow: [
-                "Bash(strom:*)",
+                ...shell("strom:*"),
                 "Read(inputs/**)",
                 "Read(output/**)",
                 "Read(notes/**)",
@@ -160,13 +169,13 @@ export function claudeSettings(tree) {
                 "Edit(data/**)",
                 "Edit(strom.json)",
                 "Edit(.git/**)",
-                "Bash(git:*)",
+                ...shell("git:*"),
                 // A password is typed by the user in their own terminal, and so is installing a plugin; the seal is strom's.
                 // (Consents the agent may ask for — strom allow …: strom asks the person in a window.)
-                "Bash(strom login:*)",
-                "Bash(strom connector add:*)",
-                "Bash(strom connector remove:*)",
-                "Bash(strom seal:*)",
+                ...shell("strom login:*"),
+                ...shell("strom connector add:*"),
+                ...shell("strom connector remove:*"),
+                ...shell("strom seal:*"),
                 // The limiter's memory (pace, refusals).
                 ...(shared ? [`Edit(${permissionPath(path.join(shared, "net"))}/**)`] : []),
                 // A session ends with its turn: nothing wakes it up later (a live run waited for a wake-up that never came).

package/dist/agents/global.js

@@ -49,7 +49,7 @@ mentions strom, a family tree or the Strom app.
 8. The Strom app (https://stromapp.info) is strom's companion: a free family
    tree app, no account, the data stay on the user's computer. The research's
    result (\`output/tree-strom.ged\`) opens in it. When the user wants to see
-   the tree, suggest it gently — best installed as an app from the browser,
+   the tree (or \`strom\` says to offer it — once), suggest it gently — best installed as an app from the browser,
    from https://stromapp.info/run/ (\`strom app install\` opens it there; it
    then works offline); \`strom app\` opens it — with the research, followed
    live while you work, when the app can take it. Without it, the user can ask
@@ -58,18 +58,21 @@ mentions strom, a family tree or the Strom app.
 /**
  * The rules that let the agent run strom without asking, in its own settings' words.
  * Claude Code: `strom` on PATH, and the installer's command by its path — right after
- * the installer an agent calls it so, until a new terminal has it on PATH.
+ * the installer an agent calls it so, until a new terminal has it on PATH — for each of
+ * its shells: Bash, and PowerShell on Windows (a Bash rule does not cover it). Narrow
+ * rules like these hold in its auto mode too, where broad ones are dropped.
  */
 function allowRules(agent) {
     if (agent === "antigravity")
         return ["command(strom)"];
-    return ["Bash(strom:*)", ...(installation().launchers ?? []).map((p) => `Bash(${p}:*)`)];
+    const commands = ["strom", ...(installation().launchers ?? [])];
+    return commands.flatMap((c) => [`Bash(${c}:*)`, `PowerShell(${c}:*)`]);
 }
 /** A rule of strom's in Claude Code's or Antigravity's settings, whichever installation wrote it. */
 function isStromRule(agent, rule) {
     if (agent === "antigravity")
         return rule === "command(strom)";
-    return /^Bash\((?:.*[\\/])?strom(?:\.exe|\.cmd)?:\*\)$/.test(rule);
+    return /^(?:Bash|PowerShell)\((?:.*[\\/])?strom(?:\.exe|\.cmd)?:\*\)$/.test(rule);
 }
 /** OpenCode: the rule that lets it run strom without asking. */
 const OPENCODE_STROM = "strom *";
@@ -247,6 +250,14 @@ export function uninstallGlobal(t) {
         fs.rmSync(t.file);
     return true;
 }
+/** What strom taught the agents (where it did), brought to this version's text; the agents whose files changed. */
+export function refreshGlobal(env) {
+    const changed = new Set();
+    for (const t of globalTargets(env))
+        if (isInstalled(t) && installGlobal(t))
+            changed.add(t.agent);
+    return [...changed];
+}
 export function isInstalled(t) {
     const cur = read(t.file);
     if (cur === undefined)

package/dist/brief/brief.js

@@ -12,6 +12,7 @@ import { methodFor } from "../core/assets.js";
 import { recentSessions } from "../core/session.js";
 import { calibrationLine } from "../core/calibration.js";
 import { taskRecordsets } from "../core/frontier.js";
+import { reviewItems } from "../core/review.js";
 import { readyConnectors } from "../core/connector.js";
 import { runs, shellArg } from "../cli/format.js";
 import { foldText } from "../core/text.js";
@@ -143,6 +144,9 @@ export function buildBrief(tree, opts) {
                 ...task.notes.slice(-3).map((n) => `note:  ${n.text}`),
             ].filter(Boolean).join("\n"),
         });
+        // 2. a review: what each item of the task is, as the tree has it
+        if (task.origin.startsWith("review:") && task.where.length)
+            sections.push({ name: "review", required: true, pointer: `strom task show ${task.id}`, text: ["## To review", ...reviewItems(tree, task)].join("\n") });
         // 2a. an imported tree: who in it is probably already in the tree
         const treeInputs = [...new Set([...(task?.subject ?? []), ...(task?.where ?? [])])]
             .map((id) => (/^I\d{4,}$/.test(id) ? tree.get(id) : undefined))

package/dist/cli/context.js

@@ -7,6 +7,7 @@ import { Writable } from "node:stream";
 import { Settings } from "../core/config.js";
 import { displayPath, expandHome } from "../core/paths.js";
 import { NeedsConsentError, NeedsInputError, StromError, UsageError } from "../core/errors.js";
+import { migrate } from "../core/migrate.js";
 import { Tree, findTreeUpwards, isTreeDir } from "../core/tree.js";
 import { readJsonIfExists } from "../core/json.js";
 import { foldText } from "../core/text.js";
@@ -158,10 +159,12 @@ export class Context {
     }
     /**
      * One of numbered options (1…n, or keys of their own like "0"); Enter takes
-     * the suggested one. Asks again on anything else. Undefined when a test ran
-     * out of answers.
+     * the suggested one. Asks again on anything else. `back` adds "0" with that
+     * label: the person changes their mind, nothing changes — undefined, as when
+     * a test ran out of answers.
      */
-    async choose(question, options, suggested) {
+    async choose(question, choices, suggested, opts = {}) {
+        const options = opts.back ? [...choices, { key: "0", label: opts.back }] : choices;
         const keys = options.map((o, i) => o.key ?? String(i + 1));
         for (;;) {
             this.io.stdout(`\n${question ? `${question}\n` : ""}${options.map((o, i) => `  ${keys[i].padStart(2)}  ${o.label}`).join("\n")}\n`);
@@ -170,7 +173,7 @@ export class Context {
             const a = await this.ask(`${ui(this.uiLang(), "ui.choose")}`, keys[suggested]);
             const i = keys.indexOf(a.trim());
             if (i >= 0)
-                return i;
+                return i < choices.length ? i : undefined;
             this.io.stdout(ui(this.uiLang(), "ui.bad.choice") + "\n");
         }
     }
@@ -276,6 +279,9 @@ export class Context {
             });
         }
         this.opened = Tree.open(root, this.env);
+        // Data an older strom wrote under an older schema: brought forward first (a dry run too — it is not the command's change).
+        for (const step of migrate(this.opened))
+            this.io.stderr(`${ui(this.uiLang(), "ui.migrated", { step })}\n`);
         this.opened.dryRun = this.dryRun;
         // A language passed from outside (--lang, STROM_LANG — e.g. by the Strom
         // app) applies to this invocation; the tree keeps its own.

package/dist/cli/human.js

@@ -0,0 +1,116 @@
+// What a person reads about their family: dates, facts and how sure they are,
+// in the research language — for the views of the tree (strom stats, pedigree,
+// person card, recent). The GEDCOM forms stay in the data; these are only how
+// they are shown.
+import { MONTHS } from "../core/gdate.js";
+import { ui } from "./ui.js";
+/**
+ * English reads "31 Aug 1830"; the others their own numeric form ("31. 8. 1830", "31.8.1830"). A month and
+ * year alone are named ("srpen 1830") — after a word ("před 3/1853") in numbers, which no grammatical case bends.
+ */
+function format(lang, date, parts) {
+    const en = lang === "en";
+    const opts = parts === "month"
+        ? { month: "long", year: "numeric" }
+        : parts === "monthafter"
+            ? { month: en ? "short" : "numeric", year: "numeric" }
+            : parts === "daymonth"
+                ? { day: "numeric", month: en ? "short" : "numeric" }
+                : { day: "numeric", month: en ? "short" : "numeric", year: "numeric" };
+    try {
+        return new Intl.DateTimeFormat(en ? "en-GB" : lang, { ...opts, timeZone: "UTC" }).format(date);
+    }
+    catch {
+        return new Intl.DateTimeFormat("en-GB", { ...opts, timeZone: "UTC" }).format(date);
+    }
+}
+/** One date without a qualifier: "31 AUG 1830", "AUG 1830", "1830" — `after` a word ("before", "between"). */
+function simple(s, lang, after = true) {
+    const m = /^(?:(\d{1,2}) )?(?:([A-Z]{3}) )?(\d{3,4})$/.exec(s.trim());
+    if (!m)
+        return s;
+    const month = m[2] ? MONTHS.indexOf(m[2]) : -1;
+    if (month < 0)
+        return m[3];
+    const date = new Date(Date.UTC(2000, month, m[1] ? Number(m[1]) : 1));
+    date.setUTCFullYear(Number(m[3]));
+    return format(lang, date, m[1] ? "day" : after ? "monthafter" : "month");
+}
+/** A GEDCOM date as a person says it: "31. 8. 1830", "asi 1830", "před 1853", "mezi 1811 a 1812". */
+export function humanDate(date, lang) {
+    if (!date)
+        return "";
+    const d = date.trim().toUpperCase();
+    let m = /^BET (.+) AND (.+)$/.exec(d);
+    if (m)
+        return ui(lang, "ui.date.between", { a: simple(m[1], lang), b: simple(m[2], lang) });
+    m = /^FROM (.+) TO (.+)$/.exec(d);
+    if (m)
+        return ui(lang, "ui.date.fromto", { a: simple(m[1], lang), b: simple(m[2], lang) });
+    m = /^(FROM|TO|ABT|CAL|EST|BEF|AFT) (.+)$/.exec(d);
+    if (m) {
+        const key = { FROM: "ui.date.from", TO: "ui.date.to", ABT: "ui.date.about", CAL: "ui.date.about", EST: "ui.date.about", BEF: "ui.date.before", AFT: "ui.date.after" };
+        return ui(lang, key[m[1]], { date: simple(m[2], lang) });
+    }
+    return simple(d, lang, false);
+}
+/** A day of the research (an ISO time): "25. 9.", with the year when it is not this one. */
+export function humanDay(iso, lang) {
+    const d = new Date(iso);
+    return format(lang, d, d.getUTCFullYear() === new Date().getUTCFullYear() ? "daymonth" : "day");
+}
+/** An amount in US dollars (what the agents' providers bill). */
+export function humanCost(usd, lang) {
+    try {
+        return new Intl.NumberFormat(lang === "en" ? "en-GB" : lang, { style: "currency", currency: "USD" }).format(usd);
+    }
+    catch {
+        return `$${usd.toFixed(2)}`;
+    }
+}
+const EVENTS = {
+    BIRT: "ui.ev.BIRT",
+    CHR: "ui.ev.CHR",
+    BAPM: "ui.ev.CHR",
+    DEAT: "ui.ev.DEAT",
+    BURI: "ui.ev.BURI",
+    CREM: "ui.ev.CREM",
+    MARR: "ui.ev.MARR",
+    MARB: "ui.ev.MARB",
+    ENGA: "ui.ev.ENGA",
+    DIV: "ui.ev.DIV",
+    OCCU: "ui.ev.OCCU",
+    RESI: "ui.ev.RESI",
+    EDUC: "ui.ev.EDUC",
+    RELI: "ui.ev.RELI",
+    TITL: "ui.ev.TITL",
+    CENS: "ui.ev.CENS",
+    CONF: "ui.ev.CONF",
+    EMIG: "ui.ev.EMIG",
+    IMMI: "ui.ev.IMMI",
+    NATU: "ui.ev.NATU",
+    PROB: "ui.ev.PROB",
+    WILL: "ui.ev.WILL",
+};
+/** The name of a kind of fact: "narození", "křest"; an EVEN by its own label. */
+export function eventName(kind, lang, label) {
+    const key = EVENTS[kind];
+    return key ? ui(lang, key) : (label ?? kind);
+}
+const STATUS = { proven: "ui.st.proven", probable: "ui.st.probable", possible: "ui.st.possible", lead: "ui.st.lead" };
+/** How sure a fact is: "doloženo", "jen stopa". */
+export function statusName(status, lang) {
+    const key = STATUS[status];
+    return key ? ui(lang, key) : status;
+}
+/** A generation of ancestors: 2 the parents, 3 the grandparents, …; farther by its number. */
+export function generationName(g, lang) {
+    const key = { 2: "ui.gen.2", 3: "ui.gen.3", 4: "ui.gen.4", 5: "ui.gen.5" };
+    return key[g] ? ui(lang, key[g]) : ui(lang, "ui.gen.n", { n: g });
+}
+/** Where a fact happened: the place, with the house when the record gives it. */
+export function humanPlace(place, house, lang) {
+    if (!house)
+        return place ?? "";
+    return ui(lang, "ui.card.house", { place: place ?? "", house }).replace(/^[,\s]+/, "");
+}

package/dist/cli/main.js

@@ -9,6 +9,8 @@ import { resetCache } from "../core/git.js";
 import { VERSION } from "../core/tree.js";
 import { isAgent } from "../core/which.js";
 import { noticeStromApp } from "../core/stromapp.js";
+import { isNewer } from "../core/update.js";
+import { refreshGlobal } from "../agents/global.js";
 import { checkArgs, GroupOnly, parseOptions, resolveCommand, splitPassthrough } from "./execute.js";
 import "../commands/index.js";
 export { splitCommand } from "./execute.js";
@@ -110,6 +112,13 @@ export async function main(argv, io, env, cwd) {
         // Started by the Strom app: remembered quietly (it is where the results go).
         if (env.STROM_APP)
             noticeStromApp(ctx.settings, env);
+        // The first run of a newer strom: what it taught the agents outside the trees gets this version's text.
+        const last = ctx.settings.config.lastVersion;
+        if (ctx.settings.home() && (!last || isNewer(VERSION, last))) {
+            refreshGlobal(env);
+            ctx.settings.config.lastVersion = VERSION;
+            ctx.settings.save();
+        }
         const args = parsed.positionals;
         checkArgs(def, args);
         if (def.writes && v["dry-run"])