ProcLease v0.1.9 experimental preview

ProcLease v0.1.9 is an experimental release adding session-scoped foreground
execution and file controls for agent hosts that retain a native execution task.
Runtime dependencies and the Rust 1.89 minimum are unchanged.

Session-scoped foreground mode

Use run --foreground inside a host-supported persistent execution session or
background Bash task. The invocation stays alive until its job finishes, and
with --json emits one flushed startup/readiness object. Application output
stays in the bounded job log. The default detached mode remains unchanged.

proclease --json run --foreground --ttl 45m --owner codex --task preview \
  --wait-for-port 5173 -- npm run dev -- --host 127.0.0.1

Foreground jobs use bounded private request/reply files for stop and extend,
without creating or probing a Unix socket. Status/log reads do not renew leases.
The existing keeper/guardian owns expiry and group cleanup; there is no command
broker, elevated daemon, automatic fallback or broader sandbox grant.

A retry key includes the launch mode. Wrong-mode retries fail even with
--reuse; a matching retry returns the retained job immediately without
attaching, launching or renewing. An extension with an unknown reply is never
automatically resent. Request IDs remain protected through their validity
window, and capacity pressure refuses work instead of allowing replay.
File state has the existing private same-user trust boundary, not authenticated
agent identity or an atomic global queue admission limit.

Cleanup and compatibility limits

The first ordinary SIGINT, SIGTERM or SIGHUP requests bounded keeper cleanup
and exits with 128 + signal, independently of blocked stdout/stderr. Notices
are best effort. Repeated signals exit immediately. A job lasts at most as long
as its session and lease. Whole-client/sandbox teardown can kill supervisors
before a final record: unverified jobs remain protected as unknown or
interrupted, never relabelled as proven cleanup.

The compatibility matrix
records pre-release Codex/strict-Claude Linux checks of cross-call file control,
logs, extension/reuse, stop and expiry under unchanged policies. This supports
session-scoped control, not survival after client exit. Claude early normal
exit was not exercised because that invocation remained alive through expiry.
Strict Claude still denies Unix sockets and isolates each tool call's localhost;
later HTTP checks fail while file controls work. No port forwarding, private
network joining or new Vite/Next.js workflow compatibility is claimed.

The suite contains 32 unit and 64 lifecycle tests, including full-pipe signal,
file-type/size/time limits, replay pressure, backwards-clock refusal and mixed
transport controls. Release automation runs the suite, format/Clippy checks,
optimized builds and archive/installer smoke checks natively on macOS ARM64/Intel
and Ubuntu 22.04 ARM64/x64 (glibc). These are distinct from real-agent tests.
The macOS minimum is 15.0; Windows and Linux musl/Alpine binaries are not provided.

Installation

Review this release's install.sh, then run:

sh install.sh --skills both
proclease --version

The checksum-verifying installer installs the CLI and matching portable skill
without sudo or Rust. Omit --skills both for CLI only. Existing unrelated skill
directories and links are preserved. Cargo installs only the CLI:

cargo install proclease --version 0.1.9 --locked

Upgrading does not replace running keepers or watches or restart managed work.
Do not signal a saved PID or delete unverified history. A service can escape
group cleanup by creating another process group/session. Retention protection
requires cooperating clients and keepers.

macOS Developer ID signing/notarization remains deferred for this experimental
prerelease and required before stable promotion. Ad hoc signatures and checksums
do not establish publisher identity. The CLI-only crate provides a docs.rs
README/source overview rather than a library API.

Created by Jared Chu, with Codex and Claude contributions. See the README for credits.

ProcLease v0.1.8 experimental preview

ProcLease v0.1.8 is an experimental patch release for agent retries and Linux
sandbox failure handling. Runtime dependencies and the Rust 1.89 minimum are
unchanged.

Explicit retry reuse

