Recommended tman settings, one tool at a time

The right caps depend on what the command actually does. A cold Rust build is silent for minutes and must not be mistaken for a hang. A Playwright suite leaks browsers and binds a port. A dev server is designed never to exit, so a wall-clock limit on it is guaranteed to fire and guaranteed to mean nothing. One page per tool, with the reasoning behind each number.

Every number below is a starting point derived from how the tool behaves, not a measurement of your machine. Each guide ends with the one command that turns it into a real one.

Every tool at a glance

tool	stall	max-time	max-mem	max-parallel
Vitest	`10m`	`15m`	`4096`	`2`
Jest	`10m`	`20m`	`4096`	`2`
pytest	`10m`	`20m`	`4096`	`2`
go test	`15m`	`20m`	`—`	`2`
dotnet test	`15m`	`20m`	`—`	`2`
cargo test	`30m`	`45m`	`—`	`1`
Playwright	`15m`	`30m`	`8192`	`1`
RSpec	`10m`	`20m`	`4096`	`1`
Gradle & Maven	`15m`	`30m`	`8192`	`1`
ESLint	`5m`	`10m`	`—`	`4`
Ruff	`5m`	`5m`	`—`	`4`
Biome	`5m`	`5m`	`—`	`4`
golangci-lint	`10m`	`15m`	`6144`	`2`
TypeScript (tsc)	`15m`	`15m`	`8192`	`2`
Vite & webpack	`10m`	`20m`	`—`	`2`

Unit and integration test runners

Vitest

Watch mode never exits; the thread pool is where memory goes.

JavaScript / TypeScript

Jest

Open handles keep the process alive forever — the exact shape stall detection catches.

JavaScript / TypeScript

pytest

Chatty by default, quiet during collection; xdist workers orphan on a hard kill.

Python

go test

Silent for minutes while compiling; keep Go's own -timeout below tman's.

dotnet test

Restore and build are quiet; testhost processes are famous orphans.

.NET

cargo test

The longest quiet stretch of any common command; linking is the memory spike.

Rust

RSpec

Chatty during the run; preloaders like Spring leave daemons behind.

Ruby

Gradle & Maven

The Gradle daemon deliberately outlives your run — supervise around it, not through it.

JVM

Browser and end-to-end suites

Playwright

Browser downloads look like a hang; browsers and web servers are the orphans.

JavaScript / TypeScript

Linters, formatters, and typecheckers

ESLint

Cheap unless type-aware rules are on — then it is a typecheck wearing a linter's name.

JavaScript / TypeScript

Ruff

Fast enough that the caps are only there to catch a pathological case.

Python

Biome

Native speed; supervise it for uniformity, and pin --error-on-warnings.

JavaScript / TypeScript

golangci-lint

The lint that actually needs a memory ceiling — whole-program analysis is greedy.

TypeScript (tsc)

Minutes of total silence on a large project, and --watch must never get a timeout.

JavaScript / TypeScript

Compilers and bundlers

Vite & webpack

Builds want the cores and the RAM; dev servers must never get a timeout.

JavaScript / TypeScript

First, attach tman to your agent

Caps only apply to commands that actually run under tman. If your test runs are still being issued bare by an AI agent, start with theper-agent setup guides — Claude Code, Codex CLI, Gemini CLI, Cursor, Antigravity, Kimi, opencode, and Copilot CLI each attach differently.

Frequently asked

What is the difference between --stall and --max-time?

--stall asks 'is this process dead?' and --max-time asks 'has this taken too long?'. A stall kill needs no output *and* no CPU, IO, or kernel IO-wait activity for the whole window, so a quiet-but-busy compile survives it. Only --max-time can bound a run that is genuinely working but will never finish, such as a wait on a peer that never answers.

Why does tman set no default memory or CPU ceiling?

Because a build is supposed to saturate cores and can legitimately want several gigabytes. Culling one out of the box would break `tman run -- vite build` in a project with no config. --max-mem and --max-cpu are opt-in, and worth opting into where a real leak mode exists — worker pools, browser fleets, whole-program analysers.

What do exit codes 124, 125, and 126 mean?

124 is a wall-clock timeout (--max-time), 125 is a stall (--stall), and 126 is a resource cull (--max-mem or --max-cpu). All three are findings rather than flakes: the right first response is to ask why the cap fired, not to widen it.

Should a lint alias and a test alias share a parallel limit?

No, and they do not have to. Slots are scoped per bucket — the alias name plus the directory governing the run — so a lint alias can hold four slots while the test alias in the same repository holds two, without either affecting the other.