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

package/CHANGELOG.cs.md

@@ -7,7 +7,7 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
 
 ## 1.19.0
 
-*Připravuje se: bety do 1.19.0-beta.7. Oddíl bude úplný s vydáním.*
+*Připravuje se: bety do 1.19.0-beta.8. Oddíl bude úplný s vydáním.*
 
 - **Na archiv, který zmlkl, se čeká, místo opakovaných dotazů.** Když archiv přestane odpovídat, strom ho nechá na
   pokoji hodinu — a když týž den mlčí dál, dvě a pak čtyři hodiny — a agent se dozví, do kdy: mezitím dělá
@@ -16,7 +16,8 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
 - **První úklid staršího výzkumu se jednou nabídne.** Výzkum, u kterého se nastřádalo hodně dat dřív, než si v tom
   strom začal sám dělat pořádek (záznamy práce, náhledy snímků a podobně), dostane v menu jednu nabídku: co by se
   smazalo, kolik a proč — bez souhlasu nic. Po souhlasu se v tom pak udržuje pořádek samo; po odmítnutí menu a
-  nastavení dál říkají, co jde uvolnit.
+  nastavení dál říkají, co jde uvolnit. `strom pack`, odebrání rodokmenu i menu uvádějí velikost balíku, zálohy nebo
+  snímků jako všude jinde (1,5 MB, u malých 24 kB), nikdy „0.0 MB“.
 - **Digitální knihovny napoprvé správně.** U Krameria Národní knihovny ČR a Moravské zemské knihovny a u ANNO
   Rakouské národní knihovny dostane agent jejich vlastní vyhledávací adresy — méně neúspěšných dotazů a hádání.
 - **Ostřejší část snímku se opravdu čte.** Když z archivu přišla část snímku v lepším rozlišení, agent i jeho čtenáři
@@ -43,8 +44,21 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
   agent nebo model (`strom fixes run <id> --agent <a> --model <m>`), s tím, kdo četl dřív; ten, kdo tu číst nemůže, se
   odmítne hned i s těmi, kdo mohou. Čas napravení se zaokrouhluje nahoru a po zkoušce se přepočítá podle čtení, jak
   běžela souběžně.
-- **Velikosti tak, jak je píše jazyk výzkumu.** `strom pack`, odebrání rodokmenu i menu uvádějí velikost balíku,
-  zálohy nebo snímků jako všude jinde (1,5 MB, u malých 24 kB), nikdy „0.0 MB“.
+- **Rodokmen, do kterého strom nesmí zapisovat, řekne proč.** strom zapíše do složky výzkumu pravidla pro Codex:
+  příkaz strom spuštěný samotný jde mimo sandbox Codexu — i na Windows, kde sandbox držel historii výzkumu zavřenou
+  a nic jiného nepustil — a co rozhoduje člověk a samotný git zůstává zakázané. Když zápisu do složky rodokmenu
+  sandbox agenta přesto brání, strom to řekne a agentovi poradí, co dělat podle toho, jak běží — spouštět strom
+  samotný, spustit Codex ve složce výzkumu, které důvěřuje, nebo nechat příkaz schválit mimo sandbox — místo holého
+  „chybí oprávnění“, které agent převyprávěl jako „nemám přístup k rodokmenu“. Kde agent nenechá žádnou svou značku,
+  pozná ho strom podle vlastní značky u agentů, které spouští, nebo podle programů, které ho spustily, a jako
+  pravděpodobnou příčinu jmenuje jeho sandbox, potom OneDrive nebo řízený přístup ke složkám ve Windows. Odmítnutý
+  zápis do historie se už nehlásí jako chybějící oprávnění k samotnému gitu a záloha nebo aktualizace, kterou nešlo
+  zapsat, žádá složku, do které lze zapisovat, a už neradí uvolnit místo na disku. `strom doctor` a `strom check`
+  zápis do výzkumu zkusí a řeknou, když nejde, i tam, kde složku nejde ani vypsat. Na disku bez pevných odkazů
+  (síťové úložiště, disk přesměrovaný přes Vzdálenou plochu) strom zase zapisuje, zámek jde jinou cestou, a zámek,
+  který pomalý disk ještě neukáže, už se po chvilce nepřebírá; rodokmen, který tam nejde založit, po sobě nic nenechá
+  a řekne to v jazyce výzkumu. Po instalaci přes npm na Windows spustí strom příkaz `strom.cmd` i tam, kde PowerShell
+  skripty odmítá.
 
 ## 1.18.0
 

package/CHANGELOG.de.md

@@ -7,7 +7,7 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
 
 ## 1.19.0
 
-*In Vorbereitung: die Betas bis 1.19.0-beta.7. Der Abschnitt ist mit dem Release vollständig.*
+*In Vorbereitung: die Betas bis 1.19.0-beta.8. Der Abschnitt ist mit dem Release vollständig.*
 
 - **Auf ein verstummtes Archiv wird gewartet, statt es immer wieder zu fragen.** Antwortet ein Archiv nicht mehr,
   lässt strom es eine Stunde in Ruhe — zwei, dann vier, wenn es am selben Tag still bleibt — und der Agent erfährt, bis
@@ -16,8 +16,10 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
   immer wieder angefragt.
 - **Das erste Aufräumen einer älteren Forschung wird einmal angeboten.** Eine Forschung, neben der sich viel
   angesammelt hat, bevor strom dort selbst Ordnung hielt (Protokolle der Arbeitssitzungen, Ansichten von Scans und
-  Ähnliches), bekommt im Menü ein Angebot: was ginge, wie viel und warum — ohne Ja geht nichts. Nach einem Ja wird dort
-  von selbst Ordnung gehalten; nach einem Nein sagen Menü und Einstellungen weiter, was sich freigeben lässt.
+  Ähnliches), bekommt im Menü ein Angebot: was ginge, wie viel und warum — ohne Ja geht nichts. Nach einem Ja wird
+  dort von selbst Ordnung gehalten; nach einem Nein sagen Menü und Einstellungen weiter, was sich freigeben lässt.
+  `strom pack`, das Entfernen eines Stammbaums und das Menü nennen die Größe eines Pakets, einer Sicherung oder der
+  Bilder wie überall sonst (1,5 MB, bei kleinen 24 kB), nie „0.0 MB“.
 - **Digitale Bibliotheken beim ersten Versuch richtig durchsucht.** Für Kramerius der Tschechischen
   Nationalbibliothek und der Mährischen Landesbibliothek und für ANNO der Österreichischen Nationalbibliothek bekommt
   der Agent die eigenen Suchadressen der Bibliotheken — weniger fehlgeschlagene Anfragen und weniger Raten.