Some agent hosts change their environment between tool calls. Ordinary keyed
retries still require the original environment. The new
run --reuse --key REQUEST_ID observes the retained job with its original
environment and never launches, renews or resurrects anything. Command,
canonical directory and all other launch options must still match. An absent,
collected or incomplete key fails without starting a job.

Mismatch diagnostics name differing fields rather than disclosing values.
Keep command prefixes and launch options unchanged when retrying. See the
lease rules.

Conservative Linux supervision

• A Unix control-socket preflight runs before reserving a job. Socket-denied
  launches leave no job and do not consume a retry key. Read-only reuse of an
  existing job remains available.
• Saved Linux PIDs are interpreted only from a complete matching execution
  context. Foreign or unverifiable contexts have unavailable metrics and never
  justify PID-based cleanup or inferred completion.
• A recent foreign-context stopping record gets a bounded finalization window
  so a healthy keeper can write its final state. It becomes unknown if
  finalization cannot be verified.
• Verified keeper-finalized history still follows the existing 24-hour/newest
  100 collection limits across reboots or namespace changes. The proof requires
  observed group absence after cleanup and no future lifecycle writer.
  Uncertain groups and unfinalized or legacy records remain protected where
  absence cannot be established, retaining their logs and retry keys.

Jobs active or stopping at a Linux reboot can remain unknown afterwards.
Restricted procfs access can disable PID-derived absence checks and metrics.
There is no forced-history deletion command; do not delete unverified records
merely to hide them or signal a PID copied from disk.

Agent workflows and limits

The documentation includes a macOS Next.js 16.4.5 polling recipe for both
Turbopack and Watchpack. It is an application opt-in, not an automatic ProcLease
configuration change. It retains the host sandbox and bundler.

The compatibility matrix
records scoped macOS and native Linux measurements made before packaging this
release. Default-Claude Linux Vite/Next workflows passed; the tested Linux
Codex workspace sandbox and strict Claude Bash sandbox remain unsupported.
Those profiles do not preserve the required supervisors across tool calls;
strict Claude also denies Unix sockets. The new diagnostics do not bypass those
restrictions. A host-supported persistent execution context is a requirement,
not a demonstrated workaround.

The suite contains 25 unit and 56 lifecycle tests. Release automation runs
formatting, Clippy, tests, optimized builds and archive/installer smoke checks
natively on macOS ARM64/Intel and Ubuntu 22.04 ARM64/x64 (glibc). These are not
new real-agent workflow measurements. The macOS deployment minimum is 15.0;
Windows and Linux musl/Alpine binaries are not provided.

Installation

Review this release's install.sh, then run:

sh install.sh --skills both
proclease --version

The installer verifies archive SHA-256 checksums and atomically replaces the
CLI without sudo or Rust. Omit --skills both for CLI-only installation.
Existing unrelated skill directories and links are preserved. Cargo installs
the CLI only; the portable skill is separate:

cargo install proclease --version 0.1.8 --locked

Upgrading does not replace running keepers or watch sessions and does not
restart or stop managed work. Status, logs and readiness never renew leases.
ProcLease manages only services it launched; descendants that leave the managed
process group can escape cleanup. Retention protection requires cooperating
clients and keepers.

macOS binaries are not Developer ID signed or notarized. Both remain required
before stable promotion and deferred for this experimental prerelease.
Checksums verify bytes, not publisher identity. The CLI-only crate provides a
docs.rs overview, README and source rather than a library API.

Created by Jared Chu, with Codex and Claude contributions. See the README for credits.

ProcLease v0.1.7 experimental preview

ProcLease v0.1.7 is an experimental patch release fixing interrupted jobs that
remained in the default list and watch views indefinitely. Runtime
dependencies and the Rust 1.89 minimum are unchanged.

Interrupted history

If a keeper dies during cleanup, its final saved record can remain stopping.
Observation derives interrupted once the managed group is gone, but cannot
recover the exact command exit time. Previously, that unknown timestamp kept
the row visible forever.

