strom-research 1.26.0-beta.8 → 1.26.1

package/CHANGELOG.cs.md

@@ -5,9 +5,21 @@
 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.26.1
+
+*4. 11. 2026 · patří k aplikaci Strom 3.22.0.*
+
+- **Přerušený zápis už výzkum natrvalo nezablokuje.** Příkaz zastavený mezi `git add` a commitem (ukončený agentem, nebo
+  na Windows s indexem gitu drženým jiným programem) mohl nechat své soubory v indexu gitu: každý další zápis pak končil
+  „data výzkumu se změnila mimo strom“, ačkoli `strom verify` ani `strom repair` nic nenašly. Nové soubory, které takový
+  zápis nechá v indexu (ve složce už nejsou a v historii nikdy nebyly), nejsou ničí změna – další zápis je sám vrátí a
+  pokračuje. `strom repair` vrátí vždy celý index k zapečetěnému stavu, i se změnou záznamu, která v něm zůstala. Zámek,
+  který nechal git ukončený uprostřed práce (`.git/index.lock`, starší než 10 minut), `strom repair` odstraní a zápis,
+  který na něm skončí, to řekne. Záznam opravdu smazaný nebo upravený mimo strom se hlásí jako dřív.
+
 ## 1.26.0
 
-*Připravuje se: bety do 1.26.0-beta.8. Oddíl bude úplný s vydáním.*
+*4. 11. 2026 · patří k aplikaci Strom 3.22.0.*
 
 - **Linie výzkumu z aplikace Strom: založit, upravit, pozastavit, seřadit.** Linii jde v aplikaci založit nebo upravit
   (osoba, směr, otázka, meze), pozastavit, ukončit nebo znovu spustit; pořadí linií je pořadí práce a stránka telefonu

package/CHANGELOG.de.md

@@ -5,9 +5,24 @@
 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.26.1
+
+*4.11.2026 · gehört zur Strom-App 3.22.0.*
+
+- **Ein unterbrochenes Schreiben sperrt die Forschung nicht mehr auf Dauer.** Ein Befehl, der zwischen `git add` und dem
+  Commit endete (vom Agenten beendet oder unter Windows mit einem Index von git, den ein anderes Programm hielt), konnte
+  seine Dateien im Index von git lassen: jedes weitere Schreiben endete mit „die Daten der Forschung wurden außerhalb
+  von strom geändert“, obwohl `strom verify` und `strom repair` nichts fanden. Die neuen Dateien, die ein solches
+  Schreiben im Index lässt (nicht mehr im Ordner, nie in der Geschichte), sind niemandes Änderung – das nächste
+  Schreiben nimmt sie von selbst heraus und macht weiter. `strom repair` setzt immer den ganzen Index auf den
+  versiegelten Stand zurück, auch mit einer dort gebliebenen Änderung eines Eintrags. Eine Sperre, die ein mitten in der
+  Arbeit beendetes git hinterließ (`.git/index.lock`, älter als 10 Minuten), entfernt `strom repair`, und ein Schreiben,
+  das daran scheitert, sagt es. Ein wirklich außerhalb von strom gelöschter oder geänderter Eintrag wird wie bisher
+  gemeldet.
+
 ## 1.26.0
 
-*In Vorbereitung: die Betas bis 1.26.0-beta.8. Der Abschnitt ist mit dem Release vollständig.*
+*4.11.2026 · gehört zur Strom-App 3.22.0.*
 
 - **Die Linien der Forschung aus der Strom-App: anlegen, ändern, pausieren, ordnen.** Eine Linie lässt sich in der App
   anlegen oder ändern (Person, Richtung, Frage, Grenzen), pausieren, beenden oder wieder aufnehmen; die Reihenfolge der

package/CHANGELOG.md