@@ -50,9 +52,24 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
   bereiter Agent oder ein anderes Modell (`strom fixes run <id> --agent <a> --model <m>`), mit dem, der vorher las;
   einer, der hier nicht lesen kann, wird sofort abgelehnt, mit denen, die es können. Die Zeit einer Behebung wird
   aufgerundet und nach dem Versuch nach den nebeneinander gelaufenen Lesungen neu gemessen.
-- **Größen, wie die Sprache der Forschung sie schreibt.** `strom pack`, das Entfernen eines Stammbaums und das Menü
-  nennen die Größe eines Pakets, einer Sicherung oder der Bilder wie überall sonst (1,5 MB, bei kleinen 24 kB), nie
-  „0.0 MB“.
+- **Ein Stammbaum, in den strom nicht schreiben darf, sagt warum.** strom schreibt Regeln für Codex in den Ordner der
+  Forschung: ein allein ausgeführter strom-Befehl läuft außerhalb der Sandbox von Codex — auch unter Windows, wo die
+  Sandbox den Verlauf der Forschung verschlossen hielt und nichts anderes zuließ —, während das, was der Mensch
+  entscheidet, und git selbst verboten bleiben. Hindert die Sandbox eines Agenten strom trotzdem am Schreiben in den
+  Ordner des Stammbaums, sagt strom das und sagt dem Agenten, was zu tun ist, je nachdem, wie er läuft — strom allein
+  ausführen, Codex im Ordner der Forschung starten, dem er vertraut, oder den Befehl außerhalb der Sandbox genehmigen
+  lassen — statt eines bloßen „keine Berechtigung“, das der Agent als fehlenden Zugriff auf den Stammbaum wiedergab.
+  Wo ein Agent kein eigenes Merkmal hinterlässt, erkennt strom ihn an seinem eigenen Merkmal bei den Agenten, die es
+  startet, oder an den Programmen, die es gestartet haben, und nennt seine Sandbox als wahrscheinliche Ursache, danach
+  OneDrive oder den überwachten Ordnerzugriff von Windows. Ein vom Verlauf verweigertes Schreiben gilt nicht mehr als
+  fehlende Berechtigung für git selbst, und eine Sicherung oder ein Update, die nicht geschrieben werden konnten,
+  verlangen einen Ordner, in den geschrieben werden darf, statt Platz auf dem Datenträger freizumachen. `strom doctor`
+  und `strom check` versuchen, in die Forschung zu schreiben, und sagen, wenn es nicht geht, auch dort, wo sich der
+  Ordner nicht einmal auflisten lässt. Auf einem Laufwerk ohne feste Verknüpfungen (eine Netzwerkfreigabe, ein über
+  Remotedesktop umgeleitetes Laufwerk) schreibt strom wieder, seine Sperre geht einen anderen Weg, und eine Sperre, die
+  ein langsames Laufwerk noch nicht zeigt, wird nicht mehr nach einem Augenblick übernommen; ein Stammbaum, der sich
+  dort nicht anlegen lässt, hinterlässt nichts und sagt es in der Sprache der Forschung. Mit npm unter Windows
+  installiert, startet `strom.cmd` strom auch dort, wo PowerShell Skripte verweigert.
 
 ## 1.18.0
 

package/CHANGELOG.md

@@ -7,16 +7,17 @@ The changes of each version in short. The full notes and the install lines are o
 
 ## 1.19.0
 
-*In preparation: the betas up to 1.19.0-beta.7. The section is complete with the release.*
+*In preparation: the betas up to 1.19.0-beta.8. The section is complete with the release.*
 
 - **An archive that went silent is waited for, not asked again and again.** When an archive stops answering, strom
   leaves it alone for an hour — two, then four when it stays silent the same day — and the agent hears until when:
   it goes on with other work, lets a download in the background wait for the archive (up to 30 minutes) and go on by
   itself, or closes the session to go on later. No more asking the archive over and over meanwhile.
-- **The first tidy of an older research is offered once.** A research that gathered much beside it before strom
-  kept order there by itself (logs of work sessions, views of scans and the like) gets one offer in the menu: what
-  would go, how much and why, and nothing goes without a yes. After a yes it is kept in order by itself; after a no,
-  the menu and the settings keep saying what can be freed.
+- **The first tidy of an older research is offered once.** A research that gathered much beside it before strom kept
+  order there by itself (logs of work sessions, views of scans and the like) gets one offer in the menu: what would
+  go, how much and why, and nothing goes without a yes. After a yes it is kept in order by itself; after a no, the
+  menu and the settings keep saying what can be freed. `strom pack`, removing a family tree and the menu say how big a
+  package, a backup or the images are as everywhere else (1,5 MB in Czech, 24 kB for a small one), never "0.0 MB".
 - **Digital libraries searched right at the first try.** For Kramerius of the Czech National Library and of the
   Moravian Library and for ANNO of the Austrian National Library, the agent gets the libraries' own search
   addresses — fewer failed requests and less guessing.
@@ -46,8 +47,21 @@ The changes of each version in short. The full notes and the install lines are o
   ordering them. The remedy may be read by another agent or model ready here (`strom fixes run <id> --agent <a>
   --model <m>`), with which one read before said; one that cannot read here is refused at once, with those that can.
   The time of a remedy is rounded up and, after the trial, measured again by the readings as they ran side by side.
-- **Sizes as the research's language writes them.** `strom pack`, removing a family tree and the menu say how big a
-  package, a backup or the images are as everywhere else (1,5 MB in Czech, 24 kB for a small one), never "0.0 MB".
+- **A family tree strom may not write into says why.** strom writes Codex's rules into the research's folder: a strom
+  command run on its own goes outside Codex's sandbox — on Windows too, where the sandbox kept the research's history
+  closed and let nothing else run — while what the person decides and git itself stay forbidden. When an agent's
+  sandbox still keeps strom from writing into the family tree's folder, strom says so and tells the agent what to do as
+  it is there — run strom on its own, start Codex in the research's folder it trusts, or have the command approved
+  outside the sandbox — instead of a bare "no permission" the agent retold as no access to the family tree. Where an
+  agent leaves no mark of its own, strom knows it by its own mark on the agents it starts, or by the programs that
+  started it, and names its sandbox as the likely cause, then OneDrive or the controlled folder access of Windows. A
+  write the history refused is no longer said as missing rights to git itself, and a backup or an update that could not
+  be written asks for a folder with the right to write in it, no longer to free room on the disk. `strom doctor` and
+  `strom check` try writing into the research and say when it does not go, also where the folder cannot even be
+  listed. On a disk without hard links (a network share, a drive redirected over Remote Desktop) strom writes again,
+  its lock made another way, and a lock a slow disk does not show yet is no longer taken over after a moment; a family
+  tree that cannot be created there leaves nothing behind, said in the research language. Installed with npm on
+  Windows, `strom.cmd` runs strom where PowerShell refuses scripts.
 
 ## 1.18.0
 

