strom-research 1.27.0-beta.4 → 1.27.0

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.27.0
 
-*Připravuje se: bety do 1.27.0-beta.4. Oddíl bude úplný s vydáním.*
+*5. 11. 2026 · patří k aplikaci Strom 3.23.0.*
 
 - **Snímky uložené ručně vrátí svůj úkol samy.** Kde se snímky archivu ukládají ručně – archiv, kam smí jen prohlížeč
   člověka, nebo archiv, jehož podmínky nic jiného nedovolují – výzkum požádá o knihu a čísla snímků a připraví pro ně
@@ -61,7 +61,8 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
   `strom help --human` uvádí pořadí úkolů, práci mimo linie, opravy a ponechání rozporu mezi příkazy člověka. Výzkum s
   OpenCode pokračuje i po sezení, které OpenCode řádně uzavřel, ale ohlásil jako neúspěšné, a po přechodné chybě sítě –
   totéž sezení se po krátkém čekání obnoví, v rámci času sezení. Když sandbox Codexu nepustí strom k výzkumu – i v
-  rouře a na Windows i u příkazu zadaného přes PowerShell –, výzkum se hned zastaví s tím, co zůstává volbou člověka,
+  rouře a na Windows i u příkazu zadaného přes PowerShell –, nebo když příkaz stromu odmítnou už pravidla Codexu, než
+  se spustí (na Windows strom v rouře nebo za `;`), výzkum se hned zastaví s tím, co zůstává volbou člověka,
   a takové
   sezení úkol nikdy neodloží. Díky za hlášení na GitHubu. Změnu čtení snímků, kterou výzkum udělal sám a po které se
   četlo zřetelně méně jistě, hned vrátí – už ne až po 60 dnech – a `strom recent` to uvede.

package/CHANGELOG.de.md

@@ -7,7 +7,7 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
 
 ## 1.27.0
 
-*In Vorbereitung: die Betas bis 1.27.0-beta.4. Der Abschnitt ist mit dem Release vollständig.*
+*5.11.2026 · gehört zur Strom-App 3.23.0.*
 
 - **Von Hand gespeicherte Bilder bringen ihre Aufgabe von selbst zurück.** Wo die Bilder eines Archivs von Hand
   gespeichert werden – ein Archiv, das nur der Browser eines Menschen erreicht, oder eines, dessen Bedingungen nichts
@@ -75,7 +75,8 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
   Forschung mit OpenCode geht weiter nach einer Sitzung, die es ordnungsgemäß abgeschlossen, aber als fehlgeschlagen
   gemeldet hat, und nach einem vorübergehenden Netzwerkfehler – dieselbe Sitzung wird nach kurzem Warten fortgesetzt,
   innerhalb der Zeit der Sitzung. Hält die Sandbox von Codex strom von der Forschung fern – auch in einer Pipe und
-  unter Windows auch bei einem über PowerShell gegebenen Befehl –, hält die Forschung sofort an und nennt, was die Wahl
+  unter Windows auch bei einem über PowerShell gegebenen Befehl – oder lehnen die Regeln von Codex einen strom-Befehl
+  ab, bevor er läuft (unter Windows strom in einer Pipe oder nach `;`), hält die Forschung sofort an und nennt, was die Wahl
   des Menschen bleibt; eine
   solche Sitzung legt ihre Aufgabe nie beiseite. Danke für die Meldung auf GitHub. Eine Änderung beim Lesen der Scans,
   die die Forschung selbst vorgenommen hat und nach der die Lesungen deutlich unsicherer wurden, wird sofort

package/CHANGELOG.md

@@ -7,7 +7,7 @@ The changes of each version in short. The full notes and the install lines are o
 
 ## 1.27.0
 
-*In preparation: the betas up to 1.27.0-beta.4. The section is complete with the release.*
+*2026-11-05 · goes with the Strom app 3.23.0.*
 
 - **Images saved by hand bring their task back by themselves.** Where an archive's images are saved by hand – an archive
   only a person's browser reaches, or one whose terms allow nothing else – the research asks for its book and the
