strom-research 1.1.1 → 1.2.0

package/README.md

@@ -58,7 +58,9 @@ npm: `npm install -g strom-research@latest`.
   OpenCode), experienced users in the terminal — strom opens it in the right
   folder, set up as you chose
 - Or let the agent work on its own through the task queue (`strom run`) and
-  read the result
+  read the result — or on and on (`strom run --loop`) while a condition of
+  yours allows it: a gate plugin, e.g. `claude-usage 10` (your Claude
+  subscription's daily ration, 10 points in hand), or one of your own (`strom gate list`)
 - Several agents can work on one family tree side by side, each on its own task
 
 **Evidence first**

package/assets/lang/cs.json

@@ -428,6 +428,7 @@
   "ui.stats.tasks": "Úkoly: ve frontě {queued} · čekají na vás {waiting} · hotové {done}",
   "ui.stats.sessions": "Sezení agenta: {n} · poslední {last}",
   "ui.stats.cost": " · dosavadní cena {cost}",
+  "ui.stats.cost.partial": " (bez přerušených sezení, která cenu neřekla: {n})",
   "ui.stats.stories": "Vyprávění: {n} (schválená {final})",
   "ui.ped.noparents": "rodiče zatím neznámí",
   "ui.ped.nofather": "otec zatím neznámý",
@@ -474,5 +475,19 @@
   "ui.menu.working.more": "Samostatně teď pracují agenti: {n}.",
   "ui.run.beside": "⚠ Agent už tu pracuje sám (běhy: {n}). Další vedle něj si vezme jiné úkoly – náklady se sčítají.",
   "ui.run.beside.sure": "Spustit další vedle něj?",
+  "ui.run.gate": "· podmínka: {name} — ptá se před každým sezením; běh může nechat čekat",
+  "ui.run.gate.wait": "⏸ čekám do {at} — {reason} (Ctrl-C běh ukončí)",
+  "ui.run.stop.gate": "podmínka „{name}“ řekla dost — {reason}",
+  "ui.run.stop.gate.error": "podmínka „{name}“ neodpověděla, jak má — {reason} (strom gate test)",
+  "ui.run.gate.once": "· podmínka: {name} — tyto úkoly spouštíte vy: zeptám se jí jednou, a kdyby nespouštěla, rozhodnete vy",
+  "ui.run.gate.anyway": "Podmínka „{name}“ by teď nespouštěla — {reason}. Spustit přesto?",
+  "ui.run.gate.later": "zatím ne",
+  "ui.run.gate.no": "ne",
+  "ui.run.gate.noanswer": "neodpověděla, jak má (strom gate test)",
+  "ui.run.stop.gate.declined": "nespuštěno — podmínka „{name}“: {reason}",
+  "ui.run.loop": "Nechat ho pracovat, dokud je co dělat a dovolí to podmínka „{name}“",
+  "ui.consent.gate.set": "Nechat podmínku „{name}“ rozhodovat, kdy agent pracující sám pokračuje?",
+  "ui.consent.gate.unset": "Odebrat podmínku „{name}“ — agent pracující sám se jí už nebude ptát?",
+  "ui.consent.gate.skip": "Nechat agenta pracovat samotného bez podmínky „{name}“?",
   "ui.run.others": "⚠ V tomto rodokmenu už pracuje jiný běh (od {since}): tento si vezme jiné úkoly – náklady se sčítají."
 }

package/assets/lang/de.json

@@ -428,6 +428,7 @@
   "ui.stats.tasks": "Aufgaben: in der Warteschlange {queued} · warten auf Sie {waiting} · erledigt {done}",
   "ui.stats.sessions": "Sitzungen des Agenten: {n} · die letzte {last}",
   "ui.stats.cost": " · Kosten bisher {cost}",
+  "ui.stats.cost.partial": " (ohne abgebrochene Sitzungen, die ihre Kosten nicht nannten: {n})",
   "ui.stats.stories": "Geschichten: {n} (freigegeben {final})",
   "ui.ped.noparents": "Eltern noch unbekannt",
   "ui.ped.nofather": "Vater noch unbekannt",
@@ -474,5 +475,19 @@
   "ui.menu.working.more": "Gerade arbeiten Agenten selbstständig: {n}.",
   "ui.run.beside": "⚠ Hier arbeitet schon ein Agent selbstständig (Läufe: {n}). Ein weiterer daneben nimmt andere Aufgaben – die Kosten addieren sich.",
   "ui.run.beside.sure": "Einen weiteren daneben starten?",