When both keeper and managed group are verified absent, the default view now
uses the last saved lifecycle-write time for the existing 30-second recent-job
window and five-job cap. This also handles records left by older versions.
list --all, watch --all and direct logs still expose retained history.

The display anchor is neither serialized nor persisted: finished_at_ms stays
null, no lifecycle record is rewritten, and conservative history collection
continues to preserve these records. Active and unverified work remains visible.
A live, reused or zombie keeper PID, uncertain group absence, or an unusable or
future modification time also keeps the row visible. Wall-clock and file times
affect the display window; the anchor is not an exact completion time.

The suite has 15 unit and 49 lifecycle tests, including real keeper interruption,
legacy records, the recent-job cap, JSON compatibility and retention protection.
See the README
for behavior and history access.

Installation

Review this release's install.sh, then run:

sh install.sh --skills both
proclease --version

The installer verifies the native archive's SHA-256 checksum and atomically
replaces the CLI without sudo or Rust. Omit --skills both for CLI-only
installation. Existing unrelated skill directories and links are preserved.

Source installation requires Rust 1.89 or newer:

cargo install proclease --version 0.1.7 --locked

Cargo installs the CLI; the portable skill is separate. The CLI-only crate has
a docs.rs overview, README and source rather than a library API.

Compatibility and limits

The release workflow runs native checks and archive/installer smoke tests on
macOS ARM64/Intel and Ubuntu 22.04 ARM64/x64 (glibc). The macOS deployment minimum
is 15.0. Windows and Linux musl/Alpine binaries are not provided.

macOS binaries are not Developer ID signed or notarized. Both remain required
before stable promotion and deferred for this experimental prerelease.
Checksums verify bytes; they do not replace an authenticated publisher signature.

ProcLease manages only services launched through it. Descendants that create a
new process group can escape cleanup. Upgrading the CLI leaves running jobs and
watch sessions on their original executable. Restart an existing watch to use
the corrected display filter; closing watch does not stop managed jobs.
Installation itself does not restart or stop anything. Status, logs and readiness
checks never renew leases. Bulk-stop retention protection requires cooperating
clients and keepers.

Created by Jared Chu, with Codex and Claude contributions. See the README for credits.

ProcLease v0.1.6 experimental preview

ProcLease v0.1.6 is an experimental prerelease adding bounded readiness checks
after launch. Runtime dependencies and the Rust 1.89 minimum are unchanged.

Readiness checks

proclease run --task preview --ttl 30m --wait-for-port 5173 -- npm run dev
proclease run --task preview --ttl 30m --wait-for-log "ready in" --wait-timeout 1m -- npm run dev

--wait-for-port observes a TCP connection on IPv4 or IPv6 loopback;
--wait-for-log looks for literal text in captured output. With both flags,
both conditions must hold. The default wait is 30 seconds and the maximum is
5 minutes. Text must be 1–512 bytes without control characters.

Readiness is an observation for this invocation. It never changes the lease,
restarts the command, persists a health state or proves application health or
port ownership. A keyed retry may change its readiness options while returning
the same retained job and deadline. --url remains metadata.

An unmet check exits nonzero and reports the job plus its readiness result;
the job may still be running under its original lease. Keep its ID, inspect
logs, stop that job or retry the same key. Do not launch a duplicate to recover
from a readiness timeout. JSON without readiness flags keeps its existing shape.

The suite includes 14 unit and 48 integration tests, including expiry during a
wait, keyed retries, literal output and bounded log observation. See the
README
and architecture
for behavior and limits.

Installation

Review this release's install.sh, then run:

sh install.sh --skills both
proclease --version

The installer verifies the native archive's SHA-256 checksum and atomically
replaces the CLI without sudo or Rust. Omit --skills both for CLI-only
installation. Existing unrelated skill directories and links are preserved.
Restart agent sessions to discover a newly installed skill.

