strom-research 1.13.0-beta.6 → 1.13.0-beta.7

package/assets/lang/cs.json

@@ -769,6 +769,7 @@
   "ui.sync.do.title.user": "platí úprava z aplikace (verze výzkumu zůstane v historii)",
   "ui.sync.sex.changed": "{n}. {who}: pohlaví {text}",
   "ui.sync.note.new": "{n}. {who}: poznámka — „{text}“",
+  "ui.sync.note.changed": "{n}. {who}: poznámka — „{old}“ → „{new}“",
   "ui.sync.source.new": "{n}. pramen: „{text}“",
   "ui.sync.source.changed": "{n}. pramen z aplikace „{text}“: opravený přepis nebo stránka",
   "ui.sync.source.reading": "{n}. pramen výzkumu „{text}“: v aplikaci přečtený jinak",
@@ -809,6 +810,7 @@
   "ui.sync.place.located": "{n}. {place}: poloha na mapě {at}",
   "ui.sync.do.add": "přidá se jako vodítko",
   "ui.sync.do.correct": "opraví vodítko výzkumu",
+  "ui.sync.do.note.changed": "ten řádek poznámky výzkumu se opraví",
   "ui.sync.do.detail": "doplní se k údaji s odkazem na strom z aplikace",
   "ui.sync.do.refine": "doplní se k údaji s odkazem na strom z aplikace (záznamu nic neodporuje)",
   "ui.sync.do.conflict": "rozpor k rozhodnutí (výzkum to má ze záznamu)",
@@ -1283,6 +1285,7 @@
   "log.repository.retract": "Odvolaný archiv: {name}",
   "log.name.remove": "Odebrané jméno: {name} – {who}",
   "log.note.remove": "Odebraná poznámka: „{note}“ – {name}",
+  "log.note.edit": "Opravená poznámka: {name}",
   "log.event.status": "Změněná jistota údaje: {who} – {fact}",
   "log.event.restore": "Údaj znovu platí: {who} – {fact}",
   "log.input.sync.undo": "Vrácený rodokmen: {name}",

package/assets/lang/de.json

@@ -769,6 +769,7 @@
   "ui.sync.do.title.user": "Die eigene Änderung gilt (die der Forschung bleibt in ihrer Geschichte)",
   "ui.sync.sex.changed": "{n}. {who}: Geschlecht {text}",
   "ui.sync.note.new": "{n}. {who}: eine Notiz — „{text}“",
+  "ui.sync.note.changed": "{n}. {who}: eine Notiz — „{old}“ → „{new}“",
   "ui.sync.source.new": "{n}. eine Quelle: „{text}“",
   "ui.sync.source.changed": "{n}. eigene Quelle „{text}“: Abschrift oder Seite korrigiert",
   "ui.sync.source.reading": "{n}. die Quelle der Forschung „{text}“: anders gelesen",
@@ -809,6 +810,7 @@
   "ui.sync.place.located": "{n}. {place}: Lage auf der Karte {at}",
   "ui.sync.do.add": "als Hinweis übernommen",
   "ui.sync.do.correct": "berichtigt den Hinweis der Forschung",
+  "ui.sync.do.note.changed": "diese Zeile der Notiz der Forschung wird berichtigt",
   "ui.sync.do.detail": "wird der Angabe hinzugefügt, mit Verweis auf den eigenen Stammbaum",
   "ui.sync.do.refine": "wird der Angabe hinzugefügt, mit Verweis auf den eigenen Stammbaum (nichts widerspricht dem Eintrag)",
   "ui.sync.do.conflict": "ein Widerspruch zum Entscheiden (die Forschung hat es aus einem Eintrag)",
@@ -1283,6 +1285,7 @@
   "log.repository.retract": "Archiv zurückgezogen: {name}",
   "log.name.remove": "Name entfernt: {name} – {who}",
   "log.note.remove": "Notiz entfernt: „{note}“ – {name}",
+  "log.note.edit": "Notiz berichtigt: {name}",
   "log.event.status": "Sicherheit einer Angabe geändert: {who} – {fact}",
   "log.event.restore": "Angabe wieder gültig: {who} – {fact}",
   "log.input.sync.undo": "Stammbaum zurückgenommen: {name}",

package/dist/agents/global.js