+  "ui.run.gate": "· Bedingung: {name} — vor jeder Sitzung gefragt; sie kann den Lauf warten lassen",
+  "ui.run.gate.wait": "⏸ warte bis {at} — {reason} (Strg-C beendet den Lauf)",
+  "ui.run.stop.gate": "die Bedingung „{name}“ sagte Halt — {reason}",
+  "ui.run.stop.gate.error": "die Bedingung „{name}“ gab keine gültige Antwort — {reason} (strom gate test)",
+  "ui.run.gate.once": "· Bedingung: {name} — diese Aufgaben starten Sie selbst: sie wird einmal gefragt, und würde sie nicht starten, entscheiden Sie",
+  "ui.run.gate.anyway": "Die Bedingung „{name}“ würde jetzt nicht starten — {reason}. Trotzdem starten?",
+  "ui.run.gate.later": "noch nicht",
+  "ui.run.gate.no": "nein",
+  "ui.run.gate.noanswer": "keine gültige Antwort (strom gate test)",
+  "ui.run.stop.gate.declined": "nicht gestartet — die Bedingung „{name}“: {reason}",
+  "ui.run.loop": "Weiterarbeiten lassen, solange es Arbeit gibt und die Bedingung „{name}“ es erlaubt",
+  "ui.consent.gate.set": "Die Bedingung „{name}“ entscheiden lassen, wann der allein arbeitende Agent weitermacht?",
+  "ui.consent.gate.unset": "Die Bedingung „{name}“ entfernen — der allein arbeitende Agent fragt sie nicht mehr?",
+  "ui.consent.gate.skip": "Den Agenten ohne die Bedingung „{name}“ allein arbeiten lassen?",
   "ui.run.others": "⚠ In diesem Stammbaum arbeitet schon ein anderer Lauf (seit {since}): dieser nimmt andere Aufgaben – die Kosten addieren sich."
 }

package/assets/method/core.md

@@ -28,8 +28,12 @@ conclusion so the next researcher can follow it.
   fact is edited with a reason. Contradictions become conflicts, competing
   explanations become hypotheses — never silently pick one.
 - **Write as you go.** Record each finding as soon as you have it. Your context
-  can be cut or summarised at any moment; what is only in the conversation is
-  lost, what is in strom is not.
+  can be cut or summarised at any moment, and a session working alone is
+  stopped at its time limit (the brief says when; near the end strom's output
+  counts down): what is only in the conversation is lost, what is in strom is
+  not. Going through many images, record each stretch when it is done (every
+  ten images, each district or year): the finds, and `strom search add …
+  --pages` for what was searched in vain — never all of it at the end.
 - **Lessons belong where they apply.** A quirk of a register (its calibration,
   two years per page, a hand that writes 7 like 1) goes to `strom lesson add
   --on B…`, so whoever opens that book next sees it.

package/assets/method/reading.md

@@ -23,7 +23,8 @@ Look at as few pixels as the question needs, and write down what you saw at once
   foreground and let it finish — your session ends with your turn, and
   whatever is left running in the background ends with it.
   (Your own subagents can read too, in batches of at most twelve — but what they
-  report is lost with your session unless you write it down.) Only the entries
+  report is lost with your session unless you write it down: record each
+  report as it comes back, before you send the next readers.) Only the entries
   that will be cited need your own eyes, at full resolution.
 - Old handwriting is decoded, not copied: never a weaker model for handwriting,
   never a guess. "Illegible" is a valid and valuable answer.

package/assets/plugins/README.md

@@ -7,6 +7,9 @@ it one folder per plugin. The folder's name is the plugin's name.
       connectors/              downloaders for archive portals
         README.md              their interface (version 1)
         example-archive/       one connector: connector.json and its program
+      gates/                   conditions on the agent working alone (strom run)
+        README.md              their interface (version 1)
+        claude-usage/          one gate: gate.json and its program
 
 **Install** a plugin by copying its folder in: `strom connector list` shows it
 and it can run at once, paced by strom and only to the hosts it names. To be
@@ -18,6 +21,10 @@ plugin whose code goes round strom always needs your yes, in your terminal
 
 **Remove** one by deleting its folder (or `strom connector remove <name>`).
 
+**Gates** decide whether the agent working alone goes on: `strom config set
+run.gate <name>` (only you), `strom gate test`, `strom run --loop`.
+
 Plugins are programs on this computer, put here by you: the `.gitignore` here
-keeps them out of any repository. strom writes this file, the `.gitignore` and
-`connectors/README.md`, and keeps them up to date.
+keeps them out of any repository. strom writes this file, the `.gitignore`,
+`connectors/README.md`, `gates/README.md` and the gates it ships, and keeps them
+up to date.