Source installation requires Rust 1.89 or newer:

cargo install proclease --version 0.1.6 --locked

Cargo installs the CLI; the portable skill is separate. The CLI-only crate has
a docs.rs overview, README and source rather than a library API.

Compatibility and limits

The release workflow runs native checks and archive/installer smoke tests on
macOS ARM64/Intel and Ubuntu 22.04 ARM64/x64 (glibc). The macOS deployment minimum
is 15.0. Windows and Linux musl/Alpine binaries are not provided.

macOS binaries are not Developer ID signed or notarized. Both remain required
before stable promotion and deferred for this experimental prerelease.
Checksums verify bytes; they do not replace an authenticated publisher signature.

ProcLease manages only services launched through it. Descendants that create a
new process group can escape cleanup. Upgrading the CLI leaves running jobs and
watch sessions on their original executable; installation does not restart or
stop them. Status, logs and readiness checks never renew leases. Bulk-stop
retention protection from v0.1.5 is retained and requires cooperating clients
and keepers.

Created by Jared Chu, with Codex and Claude contributions. See the README for credits.

ProcLease v0.1.5 experimental preview

ProcLease v0.1.5 is an experimental prerelease adding scoped bulk stop and
retention protection for its completion results. It also includes bounded
control exchanges and test corrections since v0.1.4. Runtime dependencies and the
Rust 1.89 minimum are unchanged.

Bulk stop

proclease stop --all --task preview --dry-run --json
proclease stop --all --owner claude --task preview --json

stop requires either one job ID or explicit --all. Owner and task filters
match exactly and combine with AND. The selected IDs are fixed before shutdown;
later launches are excluded. Labels are declared metadata, not authorization to
stop another task's jobs. Unfiltered stop --all covers the selected registry.

The command reports every result and scan warning, continues after individual
failures, and exits nonzero for incomplete cleanup. Unknown jobs are never
signalled from saved PIDs. Supervisor requests use absolute time limits and
bounded concurrency; the existing TERM/grace/KILL lifecycle remains authoritative.
Single-ID JSON remains unchanged. prune --json adds a deferred flag.

Bulk stop protects completion records until results are captured. Normal history
collection resumes afterward; the OS releases protection if the client dies.
All clients and keepers pruning a shared state directory must include this fix.
Upgrading the CLI leaves already-running jobs under their original supervisors;
older keepers do not honor retention protection. Existing jobs are not restarted
or stopped by installation.

The suite includes 9 unit and 42 integration tests. A 105-job reproduction of the
retention race now reports all real jobs finished, with only its deliberately
unresponsive endpoint failing. See the
verification record
for evidence and limits.

Installation

Review this release's install.sh, then run:

sh install.sh --skills both
proclease --version

The installer verifies the native archive's SHA-256 checksum and atomically
replaces the CLI without sudo or Rust. Omit --skills both for CLI-only
installation. Existing unrelated skill directories and links are preserved.
Restart agent sessions to discover a newly installed skill.

Source installation requires Rust 1.89 or newer:

cargo install proclease --version 0.1.5 --locked

Cargo installs the CLI; the portable skill is separate. The CLI-only crate has a
docs.rs overview, README and source rather than a library API. The Cargo 1.89
build-time stripping correction from v0.1.4 is retained.

Compatibility and limits

The release workflow runs native checks and archive/installer smoke tests on
macOS ARM64/Intel and Ubuntu 22.04 ARM64/x64 (glibc). The macOS deployment minimum
is 15.0. Windows and Linux musl/Alpine binaries are not provided.

macOS binaries are not Developer ID signed or notarized. Both remain required
before stable promotion and deferred for this experimental prerelease. Checksums
verify bytes; they do not replace an authenticated publisher signature.

ProcLease manages only services launched through it. Descendants that create a
new process group can escape cleanup. Use native storage for state in VMs.
Status and log reads never renew leases. Retention protection is cooperative and
can temporarily defer collection beyond the usual newest-100/24-hour policy.