package/README.md

@@ -34,7 +34,10 @@ Nothing needs admin rights.
 - **macOS, Linux**:
   `curl -fsSL https://raw.githubusercontent.com/ACiDekCZ/strom-research/main/install/install.sh | sh`
 
-With Node 22.18 or newer: `npm install -g strom-research`.
+With Node 22.18 or newer: `npm install -g strom-research`. On Windows the
+installer above is the recommended way: installed with npm, PowerShell may
+refuse `strom` ("running scripts is disabled on this system") — `strom.cmd`
+runs it.
 
 The setup asks a few things — language, where to keep the research, which
 agent (it finds the installed ones and offers Claude if there is none), the

package/assets/lang/cs.json

@@ -610,6 +610,20 @@
   "ui.doc.appurl.env.fix": "proměnnou STROM_APP_URL nastavit na adresu aplikace Strom ({web}, nebo její kopie na tomto počítači http://127.0.0.1:<port>/), nebo odebrat",
   "ui.doc.tree.ok": "{name}: data v pořádku a zapečetěná",
   "ui.doc.tree.bad": "{name}: {n, plural, one {# problém} few {# problémy} other {# problémů}}",
+  "ui.doc.write": "zápis do rodokmenu",
+  "ui.doc.write.ok": "do jeho .strom i .git lze zapisovat",
+  "ui.doc.write.sandbox": "{where}: zápis odepřen – strom běží pod agentem, nejspíš to zakazuje jeho sandbox",
+  "ui.doc.write.sandbox.fix": "spustit příkaz mimo sandbox agenta, nebo dát agentovi složku výzkumu jako zapisovatelnou",
+  "ui.doc.write.sandbox.fix.codex-strom": "spouštět strom samotný, bez roury a cd (pravidla .codex ve složce výzkumu ho pustí ze sandboxu Codexu; Codex je čte ve složce, které důvěřuje – znovu je zapíše strom agents sync), nebo schválit příkaz mimo sandbox Codexu (Codex se zeptá), nebo v nastavení zvolit úroveň „plná“ – volba jen člověka",
+  "ui.doc.write.sandbox.fix.codex": "spustit Codex ve složce výzkumu a důvěřovat jí (pravidla .codex v ní pustí strom ze sandboxu), nebo ho spustit přes strom („Pokračovat ve výzkumu s agentem“ v menu, nebo strom chat), nebo schválit příkaz mimo jeho sandbox",
+  "ui.doc.write.sandbox.fix.claude": "spustit Claude Code ve složce výzkumu (strom chat to tak dělá), nebo schválit příkaz mimo jeho sandbox",
+  "ui.doc.write.refused": "{where}: zápis odepřen – chybí právo zápisu",
+  "ui.doc.write.refused.fix": "složka, do které lze zapisovat",
+  "ui.doc.write.refused.fix.windows": "složka, do které lze zapisovat – zápisu může bránit i OneDrive nebo řízený přístup ke složkám v Zabezpečení Windows",
+  "ui.doc.write.refused.fix.agent": "strom spustil {agent}: nejspíš jeho sandbox – příkaz schválit mimo něj, nebo {agent} nechat pracovat na úrovni bez sandboxu; jinak složka, do které lze zapisovat",
+  "ui.doc.write.refused.fix.agent.windows": "strom spustil {agent}: nejspíš jeho sandbox – příkaz schválit mimo něj, nebo {agent} nechat pracovat na úrovni bez sandboxu; jinak složka, do které lze zapisovat – zápisu může bránit i OneDrive nebo řízený přístup ke složkám v Zabezpečení Windows",
+  "ui.doc.write.nolink": "{where}: disk neumí pevné odkazy – zámek jede náhradní cestou (pomalejší, když pracuje víc procesů naráz)",
+  "ui.doc.write.nolink.fix": "složka na vlastním disku tohoto počítače",
   "ui.doc.allok": "Všechno potřebné je na místě.",
   "ui.doc.problems": "{n, plural, one {# problém} few {# problémy} other {# problémů}} – co udělat, říkají šipky (strom setup nabídne instalaci toho, co chybí).",
   "ui.menu.fix": "Opravit to hned?",
@@ -1516,6 +1530,7 @@
   "ui.check.found": "{errors, plural, one {# chyba} few {# chyby} other {# chyb}}, {warnings} varování",
   "ui.check.unproven": "pozn.: osob, které nestojí na žádném vlastním záznamu: {n} → strom person list --unproven",
   "ui.check.counter": "počítadlo {prefix} zaostává za existujícími čísly (srovná se samo při příštím zápisu)",
+  "ui.check.unwritable": "zápis sem je odepřen – proč, řekne strom doctor",
   "ui.export.file": "{file} ({for}) — {persons, plural, one {# osoba} few {# osoby} other {# osob}} · {families, plural, one {# rodina} few {# rodiny} other {# rodin}} · {facts, plural, one {# údaj} few {# údaje} other {# údajů}} · {sources, plural, one {# pramen} few {# prameny} other {# pramenů}}{skipped}",
   "ui.export.for.strom": "pro aplikaci Strom",
   "ui.export.for.strom.images": "pro aplikaci Strom, s obrázky",
@@ -2194,10 +2209,24 @@
   "ui.error.pack.missing.hint": "zadat ZIP soubor, který přišel (přetáhnout ho do terminálu)",
   "ui.error.pack.no-manifest": "v {path} není {manifest}: není to výzkum zabalený stromem",
   "ui.error.pack.no-manifest.hint": "zadat ZIP soubor, který přišel",
-  "ui.error.fs.no-permission": "chybí oprávnění{where}",
+  "ui.error.fs.no-permission": "chybí oprávnění: {where}",
   "ui.error.fs.no-permission.hint": "vybrat složku, do které lze zapisovat",
   "ui.error.fs.held": "soubor {file} drží jiný program (antivirus, synchronizace nebo záloha, editor)",
   "ui.error.fs.held.hint": "za chvíli spustit tentýž příkaz znovu – nic z něj se neuložilo",