package/assets/plugins/gates/README.md

@@ -0,0 +1,95 @@
+# strom gates — interface 1
+
+A gate is a condition you set on the agent working alone. Before each session
+of `strom run` strom asks your gate: go on, wait, or stop? With
+`strom run --loop` the agent works on for as long as there is work and the gate
+lets it — your subscription's room, a budget, the night's tariff: whatever the
+gate's program decides.
+
+    plugins/gates/
+      README.md                this interface
+      claude-usage/            a gate strom ships (the Claude subscription's daily ration)
+      my-gate/                 one of yours: gate.json and its program
+
+**Use one**: `strom config set run.gate <name>` — or its name and what it is
+given, `"claude-usage 10"` (only you: an agent cannot set or remove it);
+`strom gate test` to see its answer now. `strom gate list` shows
+the gates here. `strom config unset run.gate`: no gate.
+
+## gate.json
+
+    {
+      "interface": 1,
+      "title": "My budget",
+      "command": ["node", "gate.ts"],
+      "timeout": 60
+    }
+
+- `command`: the program and its arguments, run in the gate's folder. `node`
+  is strom's own Node (TypeScript runs as it is) — best on every system. What
+  the user gives the gate after its name (`run.gate "my-gate 20 night"`) is
+  added to these arguments.
+- `timeout`: seconds it may take (default 120). No answer in time: an error.
+
+## The answer
+
+The exit status says it:
+
+| status | meaning |
+|---|---|
+| 0 | go on: the next session starts |
+| 1 | wait: strom asks again later (the computer may sleep meanwhile) |
+| 2 | stop: the run ends |
+| anything else, a crash, no answer | an error: the run ends — never spending blind |
+
+One line of JSON on stdout (the last line) may say more:
+
+    {"reason": "the week is at 61 %", "until": "2026-10-02T14:00:00Z"}
+
+- `reason`: why, for the user (in their language: `STROM_LANG`).
+- `wait` (seconds) or `until` (a time): when to ask again. Without them: in
+  15 minutes; never sooner than a minute.
+
+Plain text instead of JSON is the reason.
+
+## What strom tells the gate
+
+Environment variables, besides the user's own:
+
+| variable | |
+|---|---|
+| `STROM_GATE` | the gate's name |
+| `STROM_TREE` | the family tree's folder |
+| `STROM_LANG` | the research language (cs, de, en…) |
+| `STROM_AGENT` | the agent: claude, codex, antigravity, opencode |
+| `STROM_MODEL` | the main model, when one is set |
+| `STROM_SESSIONS` | sessions this run has had |
+| `STROM_COST_USD` | what this run has cost so far (as the agent reported it) |
+| `STROM_NEXT_TASK` | the task the next session would take |
+
+A session already at work is never stopped by a gate: it is asked between
+sessions only (a session's own time limit is `run.minutes`).
+
+The gate holds the runs that go on by themselves: `strom run --loop` and
+`--until`. Tasks you start yourself (one, `--max 3`, `--task T0007`, "work
+alone" in the menu) are your choice: the gate is asked once, and when it would
+not start now, strom tells you why and asks whether to start anyway (no is
+suggested). An agent starting them needs your yes in a window of the system;
+a script nobody can ask keeps to the gate.
+
+## claude-usage
+
+Keeps the work to the daily ration of your Claude subscription. It asks Claude
+Code (`claude -p /usage`) how much of the week is used and counts how much of
+the week is gone since its reset (a day ≈ 14.3 %). A session starts only while
+usage is at least the number you give it behind the week gone:
+
+    strom config set run.gate "claude-usage 10"     gone − used ≥ 10
+
+Without a number: 0 — no faster than the week goes; 14: about a day in hand.
+Not enough in hand: it waits until the week has caught up (past the reset: the
+new week's share). A used-up session: until it resets. Another agent than
+Claude Code: it lets the work go on.
+
+A gate is a program on this computer, put here by you (or by strom); the
+`.gitignore` of the plugins folder keeps it out of any repository.

package/assets/plugins/gates/claude-usage/gate.json

@@ -0,0 +1,10 @@
+{
+  "interface": 1,
+  "title": "Claude usage",
+  "description": "Keeps working alone to the daily ration of your Claude subscription: a session starts only while the week's usage is at least n points behind the share of the week gone (a day ≈ 14.3): strom config set run.gate \"claude-usage 10\" (without a number: 0).",
+  "command": [
+    "node",
+    "gate.ts"
+  ],
+  "timeout": 120
+}

package/assets/plugins/gates/claude-usage/gate.ts

@@ -0,0 +1,125 @@
+// A strom gate (interface 1): let the research work alone while the Claude
+// subscription has room. It asks Claude Code itself (`claude -p /usage`, the
+// plan's limits as the server reports them) and answers strom:
+//   exit 0  go on           exit 1  wait (JSON "until": when to ask again)
+//   exit 2  stop the run    — one line of JSON on stdout says why.
+//
+// The rule, the pace of the week: the share of the week gone since its reset
+// (a day is about 14.3 %) against the week's usage. With the number you give
+// it (strom config set run.gate "claude-usage 10") a session starts only while
+// usage is at least that many points behind the week gone: gone − used ≥ 10.
+// Without a number: 0 — no faster than the week goes. Else it waits until the
+// week has caught up (or past the reset); a full session: until it resets.
+//
+// strom writes this file; a copy of your own goes into a folder of its own name.
+
+import { spawnSync } from "node:child_process";
+
+const DAY = 86_400_000;
+const WEEK = 7 * DAY;
+const lang = (process.env.STROM_LANG ?? "en").slice(0, 2);
+
+const T: Record<string, Record<string, string>> = {
+  en: {
+    other: "the agent is not Claude Code — nothing to check",
+    api: "Claude Code runs on an API key, not a subscription — no plan limits",
+    go: "week {used} % used, {gone} % gone, {behind} in hand (at least {min} needed)",
+    session: "the session is used up — until it resets",
+    week: "week {used} % used, {gone} % gone, {behind} in hand (at least {min} needed) — until the week catches up",
+    bad: "the number must be 0 to 99, not \"{arg}\"",
+    unread: "cannot read `claude -p /usage`: {detail}",
+  },
+  cs: {
+    other: "agent není Claude Code — není co hlídat",
+    api: "Claude Code běží na API klíči, ne na předplatném — žádné limity plánu",
+    go: "týden: využito {used} %, uplynulo {gone} %, náskok {behind} (potřeba aspoň {min})",
+    session: "sezení je vyčerpané — do jeho obnovení",
+    week: "týden: využito {used} %, uplynulo {gone} %, náskok {behind} (potřeba aspoň {min}) — dokud čas nedožene",
+    bad: "číslo musí být 0 až 99, ne \"{arg}\"",
+    unread: "nelze přečíst `claude -p /usage`: {detail}",
+  },
+  de: {
+    other: "der Agent ist nicht Claude Code — nichts zu prüfen",
+    api: "Claude Code läuft mit einem API-Schlüssel, nicht im Abo — keine Planlimits",
+    go: "Woche: {used} % genutzt, {gone} % vergangen, Vorsprung {behind} (mindestens {min} nötig)",
+    session: "die Sitzung ist aufgebraucht — bis sie zurückgesetzt wird",
+    week: "Woche: {used} % genutzt, {gone} % vergangen, Vorsprung {behind} (mindestens {min} nötig) — bis die Zeit aufholt",
+    bad: "die Zahl muss 0 bis 99 sein, nicht \"{arg}\"",
+    unread: "`claude -p /usage` nicht lesbar: {detail}",
+  },
+};
+function say(key: string, v: Record<string, string | number> = {}): string {
+  const s = (T[lang] ?? T.en!)[key] ?? T.en![key]!;
+  return s.replace(/\{(\w+)\}/g, (_, k: string) => String(v[k] ?? ""));
+}
+function answer(code: 0 | 1 | 2, reason: string, until?: Date): never {
+  console.log(JSON.stringify({ reason, ...(until ? { until: until.toISOString() } : {}) }));
+  process.exit(code);
+}
+
+// ── your number: how many points usage must be behind the week gone ─────────
+const arg = process.argv[2] ?? "0";
+const min = Number(arg);
+if (!/^\d{1,2}$/.test(arg)) answer(2, say("bad", { arg }));
+
+if ((process.env.STROM_AGENT ?? "claude") !== "claude") answer(0, say("other"));
+
+// ── what Claude Code says ───────────────────────────────────────────────────
+const r = spawnSync("claude", ["-p", "/usage"], { encoding: "utf8", timeout: 90_000, shell: process.platform === "win32", windowsHide: true });
+if (r.error || r.status !== 0) answer(2, say("unread", { detail: r.error?.message ?? (r.stderr || r.stdout || `exit ${r.status}`).trim().split("\n")[0] ?? "" }));
+const text = r.stdout;
+if (/API key/i.test(text) && !/Current week/i.test(text)) answer(0, say("api"));
+
+const LINE = /^Current (session|week)(?: \(([^)]+)\))?:\s*(\d+)%\s*used(?:\s*·\s*resets\s*(.+))?$/i;
+let session: { used: number; resets?: Date } | undefined;
+let week: { used: number; resets?: Date } | undefined;
+for (const raw of text.split(/\r?\n/)) {
+  const m = LINE.exec(raw.trim());
+  if (!m) continue;
+  const item = { used: Number(m[3]), ...(m[4] ? { resets: resetAt(m[4]) } : {}) };
+  if (m[1]!.toLowerCase() === "session") session = item;
+  // the limit of all models is the one that stops the work; a model's own week only if there is no other
+  else if (!week || /all models/i.test(m[2] ?? "")) week = item;
+}
+if (!week?.resets) answer(2, say("unread", { detail: "no line \"Current week … resets …\"" }));
+
+const now = Date.now();
+const start = week.resets.getTime() - WEEK;
+const gone = Math.max(0, Math.min(100, ((now - start) / WEEK) * 100));
+const behind = gone - week.used;
+const v = { used: week.used, gone: Math.round(gone), behind: Math.round(behind), min };
+if (session && session.used >= 100) answer(1, say("session"), session.resets ? new Date(session.resets.getTime() + 60_000) : undefined);
+if (behind < min) {
+  // when the week gone reaches usage + the number; past the reset, the new week's number
+  let at = start + ((week.used + min) / 100) * WEEK;
+  if (at >= week.resets.getTime()) at = week.resets.getTime() + (min / 100) * WEEK;
+  answer(1, say("week", v), new Date(Math.max(at, now + 5 * 60_000)));
+}
+answer(0, say("go", v));
+
+/** "Sep 30 at 2pm (Europe/Prague)", "Oct 2 at 11:30am (UTC)" → the moment. */
+function resetAt(s: string): Date | undefined {
+  const m = /^(\w{3})\w*\s+(\d{1,2})\s+at\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)\s*\(([^)]+)\)/i.exec(s.trim());
+  if (!m) return undefined;
+  const month = ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"].indexOf(m[1]!.toLowerCase());
+  if (month < 0) return undefined;
+  const hour = (Number(m[3]) % 12) + (m[5]!.toLowerCase() === "pm" ? 12 : 0);
+  const zone = m[6]!;
+  for (const year of [new Date().getUTCFullYear(), new Date().getUTCFullYear() + 1]) {
+    const guess = Date.UTC(year, month, Number(m[2]), hour, Number(m[4] ?? 0));
+    const at = guess - offsetMs(guess, zone);
+    if (at > Date.now() - DAY) return new Date(at);
+  }
+  return undefined;
+}
+
+/** The zone's offset from UTC at that moment ("Europe/Prague" in summer: +2 h). */
+function offsetMs(at: number, zone: string): number {
+  try {
+    const name = new Intl.DateTimeFormat("en-US", { timeZone: zone, timeZoneName: "longOffset" }).formatToParts(new Date(at)).find((p) => p.type === "timeZoneName")?.value ?? "";
+    const m = /GMT([+-])(\d{2}):?(\d{2})?/.exec(name);
+    return m ? (m[1] === "-" ? -1 : 1) * (Number(m[2]) * 60 + Number(m[3] ?? 0)) * 60_000 : 0;
+  } catch {
+    return 0;
+  }
+}

package/dist/brief/brief.js

@@ -10,6 +10,7 @@ import { displayName, familiesAsChild, familiesAsPartner, formatName, label, lif
 import { langName } from "../core/lang.js";
 import { methodFor } from "../core/assets.js";
 import { recentSessions } from "../core/session.js";
+import { briefClock } from "../core/clock.js";
 import { calibrationLine } from "../core/calibration.js";
 import { taskRecordsets } from "../core/frontier.js";
 import { reviewItems } from "../core/review.js";
@@ -122,6 +123,7 @@ export function buildBrief(tree, opts) {
             ...(research?.notes ?? []).slice(-3).map((n) => `From the user: ${n.text}`),
             `Research language: ${langName(lang)} — talk to the user and write notes, tasks and summaries in ${langName(lang)}; transcripts stay in the original language.`,
             "Work ONLY through `strom` commands; never edit files in data/ (it is detected and blocks all writing). Record findings as you go.",
+            opts.deadline !== undefined ? briefClock(opts.deadline) : "",
         ].filter(Boolean).join("\n"),
     });
     // 2. the task