Created by Jared Chu, with Codex and Claude contributions. See the README for credits.

ProcLease v0.1.4 experimental preview

ProcLease v0.1.4 is an experimental compatibility prerelease. It fixes source
installation with Rust/Cargo 1.89 on affected macOS hosts. Command-line behavior,
state layout, JSON schema, runtime source and dependencies are unchanged.

Cargo installation fix

Release stripping previously applied to build-time procedural-macro libraries.
On the macOS verification host, Rust 1.89 could not load the stripped
clap_derive library (E0463). The release profile now leaves host build units
unstripped while the installed CLI keeps symbol stripping, release optimization
and thin LTO. No environment override is needed for the fixed package.

A new CI job packages the source and installs it with Rust 1.89 defaults on
macOS and Linux, alongside stable formatting, Clippy, all three unit plus
thirty-one integration tests and optimized builds. The previous manifest failed
as a local control; the fixed package passed. See
verification
for evidence and the limits of the diagnosed cause.

The immutable crates.io 0.1.3 package still has its documented caveat. Install
the corrected version with Rust 1.89 or newer:

cargo install proclease --version 0.1.4 --locked
proclease --version

Cargo installs the CLI; the portable skill is installed separately. ProcLease is
binary-only, so docs.rs provides a crate overview, README and source rather than
a library API.

Prebuilt installation

Download this release's install.sh, review it, then run:

sh install.sh --skills both
proclease --version

The installer selects a native archive, verifies its SHA-256 checksum and
installs without sudo or Rust. Existing unrelated skill folders are preserved.
Omit --skills both for CLI-only installation. Manual archive downloads include
the CLI, portable skill, README and MIT license; verify them against SHA256SUMS.
Website download links and the installer are pinned to this version together.

Compatibility and limits

The release workflow builds and tests native macOS Apple Silicon and macOS 15
Intel binaries and Ubuntu 22.04 ARM64/x64 (glibc) binaries. Both macOS targets
use a macOS 15.0 deployment minimum; older macOS is not separately runtime-tested.
Windows and Linux musl/Alpine binaries are not provided.

macOS binaries are not Developer ID signed or notarized. Publisher signing and
notarization are planned before a stable macOS release, and remain deferred for
this experimental prerelease. SHA-256 checksums verify downloaded bytes and do
not replace an authenticated publisher signature.

ProcLease manages only services launched through it. It is a supervisor, not a
sandbox: descendants that create a new process group can escape cleanup. Use
native storage for state inside VMs. Reading status, logs or resources never
renews a lease. See the README for support limits.

Created by Jared Chu, with Codex and Claude contributions. See the README for credits.

ProcLease v0.1.3 experimental preview

ProcLease v0.1.3 is an experimental corrective prerelease. It fixes four
startup and retry defects found by an independent review of v0.1.2. Command-line
usage, state layout and the JSON schema are unchanged.

Fixes

• Retry identity: a keyed retry fingerprint no longer treats argv
  [/usr/bin/true, A, value] as the same request as argv [/usr/bin/true] with
  environment A=value. Records retained from v0.1.2 keep matching their exact
  original argv and directory; colliding or changed contexts are rejected.
• Overdue startup: a lease whose deadline passes before startup completes now
  finishes expired without running the command. Previously, a very short lease
  could still run the command after the persisted deadline.
• Guardian setup failure: a failure such as a denied control-socket bind is
  now reported as a failed launch with a nonzero exit. It was reported as an
  interrupted launch with exit 0.
• Keeper spawn failure: the launch and its same-key retries now return a
  failed record with exit 1, and prune collects it by age. Previously a
  starting record remained, retries reused it as unknown, and prune skipped it.

The startup and retry corrections
describe each regression test.

Test reliability