+  "ui.error.fs.no-permission.windows.hint": "vybrat složku, do které lze zapisovat – na Windows může zápisu bránit i OneDrive nebo řízený přístup ke složkám v Zabezpečení Windows",
+  "ui.error.fs.no-permission.agent.hint": "strom spustil {agent} a zápis nejspíš zakazuje jeho sandbox: příkaz schválit mimo sandbox, nebo {agent} nechat pracovat na úrovni bez sandboxu; jinak vybrat složku, do které lze zapisovat",
+  "ui.error.fs.no-permission.agent.windows.hint": "strom spustil {agent} a zápis nejspíš zakazuje jeho sandbox: příkaz schválit mimo sandbox, nebo {agent} nechat pracovat na úrovni bez sandboxu; jinak vybrat složku, do které lze zapisovat – na Windows může zápisu bránit i OneDrive nebo řízený přístup ke složkám v Zabezpečení Windows",
+  "ui.error.fs.no-permission.unseen.hint": "strom nevidí programy, které ho spustily, jako v sandboxu agenta: když strom spustil agent, zápis nejspíš zakazuje jeho sandbox – příkaz schválit mimo sandbox; jinak vybrat složku, do které lze zapisovat",
+  "ui.error.fs.no-permission.unseen.windows.hint": "strom nevidí programy, které ho spustily, jako v sandboxu agenta: když strom spustil agent, zápis nejspíš zakazuje jeho sandbox – příkaz schválit mimo sandbox; jinak vybrat složku, do které lze zapisovat – na Windows může zápisu bránit i OneDrive nebo řízený přístup ke složkám v Zabezpečení Windows",
+  "ui.error.fs.sandboxed": "chybí oprávnění: {where} – strom běží pod agentem a nejspíš to zakazuje jeho sandbox",
+  "ui.error.fs.sandboxed.hint": "spustit příkaz mimo sandbox agenta, nebo pracovat ve složce výzkumu (i s jejími .git a .strom zapisovatelnými)",
+  "ui.error.git.unwritable": "git nemůže zapisovat do výzkumu: {where}",
+  "ui.error.git.unwritable.hint": "vybrat složku, do které lze zapisovat",
+  "ui.error.fs.folder": "místo souboru je zadaná složka: {path}",
+  "ui.error.init.unwritable": "rodokmen nejde založit v {where}: zápis tam je odepřen – nic z něj tam nezůstalo",
+  "ui.error.init.unwritable.hint": "vybrat složku, do které lze zapisovat",
+  "ui.error.init.failed": "rodokmen nejde založit v {where}: {detail} – nic z něj tam nezůstalo",
+  "ui.error.init.failed.hint": "složka na vlastním disku tohoto počítače (síťový nebo přesměrovaný disk může zápis nebo historii odmítnout)",
   "ui.task.none": "Žádné úkoly.",
   "ui.research.none": "Žádné linie výzkumu.",
   "ui.person.none": "Žádné osoby.",
@@ -2270,6 +2299,10 @@
   "ui.error.backup.failed.hint": "Uvolnit místo na disku ({where}) a spustit strom znovu – nebo se vrátit: strom update --channel {back}",
   "ui.error.backup.failed.update": "Zálohu před přechodem z {from} na {to} se nepodařilo vytvořit: {detail}. Nic se nenainstalovalo.",
   "ui.error.backup.failed.update.hint": "Uvolnit místo na disku ({where}) a znovu strom update --channel {channel}",
+  "ui.error.backup.failed.refused.hint": "Zápis do {where} je odepřen: vybrat složku, do které lze zapisovat, pak spustit strom znovu – nebo se vrátit: strom update --channel {back}",
+  "ui.error.backup.failed.other.hint": "Spustit strom znovu (víc řekne strom doctor) – nebo se vrátit: strom update --channel {back}",
+  "ui.error.backup.failed.update.refused.hint": "Zápis do {where} je odepřen: vybrat složku, do které lze zapisovat, pak znovu strom update --channel {channel}",
+  "ui.error.backup.failed.update.other.hint": "Znovu strom update --channel {channel} (víc řekne strom doctor)",
   "ui.error.folder.in-program": "{folder} leží ve složce programu strom {program} – aktualizace ji nahrazuje a odinstalace odstraňuje, výzkum by šel s ní. Nic se nezměnilo.",
   "ui.error.folder.in-program.hint": "Zvolit složku mimo ni, například {suggested}",
   "ui.error.folder.in-program.default.hint": "Zadat složku mimo ni: strom setup --home \"{suggested}\" --yes",

package/assets/lang/de.json

@@ -610,6 +610,20 @@
   "ui.doc.appurl.env.fix": "die Variable STROM_APP_URL auf eine Adresse der Strom-App setzen ({web}, oder eine Kopie auf diesem Computer http://127.0.0.1:<port>/) oder entfernen",
   "ui.doc.tree.ok": "{name}: Daten in Ordnung und versiegelt",
   "ui.doc.tree.bad": "{name}: {n, plural, one {# Problem} other {# Probleme}}",
+  "ui.doc.write": "Schreiben in diesen Stammbaum",
+  "ui.doc.write.ok": "in sein .strom und .git kann geschrieben werden",
+  "ui.doc.write.sandbox": "{where}: Schreiben verweigert – strom läuft unter einem Agenten, wahrscheinlich verbietet es dessen Sandbox",
+  "ui.doc.write.sandbox.fix": "den Befehl außerhalb der Sandbox des Agenten ausführen, oder dem Agenten den Ordner der Forschung als beschreibbar geben",
+  "ui.doc.write.sandbox.fix.codex-strom": "strom allein ausführen, ohne Pipe und cd (die Regeln in .codex im Ordner der Forschung lassen es aus der Sandbox von Codex; Codex liest sie in einem Ordner, dem es vertraut – strom agents sync schreibt sie neu), oder den Befehl außerhalb der Sandbox von Codex genehmigen (Codex fragt), oder in den Einstellungen die Stufe „voll“ wählen – allein die Wahl des Menschen",
+  "ui.doc.write.sandbox.fix.codex": "Codex im Ordner der Forschung starten und ihm vertrauen (die Regeln in .codex lassen strom aus der Sandbox), oder über strom starten („Die Forschung mit dem Agenten fortsetzen“ im Menü, oder strom chat), oder den Befehl außerhalb seiner Sandbox genehmigen",
+  "ui.doc.write.sandbox.fix.claude": "Claude Code im Ordner der Forschung starten (strom chat tut das), oder den Befehl außerhalb seiner Sandbox genehmigen",
+  "ui.doc.write.refused": "{where}: Schreiben verweigert – keine Schreibberechtigung",
+  "ui.doc.write.refused.fix": "ein Ordner, in den geschrieben werden darf",
+  "ui.doc.write.refused.fix.windows": "ein Ordner, in den geschrieben werden darf – auch OneDrive oder der überwachte Ordnerzugriff der Windows-Sicherheit kann das Schreiben verhindern",
+  "ui.doc.write.refused.fix.agent": "strom wurde von {agent} gestartet: vermutlich dessen Sandbox – den Befehl außerhalb genehmigen oder {agent} auf einer Stufe ohne Sandbox arbeiten lassen; sonst ein Ordner, in den geschrieben werden darf",
+  "ui.doc.write.refused.fix.agent.windows": "strom wurde von {agent} gestartet: vermutlich dessen Sandbox – den Befehl außerhalb genehmigen oder {agent} auf einer Stufe ohne Sandbox arbeiten lassen; sonst ein Ordner, in den geschrieben werden darf – auch OneDrive oder der überwachte Ordnerzugriff der Windows-Sicherheit kann das Schreiben verhindern",
+  "ui.doc.write.nolink": "{where}: das Laufwerk kann keine festen Verknüpfungen – die Sperre geht einen anderen Weg (langsamer, wenn mehrere zugleich arbeiten)",
+  "ui.doc.write.nolink.fix": "ein Ordner auf der eigenen Festplatte dieses Computers",
   "ui.doc.allok": "Alles Nötige ist vorhanden.",
   "ui.doc.problems": "{n, plural, one {# Problem} other {# Probleme}} – den Pfeilen folgen (strom setup bietet an, Fehlendes zu installieren).",
   "ui.menu.fix": "Jetzt beheben?",