@@ -5,9 +5,22 @@ English · [Čeština](CHANGELOG.cs.md) · [Deutsch](CHANGELOG.de.md) · [Polski
 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.26.1
+
+*2026-11-04 · goes with the Strom app 3.22.0.*
+
+- **A write cut short no longer blocks the research for good.** A command stopped between strom's `git add` and its
+  commit (ended by the agent, or git's index held by another program on Windows) could leave its files in git's index:
+  every write after it ended with "data was changed outside strom", while `strom verify` and `strom repair` found
+  nothing. The new files such a write leaves in the index — gone from the folder, never in the history — are no change
+  of anybody's: the next write takes them out by itself and goes on. `strom repair` always puts the whole index back to
+  the sealed state, a record's change left there too. A lock a git ended mid-way left (`.git/index.lock`, older than 10
+  minutes) is taken away by `strom repair`, and a write refused by it says so. A record truly deleted or edited outside
+  strom is said as ever.
+
 ## 1.26.0
 
-*In preparation: the betas up to 1.26.0-beta.8. The section is complete with the release.*
+*2026-11-04 · goes with the Strom app 3.22.0.*
 
 - **The lines of the research from the Strom app: created, changed, paused, put in order.** A line is created or changed
   in the app (its person, direction, question, limits), paused, ended or taken up again; the order of the lines is the

package/CHANGELOG.pl.md

@@ -5,9 +5,22 @@
 Zmiany każdej wersji w skrócie. Pełne informacje o wydaniach i polecenia instalacji są na
 [GitHub Releases](https://github.com/ACiDekCZ/strom-research/releases) (po angielsku).
 
+## 1.26.1
+
+*4.11.2026 · współpracuje z aplikacją Strom 3.22.0.*
+
+- **Przerwany zapis już nie blokuje badania na stałe.** Polecenie zatrzymane między `git add` a commitem (zakończone
+  przez agenta albo w Windows z indeksem gita trzymanym przez inny program) mogło zostawić swoje pliki w indeksie gita:
+  każdy kolejny zapis kończył się komunikatem „dane badania zmieniły się poza strom”, choć `strom verify` ani `strom
+  repair` nic nie znalazły. Nowe pliki, które taki zapis zostawia w indeksie (nie ma ich już w folderze, w historii
+  nigdy nie były), nie są niczyją zmianą – następny zapis sam je wycofa i działa dalej. `strom repair` zawsze przywraca
+  cały indeks do zapieczętowanego stanu, także ze zmianą rekordu, która w nim została. Blokadę zostawioną przez git
+  przerwany w trakcie pracy (`.git/index.lock`, starszą niż 10 minut) `strom repair` usuwa, a zapis, który na niej się
+  kończy, mówi o tym. Rekord naprawdę usunięty lub zmieniony poza strom jest zgłaszany jak dotąd.
+
 ## 1.26.0
 
-*W przygotowaniu: bety do 1.26.0-beta.8. Sekcja będzie kompletna z wydaniem.*
+*4.11.2026 · współpracuje z aplikacją Strom 3.22.0.*
 
 - **Linie badania z aplikacji Strom: założyć, zmienić, wstrzymać, uporządkować.** Linię można w aplikacji założyć lub
   zmienić (osoba, kierunek, pytanie, granice), wstrzymać, zakończyć lub wznowić; kolejność linii to kolejność pracy, a

package/assets/lang/cs.json

@@ -1884,6 +1884,12 @@
   "ui.check.streetplaces": "{n, plural, one {# údaj má} few {# údaje mají} other {# údajů má}} v místě ulici nebo číslo domu",
   "ui.error.tree.not-downloaded": "z iCloudu ještě nestaženo: {n, plural, one {# soubor} few {# soubory} other {# souborů}} výzkumu (první: {first}) – nic se nezapsalo",
   "ui.error.tree.not-downloaded.hint": "otevřít složku výzkumu ve Finderu a soubory stáhnout (nebo složku z iCloud Drive vyjmout), pak spustit znovu – ne strom repair",
+  "ui.error.tree.index-leftovers": "v indexu gitu zůstalo, co nechal přerušený zápis ({n, plural, one {# soubor} few {# soubory} other {# souborů}}, první: {first}), a git to nedokázal vrátit – nic se nezapsalo",
+  "ui.error.tree.index-leftovers.hint": "strom repair   (vrátí index gitu k poslednímu zapečetěnému stavu; pak spustit příkaz znovu)",
+  "ui.error.git.index-locked": "index gitu je zamčený (.git/index.lock) – ve výzkumu pracuje jiný git, nebo zámek nechal git ukončený uprostřed práce",
+  "ui.error.git.index-locked.hint": "strom repair   (odstraní zámek, který žádný git nedrží déle než 10 minut; pak spustit příkaz znovu)",
+  "ui.error.repair.index": "git nedokázal vrátit svůj index k zapečetěnému stavu",
+  "ui.error.repair.index.hint": "zavřít programy, které mohou držet složku výzkumu (synchronizace, kontrola antiviru, jiný git), pak znovu strom repair",
   "ui.error.tree.changed-outside": "data výzkumu se změnila mimo strom ({n, plural, one {# problém} few {# problémy} other {# problémů}}): nic se nezapsalo",
   "ui.error.tree.changed-outside.hint": "strom verify   (podrobnosti)\nstrom repair   (vrátí poslední zapečetěný stav)",
   "ui.error.tree.changed-outside.keys.hint": "strom verify   (podrobnosti)\nstrom repair, pak strom seal adopt   (vrátí jen to, co se udělalo mimo strom – práce obou klíčů tohoto počítače zůstane)",
@@ -3444,6 +3450,8 @@
   "ui.repair.removed": "odebráno  {file}",
   "ui.repair.from": "zapečetěný stav: {commit} · kopie nahrazených souborů: .strom/quarantine/",
   "ui.repair.still": "{n, plural, one {zbývá # problém} few {zbývají # problémy} other {zbývá # problémů}} → strom verify",
+  "ui.repair.lock": "odstraněno  .git/index.lock – zámek gitu ukončeného uprostřed práce",
+  "ui.repair.index": "index gitu vrácen k zapečetěnému stavu: {n, plural, one {# soubor} few {# soubory} other {# souborů}} po přerušeném zápisu (ve složce se nic nezměnilo)",
   "ui.error.seal.repair-in-terminal": "výzkum „{name}“ obsahuje práci zapečetěnou klíčem stromu z terminálu, který strom spuštěný z aplikace nevidí: nic se neopravilo",
   "ui.error.seal.repair-in-terminal.hint": "ve vlastním terminálu: strom repair, pak strom seal adopt – ten vidí oba klíče a vrátí jen to, co se udělalo mimo strom",
   "ui.error.back.busy": "na výzkumu se právě pracuje: návrat až po skončení práce",

package/assets/lang/de.json

@@ -1884,6 +1884,12 @@
   "ui.check.streetplaces": "{n, plural, one {# Angabe hat} other {# Angaben haben}} eine Straße oder eine Nummer im Ort",
   "ui.error.tree.not-downloaded": "noch nicht aus iCloud geladen: {n, plural, one {# Datei} other {# Dateien}} der Forschung (die erste: {first}) – nichts wurde geschrieben",
   "ui.error.tree.not-downloaded.hint": "den Ordner der Forschung im Finder öffnen und die Dateien laden (oder den Ordner aus iCloud Drive herausnehmen), dann erneut ausführen – nicht strom repair",
+  "ui.error.tree.index-leftovers": "im Index von git ist geblieben, was ein unterbrochenes Schreiben hinterlassen hat ({n, plural, one {# Datei} other {# Dateien}}, die erste: {first}), und git konnte es nicht herausnehmen – nichts wurde geschrieben",
+  "ui.error.tree.index-leftovers.hint": "strom repair   (setzt den Index von git auf den letzten versiegelten Stand zurück; dann den Befehl erneut ausführen)",
+  "ui.error.git.index-locked": "der Index von git ist gesperrt (.git/index.lock) – ein anderes git arbeitet in der Forschung, oder ein mitten in der Arbeit beendetes git hat seine Sperre hinterlassen",
+  "ui.error.git.index-locked.hint": "strom repair   (entfernt eine Sperre, die seit 10 Minuten kein git mehr hält; dann den Befehl erneut ausführen)",
+  "ui.error.repair.index": "git konnte seinen Index nicht auf den versiegelten Stand zurücksetzen",
+  "ui.error.repair.index.hint": "Programme schließen, die den Ordner der Forschung halten könnten (Synchronisierung, Virenscan, ein anderes git), dann erneut strom repair",
   "ui.error.tree.changed-outside": "die Daten der Forschung wurden außerhalb von strom geändert ({n, plural, one {# Problem} other {# Probleme}}): nichts wurde geschrieben",
   "ui.error.tree.changed-outside.hint": "strom verify   (Einzelheiten)\nstrom repair   (stellt den letzten versiegelten Stand wieder her)",
   "ui.error.tree.changed-outside.keys.hint": "strom verify   (Einzelheiten)\nstrom repair, dann strom seal adopt   (macht nur rückgängig, was außerhalb von strom geschah – die Arbeit beider Schlüssel dieses Computers bleibt)",
@@ -3444,6 +3450,8 @@
   "ui.repair.removed": "entfernt           {file}",
   "ui.repair.from": "versiegelter Stand: {commit} · Kopien ersetzter Dateien: .strom/quarantine/",
   "ui.repair.still": "noch {n, plural, one {# Problem} other {# Probleme}} → strom verify",
+  "ui.repair.lock": "entfernt  .git/index.lock – die Sperre eines mitten in der Arbeit beendeten git",
+  "ui.repair.index": "Index von git auf den versiegelten Stand zurückgesetzt: {n, plural, one {# Datei} other {# Dateien}} nach einem unterbrochenen Schreiben (im Ordner hat sich nichts geändert)",
   "ui.error.seal.repair-in-terminal": "die Forschung „{name}“ enthält Arbeit, versiegelt mit dem Schlüssel des strom aus dem Terminal, den ein aus einer App gestartetes strom nicht sieht: nichts wurde repariert",
   "ui.error.seal.repair-in-terminal.hint": "in einem eigenen Terminal: strom repair, dann strom seal adopt – es sieht beide Schlüssel und macht nur rückgängig, was außerhalb von strom geschah",
   "ui.error.back.busy": "an dieser Forschung wird gerade gearbeitet: eine Rückkehr erst, wenn die Arbeit beendet ist",

package/assets/lang/pl.json

@@ -1884,6 +1884,12 @@
   "ui.check.streetplaces": "{n, plural, one {# fakt ma} few {# fakty mają} many {# faktów ma} other {# faktów ma}} w miejscu ulicę lub numer domu",
   "ui.error.tree.not-downloaded": "jeszcze nie pobrano z iCloud: {n, plural, one {# plik} few {# pliki} many {# plików} other {# plików}} badania (pierwszy: {first}) – nic nie zapisano",
   "ui.error.tree.not-downloaded.hint": "otworzyć folder badania w Finderze i pobrać pliki (albo wyjąć folder z iCloud Drive), potem uruchomić ponownie – nie strom repair",
+  "ui.error.tree.index-leftovers": "w indeksie gita zostało to, co zostawił przerwany zapis ({n, plural, one {# plik} few {# pliki} many {# plików} other {# plików}}, pierwszy: {first}), a git nie zdołał tego wycofać – nic nie zapisano",
+  "ui.error.tree.index-leftovers.hint": "strom repair   (przywraca indeks gita do ostatniego zapieczętowanego stanu; potem uruchomić polecenie ponownie)",
+  "ui.error.git.index-locked": "indeks gita jest zablokowany (.git/index.lock) – w badaniu pracuje inny git albo blokadę zostawił git przerwany w trakcie pracy",
+  "ui.error.git.index-locked.hint": "strom repair   (usuwa blokadę, której żaden git nie trzyma dłużej niż 10 minut; potem uruchomić polecenie ponownie)",
+  "ui.error.repair.index": "git nie zdołał przywrócić swojego indeksu do zapieczętowanego stanu",
+  "ui.error.repair.index.hint": "zamknąć programy, które mogą trzymać folder badania (synchronizacja, skanowanie antywirusowe, inny git), potem ponownie strom repair",
   "ui.error.tree.changed-outside": "dane badania zmieniły się poza strom ({n, plural, one {# problem} few {# problemy} many {# problemów} other {# problemów}}): nic nie zapisano",
   "ui.error.tree.changed-outside.hint": "strom verify   (szczegóły)\nstrom repair   (przywraca ostatni zapieczętowany stan)",
   "ui.error.tree.changed-outside.keys.hint": "strom verify   (szczegóły)\nstrom repair, potem strom seal adopt   (cofa tylko to, co zrobiono poza strom – praca obu kluczy tego komputera zostaje)",
@@ -3444,6 +3450,8 @@
   "ui.repair.removed": "usunięto     {file}",
   "ui.repair.from": "stan zapieczętowany: {commit} · kopie zastąpionych plików: .strom/quarantine/",
   "ui.repair.still": "{n, plural, one {zostaje # problem} few {zostają # problemy} many {zostaje # problemów} other {zostaje # problemów}} → strom verify",
+  "ui.repair.lock": "usunięto  .git/index.lock – blokada gita przerwanego w trakcie pracy",
+  "ui.repair.index": "indeks gita przywrócony do zapieczętowanego stanu: {n, plural, one {# plik} few {# pliki} many {# plików} other {# plików}} po przerwanym zapisie (w folderze nic się nie zmieniło)",
   "ui.error.seal.repair-in-terminal": "badanie „{name}” zawiera pracę zapieczętowaną kluczem strom z terminala, którego strom uruchomiony z aplikacji nie widzi: nic nie naprawiono",
   "ui.error.seal.repair-in-terminal.hint": "we własnym terminalu: strom repair, potem strom seal adopt – ten widzi oba klucze i cofa tylko to, co zrobiono poza strom",
   "ui.error.back.busy": "nad badaniem właśnie trwa praca: powrót dopiero po jej zakończeniu",

package/dist/cli/commit.js

@@ -47,6 +47,10 @@ export function autoCommit(ctx, def) {
                 written.add(f.path);
         for (const f of tree.opsFilesTouched())
             written.add(f);
+        // what an interrupted write left in git's index (core/integrity.ts leftoverOf): its paths with the commit's own, so
+        // the commit takes the folder as it is there — never a record or log of nobody's into the history
+        for (const f of snap.leftovers)
+            written.add(f);
         // an archive: no agent edits its free-form folders — a person's own file in notes/ is theirs, never swept into a
         // commit of something else (found on Windows: strom mode committed a file of the user's) — nor by the switch itself
         const free = isArchive(tree) || def.path[0] === "mode" ? ["inputs", "output"] : ["notes", "tools", "inputs", "output"];

package/dist/cli/ui.js

@@ -1866,6 +1866,12 @@ export const UI = {
     "ui.check.streetplaces": "{n, plural, one {# fact holds} other {# facts hold}} a street or a house number in the place",
     "ui.error.tree.not-downloaded": "{n, plural, one {# file} other {# files}} of the research not downloaded from iCloud yet (the first: {first}) — nothing written",
     "ui.error.tree.not-downloaded.hint": "open the research's folder in Finder and download them (or take the folder out of iCloud Drive), then run it again — not strom repair",
+    "ui.error.tree.index-leftovers": "git's index still holds what an interrupted write left ({n, plural, one {# file} other {# files}}, the first: {first}) and git could not take it out — nothing written",
+    "ui.error.tree.index-leftovers.hint": "strom repair   (puts git's index back to the last sealed state; then run the command again)",
+    "ui.error.git.index-locked": "git's index is locked (.git/index.lock) — another git is at work in the research, or one that ended mid-way left its lock",
+    "ui.error.git.index-locked.hint": "strom repair   (takes away a lock no git has held for 10 minutes; then run the command again)",
+    "ui.error.repair.index": "git could not put its index back to the sealed state",
+    "ui.error.repair.index.hint": "programs that may hold the research's folder closed (a sync tool, an antivirus scan, another git), then strom repair again",
     "ui.error.tree.changed-outside": "the research's data was changed outside strom ({n, plural, one {# problem} other {# problems}}): nothing written",
     "ui.error.tree.changed-outside.hint": "strom verify   (details)\nstrom repair   (restores the last sealed state)",
     "ui.error.tree.changed-outside.keys.hint": "strom verify   (details)\nstrom repair, then strom seal adopt   (undoes only what was done outside strom — the work of both keys of this computer stays)",
@@ -3099,6 +3105,8 @@ export const UI = {
     "ui.repair.removed": "removed   {file}",
     "ui.repair.from": "sealed state: {commit} · copies of replaced files: .strom/quarantine/",
     "ui.repair.still": "still {n, plural, one {# problem} other {# problems}} → strom verify",
+    "ui.repair.lock": "taken away  .git/index.lock — the lock of a git that ended mid-way",
+    "ui.repair.index": "git's index back to the sealed state: {n, plural, one {# file} other {# files}} an interrupted write had left there (nothing in the folder changed)",
     "ui.error.seal.repair-in-terminal": "\"{name}\" holds work sealed with the key of the terminal's strom, which a strom started by an app cannot see: nothing repaired",
     "ui.error.seal.repair-in-terminal.hint": "in a terminal of its own: strom repair, then strom seal adopt — it sees both keys and undoes only what was done outside strom",
     "ui.error.back.busy": "somebody is at work on this research: a return only once the work is finished",

package/dist/commands/checks.js

@@ -171,10 +171,20 @@ function repair(tree) {
             params: { name: tree.config.name },
         });
     const headSealed = head !== undefined && head.hash === sealed;
+    // a lock of git's index a git that ended mid-way left (killed with the command that ran it): no git holds it any
+    // more — taken away, else nothing could be written again (a fresh one may be a git at work: left)
+    const stale = git.staleIndexLock(tree.root);
+    if (stale)
+        fs.rmSync(stale, { force: true });
     // Paths to compare: whatever differs between the sealed commit and the working tree.
     const candidates = new Set();
-    for (const c of git.changes(tree.root, SEALED_PATHS))
+    // …and what git's index holds otherwise than the last commit (a write taken back after its git add): back to it
+    const staged = [];
+    for (const c of git.changes(tree.root, SEALED_PATHS)) {
         candidates.add(c.path);
+        if (!" ?!".includes(c.code[0] ?? " "))
+            staged.push(c.path);
+    }
     if (!headSealed) {
         const r = git.runGit(tree.root, ["diff", "--name-only", "-z", sealed, "HEAD", "--", ...SEALED_PATHS]);
         for (const p of r.stdout.split("\0").filter(Boolean))
@@ -204,7 +214,17 @@ function repair(tree) {
     // commit stays unsealed and every write refused, with nothing left to repair
     if (!headSealed)
         tree.commit(`Repair: restore the sealed state of ${sealed.slice(0, 8)}\n\nCommits made outside strom were undone for data/, strom.json, history/ and quality/.`, SEALED_PATHS, true);
-    return { restored, quarantined, from: sealed, resealed: !headSealed };
+    // the folder as the sealed commit, HEAD: git's index as HEAD too (a commit above put it so already)
+    else if (staged.length) {
+        const said = git.unstage(tree.root, staged);
+        if (said !== undefined)
+            throw new StromError(`git could not put its index back to the sealed state: ${said}`, {
+                hint: "programs that may hold the research's folder closed (a sync tool, an antivirus scan, another git), then strom repair again",
+                code: "repair.index",
+                details: staged.slice(0, 50),
+            });
+    }
+    return { restored, quarantined, from: sealed, resealed: !headSealed, unstaged: headSealed ? staged.length : 0, lock: !!stale };
 }
 register({
     path: ["repair"],
@@ -225,11 +245,15 @@ register({
         const after = verifyFast(tree).findings.filter((f) => f.level === "error" && f.code !== OTHER_KEY);
         const unite = !!tree.key && otherKeys(tree.env, tree.config.id, tree.key).length > 0 && keysToUnite(tree).length > 0;
         const next = unite ? ui(lang, "ui.repair.unite") : undefined;
+        // what an interrupted write left (a stale lock of git's index, what it staged): said before the rest
+        const index = [...(r.lock ? [ui(lang, "ui.repair.lock")] : []), ...(r.unstaged ? [ui(lang, "ui.repair.index", { n: r.unstaged })] : [])];
         const text = r.restored.length + r.quarantined.length === 0
             ? r.resealed
-                ? lines(ui(lang, "ui.repair.resealed"), next)
-                : lines(ui(lang, "ui.repair.nothing"), next)
-            : lines(...r.restored.map((file) => ui(lang, "ui.repair.restored", { file })), ...r.quarantined.map((file) => ui(lang, "ui.repair.removed", { file })), ui(lang, "ui.repair.from", { commit: r.from.slice(0, 8) }), after.length ? ui(lang, "ui.repair.still", { n: after.length }) : next);
+                ? lines(...index, ui(lang, "ui.repair.resealed"), next)
+                : index.length
+                    ? lines(...index, after.length ? ui(lang, "ui.repair.still", { n: after.length }) : next)
+                    : lines(ui(lang, "ui.repair.nothing"), next)
+            : lines(...index, ...r.restored.map((file) => ui(lang, "ui.repair.restored", { file })), ...r.quarantined.map((file) => ui(lang, "ui.repair.removed", { file })), ui(lang, "ui.repair.from", { commit: r.from.slice(0, 8) }), after.length ? ui(lang, "ui.repair.still", { n: after.length }) : next);
         return { text, data: { ...r, ok: after.length === 0, ...(unite ? { unite: "strom seal adopt" } : {}) }, exitCode: after.length ? 1 : 0 };
     },
 }, {

package/dist/core/git.js

@@ -128,7 +128,22 @@ export function runGitLater(cwd, args, timeoutMs = 60_000) {
 /** A git that failed: interrupted, refused writing into the research (git.unwritable), or its own words. */
 function gitFailed(cwd, args, r, what = `git ${args[0]}`) {
     const said = r.stderr.trim() || r.stdout.trim();
-    return gitInterrupted(args, r) ?? (gitRefusedWords(said) ? gitUnwritable(gitRefusedWhere(cwd, said), said) : new StromError(`${what} failed: ${said}`));
+    return gitInterrupted(args, r) ?? (gitRefusedWords(said) ? gitUnwritable(gitRefusedWhere(cwd, said), said) : indexLocked(said) ? indexLockedError(what, said) : new StromError(`${what} failed: ${said}`));
+}
+/** git refused because its index is locked ("Unable to create '…/index.lock': File exists"). */
+function indexLocked(said) {
+    return /index\.lock['"]?: File exists/u.test(said);
+}
+/**
+ * git's index locked: another git at work in the research, or the lock a git that ended mid-way left (killed with the
+ * command that ran it). Never "remove the file manually" for a person: strom repair takes a stale one away.
+ */
+function indexLockedError(what, said) {
+    return new StromError(`${what} failed: git's index is locked (.git/index.lock) — another git is at work in the research, or one that ended mid-way left its lock`, {
+        hint: "strom repair   (takes away a lock no git has held for 10 minutes; then run the command again)",
+        code: "git.index-locked",
+        details: [said],
+    });
 }
 function git(cwd, args, input) {
     const r = runGit(cwd, args, input);
@@ -408,16 +423,41 @@ export function changes(dir, pathspec = []) {
 }
 /**
  * Take these paths out of what is staged, back to HEAD (a command taken back after its git add, its commit not made:
- * nothing it wrote stays staged, seen as changed outside strom). Best effort: what fails stays as git left it.
+ * nothing it wrote stays staged, seen as changed outside strom). Each path on the command line, in parts (pathParts —
+ * never --pathspec-from-file, which a git before 2.25 does not know). Never throws: git's words when it could not (its
+ * index held by another program, a lock a git that ended mid-way left), else undefined — the next write, or strom
+ * repair, takes the rest out (core/integrity.ts settleLeftovers).
  */
 export function unstage(dir, paths) {
     if (paths.length === 0 || !hasHead(dir))
-        return;
+        return undefined;
+    let said;
+    for (const part of pathParts(paths.map((p) => p.replace(/\\/g, "/")))) {
+        try {
+            const r = runGit(dir, ["reset", "-q", "--", ...part]);
+            if (r.status !== 0)
+                said ??= r.stderr.trim() || r.stdout.trim() || `git reset ended with ${r.status}`;
+        }
+        catch (e) {
+            said ??= e.message;
+        }
+    }
+    return said;
+}
+/** The lock git keeps on its index while it writes it ('.git/index.lock'). */
+export function indexLock(dir) {
+    return path.join(dir, ".git", "index.lock");
+}
+/** How old a lock of git's index is stale: no git holds its index for minutes (it writes it in a moment). */
+export const STALE_INDEX_LOCK_MS = 10 * 60_000;
+/** A lock of git's index a git that ended mid-way left (stale: STALE_INDEX_LOCK_MS old), else undefined. */
+export function staleIndexLock(dir, now = Date.now()) {
+    const lock = indexLock(dir);
     try {
-        runGit(dir, ["reset", "-q", "--pathspec-from-file=-", "--pathspec-file-nul"], paths.map((p) => p.replace(/\\/g, "/")).join("\0") + "\0");
+        return now - fs.statSync(lock).mtimeMs >= STALE_INDEX_LOCK_MS ? lock : undefined;
     }
     catch {
-        // git gone or ended: the next command's check says what is left
+        return undefined;
     }
 }
 /** File content at a revision, or undefined if it did not exist there. */

package/dist/core/integrity.js

@@ -34,9 +34,51 @@ export function isHistoryPath(p) {
 }
 export function snapshot(tree) {
     if (!git.hasHead(tree.root))
-        return { changes: [], head: new Map() };
-    const changes = git.changes(tree.root, SEALED_PATHS);
-    return { changes, head: git.showFiles(tree.root, "HEAD", changes.map((c) => c.path)) };
+        return { changes: [], head: new Map(), leftovers: [] };
+    const all = git.changes(tree.root, SEALED_PATHS);
+    const head = git.showFiles(tree.root, "HEAD", all.map((c) => c.path));
+    const leftovers = all.filter((c) => leftoverOf(tree.root, c, head.get(c.path))).map((c) => c.path);
+    const changes = leftovers.length ? all.filter((c) => !leftovers.includes(c.path)) : all;
+    return { changes, head, leftovers };
+}
+/**
+ * What a write taken back after its git add left in git's index (found on Windows, 1.26.0: its files put back, the
+ * process ended or git's index held by another program before they were taken out of it — every write after it refused,
+ * "data was changed outside strom", its new log and record said deleted): a path the index holds while it is neither
+ * in the last commit nor in the folder. Nothing of it was ever in the history and nothing of it is in the folder: no
+ * change of anybody's. Only that: a file of the last commit deleted or edited (staged or not), or the index alone
+ * differing from a file of the last commit, is still said — strom repair puts that back (its index with it).
+ */
+function leftoverOf(root, c, committed) {
+    // added to the index ("AD": a path the last commit does not have, so git says) — never a deletion or a change of a
+    // path of the last commit, whatever was read of it
+    if (c.code[0] !== "A")
+        return false;
+    const abs = path.join(root, c.path);
+    return committed === undefined && !fs.existsSync(abs) && !inCloudOnly(abs);
+}
+/**
+ * Take what an interrupted write left in git's index out of it (back to the last commit) before strom writes: else its
+ * next commit would hold it — a record or a log in the history that is in no folder. Under the tree's lock. git's words
+ * when it could not (its index held, a lock left), else undefined.
+ */
+export function settleLeftovers(tree, snap) {
+    if (!snap.leftovers.length || tree.dryRun)
+        return undefined;
+    return git.unstage(tree.root, snap.leftovers);
+}
+/**
+ * Writing refused while git's index holds what an interrupted write left and git could not take it out: the way is
+ * strom repair (it takes away a lock no git holds any more), never "changed outside strom".
+ */
+export function leftoversError(files, said) {
+    const first = files[0] ?? "data/";
+    return new StromError(`git's index still holds what an interrupted write left (${counted(Math.max(1, files.length), "file")}, the first: ${first}) and git could not take it out — nothing written`, {
+        hint: "strom repair   (puts git's index back to the last sealed state; then run the command again)",
+        code: "tree.index-leftovers",
+        params: { n: String(Math.max(1, files.length)), first },
+        details: [said, ...files.slice(0, 50)],
+    });
 }
 const RECORD_DIRS = new Set(Object.values(RECORD_TYPES).map((d) => `data/${d.dir}/`));
 function isRecordPath(p) {
@@ -478,7 +520,11 @@ export function writableUnasked(tree) {
     if (!tree.key)
         return false;
     try {
-        return !verifyFast(tree).findings.some((f) => f.level === "error");
+        const snap = snapshot(tree);
+        // what an interrupted write left in git's index: out of it first, or no write (its commit would hold it)
+        if (settleLeftovers(tree, snap) !== undefined)
+            return false;
+        return !verifyFast(tree, snap).findings.some((f) => f.level === "error");
     }
     catch {
         return false;
@@ -499,10 +545,15 @@ export function lastSealed(tree, key) {
 export const REPAIR_IN_TERMINAL_HINT = "the user runs in their terminal: strom repair, then strom seal adopt   (it sees both keys and undoes only what was done outside strom)";
 /** Refuse to write on top of data that was changed outside strom. */
 export function assertIntact(tree) {
-    const { findings } = verifyFast(tree);
+    const snap = snapshot(tree);
+    const { findings } = verifyFast(tree, snap);
     const errors = findings.filter((f) => f.level === "error");
     if (errors.length === 0) {
         tree.requireKey();
+        // what an interrupted write left in git's index (no change of anybody's): out of it before this write commits
+        const said = settleLeftovers(tree, snap);
+        if (said !== undefined)
+            throw leftoversError(snap.leftovers, said);
         return;
     }
     // the last commit sealed with another key of this computer: the person unites them (never strom repair)

package/dist/core/tree.js

@@ -31,7 +31,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.26.0-beta.8";
+export const VERSION = "1.26.1";
 const GITIGNORE = `# Strom Research — local state and large files are not versioned
 .strom/
 /media/
@@ -384,7 +384,8 @@ export class Tree {
                 failed ??= e;
             }
         }
-        // what a commit that did not happen staged (its git add done): back to HEAD, nothing seen as changed outside strom
+        // what a commit that did not happen staged (its git add done): back to HEAD, nothing seen as changed outside strom —
+        // what git could not take out now (its index held, the process ending) the next write or strom repair takes out
         if (restored.length && !this.dryRun)
             git.unstage(this.root, restored);
         this.undo.clear();

package/package.json

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