package/dist/cli/main.js

@@ -11,6 +11,8 @@ import { isAgent } from "../core/which.js";
 import { noticeStromApp } from "../core/stromapp.js";
 import { isNewer } from "../core/update.js";
 import { refreshGlobal } from "../agents/global.js";
+import { clockLine } from "../core/clock.js";
+import { currentSession } from "../core/session.js";
 import { checkArgs, GroupOnly, parseOptions, resolveCommand, splitPassthrough } from "./execute.js";
 import "../commands/index.js";
 export { splitCommand } from "./execute.js";
@@ -74,6 +76,9 @@ export async function main(argv, io, env, cwd) {
     const json = argv.includes("--json");
     const debug = argv.includes("--debug");
     resetCache();
+    // what ran, for the reminder of the session's time
+    let ran;
+    let command;
     try {
         // "strom 'person list'" (one quoted word) means the same as strom person list.
         if (argv[0] && !argv[0].startsWith("-") && /\s/.test(argv[0].trim()))
@@ -109,6 +114,8 @@ export async function main(argv, io, env, cwd) {
             return EXIT.ok;
         }
         const ctx = Context.fromOptions({ env, cwd, io, json, values: v });
+        ran = ctx;
+        command = def.path.join(" ");
         // Started by the Strom app: remembered quietly (it is where the results go).
         if (env.STROM_APP)
             noticeStromApp(ctx.settings, env);
@@ -153,9 +160,27 @@ export async function main(argv, io, env, cwd) {
         // command has the tree to itself from its first read to its commit.
         const result = def.writes && def.tree && def.lock !== "sections" ? await ctx.tree().holdTreeLock(work) : await work();
         print(io, ctx, result);
+        remind(io, ctx, command);
         return result.exitCode ?? EXIT.ok;
     }
     catch (err) {
-        return printError(io, json, err, debug);
+        const code = printError(io, json, err, debug);
+        remind(io, ran, command);
+        return code;
     }
 }
+/** Near the end of a session with a time limit (strom run), every command reminds the agent how long it has left. */
+function remind(io, ctx, command) {
+    const line = ctx && command !== "session close" ? clockLine(ctx.env) : undefined;
+    if (!line)
+        return;
+    try {
+        // closed already: nothing to remind of
+        if (ctx.hasTree() && !currentSession(ctx.tree(), ctx.env))
+            return;
+    }
+    catch {
+        return;
+    }
+    io.stderr(line + "\n");
+}

package/dist/cli/menu.js

@@ -14,6 +14,7 @@ import { liveHolder } from "../core/lock.js";
 import { newerVersion } from "../core/update.js";
 import { taskQueue, waitingForUser } from "../commands/tasks.js";
 import { humanTask } from "../commands/browse.js";
+import { loadGate } from "../core/gate.js";
 import { lacksImages } from "../core/queue.js";
 import { othersAtWork } from "../core/session.js";
 import { DEFAULT_RUN_MINUTES } from "../core/config.js";
@@ -129,10 +130,15 @@ export async function runMenu(ctx, run) {
                             out(`      ${t("ui.plan.more", { n: queue.length - shown.length })}`);
                     }
                     out(t("ui.run.limit", { minutes: ctx.settings.number("run.minutes", fresh.config, DEFAULT_RUN_MINUTES) }));
-                    const how = shown.length ? await ctx.choose(t("ui.run.what"), [{ label: t("ui.run.queue") }, { label: t("ui.run.pick") }], 0, { back: t("ui.browse.back") }) : 0;
+                    // With a gate of the user's (run.gate): on for as long as there is work and the gate lets it.
+                    const gate = gateTitle(ctx);
+                    const ways = [{ label: t("ui.run.queue") }, { label: t("ui.run.pick") }, ...(gate ? [{ label: t("ui.run.loop", { name: gate }) }] : [])];
+                    const how = shown.length ? await ctx.choose(t("ui.run.what"), ways, 0, { back: t("ui.browse.back") }) : 0;
                     if (how === undefined)
                         return;
-                    if (how === 0) {
+                    if (how === 2)
+                        args = ["--loop"];
+                    else if (how === 0) {
                         let n = -1;
                         while (!(Number.isInteger(n) && n >= 0 && n <= 100)) {
                             if (outOfAnswers())
@@ -280,6 +286,20 @@ export async function runMenu(ctx, run) {
 }
 /** How many tasks of the queue the menu lists before the agent works alone. */
 const RUN_LIST = 15;
+/** The title of the user's gate (run.gate), when there is one to ask. */
+function gateTitle(ctx) {
+    const name = ctx.settings.runGate();
+    const shared = ctx.settings.shared()?.value;
+    if (!name || !shared)
+        return undefined;
+    try {
+        const g = loadGate(shared, name);
+        return g.manifest.title ?? g.name;
+    }
+    catch {
+        return name; // the run says what is wrong with it
+    }
+}
 /** "2", "1,4", "2-5", "1 3 6-8" → those numbers (1…max), in the order given, each once; undefined when anything else. */
 export function pickNumbers(answer, max) {
     const out = [];

package/dist/cli/ui.js

@@ -361,6 +361,7 @@ export const UI = {
     "ui.stats.tasks": "Tasks: in the queue {queued} · waiting for you {waiting} · done {done}",
     "ui.stats.sessions": "Sessions of the agent: {n} · the last {last}",
     "ui.stats.cost": " · cost so far {cost}",
+    "ui.stats.cost.partial": " (without sessions stopped before they said what they cost: {n})",
     "ui.stats.stories": "Stories: {n} (approved {final})",
     "ui.ped.noparents": "parents not known yet",
     "ui.ped.nofather": "father not known yet",
@@ -408,6 +409,20 @@ export const UI = {
     "ui.run.beside": "⚠ An agent is already working on its own here (runs: {n}). Another one beside it takes other tasks — the costs add up.",
     "ui.run.beside.sure": "Start another one beside it?",
     "ui.run.others": "⚠ Another run works in this family tree already (since {since}): this one takes other tasks — the costs add up.",
+    "ui.run.gate": "· condition: {name} — asked before each session; it may make the run wait",
+    "ui.run.gate.wait": "⏸ waiting until {at} — {reason} (Ctrl-C ends the run)",
+    "ui.run.stop.gate": "the condition “{name}” said stop — {reason}",
+    "ui.run.stop.gate.error": "the condition “{name}” gave no proper answer — {reason} (strom gate test)",
+    "ui.run.gate.once": "· condition: {name} — these tasks are yours to start: it is asked once, and if it would not start, you decide",
+    "ui.run.gate.anyway": "The condition “{name}” would not start now — {reason}. Start anyway?",
+    "ui.run.gate.later": "not yet",
+    "ui.run.gate.no": "no",
+    "ui.run.gate.noanswer": "no proper answer (strom gate test)",
+    "ui.run.stop.gate.declined": "not started — the condition “{name}”: {reason}",
+    "ui.run.loop": "Let it work on while there is work and the condition “{name}” allows it",
+    "ui.consent.gate.set": "Let the condition “{name}” decide when the agent working alone goes on?",
+    "ui.consent.gate.unset": "Remove the condition “{name}” — the agent working alone no longer asks it?",
+    "ui.consent.gate.skip": "Let the agent work on its own without the condition “{name}”?",
 };
 /** A text for the person, in their language. */
 export function ui(lang, key, values = {}) {

package/dist/commands/browse.js

@@ -112,7 +112,8 @@ register({
         out.push("", ui(lang, "ui.stats.tasks", s.tasks));
         if (s.sessions.count)
             out.push(ui(lang, "ui.stats.sessions", { n: s.sessions.count, last: humanDay(s.sessions.last, lang) }) +
-                (s.sessions.costUsd ? ui(lang, "ui.stats.cost", { cost: humanCost(s.sessions.costUsd, lang) }) : ""));
+                (s.sessions.costUsd ? ui(lang, "ui.stats.cost", { cost: humanCost(s.sessions.costUsd, lang) }) : "") +
+                (s.sessions.costUsd && s.sessions.costPartial ? ui(lang, "ui.stats.cost.partial", { n: s.sessions.costPartial }) : ""));
         if (s.stories.written)
             out.push(ui(lang, "ui.stats.stories", { n: s.stories.written, final: s.stories.final }));
         return { text: lines(...out), data: s };

package/dist/commands/gates.js

@@ -0,0 +1,58 @@
+// Gates: the user's condition on the agent working alone (core/gate.ts).
+import { register } from "../cli/registry.js";
+import { lines, table } from "../cli/format.js";
+import { StromError } from "../core/errors.js";
+import { askGate, ensureGatesDir, gatesDir, listGates, loadGate } from "../core/gate.js";
+function shared(ctx) {
+    const s = ctx.settings.shared()?.value;
+    if (!s)
+        throw new StromError("strom is not set up yet", { hint: "strom setup" });
+    ensureGatesDir(s);
+    return s;
+}
+register({
+    path: ["gate", "list"],
+    summary: "Gates: conditions on the agent working alone (strom run) — which there are, which one is asked",
+    group: "research",
+    run(ctx) {
+        const s = shared(ctx);
+        const set = ctx.settings.runGate();
+        const setName = set?.split(" ")[0];
+        const gates = listGates(s);
+        const folder = `folder: ${ctx.display(gatesDir(s))} — copy a gate's folder in to install it (the interface: README.md there)`;
+        return {
+            text: lines(gates.length ? table(gates.map((g) => [g.name === setName ? `${g.name} ◀ run.gate${set !== setName ? ` (${set})` : ""}` : g.name, g.manifest.title ?? "", g.manifest.command.join(" ")])) : "no gates", set ? `asked before each session of strom run: ${set} (strom config unset run.gate: none)` : "none is asked: strom config set run.gate <name> (only you)", folder),
+            data: { folder: gatesDir(s), gate: set ?? null, gates: gates.map((g) => ({ name: g.name, title: g.manifest.title, command: g.manifest.command, dir: g.dir })) },
+        };
+    },
+}, {
+    path: ["gate", "test"],
+    summary: "Ask a gate now what it would answer before a session: go on, wait (until when) or stop — and why",
+    group: "research",
+    args: [{ name: "gate", description: 'the gate and what it is given, e.g. "claude-usage 10" (default: run.gate)' }],
+    examples: ["strom gate test", 'strom gate test "claude-usage 10"'],
+    run(ctx, { args }) {
+        const s = shared(ctx);
+        const name = args[0] ?? ctx.settings.runGate();
+        if (!name)
+            throw new StromError("no gate named and none set", { hint: "strom gate list — strom gate test <name>" });
+        const gate = loadGate(s, name);
+        const tree = ctx.hasTree() ? ctx.tree() : undefined;
+        const agent = ctx.settings.agent(tree?.config).value;
+        const said = askGate(gate, ctx.env, {
+            tree: tree?.root ?? "",
+            lang: tree?.lang ?? ctx.uiLang(),
+            agent,
+            model: ctx.settings.models(agent, tree?.config).lead,
+            sessions: 0,
+            costUsd: 0,
+        });
+        const until = said.verdict === "wait" ? new Date(Date.now() + said.waitMs) : undefined;
+        const word = { go: "go on", wait: `wait until ${until?.toLocaleString(ctx.uiLang(), { weekday: "short", day: "numeric", month: "numeric", hour: "2-digit", minute: "2-digit" })}`, stop: "stop", error: "error — a run would stop" }[said.verdict];
+        return {
+            text: `${[gate.name, ...gate.args].join(" ")}: ${word}${said.reason ? ` — ${said.reason}` : ""}`,
+            data: { gate: gate.name, verdict: said.verdict, ...(said.reason ? { reason: said.reason } : {}), ...(until ? { until: until.toISOString() } : {}) },
+            exitCode: said.verdict === "error" ? 1 : 0,
+        };
+    },
+});

package/dist/commands/index.js

@@ -18,5 +18,6 @@ import "./browse.js";
 import "./story.js";
 import "./output.js";
 import "./session.js";
+import "./gates.js";
 import "./checks.js";
 import "./setup.js";

package/dist/commands/research.js

@@ -192,7 +192,11 @@ register({
         const tasks = created.map((id) => tree.get(id)).filter((t) => !!t);
         const open = tree.list("task").filter((t) => t.research === research.id && ["open", "doing"].includes(t.state));
         // what a session costs here, from those so far: the user decides with the price in view
-        const costs = tree.list("session").map((s) => s.metrics?.costUsd).filter((c) => typeof c === "number");
+        const costs = tree
+            .list("session")
+            .filter((s) => !s.metrics?.costPartial) // stopped before it said: more than it shows
+            .map((s) => s.metrics?.costUsd)
+            .filter((c) => typeof c === "number");
         const avg = costs.length ? costs.reduce((a, b) => a + b, 0) / costs.length : undefined;
         const list = tree.dryRun ? planned.map((t) => `  would add: ${t.level} · ${t.what}`) : tasks.map((t) => `  ${t.id} ${t.level} · ${t.what}`);
         const text = lines(...tree.written.map((o) => o.summary), tree.dryRun ? "(dry run — nothing written)" : undefined, "", list.length ? `${label(p)} — ${tree.dryRun ? planned.length : tasks.length} new task(s):` : `${label(p)} — nothing new to review${open.length ? `; ${open.length} task(s) of the review still open` : ""}`, ...list, open.length ? `${open.length} open in ${research.id}, about ${open.length} session(s)${avg !== undefined ? ` — sessions here cost $${avg.toFixed(2)} on average` : ""}` : undefined, open.length ? `next   strom run --research ${research.id}   (the agent alone) · or in a conversation: strom session start --research ${research.id}` : undefined);