# Time budget This file says how long a command, proof, seat or wait may run, and where a measurement that cannot fit goes. The pstack block in `AGENTS.md` points here. The `sync-pstack` skill renders this file from its shared source in `udecode/dotai`, so change it there. - **Time budget.** No command or proof that a run starts takes more than an hour, so development stays fast (owner's word, 2026-10-16); only a stress run, below, takes longer. A panel seat, an `architect` or arena runner and a Codex worker have no time limit, because a long review or build is worth its wait (owner's word, 2026-11-19). `cross.mjs` stops one only after 1,200 seconds with no sign of work: no output from a Codex or agy run, and no output or transcript write from a Claude run. It still honors a `--timeout` the lead passes, such as for a measurement whose command must fit the hour. Nothing waits for the host's load to drop (owner's word, 2026-10-19), except for a share of the machine's core pool (owner's word, 2026-10-26). Each worker holds half a core of that pool while it runs, so twice as many workers as cores run at once. A `proof.mjs` command asks for one worker's share, and the pool counts the workers the command runs (owner's word, 2026-11-14). Each process under the command that is running or ready to run is one worker, and a process whose threads use several cores is that many. A command holds the larger of its ask and that count, so a session never has to know how many workers its command starts. `--cores ` asks for the share of n workers before the command starts, so a command known to be large waits for that room first. The count leaves out a process that detaches from its command, and anything that runs outside `proof.mjs` and land.mjs. A `--stress` run holds a whole core for each worker instead, and runs at most half as many workers as the machine has cores, so a run that lasts hours leaves the other half to shorter proofs (owner's word, 2026-11-13). `proof.mjs` refuses a `--stress` run whose `--cores` is over that half. That refusal reads only `--cores`, so the session passes the command's real worker count there, and a stress run that starts more workers than that still holds a whole core for each. A landing takes one core before its first rebuild or check and holds it through every recheck, and the pool counts the workers of its lint fix and checks under it. A landing and its check never wait in the pool, whatever the cores and memory, because every session waits on its landing (owner's word, 2026-11-16); the pool only counts their workers against the proofs that queue. A proof waits while the cores held by every session on the machine, plus the cores every waiter ahead of it asked for, leave too few for it, or while free memory is under 15%, and prints who holds the pool and what each holder uses beyond its ask. It also waits up to six seconds after another command starts, while the pool counts that command's workers, so commands that start together cannot all enter before the pool has counted the workers of any of them. Waiters enter in the order they arrived, except that a small ask that fits the free cores now enters past a larger waiter that has waited under five minutes. A proof that another proof or a land check starts takes no share, because its parent already holds one. Many proofs started at once therefore run as cores free up. The lead runs a gate or proof now. When it fails only because the host is loaded, the lead reruns it now, or does other ready work and reruns it when that work is done. Host load alone never makes a time-sensitive measurement inconclusive; only its own measured noise does, such as the gap between interleaved same-code arms. When that noise makes it inconclusive, the lead logs it `inconclusive` with `proof:` its log, names its next probe and goes on. A rerun that cannot fit the hour goes to a suggested task, as below. In the owner's Claude Code, the user-scope hook `~/.claude/hooks/block-load-waits.mjs` refuses a shell loop that sleeps until the load average drops. The budget keeps a lead from holding long work while other chips wait to land, so long work runs in a dedicated chip. Before a proof that may run long, the lead times one sample and narrows the proof to fit. It never runs one protocol as pieces that together pass the hour. A measurement that a decision waits on, such as a probe before a design is accepted, narrows to fit as well, and an inconclusive narrowed result leaves that decision open with its next probe named. Any other measurement that cannot fit, such as a soak, a large-cohort sweep, a multi-round interleaved timing protocol or a final rerun of built code, never blocks the run or its close. When it is still worth running, the lead offers it as a suggested task with `via: time` through the `chips` skill's Offer mode, waiting `run:`, so its card's worktree starts from the landed change. The offer names the command, the source identity it must measure, its budget, what a miss triggers and the plan step it settles. The measurement goes to `## Open work` with `owner:` the owner and `stop:` that task landing or being dropped, and this hand-off is the owner's word that the narrower exit condition counts as done. The Close claims only what the run measured. The card's session confirms that its worktree holds that source identity before it runs, and stops and tells the owner when it does not. A conclusive miss it finds is a pivot finding, which that session leads as the Autopilot rule says. Only that session, or the run once the owner asks, passes `--stress`. Without `--stress`, `proof.mjs` stops a command after 3,600 seconds or its shorter `--timeout`, kills every process still in the command's process group and logs the run as timed out. `proof.mjs` refuses a longer `--timeout` without `--stress`.