@@ -65,8 +65,8 @@ The changes of each version in short. The full notes and the install lines are o
   counted. `strom help --human` lists the order of tasks, work off the lines, fixes and leaving a conflict among the
   person's own commands. OpenCode's research goes on after a session it closed properly but reported as failed, and
   after a passing network error – the same session resumed after a short wait, within the session's time. Codex kept
-  away from strom by its sandbox – also in a pipe, and on Windows with a command said through PowerShell – stops the
-  research at once with what remains the person's choice, and such a session never puts its task aside. Thanks for the
+  away from strom by its sandbox – also in a pipe, and on Windows with a command said through PowerShell – or a strom
+  command its own rules refuse before it runs (on Windows strom in a pipe or after `;`) stops the research at once with what remains the person's choice, and such a session never puts its task aside. Thanks for the
   report on GitHub.
   A change the research made by itself in reading the scans, after which the readings got clearly less sure, is taken
   back at once – no longer only after 60 days – and `strom recent` says so.

package/CHANGELOG.pl.md

@@ -7,7 +7,7 @@ Zmiany każdej wersji w skrócie. Pełne informacje o wydaniach i polecenia inst
 
 ## 1.27.0
 
-*W przygotowaniu: bety do 1.27.0-beta.4. Sekcja będzie kompletna z wydaniem.*
+*5.11.2026 · współpracuje z aplikacją Strom 3.23.0.*
 
 - **Skany zapisane ręcznie same przywracają swoje zadanie.** Tam, gdzie skany archiwum zapisuje się ręcznie – archiwum,
   do którego wolno tylko przeglądarce człowieka, albo takie, którego warunki nie pozwalają na nic innego – badanie
@@ -68,7 +68,8 @@ Zmiany każdej wersji w skrócie. Pełne informacje o wydaniach i polecenia inst
   sprzeczności wśród poleceń człowieka. Badanie z OpenCode toczy się dalej po sesji, którą OpenCode poprawnie zamknął,
   ale zgłosił jako nieudaną, oraz po przejściowym błędzie sieci – ta sama sesja zostaje wznowiona po krótkim
   oczekiwaniu, w ramach czasu sesji. Gdy sandbox Codexa nie dopuści strom do badań – także w potoku, a w Windows