@@ -1516,6 +1530,7 @@
   "ui.check.found": "{errors} Fehler, {warnings, plural, one {# Warnung} other {# Warnungen}}",
   "ui.check.unproven": "Hinweis: Personen, die sich auf keinen eigenen Eintrag stützen: {n} → strom person list --unproven",
   "ui.check.counter": "Zähler {prefix} liegt hinter den vorhandenen Nummern (gleicht sich beim nächsten Schreiben selbst aus)",
+  "ui.check.unwritable": "Schreiben hierher verweigert – warum, sagt strom doctor",
   "ui.export.file": "{file} ({for}) — {persons, plural, one {# Person} other {# Personen}} · {families, plural, one {# Familie} other {# Familien}} · {facts, plural, one {# Angabe} other {# Angaben}} · {sources, plural, one {# Quelle} other {# Quellen}}{skipped}",
   "ui.export.for.strom": "für die Strom-App",
   "ui.export.for.strom.images": "für die Strom-App, mit Bildern",
@@ -2194,10 +2209,24 @@
   "ui.error.pack.missing.hint": "die ZIP-Datei angeben, die gekommen ist (ins Terminal ziehen)",
   "ui.error.pack.no-manifest": "keine {manifest} in {path}: keine von strom gepackte Forschung",
   "ui.error.pack.no-manifest.hint": "die ZIP-Datei angeben, die gekommen ist",
-  "ui.error.fs.no-permission": "keine Berechtigung{where}",
+  "ui.error.fs.no-permission": "keine Berechtigung: {where}",
   "ui.error.fs.no-permission.hint": "einen Ordner wählen, in den geschrieben werden darf",
   "ui.error.fs.held": "ein anderes Programm hält {file} (Virenschutz, Synchronisation oder Sicherung, Editor)",
   "ui.error.fs.held.hint": "denselben Befehl gleich noch einmal ausführen – nichts davon wurde gespeichert",
+  "ui.error.fs.no-permission.windows.hint": "einen Ordner wählen, in den geschrieben werden darf – unter Windows kann auch OneDrive oder der überwachte Ordnerzugriff der Windows-Sicherheit das Schreiben verhindern",
+  "ui.error.fs.no-permission.agent.hint": "strom wurde von {agent} gestartet, und vermutlich verbietet dessen Sandbox das Schreiben: den Befehl außerhalb der Sandbox genehmigen oder {agent} auf einer Stufe ohne Sandbox arbeiten lassen; sonst einen Ordner wählen, in den geschrieben werden darf",
+  "ui.error.fs.no-permission.agent.windows.hint": "strom wurde von {agent} gestartet, und vermutlich verbietet dessen Sandbox das Schreiben: den Befehl außerhalb der Sandbox genehmigen oder {agent} auf einer Stufe ohne Sandbox arbeiten lassen; sonst einen Ordner wählen, in den geschrieben werden darf – unter Windows kann auch OneDrive oder der überwachte Ordnerzugriff der Windows-Sicherheit das Schreiben verhindern",
+  "ui.error.fs.no-permission.unseen.hint": "strom sieht die Programme nicht, die es gestartet haben, wie in der Sandbox eines Agenten: wurde strom von einem Agenten gestartet, verbietet vermutlich dessen Sandbox das Schreiben – den Befehl außerhalb der Sandbox genehmigen; sonst einen Ordner wählen, in den geschrieben werden darf",
+  "ui.error.fs.no-permission.unseen.windows.hint": "strom sieht die Programme nicht, die es gestartet haben, wie in der Sandbox eines Agenten: wurde strom von einem Agenten gestartet, verbietet vermutlich dessen Sandbox das Schreiben – den Befehl außerhalb der Sandbox genehmigen; sonst einen Ordner wählen, in den geschrieben werden darf – unter Windows kann auch OneDrive oder der überwachte Ordnerzugriff der Windows-Sicherheit das Schreiben verhindern",
+  "ui.error.fs.sandboxed": "keine Berechtigung: {where} – strom läuft unter einem Agenten, und wahrscheinlich verbietet es dessen Sandbox",
+  "ui.error.fs.sandboxed.hint": "den Befehl außerhalb der Sandbox des Agenten ausführen, oder im Ordner der Forschung arbeiten (auch dessen .git und .strom beschreibbar)",
+  "ui.error.git.unwritable": "git kann nicht in die Forschung schreiben: {where}",
+  "ui.error.git.unwritable.hint": "einen Ordner wählen, in den geschrieben werden darf",
+  "ui.error.fs.folder": "statt einer Datei wurde ein Ordner angegeben: {path}",
+  "ui.error.init.unwritable": "der Stammbaum lässt sich in {where} nicht anlegen: das Schreiben dort wird verweigert – nichts davon ist dort geblieben",
+  "ui.error.init.unwritable.hint": "einen Ordner wählen, in den geschrieben werden darf",
+  "ui.error.init.failed": "der Stammbaum lässt sich in {where} nicht anlegen: {detail} – nichts davon ist dort geblieben",
+  "ui.error.init.failed.hint": "ein Ordner auf der eigenen Festplatte dieses Computers (ein Netz- oder umgeleitetes Laufwerk kann das Schreiben oder den Verlauf verweigern)",
   "ui.task.none": "Keine Aufgaben.",
   "ui.research.none": "Keine Forschungsrichtungen.",
   "ui.person.none": "Keine Personen.",
@@ -2270,6 +2299,10 @@
   "ui.error.backup.failed.hint": "Platz auf dem Datenträger freimachen ({where}) und strom erneut starten – oder zurück: strom update --channel {back}",
   "ui.error.backup.failed.update": "Die Sicherung vor dem Wechsel von {from} auf {to} ließ sich nicht erstellen: {detail}. Es wurde nichts installiert.",
   "ui.error.backup.failed.update.hint": "Platz auf dem Datenträger freimachen ({where}), dann erneut strom update --channel {channel}",