Test teardown could remove a fixture directory while a job's keeper was still
writing its final record, which left partial fixture directories. The test
fixtures now wait for their own supervisors before deleting state. This change is
test-only; production lifecycle code is unchanged. See
fixture teardown residue.
The lease-extension test now uses a 60-second lease, because a 10-second lease
could expire under load before the test extended it; its assertions are
unchanged. The release archive smoke check applies the same teardown rule. It also confirms that the
packaged command started before it accepts the service's expiry.

Website sources

The website refresh adds a lease-ring logo and favicons, a balanced responsive
type scale, em-dash-free copy, clearer product answers and factual search/social
metadata. It is prepared separately from deployment. See the
website verification for checks
and the subsequent narrow-screen enlarged-text selector correction.

Install

Download install.sh from this release, review it, then run:

sh install.sh --skills both
proclease --version

The installer selects your native binary, verifies its SHA-256 checksum and
installs to ~/.local/bin, without sudo or Rust. Add that directory to PATH if
needed. Existing unrelated skill folders are preserved. Omit --skills both
to install the CLI without linking agent skills.

Alternatively, download your platform's .tar.gz, verify it against
SHA256SUMS, and put its proclease executable on PATH. Each archive includes
the shared skill, README and MIT license.

Compatibility and limits

The release workflow builds and tests each archive natively on GitHub's macOS
Apple Silicon and macOS 15 Intel runners and on Ubuntu 22.04 ARM64/x64 (glibc).
Both macOS binaries target macOS 15.0; an older Apple Silicon OS is not separately
runtime-tested. macOS binaries are not Developer ID signed or notarized. Linux
musl/Alpine and Windows binaries are not provided. The CLI source was published
to crates.io after this binary prerelease; source builds
require Rust 1.89 or newer. Current stable Rust/Cargo is recommended. See the
registry verification
for the macOS Rust/Cargo 1.89 stripping caveat.

ProcLease manages only services launched through it. It is a supervisor, not a
sandbox: descendants that create a new process group can escape cleanup. Use
native storage for state inside a VM, not a host-shared directory. Reading status,
logs or resource usage never renews a lease. See the README for support limits.

Created by Jared Chu, with Codex and Claude contributions. See the README for credits.

ProcLease v0.1.2 — first preview

ProcLease's first experimental prerelease puts explicit deadlines on development
servers and watchers started by coding agents.

• Time-limited foreground jobs with explicit extension and process-group cleanup.
• A shared user registry, bounded logs, retained retry keys and JSON output.
• Live CPU/RSS totals, adaptive terminal tables and briefly visible completions.
• Finished history retained for 24 hours or the newest 100 jobs, whichever is first.
• One portable skill for Codex and Claude Code.

Install

Download install.sh from this release, review it, then run:

sh install.sh --skills both
proclease --version

The installer selects your native binary, verifies its SHA-256 checksum and
installs to ~/.local/bin, without sudo or Rust. Add that directory to PATH if
needed. Existing unrelated skill folders are preserved. Omit --skills both
to install the CLI without linking agent skills.

Alternatively, download your platform's .tar.gz, verify it against
SHA256SUMS, and put its proclease executable on PATH. Each archive includes
the shared skill, README and MIT license.

Compatibility and limits

Native tests run on the current GitHub macOS Apple Silicon runner, macOS 15 Intel,
and Ubuntu 22.04 ARM64/x64 (glibc). Both macOS binaries target macOS 15.0; an older
Apple Silicon OS is not separately runtime-tested. macOS binaries are not Developer ID signed
or notarized. Linux musl/Alpine and Windows binaries are not provided.

ProcLease manages only services launched through it. It is a supervisor, not a
sandbox: descendants that create a new process group can escape cleanup. Use
native storage for state inside a VM, not a host-shared directory. Reading status,
logs or resource usage never renews a lease. See the README for support limits.

Created by Jared Chu, with Codex implementation and Claude review contributions.