Three verbs tell you everything about a run. status is the cold re-orient command — reach for it first when you've lost context.

cold re-orientation — after losing context, read loom list then loom status <name>, then go to the durable artifacts on disk:

Run-level agent logs live under .loom/<plan>/logs/; milestone sprint logs live under that milestone's own logs/. The last timestamped ▶ line tells you which stage is still active.

Killed process or lost terminal? Resume is just re-running Loom. Done sprints are re-derived from the committed ledger and skipped — you only ever lose the in-flight sprint.

A run that's genuinely botched — and should not resume — gets wiped instead:

--clean and --remove dry-run by default — they print what they would delete and ask first; add --yes (-y) to skip the prompt.

A 529/overloaded, a rate-limit, a 5xx, or a dropped connection is not a stop. Loom retries the stage on the LOOM_RETRY_DELAYS schedule — by default immediate, then +10 min, then +1 h, then give up (four attempts).

Detection is allow-list only: a genuine error — auth, a CLI bug — stays terminal and is never retried. Set LOOM_RETRY_DELAYS= (empty) to disable retry and fail fast.

Two distinct ceilings guard against a runaway agent — and the routine one is a no-progress guard, not an elapsed-time limit, so a long chunk on a busy box is never killed just for taking a while.

Both are per-unit overridable via a sprint file's front-matter, so an unusually long or quiet unit can raise its own ceilings without changing the job-wide defaults:

---
no_progress_secs: 3600
timeout_secs: 28800
---

When the stall guard does fire on execute, Loom doesn't discard the work: it commits the worktree and runs the real gate. A green gate ⇒ the chunk is DONE and the run advances.

Each agent runs inside a containment wrapper — best-effort bubblewrap by default: a private PID namespace and a read-only main checkout, transparent otherwise. Network and the rest of the filesystem stay read-write, so the agent can build in its worktree, run git and tests, and reach the API.

modes — set LOOM_SANDBOX (also read from .env.loom, so per-project opt-in is one line):

host setup (bubblewrap) — install it, then confirm unprivileged user namespaces work:

sudo apt install bubblewrap     # Debian/Ubuntu
sudo dnf install bubblewrap     # Fedora
sudo pacman -S bubblewrap       # Arch

bwrap --dev-bind / / --proc /proc --unshare-pid true && echo ok

If that fails with setting up uid map: Permission denied, your kernel restricts unprivileged userns. On Ubuntu ≥24.04 (AppArmor), the preferred fix grants only bwrap the right — minimal, no system-wide relaxation, no setuid:

sudo tee /etc/apparmor.d/bwrap >/dev/null <<'EOF'
abi <abi/4.0>,
include <tunables/global>
profile bwrap /usr/bin/bwrap flags=(unconfined) {
  userns,
  include if exists <local/bwrap>
}
EOF
sudo apparmor_parser -r /etc/apparmor.d/bwrap

Or relax it more broadly (reverts a deliberate hardening), or — on distros gated by unprivileged_userns_clone instead — flip that sysctl (persist in /etc/sysctl.d/):

sudo sysctl -w kernel.apparmor_restrict_unprivileged_userns=0
sudo sysctl -w kernel.unprivileged_userns_clone=1

Re-run the check; Loom then reports sandbox — agents run under bwrap … at startup.

Back to the rest of the docs: