LanQueue 0.9.0
See the version list below for details.
dotnet tool install --global LanQueue --version 0.9.0
dotnet new tool-manifest
dotnet tool install --local LanQueue --version 0.9.0
#tool dotnet:?package=LanQueue&version=0.9.0
nuke :add-package LanQueue --version 0.9.0

LanQueue
RAM and new hardware are expensive. Your old PCs are not. Plug them back in and give them work.
lanq is a small .NET global tool that sends builds, tests, log analysis and headless coding-agent jobs to the
other computers you already own. Your old machines can still help you get development done: all a worker needs is a
LAN connection, SSH, git and the toolchain for your jobs, and it joins your queue. No git on the old PC? Set
transfer: archive and it needs only SSH, tar and your toolchain. Your dev PC stays free for writing code.
Install
dotnet tool install --global LanQueue
dotnet tool update --global LanQueue
Requires the .NET 10 SDK on the machine you run lanq from, plus git and ssh on the PATH.
No .NET SDK? Each GitHub release also has a single-file native lanq for Windows (x64, Arm64), Linux (x64, Arm64,
glibc 2.27 and later) and macOS (Apple silicon), with SHA256SUMS, build-provenance attestations and a Scoop
manifest: https://github.com/jangolath/lanqueue#install
Quick start
- Write a starter
machines.ymlwithlanq init(or start from the example), list your machines, and make sure key-based SSH login works. - Check your setup and the fleet:
lanq doctor --remote, thenlanq health - Run a job from inside a git repository:
lanq run --needs dotnet,linux -- dotnet test -c Release - Bring results back: add
--fetch 'TestResults/**/*.trx'(repeatable) and the matching files land in.lanq/artifacts/<job id>/, whether the job passed or failed.
Onboarding a PC: lanq makeready --ssh user@old-pc.lan --os windows runs the read-only
lanq-makeready check over SSH (built in, sent on stdin, nothing written to
the PC) and suggests a machines.yml entry; lanq makeready --all checks every configured machine and prints one
summary table (--json for one object). lanq unlock <machine> clears slots left by a crashed run.
For scripts and coding agents, run, health, doctor, stats, makeready, init and wake take --json and
print one object with suggested nextSteps. lanq run --dry-run shows where a job would go without sending it,
lanq doctor --json lists each check with its fix, lanq stats --json gives pass rates and run times per machine and
per command, and --shards auto --target-minutes 10 sizes shards from earlier runs. See
docs/JSON.md and
AGENTS.md.
lanq picks the least loaded machine that has what the job needs, ships your current git state (including
uncommitted changes) to a throw-away worktree, runs the one allowlisted command, streams the log back and cleans up.
lanq's exit code is the job's own exit code; 2 means rejected by policy or bad arguments, 70 an infrastructure
error, 75 no eligible machine and 124 that the job ran past --timeout <minutes> (default 240) and was stopped.
A job that itself exits with 124 looks the same; the [lanq] TimedOut: ... status line on stderr tells them apart.
Setting up a pool for a team (one orchestrator, Windows 10/11 and Linux workers, low-RAM micro PCs, overnight family PCs)? Follow the team quick start.
What a worker needs
An SSH server, the toolchain your jobs use, and git (recommended, the default) or, with transfer: archive, just
tar (the built-in bsdtar on Windows 10 1803+; GNU tar or bsdtar plus gzip on Linux, busybox tar is refused). Nothing from lanqueue is installed on it, and it needs no GitHub
access. Setup steps for Linux and Windows: docs/WORKERS.md.
Lend it a shared or old PC
allowed_hoursper machine, by day:["Mon-Fri 22:00-07:00", "Sat,Sun 01:00-09:00"], on the worker's own clock. A job still running when the window ends is stopped after a grace period (exit 124,[lanq] WindowClosed).- Optional Wake-on-LAN per machine (
wake: {mac: "aa:bb:cc:dd:ee:ff"}):lanq runwakes one sleeping machine only when no awake one can take the job (needs--wait,--no-waketurns it off),lanq health --wakewakes sleepers, both only insideallowed_hourswith at leastmin_window_minutes+wait_secondsof the window left;lanq wake <machine> [--wait] [--json]wakes it on request. Needs Wake-on-LAN enabled in the BIOS/UEFI and the NIC driver, usually wired Ethernet; see docs/WORKERS.md. - A
PAUSEfile (Linux:PAUSEorpause) in the worker'swork_rootholds the machine; anyone at that PC can create or delete it. A job already running is not affected. - Jobs run at low priority by default (
nice/ioniceon Linux, BelowNormal on Windows);priority: normalturns it off. - Machines with little free memory are held (
min_free_mem_gb, Linux memory pressure), andlanq run --mem 4asks for a machine with at least 4 GB available. - Per-machine
env:(for exampleNODE_OPTIONS: "--max-old-space-size=2048") andpath_prepend:(for nvm, pyenv, rustup or sdkman tools a non-login SSH session cannot find).
Split long work across the pool
lanq run --shards 4 -- npx jest --shard={shard}/{shards} runs four pieces at once on free slots (--shards auto
uses every free slot that can take the job); each gets {shard}/{shards} in its arguments and LANQ_SHARD/
LANQ_SHARDS in its environment, and the snapshot is built once. Exit 0 only if every shard passed; --json prints
one object with a shards array. lanq health shows cores, total RAM, free slots and what each machine suits.
Recipes for .NET, Node, Python, Go and Rust:
docs/SHARDING.md.
Route jobs and run a whole plan
--min-size heavy or --size light,medium sends a job only to machines of that size (probed, or size: in
machines.yml), and --on big-01 only to named machines; every other rule still applies. A repository's lanq.yml
lists its jobs (build, unit tests, integration tests, a serial tail with after:), each one lanq run line, and
lanq run --plan runs them side by side on one snapshot with one result (--only, --dry-run, --json):
docs/PLANS.md.
Per-job options
--env NAME=VALUEsets a variable for one job, for names you list inpolicy.allowed_env(none by default); a deny table (loader, runtime startup, toolchain, profile,GIT_*andSSH_*variables) wins over that list. Settings only, never secrets.--exclusivetakes every slot of the machine, so nothing else runs there; it waits for an idle machine.--baselinereruns a failed job at the base commit (the merge-base with the default branch, or--baseline-ref) and says whether the failure isneworpreexisting; the exit code stays the job's.
Safe by default
- Key-only SSH with strict host-key checking; there is no password option.
- Only commands and directories you allowlist can run; arguments are quoted, never interpreted by a shell (Windows
workers never take arguments containing
"<>^%, nor&|unless the program is a native.exe, sincecmd.exeshims would re-parse them). - Worker output is untrusted: control, bidi and zero-width characters are shown as
?. --fetchtreats the worker as untrusted: regular files only (links never followed), sent as checksummed text (no archive is ever extracted), every path, size, count and hash checked again locally, files created new below.lanq/artifacts/<job id>/and never through a link. Fetch problems are reported but never change the exit code.- Best-effort secret scan of the command and uncommitted changes, plus the names of committed files (
.env,id_rsa,*.pemand similar) and the content of.npmrc,.pypircand.yarnrc.yml, before anything leaves your machine. - On git workers, git runs with hooks off, transports refused and the system and global git config ignored (git 2.32+), and a tampered cache is recreated; later jobs send only new commits.
- No daemon, no telemetry, and no network access except the SSH hosts you list.
More
MIT licensed.
| Product | Versions Compatible and additional computed target framework versions. |
|---|---|
| .NET | net10.0 is compatible. net10.0-android was computed. net10.0-browser was computed. net10.0-ios was computed. net10.0-maccatalyst was computed. net10.0-macos was computed. net10.0-tvos was computed. net10.0-windows was computed. |
This package has no dependencies.
| Version | Downloads | Last Updated |
|---|---|---|
| 0.12.0 | 99 | 11/14/2026 |
| 0.11.0 | 97 | 11/14/2026 |
| 0.10.1 | 92 | 11/14/2026 |
| 0.10.0 | 97 | 11/13/2026 |
| 0.9.2 | 91 | 11/13/2026 |
| 0.9.1 | 95 | 11/13/2026 |
| 0.9.0 | 93 | 11/13/2026 |
| 0.8.1 | 98 | 11/10/2026 |
| 0.8.0 | 87 | 11/10/2026 |
| 0.7.0 | 93 | 11/10/2026 |
| 0.6.0 | 88 | 11/10/2026 |
| 0.5.1 | 90 | 11/9/2026 |
| 0.5.0 | 90 | 11/9/2026 |
| 0.4.0 | 96 | 11/9/2026 |
| 0.3.1 | 91 | 11/9/2026 |
| 0.3.0 | 85 | 11/8/2026 |
| 0.2.0 | 98 | 11/8/2026 |
### Per-job environment variables
- `lanq run --env NAME=VALUE` (repeatable; single runs, `--shards`, `--dry-run`) sets a variable for this job only.
Shards get it too. The split is at the first `=`, and a name may be given only once (names are compared ignoring
case).
- The developer decides which names jobs may set: machines.yml `policy.allowed_env`, exact names or prefixes ending in
`*` (`[CONFIGURATION, TEST_FILTER, "MYAPP_*"]`). It is empty by default, so every `--env` is refused until the
developer lists names. A name not listed is `Rejected` (2) with an `ask_developer` step.
- A hard deny table applies on top, even to listed names, because these variables can make an allowlisted command run
other code or move where tools keep their files: the loader and shell startup names machines.yml already refused,
`PATH`, Node (`NODE_OPTIONS`, `NODE_PATH`), .NET (`DOTNET_STARTUP_HOOKS`, `DOTNET_ROOT*`, `CORECLR_*`, `COR_*`, ...),
Java, Python, Perl and Ruby startup and path variables, the Go toolchain and module settings and `CC`/`CXX`/`CGO_*`,
Rust (`RUSTFMT`, `RUSTUP_TOOLCHAIN`, `RUSTC`, `RUSTDOC`, `RUSTFLAGS`, `RUSTDOCFLAGS`, `RUSTC_WRAPPER`,
`RUSTC_WORKSPACE_WRAPPER`, `CARGO_ENCODED_RUSTFLAGS`, `CARGO_HOME`, `CARGO_TARGET_*`, `CARGO_BUILD_*`,
`CARGO_REGISTRIES_*`, `CARGO_SOURCE_*`), build tools (`JAVA_OPTS`, `GRADLE_USER_HOME`, `GRADLE_OPTS`, `MAVEN_OPTS`,
`MAVEN_ARGS`,
`MAKEFILES`, `MAKEFLAGS`, `DOTNET_HOST_PATH`, `NUGET_PLUGIN_PATHS`, `COMPLUS_*`, `DOTNET_MSBUILD_SDK_RESOLVER_*`),
TLS trust and proxies (`NODE_TLS_REJECT_UNAUTHORIZED`, `NODE_EXTRA_CA_CERTS`, `SSL_CERT_FILE`, `SSL_CERT_DIR`,
`REQUESTS_CA_BUNDLE`, `CURL_CA_BUNDLE`, `HTTP_PROXY`, `HTTPS_PROXY`, `ALL_PROXY`, `NO_PROXY`), package indexes
(`PIP_*`, `UV_INDEX_URL`, `UV_EXTRA_INDEX_URL`, `UV_INDEX`, `UV_DEFAULT_INDEX`, `UV_FIND_LINKS`, `UV_PYTHON`), OpenSSL and glibc module paths, profile and system folders (`HOME`, `USERPROFILE`, `APPDATA`, `TEMP`,
`TMP`, `XDG_CONFIG_HOME`, ...), `IFS`, `CDPATH`, and every name starting `GIT_`, `SSH_`, `NPM_CONFIG_`, `YARN_`,
`MSBUILD`, `LD_`, `DYLD_` or `LANQ_`. `NODE_ENV`, `GOOS` and `GOARCH` stay allowed. An `allowed_env` entry the
table fully covers (`GIT_*`, `HOME`, `PIP_*`, `CARGO_BUILD_*`, `CARGO_REGISTRIES_*`, `CARGO_SOURCE_*`) makes the
config fail to load; a prefix that only
partly overlaps (`NODE_*`, `UV_*`, `CARGO_*`) loads, and `lanq doctor` prints an informational `OK` line (`allowed_env`) saying those names stay refused, for
example `policy.allowed_env CARGO_*: names on lanq's deny list (CARGO_ENCODED_RUSTFLAGS, CARGO_HOME, CARGO_TARGET_*,
...) stay refused`.
- A deny-table name on the command line is a `fix_command` step ("this variable can never be set by a job; drop it or
ask the developer: ..."); from `lanq.yml` it is `ask_developer` ("the developer drops it from that job's env: in
lanq.yml").
- Each value must be non-empty and free of control characters, at most 4,096 characters, and 16,384 for all of a job's
variables together (`NAME=VALUE` each). Values are never echoed in a refusal.
- A machine whose own `env:` in machines.yml sets the same name is not used for the job (`env_conflict`), and neither
is a Windows machine on which lanq's largest job script plus the values would pass 8,000 characters
(`windows_command_too_long`). Both are permanent and judged from the config. When every capable machine clashes,
the run ends at once with `NoCapacity` (75, `retryable: false`) and an `ask_developer` step ("ask the developer:
they can drop --env CONFIGURATION or remove it from the machine's env (build-01, big-01)"); when the length rules
out the last ones, it is `Rejected` (2), naming each clashing machine too, with an `ask_developer` step ("they can
shorten or drop the --env values, or change machines.yml"; for a plan, "that job's env: values in lanq.yml"). An
agent stops and reports these; it never edits the config or drops variables to get through.
- `lanq.yml` gains `env:` in a job and in `defaults:`, a mapping of `NAME: value`. It is merged by name, the job's value
winning: the one exception to "a job's value replaces the default". Each entry becomes an `--env` flag.
- Variables go after the machine's `env:` and before lanq's own `LANQ_*`, quoted as data like the machine's.
### Exclusive jobs
- `lanq run --exclusive` (lanq.yml `exclusive: true`) takes every slot of the machine (`max_jobs`), all or nothing, so
no other lanq job, from you or anyone else, runs there while it does.
- It waits while any live slot is in use (`busy`, retryable: "busy (slots 1/4; --exclusive needs all 4 free)"). There
is no reservation, so on a machine that is never idle it waits out `--wait` and ends `NoCapacity` (75). Use `--on` with a
machine that is idle, or run it in quiet hours.
- `--exclusive --shards N` puts one shard on each machine; `--shards auto` counts the idle machines. A fixed N above the
machines that can take the job by config (capabilities, `size:`, `--env`) is refused (2) before any network.
`--mem` and Windows arguments are not part of that count, so extra shards wait for a machine that is idle.
- In a plan, the dry run marks an exclusive job's machine full, so a sibling job waits.
- Each slot of an exclusive job is an ordinary slot file, so `lanq unlock` and the stale-slot reclaim handle it like any
other (slot release itself now checks the holder; see Security).
- An exclusive claim also backs out when a live `slot-N` above its own `max_jobs` exists: another developer's
`machines.yml` with a higher `max_jobs` for the same `work_root` has a job there. That is one look at claim time, so
such a developer can still start a job in a higher slot afterwards: everyone sharing a worker should use the same
`max_jobs`.
- To fit the Windows command-line limit, every Windows slot claim (normal and exclusive) carries its fixed PowerShell
slot functions compressed (deflate, base64) and dot-sources them in memory, as the helper install already does. Some endpoint-protection tools flag that
pattern; the inflated text is lanq's constant claim code, and AMSI scans it as such.
### Baseline rerun: is this failure new?
- `lanq run --baseline` (lanq.yml `baseline: true`): when a job, a shard or a plan job ends `Failed` (its own non-zero
exit), lanq runs the same request again at the base commit, a clean tree, and says whether the failure is new.
Never after `TimedOut`, `WindowClosed`, `InfraError`, `NoCapacity`, `Rejected` or `Cancelled`.
- The base is the merge-base of HEAD and the default branch (`origin/HEAD`, else `origin/main`, `origin/master`,
`main`, `master`). `--baseline-ref REF` (lanq.yml `baseline_ref:`, implies `--baseline`) uses the merge-base of HEAD
and REF instead. On the base commit with uncommitted changes, the base is HEAD without them; with none, the baseline
is `skipped`. Refused (`Rejected`, 2) before anything is sent: a REF that is empty, over 256 characters, has control
characters, starts with `-` or contains `..`; a REF that is not a commit; a repository with no commit; no default
branch; unrelated history. A shallow clone that lacks the merge-base is not refused: the baseline is `inconclusive`.
- lanq.yml `baseline_ref:` must name a branch or tag (under `refs/heads/`, `refs/remotes/` or `refs/tags/`): a commit
id, `HEAD`/`*_HEAD` and revision characters are refused ("baseline_ref must name a branch or tag (a commit can be
given on the command line with --baseline-ref)"), so a repository's file cannot make lanq send any old tree to an
archive worker. `--baseline-ref` on the command line still takes any commit. A short name must exist under exactly
one of those (`baseline_ref NAME is both a branch and a tag; write refs/heads/NAME or refs/tags/NAME`, `baseline_ref
NAME names more than one ref (refs/heads/NAME, refs/remotes/NAME); write one of them`); a full `refs/heads/NAME` or
`refs/tags/NAME` is accepted; git's short forms `heads/main`, `tags/v1.0` and `remotes/origin/main`, which git would
accept, are refused with the full ref to write (`baseline_ref heads/main: write refs/heads/main`). The baseline's `ref` and label show the name as written.
- How the keys combine: a job's own `baseline: false` with its own `baseline_ref:` is an error; its own `baseline: false`
drops an inherited ref quietly; its own `baseline_ref:` turns the baseline on even when `defaults:` say `false`; its
own `baseline: true` under `defaults:` with `baseline: false` and a ref gives a plain `--baseline`.
- The verdict is `new` (the base completed), `preexisting` (the base failed too, any exit code), `inconclusive`
(anything else: timed out, no machine, the base could not be read or sent, Ctrl+C) or `skipped`. It is information
only: the run's status and exit code never change.
- Shards: only the failed shards rerun, with the same `LANQ_SHARD`/`LANQ_SHARDS`. Plans: only the failed jobs that
asked for it, after the whole plan has ended. Each rerun gets its own `--wait`.
- A rerun goes to the machine the job failed on: while that machine could take it but is busy, it waits up to 2 looks
(about 15 s each, never past what is left of its `--wait`) for a slot there, then takes any eligible machine; with
`--wait 0` (the default) it does not wait for it. A held or ruled-out machine is not waited for. On another machine,
`baseline.sameMachine` is `false` and the message and the `new` reason end `(on big-01, not build-01 where it
failed: the result may reflect the machine)`. Rerun lines are prefixed `[baseline]`, `[baseline 2/4]` or
`[baseline unit 2/4]` (`[baseline] [lanq] waiting for a slot on build-01, where the job failed, before taking
another machine (look 1 of 2)`, or `... (the other baseline reruns hold some)` while sibling reruns hold slots).
- Ctrl+C: a rerun not yet started is `inconclusive: cancelled (Ctrl+C) before it started` on every path (single,
shards, plans), with `status` `null` before it began waiting and `Cancelled` (130) while it waited or claimed a slot;
a running one is stopped and cleaned up (`Cancelled`, 130, inconclusive). A rerun that finds no machine is
`NoCapacity` (75), inconclusive.
- A rerun of an older commit leaves the worker's newer stored base (and `bases.json`) alone, so the next normal job
still gets a small incremental bundle.
- Output: a `[lanq] baseline: ...` line per rerun before the status line, a `baseline` object in `--json` (run, each
shard, each plan job), and the verdict in the `fix_code` reason. `--dry-run` prints the base (`Baseline: on failure,
rerun at 1a2b3c4 (merge-base with origin/main) (a dry run runs nothing)`; the JSON message has no suffix). When the
merge-base is the branch tip the base is named by the branch: `at 1a2b3c4 (origin/main)`.
- The base commit's payload gets the same committed-name and package-config secret scans as any snapshot (a hit:
`inconclusive: the base commit was not sent: Refused: possible secrets in payload (...)`). On an archive worker the
rerun receives the base commit's tree, an older version of the files.
- A red run costs about twice as long with `--baseline`.
### JSON and records
- Run, shard and plan job objects (and the dry runs) gain `env` (the variable names only, never values),
`exclusive: true` and `baseline` (`{ref, sha, status, exitCode, machine, jobId, logPath, durationSeconds, verdict,
message}`, plus `sameMachine` when the rerun ran somewhere). Each is left out when it does not apply.
- New permanent reason codes `env_conflict` and `windows_command_too_long`.
- `lanq health --json` rows gain `slotsStale` (only when above 0), and `freeSlots` counts live slots only; the text
line adds `(4 stale: reclaimed by the next claim)` and busy reasons `, 1 stale: reclaimed by the next claim`.
- `jobs.jsonl` gains optional `envNames`, `exclusive`, and on baseline reruns `baselineOf` (the failed job's id) and
`commit` (the base's short id); `v` stays 2. `lanq stats`, `--target-minutes` and the plan's history order leave
baseline reruns out.
- Like the other job options, `--env`, `--exclusive`, `--baseline` and `--baseline-ref` are refused with `--plan`
(set them in `lanq.yml`).
### Security
- `--env` is gated by `policy.allowed_env` (empty by default) and the hard deny table, and each `NAME=VALUE` goes
through the secret scan (`Rejected` 2, value never echoed). A repository's `lanq.yml` can set only names the
developer allowed. The table is a guard against the obvious ways a variable can turn an allowlisted command into
other code; it is not a sandbox.
- Values are visible to other users of the worker (its process list) and appear in the dry run and in suggested
commands in `nextSteps`, which repeat your command line. Never pass secrets with `--env`.
- Slot release now checks the holder: cleanup removes each slot (a normal job's single slot too) only while its first
line is still this job's id, so a late cleanup can no longer delete a slot another job reclaimed meanwhile.
- A claim that did not report back (timed out, lost connection, unreadable output, Ctrl+C mid-claim) is followed by a
best-effort release of the slots that hold this job's id (15 seconds, never fails the job).
### Fixes
- `--shards` with `--mem`: a shard that started while lanq was probing the machines was counted as running, as if its
memory showed in the probe's answer, although the machine answered before it ran. The next round could then place
one shard too many on that machine. Which shards are not running yet is now taken before the probe.
- Stale slots (a crashed run's, more than 30 minutes past their deadline) no longer make a machine busy. The probe
reports them (`slots_stale=`), placement and `freeSlots` count only live slots, and the next claim reclaims them as
it passes. Before, one dead job's slot kept a machine busy for every `--exclusive` job for ever, and a dead
exclusive job's slots blocked the machine for everyone until something reclaimed them. `lanq health` shows them as
`(4 stale: reclaimed by the next claim)`.
- A stale slot a claim cannot reclaim counts as busy for the rest of the run. The claim reports it
(`RECLAIM=STUCK slot-N`) only when the slot's `.reclaim` lock is older than about a minute (a dead reclaimer's), no lock
could be made, or the file could not be moved or deleted; a younger lock (a reclaim in progress) or a claim that
simply lost the slot to another job never marks the machine. lanq prints one line per machine, counting the slots
the claim named: `[lanq] build-01: 1 stale slot could not be reclaimed (a .reclaim lock or file
permissions); counting it as busy for this run; lanq unlock build-01 clears it`. Busy reasons then read `busy (slots
2/2, 1 stale, not reclaimable)`. On Windows an unreadable slot above `max_jobs` now counts as live, as on Linux.
- Linux workers: stopping a stale job from inside the stale-slot reclaim or `lanq unlock` overwrote the loop's own
variables, which could miss the reclaim, leave a `.reclaim` lock behind and report a slot as `REMOVED=` that was not.
### Tests
- Two tests that failed now and then on GitHub's Windows runner are now deterministic. The `--mem` placement test's
fake machine now reports less free memory once a shard's upload is done, as a real job would use it. The newline-free flood test now measures the reader's
memory on one thread, not process-wide, where work left by earlier tests counted too.
- The exclusive-claim race tests run the real sh scripts behind a ready/go barrier, including an exclusive claim that
must back out while two normal claims race it.
- The plan test for `--wait` counting only while no plan job holds a slot (`WaitCountsOnlyWhileNoPlanJobHoldsASlot`)
no longer depends on timing: it releases the first job only after the second has said it waits.
### Dependencies
- The native binaries carry the .NET 10.0.15 runtime (was 10.0.14).
### Docs
- README sections for `--env`, `--exclusive` and `--baseline`:
https://github.com/jangolath/lanqueue/blob/main/README.md
- Plan keys `env`, `exclusive`, `baseline` and `baseline_ref`: https://github.com/jangolath/lanqueue/blob/main/docs/PLANS.md
- The new JSON fields and reason codes: https://github.com/jangolath/lanqueue/blob/main/docs/JSON.md
- What an agent may and may not do with each: https://github.com/jangolath/lanqueue/blob/main/AGENTS.md and
https://github.com/jangolath/lanqueue/blob/main/docs/AGENTS-GUIDE.md (also the snippets, the skill and llms.txt).
- `machines.example.yml` shows a commented `policy.allowed_env`.
Full changelog: https://github.com/jangolath/lanqueue/blob/main/CHANGELOG.md