+  "ui.error.backup.failed.refused.hint": "Das Schreiben in {where} wird verweigert: einen Ordner wählen, in den geschrieben werden darf, dann strom erneut starten – oder zurück: strom update --channel {back}",
+  "ui.error.backup.failed.other.hint": "strom erneut starten (strom doctor sagt mehr) – oder zurück: strom update --channel {back}",
+  "ui.error.backup.failed.update.refused.hint": "Das Schreiben in {where} wird verweigert: einen Ordner wählen, in den geschrieben werden darf, dann erneut strom update --channel {channel}",
+  "ui.error.backup.failed.update.other.hint": "Erneut strom update --channel {channel} (strom doctor sagt mehr)",
   "ui.error.folder.in-program": "{folder} liegt im Programmordner von strom {program} – ein Update von strom ersetzt, was dort liegt, und die Deinstallation entfernt es, die Forschung mit. Nichts wurde geändert.",
   "ui.error.folder.in-program.hint": "Einen Ordner außerhalb wählen, zum Beispiel {suggested}",
   "ui.error.folder.in-program.default.hint": "Einen Ordner außerhalb angeben: strom setup --home \"{suggested}\" --yes",

package/dist/agents/files.js

@@ -13,7 +13,7 @@ import { PROFILES, selfReading } from "./profiles.js";
 import { isArchive } from "../core/mode.js";
 import { Settings } from "../core/config.js";
 import { agentAppUrl, appSite } from "../core/stromapp.js";
-import { configDir } from "../core/paths.js";
+import { configDir, ownCommand } from "../core/paths.js";
 import { within } from "../core/relocate.js";
 import { agentBrowser } from "../core/connector.js";
 import { CHROME_ALLOW, CHROME_DENY, chromeDomain } from "../core/browser.js";
@@ -50,16 +50,20 @@ the researcher; \`strom\` is your only way to read and change the research.
 5. Material from the user goes in with \`strom intake <file or folder>\` or
    \`strom intake --text "…"\`. Exit code 3 means strom needs an answer from the
    user; exit code 4 means the USER must run the given command in their own
-   terminal — never do it yourself.
+   terminal — never do it yourself. strom saying your sandbox refused writing
+   (\`fs.sandboxed\`): never another folder or setting — ask for the command
+   to run outside your sandbox, or work in this folder (its \`.git\` and
+   \`.strom\` too).
 6. You may read \`inputs/\`, \`output/\`, \`notes/\` and \`.strom/views/\`, and write
    your own working notes in \`notes/\`. Scans are looked at through views:
    \`strom media view B0001:57 --half left\` writes one to \`.strom/views/\`;
    the views of a scan or a batch come in one call (\`B0001:57-60 --half both\`).
    A text in those files: \`strom grep "<text>"\` (each line with its file and
    number) — never read a big file in pieces.
-7. Run strom commands on their own — no pipes (\`| head\`, \`| grep\`): output is
-   already short, listings take \`--limit\` and \`--page\`, and piped commands may
-   be refused by your permissions.${ps ? `\n   ${ps}` : ""}
+7. Run strom commands on their own — no pipes (\`| head\`, \`| grep\`), no
+   redirection (\`2>&1\`), no \`cd\` before them: output is already short,
+   listings take \`--limit\` and \`--page\`, and such commands may be refused by
+   your permissions (Codex's sandbox lets strom out only on its own).${ps ? `\n   ${ps}` : ""}
 8. Other agents may work on this tree too (Claude Code, Codex, Antigravity,
    OpenCode, Grok — the user's choice). \`strom\` shows who is working now; never take a task
    another one has started.
@@ -257,6 +261,7 @@ function treeRules(tree, agent) {
             ...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.)
+            // A rule matches only the command right after strom's name: strom itself refuses these to an agent (CommandDef.person).
             ...shell("strom login:*"),
             ...shell("strom connector add:*"),
             ...shell("strom connector remove:*"),
@@ -309,13 +314,41 @@ CLAUDE.md in this folder is written for Claude Code: its way of delegating (the
 Agent tool, the models opus, sonnet and haiku) is not yours. Follow AGENTS.md,
 and read scans yourself as it says under "Reading scans".
 `;