-  także przy poleceniu podanym przez PowerShell –, badanie od razu się zatrzymuje z tym, co pozostaje wyborem
+  także przy poleceniu podanym przez PowerShell – albo gdy polecenie strom odrzucą już reguły Codexa, zanim się
+  uruchomi (w Windows strom w potoku lub po `;`), badanie od razu się zatrzymuje z tym, co pozostaje wyborem
   człowieka, a taka sesja nigdy
   nie odkłada zadania. Dziękujemy za zgłoszenie na GitHubie. Zmiana odczytu skanów, którą badanie wprowadziło samo i po
   której odczyty stały się wyraźnie mniej pewne, zostaje od razu cofnięta – już nie dopiero po 60 dniach – a `strom

package/dist/commands/session.js

@@ -1196,8 +1196,11 @@ register(updatedDuringRun({
                 const after = Tree.open(root, runEnv);
                 let s = after.get(session.id);
                 // strom itself refused to the agent (its permissions, its sandbox — said through any shell): kept with the
-                // session's metrics, so the session is not counted against its task
-                const stromDenied = result.denied?.filter(deniedStrom).length ?? 0;
+                // session's metrics, so the session is not counted against its task. strom first in the command — in any part
+                // of it only where the agent refused the command whole before any of it ran (Codex's policy: deniedWhole); a
+                // sandbox that refused `touch ../x` in `touch ../x && strom …` refused no strom
+                const whole = new Set(result.deniedWhole ?? []);
+                const stromDenied = result.denied?.filter((d, i) => deniedStrom(d, whole.has(i))).length ?? 0;
                 if (stromDenied)
                     result = { ...result, metrics: { ...result.metrics, stromDenied } };
                 // the agent closed the session itself and its process then failed by its exit code alone (OpenCode: 1 after its
@@ -1253,7 +1256,7 @@ register(updatedDuringRun({
                 // what it cost: the agent's own and its readers', both apart too
                 const m = after.get(s.id)?.metrics ?? withReaders(result.metrics, s.metrics);
                 const total = sessionCost(m);
-                report.push({ session: s.id, task: task.id, outcome: result.outcome, ...(result.exitOnly && result.outcome === "ok" ? { agentExit: result.exitCode } : {}), ...(result.recovered ? { recovered: result.recovered } : {}), ...(s.summary ? { summary: s.summary } : {}), ...(total !== undefined ? { costUsd: total } : {}), ...(m.readersUsd !== undefined ? { agentUsd: m.costUsd ?? 0, readersUsd: m.readersUsd } : {}) });
+                report.push({ session: s.id, task: task.id, outcome: result.outcome, ...(result.exitOnly && result.outcome === "ok" ? { agentExit: result.exitCode } : {}), ...(result.recovered ? { recovered: result.recovered } : {}), ...(result.denied?.length ? { denied: result.denied.length } : {}), ...(stromDenied ? { stromDenied } : {}), ...(s.summary ? { summary: s.summary } : {}), ...(total !== undefined ? { costUsd: total } : {}), ...(m.readersUsd !== undefined ? { agentUsd: m.costUsd ?? 0, readersUsd: m.readersUsd } : {}) });
                 out(`■ ${s.id} ${s.state} · ${result.outcome}${costText(m) ? ` · ${costText(m)}` : ""}${s.summary ? ` · ${truncate(s.summary, 80)}` : ""}`);
                 if (result.denied?.length)
                     out(ui(lang, "ui.run.denied", { n: result.denied.length, what: result.denied.slice(0, 3).join(" · ") }));

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

package/dist/runners/codex.js

@@ -135,6 +135,105 @@ export function codexRefusedStrom(output, session) {
     const mark = refusalMark(session);
     return !!mark && output.replace(/\r?\n/g, "").includes(`${SANDBOX_REFUSAL} ${mark}`);
 }
+/**
+ * One string as Rust's Debug writes it (`"…"` with `\"`, `\\`, `\n`, `\u{…}`), read from its opening quote at `at`:
+ * its text and where it ended — undefined when it does not end (a line cut short).
+ */
+function debugString(s, at) {
+    if (s[at] !== '"')
+        return undefined;
+    let text = "";
+    for (let i = at + 1; i < s.length; i++) {
+        const c = s[i];
+        if (c === '"')
+            return { text, end: i + 1 };
+        if (c !== "\\") {
+            text += c;
+            continue;
+        }
+        const e = s[++i];
+        if (e === undefined)
+            return undefined;
+        if (e === "u") {
+            const u = /^\{([0-9a-fA-F]{1,6})\}/u.exec(s.slice(i + 1));
+            if (!u)
+                return undefined;
+            text += String.fromCodePoint(parseInt(u[1], 16));
+            i += u[0].length;
+        }
+        else
+            text += { n: "\n", r: "\r", t: "\t", "0": "\0" }[e] ?? e;
+    }
+    return undefined;
+}
+/**
+ * A command line as Codex renders it (the shlex crate's join: words '…'-quoted, or "…"-quoted with \ before $ ` " \
+ * where a backslash keeps single quotes out — Windows paths) split into its words again.
+ */
+function shlexWords(line) {
+    const words = [];
+    let word;
+    for (let i = 0; i < line.length; i++) {
+        const c = line[i];
+        if (/\s/u.test(c)) {
+            if (word !== undefined)
+                words.push(word);
+            word = undefined;
+        }
+        else if (c === "'") {
+            const close = line.indexOf("'", i + 1);
+            if (close < 0)
+                return [];
+            word = (word ?? "") + line.slice(i + 1, close);
+            i = close;
+        }
+        else if (c === '"') {
+            word ??= "";
+            for (i++; i < line.length && line[i] !== '"'; i++)
+                word += line[i] === "\\" && i + 1 < line.length ? line[++i] : line[i];
+            if (i >= line.length)
+                return [];
+        }
+        else
+            word = (word ?? "") + (c === "\\" && i + 1 < line.length ? line[++i] : c);
+    }
+    if (word !== undefined)
+        words.push(word);
+    return words;
+}
+/**
+ * A command Codex's own policy refused before it ran, as Codex alone says it — a line of its log on its stderr, never a
+ * command_execution item, never what a command printed or the agent wrote (codex-cli 0.166.0 on Windows, found
+ * 2026-11-05):
+ *   `<time> ERROR codex_core::tools::router: error=exec_command failed: CreateProcess { message: "Rejected(\"`<the
+ *   command, its shell around it>` rejected: blocked by policy\")" }`
+ * "Blocked by policy" is an approval nobody gives in `codex exec`: with Codex's own Windows sandbox not in use (as where
+ * it was found) every part of a command no rule allows is refused — `strom.cmd … | Select-Object`, `Set-Location .; strom.cmd …`:
+ * the rule lets strom run, the part after it is refused, and so the whole command (Codex's exec_policy.rs,
+ * render_decision_for_unmatched_command). A refusal by a rule of its own (strom's `git`, `strom login`, the person's:
+ * its justification) or of Codex's `rm -f` is what the rules say: no such refusal here. The command as the agent meant
+ * it (its shell around it taken off); undefined: no such line.
+ */
+export function codexPolicyRejected(line) {
+    const clean = line.replace(/\u001b\[[0-9;]*m/gu, "");
+    const at = /^\s*(?:\S+\s+)?ERROR\s+codex_core::tools::router:\s+error=[\p{L}\p{N}_.-]+ failed: CreateProcess \{ message: "/u.exec(clean);
+    if (!at)
+        return undefined;
+    const outer = debugString(clean, at.index + at[0].length - 1);
+    if (!outer || !/^\s*\}\s*$/u.test(clean.slice(outer.end)) || !outer.text.startsWith('Rejected("'))
+        return undefined;
+    const reason = debugString(outer.text, "Rejected(".length);
+    if (!reason || outer.text.slice(reason.end) !== ")")
+        return undefined;
+    const said = /^`([\s\S]+)` rejected: blocked by policy$/u.exec(reason.text);
+    if (!said)
+        return undefined;
+    const words = shlexWords(said[1]);
+    // the agent's own command: what its shell was given (-Command, -c, /c, -lc), else the words as they are
+    const flag = words.findIndex((w, i) => i > 0 && /^(?:-(?:command|c|lc)|\/[ck])$/iu.test(w));
+    const command = flag > 0 && flag < words.length - 1 ? words.slice(flag + 1).join(" ") : words.length ? words.join(" ") : said[1];
+    return shellUnwrapped(command);
+}
 /** The error Codex said last, kept when an earlier one said the plan's limit (the later one may only say the turn failed). */
 function failure(said, had) {
     return looksLikeLimit(had).limit && !looksLikeLimit(said).limit ? had : said || had;
@@ -165,6 +264,17 @@ function runCodex(opts) {
         tellUsage(opts, { total: true, in: usageNumber(u.input_tokens), cr: usageNumber(u.cached_input_tokens), out: usageNumber(u.output_tokens), turns: steps || undefined });
         steps = 0;
     };
+    // a command its policy refused before it ran is said on its stderr alone (codexPolicyRejected): counted like a denial —
+    // strom's own command so refused stops the run as its sandbox's refusal does (#8: on Windows Codex runs every command
+    // through PowerShell, and strom in a pipe, after `;` or `&` was refused so — the run went on and put its tasks aside)
+    const stderrLine = (line, heard) => {
+        const command = codexPolicyRejected(line);
+        if (command === undefined)
+            return;
+        // refused whole before any of it ran: strom counts refused in any part of it (deniedStrom's `whole`)
+        (heard.deniedWhole ??= []).push(heard.denied.length);
+        heard.denied.push(`Bash: ${command.slice(0, 120)}`);
+    };
     return runJsonLines("codex", codexArgs(opts), opts.env, opts, resume, (msg, heard) => {
         if (msg.type === "thread.started" && typeof msg.thread_id === "string") {
             heard.sessionId = msg.thread_id;
@@ -185,8 +295,9 @@ function runCodex(opts) {
         // "declined"): counted like a denial, the command as the agent meant it (its shell around it taken off). strom's own
         // refusal under an agent counts with the exit code 0 too: in a pipe (`strom … | cat`, `| Select-Object`) the code
         // is the last program's — but then only strom's error with this session's mark, never its words quoted
-        // (codexRefusedStrom). (Codex 0.155's exec_command says nothing at all of a command it refused before it ran — its
-        // rules — or one its sandbox stopped within 150 ms; strom itself starts slower and is always said.)
+        // (codexRefusedStrom). (Codex's exec_command gives no item of a command its policy refused before it ran — said on
+        // its stderr alone: stderrLine above — nor of one its sandbox stopped within 150 ms; strom itself starts slower and
+        // is always said.)
         if (msg.type === "item.completed" &&
             item?.type === "command_execution" &&
             (item.status === "declined" ||
@@ -218,5 +329,5 @@ function runCodex(opts) {
             const e = msg.error;
             heard.text = failure(String(e?.message ?? msg.message ?? ""), heard.text);
         }
-    });
+    }, { stderrLine });
 }

package/dist/runners/jsonl.js

@@ -78,7 +78,7 @@ export async function runJsonLines(command, args, env, opts, resume, onEvent, wa
         heard.deniedBefore = heard.denied.length;
         heard.error = undefined;
         heard.endedNormally = undefined;
-        const a = await attempt(command, args, input, env, opts, timeoutMs, heard, onEvent);
+        const a = await attempt(command, args, input, env, opts, timeoutMs, heard, onEvent, ways.stderrLine);
         lastStderr = a.stderr;
         // (its events set them while it ran)
         const said = heard.responses;
@@ -200,12 +200,13 @@ export async function runJsonLines(command, args, env, opts, resume, onEvent, wa
         ...(recovered ? { recovered } : {}),
         ...(limit.resumeAt ? { resumeAt: limit.resumeAt } : {}),
         ...(heard.denied.length ? { denied: heard.denied } : {}),
+        ...(heard.deniedWhole?.length ? { deniedWhole: heard.deniedWhole } : {}),
         ...(heard.refused?.length ? { refused: heard.refused } : {}),
         ...(outcome === "error" && looksLikeModelRejected(all) ? { modelRejected: true } : {}),
     };
 }
 /** One start of the agent; its events go to `heard`. */
-function attempt(command, args, input, env, opts, timeoutMs, heard, onEvent) {
+function attempt(command, args, input, env, opts, timeoutMs, heard, onEvent, onStderr) {
     return new Promise((resolve) => {
         const child = spawnAgent(command, args, { cwd: opts.cwd, env, stdio: ["pipe", "pipe", "pipe"], windowsHide: true, detached: OWN_GROUP });
         feedStdin(child, input);
@@ -246,9 +247,28 @@ function attempt(command, args, input, env, opts, timeoutMs, heard, onEvent) {
             log.flush();
         });
         let stderr = "";
+        // its stderr a whole line at a time too, for a runner that reads it (a line cut between two chunks read whole)
+        const errText = new StringDecoder("utf8");
+        let errLine = "";
+        const errLines = (chunk, end = false) => {
+            if (!onStderr)
+                return;
+            errLine += chunk;
+            let nl;
+            while ((nl = errLine.indexOf("\n")) >= 0) {
+                onStderr(errLine.slice(0, nl).replace(/\r$/u, ""), heard);
+                errLine = errLine.slice(nl + 1);
+            }
+            if (end && errLine)
+                onStderr(errLine.replace(/\r$/u, ""), heard);
+            if (end)
+                errLine = "";
+        };
         child.stderr?.on("data", (d) => {
-            stderr += d.toString("utf8");
-            appendLog(opts.logFile, d.toString("utf8"));
+            const t = errText.write(d);
+            stderr += t;
+            appendLog(opts.logFile, t);
+            errLines(t);
         });
         const end = () => {
             if (timer)
@@ -264,6 +284,9 @@ function attempt(command, args, input, env, opts, timeoutMs, heard, onEvent) {
             buffer += text.end();
             if (buffer)
                 handle(buffer);
+            const errRest = errText.end();
+            stderr += errRest;
+            errLines(errRest, true);
             log.rest(buffer);
             log.flush();
             resolve({ code, signal, timedOut, stderr });

package/dist/runners/runner.js

@@ -79,11 +79,48 @@ export function shellUnwrapped(command) {
 }
 /**
  * Whether a refused tool call ("Bash: …", "PowerShell: …", as a run collects them) ran strom itself: strom, strom.cmd,
- * strom.exe, strom.ps1 or a second installation's strom-<suffix>, by its name or its path, first in the command.
+ * strom.exe, strom.ps1 or a second installation's strom-<suffix>, by its name or its path, first in the command — never
+ * inside quotes (`echo "x; strom brief"`) or as another program's argument. `whole`: the command was refused whole
+ * before any of it ran (Codex's policy, RunResult.deniedWhole): there strom counts first in any part of it too — after
+ * `;`, `&&`, `||`, a pipe or a new line (`Set-Location .; strom.cmd …`: found on Windows, #8). A command refused while
+ * it ran (a sandbox) is strom's only with strom first: in `touch ../x && strom …` the sandbox refused touch, and strom
+ * never ran.
  */
-export function deniedStrom(denied) {
+export function deniedStrom(denied, whole = false) {
     const command = shellUnwrapped(denied.replace(/^[\p{L}\p{N}_]+: /u, ""));
-    return /^(['"]?)(?:[^\s'"]*[\\/])?strom(?:-[\p{L}\p{N}_.-]+?)?(?:\.cmd|\.exe|\.ps1|\.bat)?\1(?:\s|$)/iu.test(command);
+    return (whole ? commandParts(command) : [command]).some((part) => STROM_FIRST.test(part.replace(/^&\s*/u, "")));
+}
+/** strom by its name or path first in a command (its own quotes around it, the same at both ends). */
+const STROM_FIRST = /^(['"]?)(?:[^\s'"]*[\\/])?strom(?:-[\p{L}\p{N}_.-]+?)?(?:\.cmd|\.exe|\.ps1|\.bat)?\1(?:\s|$)/iu;
+/** The parts of a command line between `;`, `&&`, `||`, `|` and new lines outside quotes, each trimmed. */
+function commandParts(command) {
+    const parts = [];
+    let part = "";
+    let quote;
+    for (let i = 0; i < command.length; i++) {
+        const c = command[i];
+        if (quote) {
+            part += c;
+            if (c === "\\" && quote === '"' && i + 1 < command.length)
+                part += command[++i];
+            else if (c === quote)
+                quote = undefined;
+        }
+        else if (c === "'" || c === '"') {
+            quote = c;
+            part += c;
+        }
+        else if (c === ";" || c === "\n" || c === "|" || (c === "&" && command[i + 1] === "&")) {
+            parts.push(part.trim());
+            part = "";
+            if (command[i + 1] === c)
+                i++;
+        }
+        else
+            part += c;
+    }
+    parts.push(part.trim());
+    return parts.filter(Boolean);
 }
 /** A command as a run's progress shows it: "$ " and its first line, cut at 140 characters — a cut ends in "…". */
 export function commandLine(command) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strom-research",
-  "version": "1.27.0-beta.4",
+  "version": "1.27.0",
   "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"
   }
 }