@@ -93,36 +93,100 @@ function allowRules(agent) {
  */
 const TOML_BEGIN = "# strom: begin (strom agents install; removed by strom agents uninstall)";
 const TOML_END = "# strom: end";
+const isTomlTable = (l) => /^\s*\[/.test(l);
+const isPermissionHeader = (l) => /^\s*\[permission\]\s*(#.*)?$/.test(l);
+const hasOwnAllow = (lines) => lines.some((l) => /^\s*allow\s*=/.test(l));
+/** A line of strom's own in config.toml: its [permission] header, or an allow list of nothing but strom's rules. */
+function isGrokStromLine(l) {
+    if (isPermissionHeader(l))
+        return true;
+    const m = /^\s*allow\s*=\s*\[(.*)\]\s*$/.exec(l);
+    const rules = m ? [...m[1].matchAll(/"([^"]*)"/g)].map((r) => r[1]) : [];
+    return rules.length > 0 && rules.every((r) => isStromRule("grok", r));
+}
+/** Strom's block among the lines of config.toml (split at \n): the lines of its begin and its end, or undefined. */
+function grokBlock(lines) {
+    const b = lines.findIndex((l) => l.trim() === TOML_BEGIN);
+    if (b < 0)
+        return undefined;
+    const e = lines.findIndex((l, i) => i > b && l.trim() === TOML_END);
+    if (e > b)
+        return [b, e];
+    // its end line lost: strom's own lines after its begin, never the person's that follow
+    let last = b;
+    while (last + 1 < lines.length && isGrokStromLine(lines[last + 1]))
+        last++;
+    return [b, last];
+}
+/**
+ * Strom's block taken out, the person's text before and after it kept as it is — only the blank line an install puts
+ * between the person's text and the block it appends goes with it.
+ */
 function grokWithout(text) {
-    const lines = text.split("\n");
-    const out = [];
-    let inside = false;
-    for (const l of lines) {
-        if (l.trim() === TOML_BEGIN)
-            inside = true;
-        else if (l.trim() === TOML_END)
-            inside = false;
-        else if (!inside)
-            out.push(l);
+    let lines = text.split("\n");
+    const blank = (i) => i >= 0 && i < lines.length && lines[i].trim() === "";
+    for (let at = grokBlock(lines); at; at = grokBlock(lines)) {
+        const [b, e] = at;
+        let from = b;
+        let to = e + 1;
+        // a blank line before it, and the end of the file or another blank line after it: the one before was strom's
+        if (blank(b - 1) && (e + 1 >= lines.length || blank(e + 1)))
+            from = b - 1;
+        // first in the file, then a blank line and the person's text: that blank line was strom's
+        else if (b === 0 && blank(e + 1) && e + 1 < lines.length - 1)
+            to = e + 2;
+        // taken to the end of a file with no line break at its end: the CR of the break before it went with it
+        const tail = to >= lines.length && from > 0 ? [lines[from - 1].replace(/\r$/, "")] : lines.slice(from - 1, from);
+        lines = [...lines.slice(0, Math.max(0, from - 1)), ...tail, ...lines.slice(to)];
     }
-    return out.join("\n");
+    return lines.join("\n");
 }
 function grokWith(text) {
-    const rest = grokWithout(text);
     const allow = `allow = [${allowRules("grok").map((r) => JSON.stringify(r)).join(", ")}]`;
-    const lines = rest.split("\n");
-    const header = lines.findIndex((l) => /^\s*\[permission\]\s*(#.*)?$/.test(l));
+    const nl = text.includes("\r\n") ? "\r\n" : "\n";
+    const cr = nl === "\r\n" ? "\r" : "";
+    const lines = text.split("\n");
+    const at = grokBlock(lines);
+    if (at) {
+        // strom's block there already: brought to this version where it is, the person's text around it untouched
+        const [b, e] = at;
+        const header = lines.findIndex((l, i) => (i < b || i > e) && isPermissionHeader(l));
+        let inner;
+        if (header < 0)
+            inner = ["[permission]", allow];
+        else if (header < b && !lines.slice(header + 1, b).some(isTomlTable)) {
+            // in the person's own table: up to the next table
+            let end = lines.findIndex((l, i) => i > e && isTomlTable(l));
+            if (end < 0)
+                end = lines.length;
+            if (hasOwnAllow([...lines.slice(header + 1, b), ...lines.slice(e + 1, end)]))
+                return undefined;
+            inner = [allow];
+        }
+        if (inner) {
+            const last = e === lines.length - 1; // the file ends with strom's end line: no line break after it
+            const block = [TOML_BEGIN, ...inner, TOML_END].map((l, i, all) => (last && i === all.length - 1 ? l : l + cr));
+            return [...lines.slice(0, b), ...block, ...lines.slice(e + 1)].join("\n");
+        }
+        // a table of strom's beside the person's own [permission] table (two would break the file): into theirs
+    }
+    const rest = at ? grokWithout(text) : text;
+    const rl = rest.split("\n");
+    const header = rl.findIndex(isPermissionHeader);
     if (header < 0) {
-        const body = rest.replace(/\s+$/, "");
-        return `${body ? `${body}\n\n` : ""}${TOML_BEGIN}\n[permission]\n${allow}\n${TOML_END}\n`;
+        // appended after a blank line, the person's last line ending as it did (grokWithout takes exactly this away)
+        const block = [TOML_BEGIN, "[permission]", allow, TOML_END].join(nl);
+        if (!rest)
+            return block + nl;
+        return rest.endsWith("\n") ? `${rest}${nl}${block}${nl}` : `${rest}${nl}${nl}${block}`;
     }
     // the user's table: up to the next table
-    let end = lines.findIndex((l, i) => i > header && /^\s*\[/.test(l));
+    let end = rl.findIndex((l, i) => i > header && isTomlTable(l));
     if (end < 0)
-        end = lines.length;
-    if (lines.slice(header + 1, end).some((l) => /^\s*allow\s*=/.test(l)))
+        end = rl.length;
+    if (hasOwnAllow(rl.slice(header + 1, end)))
         return undefined;
-    return [...lines.slice(0, header + 1), TOML_BEGIN, allow, TOML_END, ...lines.slice(header + 1)].join("\n");
+    return [...rl.slice(0, header + 1), ...[TOML_BEGIN, allow, TOML_END].map((l) => l + cr), ...rl.slice(header + 1)].join("\n");
 }
 /** A rule of strom's in Claude Code's or Antigravity's settings, whichever installation wrote it. */
 function isStromRule(agent, rule) {
@@ -223,30 +287,54 @@ function hasAllow(t, s) {
     const own = path.join(path.dirname(t.file), "strom.md");
     return isObject(bash) && bash[OPENCODE_STROM] === "allow" && Array.isArray(s.instructions) && s.instructions.includes(own);
 }
+/** Strom allowed in the settings; what it made there to do it. */
 function addAllow(t, s) {
+    const made = [];
+    const plain = [];
     if (t.agent !== "opencode") {
+        if (!isObject(s.permissions))
+            made.push("permissions");
+        const perms = isObject(s.permissions) ? s.permissions : {};
+        if (!Array.isArray(perms.allow))
+            made.push("permissions.allow");
         const have = allowList(s);
-        s.permissions = { ...(s.permissions ?? {}), allow: [...have, ...allowRules(t.agent).filter((r) => !have.includes(r))] };
-        return;
+        s.permissions = { ...perms, allow: [...have, ...allowRules(t.agent).filter((r) => !have.includes(r))] };
+        return { made };
     }
+    if (!isObject(s.permission))
+        (typeof s.permission === "string" ? plain : made).push("permission");
     const perm = isObject(s.permission) ? s.permission : typeof s.permission === "string" ? { "*": s.permission } : {};
     // A plain value for bash ("ask") becomes the general rule; strom's comes after it (the last match counts).
+    if (!isObject(perm.bash))
+        (typeof perm.bash === "string" ? plain : made).push("permission.bash");
     const bash = isObject(perm.bash) ? perm.bash : typeof perm.bash === "string" ? { "*": perm.bash } : {};
     s.permission = { ...perm, bash: { ...bash, [OPENCODE_STROM]: "allow" } };
     const own = path.join(path.dirname(t.file), "strom.md");
+    if (!Array.isArray(s.instructions))
+        made.push("instructions");
     const list = Array.isArray(s.instructions) ? s.instructions : [];
     if (!list.includes(own))
         s.instructions = [...list, own];
+    return { made, plain };
 }
-function removeAllow(t, s) {
+/**
+ * Strom's rules out of the settings. What strom made there (rec) goes when empty, and nothing else; a value it turned
+ * into an object becomes plain again. Nothing recorded (an installation before the record): every container left
+ * empty goes, as before.
+ */
+function removeAllow(t, s, rec) {
+    const goes = (p) => (rec ? (rec.made ?? []).includes(p) : true);
+    const wasPlain = (p, v) => (rec?.plain ?? []).includes(p) && Object.keys(v).length === 1 && "*" in v;
     if (t.agent !== "opencode") {
+        if (!isObject(s.permissions))
+            return;
         const rest = allowList(s).filter((r) => !isStromRule(t.agent, r));
         const perms = { ...s.permissions };
-        if (rest.length)
+        if (rest.length || !goes("permissions.allow"))
             perms.allow = rest;
         else
             delete perms.allow;
-        if (Object.keys(perms).length)
+        if (Object.keys(perms).length || !goes("permissions"))
             s.permissions = perms;
         else
             delete s.permissions;
@@ -255,7 +343,7 @@ function removeAllow(t, s) {
     const own = path.join(path.dirname(t.file), "strom.md");
     if (Array.isArray(s.instructions)) {
         const rest = s.instructions.filter((i) => i !== own);
-        if (rest.length)
+        if (rest.length || !goes("instructions"))
             s.instructions = rest;
         else
             delete s.instructions;
@@ -264,16 +352,97 @@ function removeAllow(t, s) {
         const bash = { ...s.permission.bash };
         delete bash[OPENCODE_STROM];
         const perm = { ...s.permission };
-        if (Object.keys(bash).length)
+        if (wasPlain("permission.bash", bash))
+            perm.bash = bash["*"];
+        else if (Object.keys(bash).length || !goes("permission.bash"))
             perm.bash = bash;
         else
             delete perm.bash;
-        if (Object.keys(perm).length)
+        if (wasPlain("permission", perm))
+            s.permission = perm["*"];
+        else if (Object.keys(perm).length || !goes("permission"))
             s.permission = perm;
         else
             delete s.permission;
     }
 }
+/** The spans of the JSON value at i of a text JSON.parse read (so nothing here needs to check it). */
+function jsonSpan(text, i) {
+    const ws = (k) => {
+        while (k < text.length && /\s/.test(text[k]))
+            k++;
+        return k;
+    };
+    const strEnd = (k) => {
+        for (k++; text[k] !== '"'; k++)
+            if (text[k] === "\\")
+                k++;
+        return k + 1;
+    };
+    const start = ws(i);
+    const c = text[start];
+    if (c === '"')
+        return { start, end: strEnd(start) };
+    if (c === "{" || c === "[") {
+        const keys = new Map();
+        const items = [];
+        let k = ws(start + 1);
+        while (text[k] !== (c === "{" ? "}" : "]")) {
+            if (c === "{") {
+                const keyEnd = strEnd(k);
+                const key = JSON.parse(text.slice(k, keyEnd));
+                const v = jsonSpan(text, ws(keyEnd) + 1); // after the colon
+                keys.set(key, v);
+                k = ws(v.end);
+            }
+            else {
+                const v = jsonSpan(text, k);
+                items.push(v);
+                k = ws(v.end);
+            }
+            if (text[k] === ",")
+                k = ws(k + 1);
+        }
+        return c === "{" ? { start, end: k + 1, keys } : { start, end: k + 1, items };
+    }
+    let end = start;
+    while (end < text.length && !/[\s,\]}]/.test(text[end]))
+        end++;
+    return { start, end };
+}
+/**
+ * The settings written as the person's file is: what did not change exactly as its text has it, what did in its
+ * indentation (or compact, as the file is), its line breaks, the whitespace around it. A blank file or none: strom's
+ * way, two spaces and a line break at the end.
+ */
+function formatJson(s, text) {
+    if (text === undefined || !text.trim())
+        return JSON.stringify(s, null, 2) + "\n";
+    const body = text.trim();
+    const nl = body.includes("\r\n") ? "\r\n" : "\n";
+    // the first indented line is one level in; all on one line: compact (an empty {} says nothing: strom's way)
+    const indent = /\n([ \t]+)\S/.exec(body)?.[1] ?? (body.includes("\n") || /^\{\s*\}$/.test(body) ? "  " : "");
+    const same = (v, at) => JSON.stringify(v) === JSON.stringify(JSON.parse(text.slice(at.start, at.end)));
+    const write = (v, at, depth) => {
+        if (at && same(v, at))
+            return text.slice(at.start, at.end);
+        if (v === null || typeof v !== "object")
+            return JSON.stringify(v) ?? "null";
+        const entries = Array.isArray(v)
+            ? v.map((x, i) => [undefined, x, at?.items?.[i]])
+            : Object.entries(v).map(([k, x]) => [k, x, at?.keys?.get(k)]);
+        const [open, close] = Array.isArray(v) ? ["[", "]"] : ["{", "}"];
+        if (!entries.length)
+            return open + close;
+        const parts = entries.map(([k, x, sub]) => (k === undefined ? "" : JSON.stringify(k) + (indent ? ": " : ":")) + write(x, sub, depth + 1));
+        if (!indent)
+            return open + parts.join(",") + close;
+        const pad = (d) => indent.repeat(d);
+        return open + nl + parts.map((p) => pad(depth + 1) + p).join("," + nl) + nl + pad(depth) + close;
+    };
+    const lead = text.slice(0, text.length - text.trimStart().length);
+    return lead + write(s, jsonSpan(text, 0), 0) + text.slice(text.trimEnd().length);
+}
 function readMade(file) {
     try {
         const v = JSON.parse(fs.readFileSync(file, "utf8"));
@@ -287,10 +456,11 @@ function writeMade(file, m) {
     try {
         const files = m.files && Object.keys(m.files).length ? m.files : undefined;
         const dirs = m.dirs?.length ? [...new Set(m.dirs)].sort() : undefined;
-        if (!files && !dirs)
+        const json = m.json && Object.keys(m.json).length ? m.json : undefined;
+        if (!files && !dirs && !json)
             fs.rmSync(file, { force: true });
         else
-            writeFileAtomic(file, JSON.stringify({ ...(files ? { files } : {}), ...(dirs ? { dirs } : {}) }, null, 2) + "\n");
+            writeFileAtomic(file, JSON.stringify({ ...(files ? { files } : {}), ...(dirs ? { dirs } : {}), ...(json ? { json } : {}) }, null, 2) + "\n");
     }
     catch {
         // the user config not writable: the files stay as an uninstall without the record leaves them
@@ -312,31 +482,46 @@ function hasStrom(t, text) {
     const own = path.join(path.dirname(t.file), "strom.md");
     return (Array.isArray(s.instructions) && s.instructions.includes(own)) || (isObject(s.permission) && isObject(s.permission.bash) && OPENCODE_STROM in s.permission.bash);
 }
-/** Recorded after a write: the file created now, or the person's (one without strom's part); the folders made for it. */
-function noteWritten(t, before, firstDir) {
+/**
+ * Recorded after a write: the file created now, or the person's (one without strom's part); the folders made for it;
+ * in a settings file, what strom made in it (json).
+ */
+function noteWritten(t, before, firstDir, json) {
     const m = readMade(t.made);
     const files = { ...(m.files ?? {}) };
     const dirs = [...(m.dirs ?? [])];
+    const jsons = { ...(m.json ?? {}) };
+    const fresh = before === undefined || !hasStrom(t, before);
     if (before === undefined)
         files[t.file] = "created";
     // there without strom's part: the person's — also one recorded created, deleted since and made again by the person
-    else if (!hasStrom(t, before))
+    else if (fresh)
         files[t.file] = "existed";
     // strom's part already there: what is recorded stands; nothing recorded, an older installation's file — whose, nobody can tell
+    const prev = jsons[t.file];
+    const both = (a, b) => [...new Set([...(a ?? []), ...(b ?? [])])];
+    const kept = (j) => ({ ...(j.made?.length ? { made: j.made } : {}), ...(j.plain?.length ? { plain: j.plain } : {}), ...(j.blank !== undefined ? { blank: j.blank } : {}) });
+    if (json && fresh)
+        jsons[t.file] = kept(json);
+    else if (json && prev)
+        jsons[t.file] = kept({ ...prev, made: both(prev.made, json.made), plain: both(prev.plain, json.plain) });
+    // strom's part there and nothing recorded of it: an older installation's, taken away as it was before the record
     if (firstDir)
         for (let d = path.dirname(t.file);; d = path.dirname(d)) {
             dirs.push(d);
             if (d === firstDir || path.dirname(d) === d)
                 break;
         }
-    if (JSON.stringify(files) !== JSON.stringify(m.files ?? {}) || dirs.length !== (m.dirs ?? []).length)
-        writeMade(t.made, { files, dirs });
+    if (JSON.stringify(files) !== JSON.stringify(m.files ?? {}) || dirs.length !== (m.dirs ?? []).length || JSON.stringify(jsons) !== JSON.stringify(m.json ?? {}))
+        writeMade(t.made, { files, dirs, json: jsons });
 }
 /** Its part taken away: the file is the person's again (or gone); the folders strom made for it go when empty. */
 function noteRemoved(t) {
     const m = readMade(t.made);
     const files = { ...(m.files ?? {}) };
     delete files[t.file];
+    const json = { ...(m.json ?? {}) };
+    delete json[t.file];
     const here = path.dirname(t.file);
     const within = (d) => here === d || here.startsWith(d.endsWith(path.sep) ? d : d + path.sep);
     // deepest first: a folder strom made in another it made
@@ -353,12 +538,13 @@ function noteRemoved(t) {
         }
         return false;
     });
-    writeMade(t.made, { files, dirs });
+    writeMade(t.made, { files, dirs, json });
 }
 /** Write it for one agent; false when it was already there as it is. */
 export function installGlobal(t) {
     const cur = read(t.file);
     let next;
+    let json;
     if (t.kind === "allow" && t.agent === "grok") {
         const with_ = grokWith(cur ?? "");
         if (with_ === undefined)
@@ -369,8 +555,11 @@ export function installGlobal(t) {
         const s = settingsOf(cur);
         if (!s || hasAllow(t, s))
             return false;
-        addAllow(t, s);
-        next = JSON.stringify(s, null, 2) + "\n";
+        json = addAllow(t, s);
+        if (cur !== undefined && !cur.trim())
+            json.blank = cur;
+        // written as the person's file is: its indentation, its line breaks, a line break at its end or none
+        next = formatJson(s, cur);
     }
     else if (t.kind === "own")
         next = t.agent === "claude" || t.agent === "grok" ? skill(t.app) : globalText(t.app);
@@ -382,12 +571,13 @@ export function installGlobal(t) {
         return false;
     const firstDir = fs.mkdirSync(path.dirname(t.file), { recursive: true });
     writeFileAtomic(t.file, next);
-    noteWritten(t, cur, firstDir);
+    noteWritten(t, cur, firstDir, json);
     return true;
 }
 /** Take it away again; false when there was nothing of strom's. */
 export function uninstallGlobal(t) {
-    const removed = takeAway(t, readMade(t.made).files?.[t.file]);
+    const m = readMade(t.made);
+    const removed = takeAway(t, m.files?.[t.file], m.json?.[t.file]);
     if (removed)
         noteRemoved(t);
     return removed;
@@ -397,18 +587,17 @@ export function uninstallGlobal(t) {
  * an installation that recorded nothing stays as it did before the record — a settings file kept as {}, a text file
  * with nothing but strom's part gone.
  */
-function takeAway(t, made) {
+function takeAway(t, made, rec) {
     const cur = read(t.file);
     if (cur === undefined)
         return false;
     if (t.kind === "allow" && t.agent === "grok") {
-        if (!cur.includes(TOML_BEGIN))
+        if (!grokBlock(cur.split("\n")))
             return false;
+        // the person's text before and after strom's block as it was
         const rest = grokWithout(cur);
-        if (rest.trim())
-            writeFileAtomic(t.file, rest.replace(/\n{3,}/g, "\n\n").replace(/\s*$/, "\n"));
-        else if (made === "existed")
-            writeFileAtomic(t.file, "");
+        if (rest.trim() || made === "existed")
+            writeFileAtomic(t.file, rest);
         else
             fs.rmSync(t.file);
         return true;
@@ -419,11 +608,15 @@ function takeAway(t, made) {
         const any = t.agent === "opencode" ? s && hasAllow(t, s) : s && allowList(s).some((r) => isStromRule(t.agent, r));
         if (!s || !any)
             return false;
-        removeAllow(t, s);
+        removeAllow(t, s, rec);
         if (!Object.keys(s).length && made === "created")
             fs.rmSync(t.file);
+        // the person's blank file: blank again
+        else if (!Object.keys(s).length && rec?.blank !== undefined)
+            writeFileAtomic(t.file, rec.blank);
+        // written as the person's file is
         else
-            writeFileAtomic(t.file, JSON.stringify(s, null, 2) + "\n");
+            writeFileAtomic(t.file, formatJson(s, cur));
         return true;
     }
     if (t.kind === "own") {
@@ -455,8 +648,9 @@ export function isInstalled(t) {
     const cur = read(t.file);
     if (cur === undefined)
         return false;
+    // strom's block there, wherever the person's text puts it (an install brings it to this version where it is)
     if (t.kind === "allow" && t.agent === "grok")
-        return cur.includes(TOML_BEGIN) && grokWith(cur) === cur;
+        return grokBlock(cur.split("\n")) !== undefined;
     if (t.kind === "allow")
         return hasAllow(t, settingsOf(cur) ?? {});
     return t.kind === "own" || cur.includes(BEGIN);

package/dist/cli/ui.js

@@ -676,6 +676,7 @@ export const UI = {
     "ui.sync.do.title.user": "the edit wins (the research's in its history)",
     "ui.sync.sex.changed": "{n}. {who}: sex {text}",
     "ui.sync.note.new": "{n}. {who}: a note — “{text}”",
+    "ui.sync.note.changed": "{n}. {who}: a note — “{old}” → “{new}”",
     "ui.sync.source.new": "{n}. a source: “{text}”",
     "ui.sync.source.changed": "{n}. the file's source “{text}”: its transcript or page corrected",
     "ui.sync.source.reading": "{n}. the research's source “{text}”: read otherwise in the file",
@@ -725,6 +726,7 @@ export const UI = {
     "ui.sync.place.located": "{n}. {place}: on the map at {at}",
     "ui.sync.do.add": "added as a lead",
     "ui.sync.do.correct": "corrects the research's lead",
+    "ui.sync.do.note.changed": "that line of the research's note corrected",
     "ui.sync.do.detail": "added to the fact, citing the tree sent",
     "ui.sync.do.refine": "added to the fact, citing the tree sent (nothing in it disagrees with the record)",
     "ui.sync.do.conflict": "a conflict to decide (the research has it from a record)",

package/dist/commands/sync.js

@@ -102,8 +102,8 @@ function changeLine(tree, c, incoming, lang) {
         now: c.kind === "fact.detail" ? detailText(c.fact, lang, short) : factText(c.fact, lang, short),
         when: [humanDate(c.fact?.date, lang), humanPlace(c.fact?.place, undefined, lang)].filter(Boolean).join(", "),
         text: truncate(c.text ?? "", 120),
-        old: c.title ? truncate(c.title.was, 80) || "—" : shownName(c.wasName),
-        new: c.title ? truncate(c.text ?? "", 80) || "—" : shownName(c.text),
+        old: c.note ? truncate(c.note.was, 80) : c.title ? truncate(c.title.was, 80) || "—" : shownName(c.wasName),
+        new: c.note ? truncate(c.text ?? "", 80) : c.title ? truncate(c.text ?? "", 80) || "—" : shownName(c.text),
         title: c.title ? ui(lang, c.title.part === "before" ? "ui.conflict.titleBefore" : "ui.conflict.titleAfter") : "",
         child: name(c.child),
         // a child's tie to each parent: one word for both, else each parent's
@@ -138,17 +138,19 @@ function changeLine(tree, c, incoming, lang) {
                         ? "ui.sync.do.name.user"
                         : c.kind === "name.title" && (c.action === "add" || c.action === "user")
                             ? `ui.sync.do.title${c.action === "user" ? ".user" : ""}`
-                            : c.kind === "family.union" && c.action !== "report"
-                                ? "ui.sync.do.family.union"
-                                : c.kind === "fact.detail" && c.action === "add"
-                                    ? "ui.sync.do.detail"
-                                    : c.kind === "fact.part" && (c.action === "add" || c.action === "user")
-                                        ? `ui.sync.do.part${c.action === "user" ? ".user" : ""}`
-                                        : c.kind.startsWith("source.") || c.kind === "fact.cite" || c.kind === "person.cite" || c.kind === "family.cite"
-                                            ? `ui.sync.do.${c.kind}${c.reads || (c.kind === "source.new" && newReads(c, incoming)) ? ".read" : ""}`
-                                            : c.kind === "fact.new" && c.reads
-                                                ? "ui.sync.do.reading"
-                                                : `ui.sync.do.${c.action}`;
+                            : c.kind === "note.changed" && c.action !== "pick"
+                                ? "ui.sync.do.note.changed"
+                                : c.kind === "family.union" && c.action !== "report"
+                                    ? "ui.sync.do.family.union"
+                                    : c.kind === "fact.detail" && c.action === "add"
+                                        ? "ui.sync.do.detail"
+                                        : c.kind === "fact.part" && (c.action === "add" || c.action === "user")
+                                            ? `ui.sync.do.part${c.action === "user" ? ".user" : ""}`
+                                            : c.kind.startsWith("source.") || c.kind === "fact.cite" || c.kind === "person.cite" || c.kind === "family.cite"
+                                                ? `ui.sync.do.${c.kind}${c.reads || (c.kind === "source.new" && newReads(c, incoming)) ? ".read" : ""}`
+                                                : c.kind === "fact.new" && c.reads
+                                                    ? "ui.sync.do.reading"
+                                                    : `ui.sync.do.${c.action}`;
     // an archive: nobody reads a record there, nor is an agent told — said without it
     const said = isArchive(tree) && `${does}.archive` in UI ? `${does}.archive` : does;
     return `${ui(lang, key, v)} → ${ui(lang, said)}`;

package/dist/core/changelog.js

@@ -54,6 +54,7 @@ const SAID = {
     "story.approve": "log.story.approve",
     "story.discard": "log.story.discard",
     "note.add": "log.note.add",
+    "note.edit": "log.note.edit",
     "input.add": "log.input.add",
     "input.sync": "log.input.sync",
     "input.done": "log.input.done",

package/dist/core/phrases.js

@@ -173,6 +173,7 @@ export const PHRASES = {
     "log.repository.retract": "Archive withdrawn: {name}",
     "log.name.remove": "Name taken off: {name} – {who}",
     "log.note.remove": "Note taken off: \"{note}\" – {name}",
+    "log.note.edit": "Note corrected: {name}",
     "log.event.status": "How sure a fact is, changed: {who} – {fact}",
     "log.event.restore": "A fact back again: {who} – {fact}",
     "log.input.sync.undo": "Family tree taken back: {name}",

package/dist/core/sync.js

@@ -386,6 +386,39 @@ function knownNote(text, said) {
     // a word or two of the app's own ("Birth:", "Address:") around what the research said — never a short note all new
     return unknown.length <= w.size * 0.2 || (unknown.length < 3 && unknown.length * 2 <= w.size);
 }
+/** A line of a note as compared: NFC, its spaces one (the app joins what GEDCOM splits). */
+const noteLine = (t) => t.normalize("NFC").replace(/\s+/g, " ").trim();
+/** The words of a line as the user wrote them (lower case, accents kept, a letter alone too): what an edit changes. */
+const lineWords = (t) => new Set(t.normalize("NFC").toLowerCase().match(/[\p{L}\p{M}\p{N}]+/gu) ?? []);
+/**
+ * Of the research's lines, the one this line is an edit of: at least `share` of the words of the longer of the two in
+ * both (a year changed, a name corrected, a word added or taken away), the most of them.
+ */
+function closest(ours, line, share) {
+    const w = lineWords(line);
+    let best;
+    let most = 0;
+    for (const x of ours) {
+        const v = lineWords(x.line);
+        const both = [...w].filter((y) => v.has(y)).length;
+        if (both && both >= share * Math.max(w.size, v.size) && both > most)
+            [best, most] = [x, both];
+    }
+    return best;
+}
+/** A note with one of its lines (as compared) another: the first such line, the others as they are. */
+function swapLine(text, was, now) {
+    const lines = text.split("\n");
+    const i = lines.findIndex((l) => noteLine(l) === was);
+    if (i >= 0)
+        lines[i] = now;
+    return lines.join("\n");
+}
+/** The line only adds words around the research's ("Address: čp. 35" of "čp. 35"): the app's own shape, no line of its own. */
+function onlyAdds(ours, line) {
+    const w = lineWords(line);
+    return [...lineWords(ours)].every((y) => w.has(y));
+}
 /**
  * A tree the Strom app sent the bridge, with the version the app said with it (X-Strom-App-Version, ?app=) as its HEAD's
  * 2 VERS under 1 SOUR STROM, where the file names no version of the app (the app writes "1.0" there): the file is read
@@ -1988,13 +2021,52 @@ export function planSync(tree, incoming, edits, opts = {}) {
         if (fresh.length)
             push({ kind: owner.family || owner.partners ? "family.cite" : "person.cite", action: "add", ...owner, cites: fresh, ...(fresh.some((c) => reads(c.source)) ? { reads: true } : {}) });
     };
-    /** A note coming back holds the research's too (the app joins them): only its lines the research has not said. */
-    const notesDiff = (owner, inc, said, facts) => {
+    /**
+     * A note coming back holds the research's too (the app joins them): only its lines the research has not said. A line
+     * of the research's own note the user edited in the app (a year, a name: hardly a word else — N38, found with the
+     * app's 3.10.0-beta.13: "nothing new taken", the edit lost) is no line the research has said: the user's own note
+     * (typed by the user, or the app's) corrected, a session's kept and the user's line beside it (sync.edits user, an
+     * archive: corrected too); a line like one the note still has, a line of its own. A line as the app was given it
+     * (the base) is no edit: the research's since stays.
+     */
+    const notesDiff = (owner, inc, said, facts, mine) => {
         const words = new Set(wordsOf([...said, ...facts.map((f) => [f.place, f.value, f.label].join(" "))].join("\n")));
+        // what the research says, and what the app was given (the base: a copy older than the research's edit is no edit)
+        const exactly = new Set(said.flatMap((t) => t.split(/\n+/)).map(noteLine).filter(Boolean));
+        const sent = new Set((inc ?? []).flatMap((t) => t.split(/\n+/)).map(noteLine).filter(Boolean));
+        const ours = (mine ?? []).flatMap((n) => n.text.split(/\n+/).map(noteLine).filter(Boolean).map((line) => ({ note: n, line })));
+        const used = new Set();
         for (const t of inc ?? []) {
-            const fresh = t.split(/\n+/).filter((line) => line.trim() && !knownNote(line, words));
-            if (fresh.length && !knownNote(fresh.join("\n"), words))
-                push({ kind: "note.new", action: "add", ...owner, text: fresh.join("\n") });
+            const lines = t.split(/\n+/).map((line) => line.trim()).filter(Boolean);
+            const own = new Set();
+            const fresh = lines.filter((line) => {
+                const l = noteLine(line);
+                if (exactly.has(l))
+                    return false;
+                // an edit of a line the note no longer has; a line beside one it still has, like it but for a word or two
+                const edit = closest(ours.filter((x) => !used.has(x) && !sent.has(x.line)), l, 0.5);
+                const like = !edit && closest(ours.filter((x) => sent.has(x.line) && !onlyAdds(x.line, l)), l, 0.6);
+                if (edit) {
+                    used.add(edit);
+                    // a file that names no commit it stands on (an older export, another program's): which is newer nobody can
+                    // tell — only shown, taken with --only (N39: an older copy set the user's correction back)
+                    if (!base) {
+                        push({ kind: "note.changed", action: "pick", ...owner, text: line.normalize("NFC"), note: { at: edit.note.at, was: edit.line } });
+                        return false;
+                    }
+                    if (edit.note.by === "user" || edits === "user") {
+                        push({ kind: "note.changed", action: "correct", ...owner, text: line.normalize("NFC"), note: { at: edit.note.at, was: edit.line } });
+                        return false;
+                    }
+                }
+                if (edit || like)
+                    own.add(line);
+                return !edit && !like && !knownNote(line, words);
+            });
+            const take = fresh.length > 0 && !knownNote(fresh.join("\n"), words);
+            const out = lines.filter((line) => own.has(line) || (take && fresh.includes(line)));
+            if (out.length)
+                push({ kind: "note.new", action: "add", ...owner, text: out.join("\n") });
         }
     };
     // people
@@ -2081,7 +2153,7 @@ export function planSync(tree, incoming, edits, opts = {}) {
             const overGuess = mySex === "U" && guessed !== undefined && !incoming.sexU;
             push({ kind: "sex.changed", action: b ? (edits === "user" ? "user" : backed || since || overGuess ? "conflict" : "correct") : "report", person: id, name, text: p.sex });
         }
-        notesDiff({ person: id, name }, p.notes, [o.said, b?.said ?? "", ...o.names], o.facts);
+        notesDiff({ person: id, name }, p.notes, [o.said, b?.said ?? "", ...o.names], o.facts, tree.get(id)?.notes);
     }
     if (base && !partial)
         for (const [key, b] of base.persons)
@@ -2264,7 +2336,7 @@ export function planSync(tree, incoming, edits, opts = {}) {
         const both = [...new Set([...o.partners, ...partners])];
         factsDiff({ family: fam.id, partners: both }, f.facts, o.facts, b?.facts, true);
         citesDiff({ family: fam.id, partners: both }, f.cites, fam, b?.cites);
-        notesDiff({ family: fam.id, partners: both }, f.notes, [o.said ?? "", b?.said ?? "", ...both.map((k) => ours.persons.get(k)?.names.join(" ") ?? "")], o.facts);
+        notesDiff({ family: fam.id, partners: both }, f.notes, [o.said ?? "", b?.said ?? "", ...both.map((k) => ours.persons.get(k)?.names.join(" ") ?? "")], o.facts, fam.notes);
         // how the couple is bound (no record proves it): the user's word where it changed since given, or where the research
         // has none; another word with nothing to stand on only said; none in the file takes nothing away (an older app)
         // (the one partner's married or divorced is the couple's facts' to say once the unknown one is named)
@@ -3410,6 +3482,23 @@ export function applySync(tree, plan, incoming, source, only) {
                     applied.push({ do: "note.add", id: owner, before: n.at });
                     break;
                 }
+                case "note.changed": {
+                    // the user's edit of a line of the research's note: that line of it corrected, the rest of the note as it was
+                    if (!owner || !c.text || !c.note)
+                        break;
+                    const { at, was } = c.note;
+                    const edited = noteLine(c.text);
+                    const rec = tree.get(owner);
+                    if (!rec?.notes.some((n) => n.at === at && n.text.split("\n").some((l) => noteLine(l) === was)))
+                        break;
+                    update(tree, owner, typeOfId(owner) === "family" ? "family" : "person", (o) => ({ ...o, notes: o.notes.map((n) => (n.at === at ? { ...n, text: swapLine(n.text, was, edited) } : n)) }), {
+                        op: "note.edit",
+                        summary: `${owner} note "${truncateText(was, 50)}" → "${truncateText(edited, 50)}": the user's edit (${reason})`,
+                        reason,
+                    });
+                    applied.push({ do: "note.edit", id: owner, before: JSON.stringify({ at, now: edited, was }) });
+                    break;
+                }
                 case "sex.changed": {
                     if (!owner || !c.text)
                         break;
@@ -3911,6 +4000,19 @@ export function undoSync(tree, input) {
                     : { op: "person.edit", summary: `${a.id} shown by its name before again: ${reason}`, reason });
                 break;
             }
+            case "note.edit": {
+                // the line as it was, back in its note (the note as it is now otherwise)
+                const b = JSON.parse(String(a.before ?? "{}"));
+                const rec = tree.get(a.id);
+                if (!b.at || !b.now || !b.was || !rec?.notes.some((n) => n.at === b.at && n.text.split("\n").some((l) => noteLine(l) === b.now)))
+                    break;
+                update(tree, a.id, typeOfId(a.id) === "family" ? "family" : "person", (o) => ({ ...o, notes: o.notes.map((n) => (n.at === b.at ? { ...n, text: swapLine(n.text, b.now, b.was) } : n)) }), {
+                    op: "note.edit",
+                    summary: `${a.id} note "${truncateText(b.now, 50)}" → "${truncateText(b.was, 50)}" again: ${reason}`,
+                    reason,
+                });
+                break;
+            }
             case "note.add":
                 update(tree, a.id, typeOfId(a.id) ?? "person", (o) => ({ ...o, notes: o.notes.filter((x) => x.at !== a.before) }), { op: "note.remove", summary: `${a.id} note "${noteText(tree, a.id, a.before)}" removed: ${reason}`, reason });
                 break;

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.13.0-beta.6";
+export const VERSION = "1.13.0-beta.7";
 const GITIGNORE = `# Strom Research — local state and large files are not versioned
 .strom/
 /media/

package/package.json

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