+/**
+ * Codex's rules for this tree (.codex/rules/strom.rules, read once the folder is trusted): strom run as a command of
+ * its own goes outside Codex's sandbox without asking — it writes the research's .strom and .git, which the sandbox
+ * keeps closed (measured 2026-10-22, codex-cli 0.163: on Windows .git stays closed even as a writable root, and nothing
+ * runs at all without a rule; on macOS too) — what the person decides stays forbidden, and git itself. Only strom's
+ * command alone: one in a pipe or after `cd` runs in the sandbox (Codex's rules match a plain command). Codex keeps
+ * .codex closed to the agent itself.
+ * The whole of strom is allowed, as for Claude Code (Bash(strom:*)): what strom writes outside the research (strom
+ * export --out, strom init <folder>) is strom's own decision, and what is the person's it refuses to an agent itself.
+ * The forbidden rules match only the command right after strom's name (strom --json seal adopt is not matched — a
+ * value-taking option cannot be listed): they are the second layer and give the agent the reason; the first is strom
+ * refusing the user's own commands to any agent, whatever comes before them (CommandDef.person).
+ */
+export function codexRules(tree) {
+    const own = ownCommand(tree.env);
+    const names = JSON.stringify(["strom", "strom.cmd", ...(own ? [own, `${own}.cmd`] : [])]);
+    const rule = (pattern, decision, why) => `prefix_rule(pattern = [${pattern}], decision = "${decision}", justification = ${JSON.stringify(why)})`;
+    return [
+        "# strom: generated (strom agents sync) — Codex's rules for this family tree; changed by strom only",
+        rule(names, "allow", "strom writes the research (its .strom and .git) and keeps its rules"),
+        rule(`${names}, ["login", "seal"]`, "forbidden", "a login and the seal are the user's own"),
+        rule(`${names}, "connector", ["add", "remove"]`, "forbidden", "installing a plugin is the user's own"),
+        rule('"git"', "forbidden", "strom keeps the history: never git itself"),
+        "",
+    ].join("\n");
+}
+export const CODEX_RULES = path.join(".codex", "rules", "strom.rules");
 /** Denied as well when the user lets the agent do everything else (agent.permissions full). */
 export const BYPASS_DENY = [
     // its own permissions and instructions
     "Edit(.claude/**)",
     ...["AGENTS.md", "CLAUDE.md"].map((f) => `Edit(${f})`),
-    // (Grok Build's own rules and instructions)
+    // (Grok Build's and Codex's own rules and instructions)
     "Edit(.grok/**)",
+    "Edit(.codex/**)",
     // downloads round strom's limiter
     "Bash(curl:*)",
     "Bash(wget:*)",
@@ -459,6 +492,7 @@ function dropAgentFiles(tree) {
         [path.join(".grok", "config.toml"), grokConfig(tree)],
         [path.join(".grok", "rules", "strom.md"), GROK_RULES],
         [GROK_HOOKS, JSON.stringify(grokWebHooks(tree.root), null, 2) + "\n"],
+        [CODEX_RULES, codexRules(tree)],
     ];
     for (const [rel, content] of generated) {
         const file = path.join(tree.root, rel);
@@ -505,7 +539,7 @@ function dropAgentFiles(tree) {
 export const GROK_HOOKS = path.join(".grok", "hooks", "strom.json");
 /** Claude Code's subagent for reading scans, in the tree. */
 export const CLAUDE_SCAN_READER = path.join(".claude", "agents", `${SCAN_READER}.md`);
-export const AGENT_FILES = ["AGENTS.md", "CLAUDE.md", path.join(".claude", "settings.json"), CLAUDE_SCAN_READER, "opencode.json", path.join(".grok", "config.toml"), path.join(".grok", "rules", "strom.md"), GROK_HOOKS];
+export const AGENT_FILES = ["AGENTS.md", "CLAUDE.md", path.join(".claude", "settings.json"), CLAUDE_SCAN_READER, "opencode.json", path.join(".grok", "config.toml"), path.join(".grok", "rules", "strom.md"), GROK_HOOKS, CODEX_RULES];
 /**
  * strom's files of the agents written for the tree (only what changed: the files written, to commit). `said.shim`: the
  * shim in .strom/bin was written now (never committed: not among the files).
@@ -540,6 +574,7 @@ export function syncAgentFiles(tree, said = {}) {
     write(path.join(".grok", "config.toml"), grokConfig(tree));
     write(path.join(".grok", "rules", "strom.md"), GROK_RULES);
     write(GROK_HOOKS, JSON.stringify(grokWebHooks(tree.root), null, 2) + "\n");
+    write(CODEX_RULES, codexRules(tree));
     // the strom the agent hooks name (the tree's .strom/bin, never committed) — there also for a conversation strom did not start
     if (!tree.dryRun) {
         try {

package/dist/agents/global.js

@@ -56,7 +56,9 @@ mentions strom, a family tree or the Strom app.
    "Continue the research with the agent".
 6. When strom needs the user's consent it opens a window on their screen —
    tell them to answer it; you cannot. Exit code 4 means the user must run
-   the given command themselves.
+   the given command themselves. strom saying your sandbox refused writing
+   (\`fs.sandboxed\`): never another folder or setting — ask for the command
+   to run outside your sandbox, or work in the family tree's folder.
 7. Old handwriting is read by your strongest model — never a faster or
    cheaper model, subagent or pass; a name or place the next search depends
    on is read again on an enlarged crop before it is recorded.

package/dist/agents/launch.js

@@ -17,7 +17,9 @@
 //
 // Claude Code always gets the tree's allow and deny lists (--settings); Codex
 // works in its sandbox on the tree folder with its .git (strom commits) and the
-// shared folder writable and the network on (strom fetches).
+// shared folder writable and the network on (strom fetches) — and strom itself
+// runs outside it by the tree's rules (.codex/rules/strom.rules): on Windows its
+// sandbox keeps .git closed though it is named writable.
 import { claudeArgs } from "../runners/claude.js";
 import { codexTrust, codexWritable } from "../runners/codex.js";
 import { grokOwnEnv, grokTrust } from "../runners/grok.js";

package/dist/cli/backups.js

@@ -4,6 +4,8 @@ import { EXIT, StromError } from "../core/errors.js";
 import { backupOnce, backupsDir, BackupFailed, mb } from "../core/backup.js";
 import { installation, replacedHolding } from "../core/self.js";
 import { ui } from "./ui.js";
+import { isAgent } from "../core/which.js";
+import { refusedCode, SANDBOX_HINT } from "../core/writable.js";
 /** A local date and time for a sentence. */
 function when(iso) {
     const d = new Date(iso);
@@ -50,17 +52,34 @@ export function backupBefore(ctx, t, opts = {}) {
         const where = backupsDir(home);
         const back = t.fromChannel ?? "stable";
         const params = { ...said, detail, where, back, channel: opts.update?.channel ?? "" };
+        // room on the disk only where the disk is full (found on Windows: an agent's sandbox refused the backup's lock, EPERM,
+        // and strom advised freeing room); a refused write says so — under an agent most likely its sandbox
+        const code = e instanceof BackupFailed ? e.code : e.code;
+        const why = (e instanceof BackupFailed && e.room) || code === "ENOSPC" ? "room" : refusedCode(code) ? "refused" : "other";
+        const agent = isAgent(ctx.env);
         if (opts.update)
             throw new StromError(`the backup before going from ${said.from} to ${said.to} could not be made: ${detail} — nothing was installed`, {
                 exitCode: EXIT.noBackup,
-                hint: `free room on the disk (${where}), then strom update --channel ${opts.update.channel} again`,
+                hint: why === "room"
+                    ? `free room on the disk (${where}), then strom update --channel ${opts.update.channel} again`
+                    : why === "refused"
+                        ? `${agent ? `writing into ${where} was refused — ${SANDBOX_HINT}` : `writing into ${where} is refused: a folder with the right to write in it`}; then strom update --channel ${opts.update.channel} again`
+                        : `strom doctor says more; then strom update --channel ${opts.update.channel} again`,
+                ...(why !== "room" ? { hintCode: `backup.failed.update.${why}` } : {}),
                 code: "backup.failed.update",
                 params,
                 details: { from: t.from, to: t.to, where, ...(e instanceof BackupFailed && e.room ? { room: e.room } : {}) },
             });
         throw new StromError(`the backup before going from ${said.from} to ${said.to} could not be made: ${detail} — nothing is switched: this strom opens no family tree for writing until it is made (tried again at each run)`, {
             exitCode: EXIT.noBackup,
-            hint: `tell the user: free room on the disk (${where}), then run strom again — or go back: strom update --channel ${back}`,
+            hint: why === "room"
+                ? `tell the user: free room on the disk (${where}), then run strom again — or go back: strom update --channel ${back}`
+                : why === "refused"
+                    ? agent
+                        ? `writing into ${where} was refused — ${SANDBOX_HINT}`
+                        : `writing into ${where} is refused: a folder with the right to write in it, then run strom again — or go back: strom update --channel ${back}`
+                    : `strom doctor says more; run strom again — or go back: strom update --channel ${back}`,
+            ...(why !== "room" ? { hintCode: `backup.failed.${why}` } : {}),
             code: "backup.failed",
             params,
             details: { from: t.from, to: t.to, where, ...(e instanceof BackupFailed && e.room ? { room: e.room } : {}) },

package/dist/cli/main.js

@@ -2,14 +2,14 @@
 // and commit what a writing command changed. Returns the exit code.
 import fs from "node:fs";
 import { takeOverConnectors } from "../core/terms.js";
-import { notePersonFolder } from "../core/trust.js";
+import { agentInAncestry, ancestryUnread, notePersonFolder } from "../core/trust.js";
 import { netTrust } from "../core/net.js";
 import { connectorsDir, listConnectors } from "../core/connector.js";
 import { Cancelled, EXIT, notFound, StromError, UsageError } from "../core/errors.js";
 import { ownCommand } from "../core/paths.js";
 import { Context } from "./context.js";
 import { commands, match } from "./registry.js";
-import { asCommand, asCommandJson } from "./format.js";
+import { asCommand, asCommandJson, shellArg } from "./format.js";
 import { groupHelpAs, helpAs } from "./help.js";
 import { autoCommit } from "./commit.js";
 import { assertIntact } from "../core/integrity.js";
@@ -23,6 +23,7 @@ import { fireHooks, HOOK_INTERFACE } from "../core/hooks.js";
 import { prependPath } from "../runners/runner.js";
 import { shimDir } from "../commands/session.js";
 import { isAgent } from "../core/which.js";
+import { noPermission } from "../core/writable.js";
 import { completePath, pathOf, pathToRemember } from "../core/userpath.js";
 import { appUrlShown, noticeStromApp } from "../core/stromapp.js";
 import { lastChannelOf, pendingTransition, updateChannel, whatsNewUrl } from "../core/update.js";
@@ -53,8 +54,11 @@ function print(io, ctx, result) {
     else if (result.text)
         io.stdout(result.text.endsWith("\n") ? result.text : result.text + "\n");
 }
-/** File-system errors in plain words (a missing @file, a folder without rights). */
-function systemError(e) {
+/**
+ * File-system errors in plain words (a missing @file, a folder without rights — under an agent most likely its
+ * sandbox, core/writable.ts).
+ */
+function systemError(e, agent) {
     const where = e.path ? `: ${e.path}` : "";
     // a file another program held past the waits (Windows: an antivirus, a sync tool, an editor) — no lack of rights:
     // running it again does it (what the command wrote was taken back)
@@ -65,9 +69,10 @@ function systemError(e) {
             return e.path ? notFound(e.path) : new UsageError("no such file or folder", { hint: "check the path (relative paths start in the current folder)" });
         case "EACCES":
         case "EPERM":
-            return new UsageError(`no permission to use${where}`, { hint: "a folder with the right to write in it", code: "fs.no-permission", params: { where } });
+        case "EROFS":
+            return noPermission(e.path, agent);
         case "EISDIR":
-            return new UsageError(`a folder was given where a file is expected${where}`);
+            return new UsageError(`a folder was given where a file is expected${where}`, { code: "fs.folder", ...(e.path ? { params: { path: e.path } } : {}) });
         case "ENOTDIR":
             return new UsageError(`a file was given where a folder is expected${where}`);
         case "ENOSPC":
@@ -97,8 +102,27 @@ function inLanguage(e, lang) {
     const say = (text) => placeholders(lang, text);
     return { message: say(localized(lang, key, message, e.params)), ...(e.hint ? { hint: say(hint ? localized(lang, hintKey, hint, e.params) : e.hint) } : {}), prefix: ui(lang, "ui.error.prefix") };
 }
-function printError(io, json, err, debug, lang) {
-    const e = err instanceof StromError ? err : (systemError(err) ?? err);
+const REFUSALS = new Set(["fs.no-permission", "git.unwritable", "init.unwritable"]);
+/**
+ * A refusal to write under an agent: most likely its sandbox — said so, with what the agent does (core/writable.ts).
+ * Without an agent's marks, an agent among strom's parent processes (read here only, on a refusal: found on Windows,
+ * Codex's sandbox ran strom with none of its marks) is named to the person as the likely cause — not certain, so
+ * the other causes after it.
+ */
+function underAgent(e, env) {
+    if (!REFUSALS.has(e.code ?? ""))
+        return e;
+    if (isAgent(env))
+        return noPermission(e.params?.where, env);
+    const above = agentInAncestry(env);
+    if (above)
+        return noPermission(e.params?.where, false, process.platform, above);
+    return ancestryUnread(env) ? noPermission(e.params?.where, false, process.platform, "?") : e;
+}
+function printError(io, json, err, debug, lang, env) {
+    const agent = isAgent(env) && env;
+    const sys = err instanceof StromError ? err : (systemError(err, agent) ?? err);
+    const e = sys instanceof StromError ? underAgent(sys, env) : sys;
     if (e instanceof StromError) {
         if (json)
             io.stdout(toJson(e.toJSON()));
@@ -221,6 +245,13 @@ export async function main(argv, io, env, cwd) {
             .map((x) => `${x[0].toUpperCase()}${x.slice(1).padStart(4, "0")}`);
         ran = ctx;
         command = def.path.join(" ");
+        // What the user does in their own terminal (a login, the seal, a plugin installed): refused to an agent here, after
+        // every option is read — the agents' rules match only what follows the command's name (strom --json seal adopt
+        // passed Codex's), so they are a second layer and strom the first
+        if (def.person && isAgent(env)) {
+            const said = (def.options ?? []).flatMap((o) => (v[o.name] === undefined || v[o.name] === false ? [] : o.type === "boolean" ? [`--${o.name}`] : [`--${o.name}`, String(v[o.name])]));
+            ctx.requireHuman(def.person, ["strom", ...def.path, ...[...parsed.positionals, ...said].map(shellArg)].join(" "), def.path[0], undefined, { window: false });
+        }
         // The PATH of the person's terminal remembered (never an agent's, a hook's, one strom started); a strom the system
         // started (a link from the Strom app, the bridge, the phone's server) gets what of it is missing — and so do the
         // agents and readers it starts (core/userpath.ts)
@@ -474,7 +505,7 @@ export async function main(argv, io, env, cwd) {
         // the usage is the agent's (or a program's): a person reads the error and its hint in their language, no English
         if (said instanceof StromError && said.usage && !json && !isAgent(env))
             said.usage = undefined;
-        const code = printError(io, json, said, debug, lang);
+        const code = printError(io, json, said, debug, lang, env);
         remind(io, ran, command, Date.now() - startedAt);
         return code;
     }

package/dist/cli/registry.js

@@ -118,6 +118,9 @@ export function describe(def, appUrl) {
         out.writes = true;
     if (def.tree)
         out.needsTree = true;
+    // the user's own, in their terminal: refused to an agent
+    if (def.person)
+        out.userOnly = true;
     if (def.aliases?.length)
         out.aliases = def.aliases.map((a) => a.join(" "));
     if (def.args?.length)