v0.1.18

v0.1.18 - 2026-07-07

Status: Maintenance Release

v0.1.18 is a small maintenance release. It refreshes compatible dependency locks, aligns the
documented Rust baseline with the workspace's practical requirement, updates Windows FFI
dependencies, and hardens the TypeScript npm publish path. No public API or process-control
behavior changes are intended.

Highlights

• Compatible dependency refresh: refreshed Rust and TypeScript lockfiles, including
  @types/node 22.20.0, without changing Node runtime support policy.
• Rust baseline: set the workspace rust-version and public build guidance to Rust 1.88.0,
  matching the resolved dependency baseline.
• Windows FFI dependencies: updated rsfulmen to =0.1.5 and workspace windows-sys to
  0.61; the lockfile now resolves a single windows-sys 0.61.x graph, with Windows-only
  handle checks adjusted for pointer-typed HANDLEs.
• TypeScript npm publishing: the npm publish workflow now uses Node 24 and validates the
  trusted-publishing runtime floor before publishing.

Upgrade Notes

• No public API changes are intended.
• Rust builders should use Rust 1.88.0 or newer.
• Go prebuilt libraries are produced by the Go Bindings Prep workflow after this release-prep
  commit is merged to main; do not tag v0.1.18 before that artifact PR merges.
• TypeScript release publishing should continue to run N-API prebuilds from the tag before npm
  publish.

v0.1.17

v0.1.17 - Session-Spawn Bindings + Portable Liveness

Release Date: 2026-07-06
Status: Released

Summary

v0.1.17 makes sysprims' detached session-spawn primitives available across the FFI boundary.
Rust already had the session crate; this release adds JSON C-ABI exports and TypeScript/Bun
wrappers for launching parent-outliving processes with setsid and nohup semantics. It also
adds portable process-liveness predicates for kill-then-check workflows, tightens PID validation
around process inspection, and documents the session-spawn contract in ADR-0016.

The release is additive. Existing signal, PID, timeout, and process-tree behavior is unchanged.

Highlights

• Session-spawn FFI: sysprims_run_setsid and sysprims_run_nohup expose detached spawn
  primitives through the C ABI using strict JSON input/output contracts.
• TypeScript and Bun bindings: runSetsid() and runNohup() are available from
  @sysprims/sysprims, with Bun >=1.3 documented as supported alongside Node.js >=18.
• Structural session identifiers: runSetsid() reports pid == sid == pgid from the child
  PID, avoiding post-spawn child getsid/getpgid lookups and PID-reuse races.
• Honest nohup supervision model: runNohup() reports the caller's inherited session and
  process group context so consumers do not mistake the child for a new process group leader.
• Portable liveness checks: sysprims_proc::is_live(pid) and
  sysprims_proc::is_fully_gone(pid) normalize zombie handling across supported platforms.
• Security hardening: explicit nohup output files are opened append/create with final-path
  symlink rejection, and ADR-0011 PID-safety validation now covers more process APIs.

Changes

Session-Spawn FFI Contract

The new C-ABI exports use the same JSON pattern as the rest of sysprims FFI:

SysprimsErrorCode sysprims_run_setsid(
    const char *config_json,
    char **result_json_out
);

SysprimsErrorCode sysprims_run_nohup(
    const char *config_json,
    char **result_json_out
);

Inputs are versioned schema documents:

• schemas/session/v1.0.0/run-setsid-config.schema.json
• schemas/session/v1.0.0/run-nohup-config.schema.json

Both outputs use:

• schemas/session/v1.0.0/session-spawn-result.schema.json

The FFI parser requires exact schema_id values, rejects unknown fields, and rejects empty
argv or empty argv[0] before spawning.

TypeScript and Bun

TypeScript consumers get thin wrappers over the native N-API binding:

import { runSetsid, runNohup } from "@sysprims/sysprims";

const detached = runSetsid({
  argv: ["sh", "-c", "exec sleep 60"],
});

const background = runNohup({
  argv: ["sh", "-c", "printf ready"],
  outputFile: "/tmp/sysprims-worker.log",
  wait: true,
});

The binding surface is supported on Node.js >=18 and Bun >=1.3. Bun support applies to the
Node-API binding surface; browser runtimes remain out of scope.

runSetsid: Structural Identifiers

runSetsid() starts the child in a new session. On Unix, a successful setsid() call makes the
child process the session leader and process-group leader, so sysprims reports:

pid == sid == pgid
identifier_provenance = "setsid_structural_child_pid"
session_kind = "new_session"

The implementation deliberately derives sid and pgid from the returned child PID instead of
querying the child after spawn. That avoids a race where a short-lived child exits and its PID is
reused before a follow-up getsid or getpgid lookup.

runNohup: Caller Context, Child PID Supervision

runNohup() starts a child that can outlive the parent, ignores SIGHUP where supported, and
does not create a new session or process group. The result therefore reports the caller's own
session and process group captured before spawn:

session_kind = "inherited_session"
identifier_provenance = "caller_context_before_spawn"

Upgrade warning: a nohup result's pgid is the caller's process group. Supervise the child by
the returned pid; never use kill(-pgid, ...) from a runNohup() result, because that would
signal the caller and its siblings.

When output_file is supplied, sysprims opens it with append/create semantics and rejects a
final-component symlink using O_NOFOLLOW on Unix. Symlink rejection maps to a permission-denied
error instead of silently following the link.

Portable Liveness

v0.1.17 adds:

sysprims_proc::is_live(pid)
sysprims_proc::is_fully_gone(pid)

These functions answer the common post-signal question without forcing callers to treat
get_process(pid) as a liveness predicate. That matters because exited-but-unreaped children
look different across platforms:

Platform	Exited but unreaped child
Linux	Present as Zombie in /proc
macOS	Often unreadable or already NotFound
Windows	No zombie state

is_live(pid) returns false for a zombie on every platform. is_fully_gone(pid) distinguishes
an unreaped zombie from a fully reaped or absent PID where the platform exposes that state.

Both predicates reject PID 0 and PIDs above i32::MAX under ADR-0011.

PID Validation Hardening

ADR-0011 validation now also covers:

• get_process
• get_process_with_options
• wait_pid
• cpu_total_time_ns

Those APIs now reject PIDs above i32::MAX with InvalidArgument, matching the existing
validation behavior in tree and guard APIs. Well-formed callers are unaffected.

Documentation and Release Hygiene

• ADR-0016 documents the session-spawn FFI contract, identifier provenance, and supervision
  rules.
• Session-safety incident documentation was promoted for easier discovery.
• docs/standards/platform-support.md now reconciles shipped artifact lists with release
  reality, including legacy darwin-amd64 artifacts retained for backward compatibility.
• llvm-mingw is pinned to 20260407 across CI, release, and Go-bindings prep workflows for
  reproducible Windows arm64 GNU-ABI builds.

Artifact Notes

The Go prebuilt libraries for v0.1.17 are produced by the Go Bindings Prep workflow after this
release-doc/version package lands on main. The release tag must point at the later Go-bindings
merge commit, not this documentation commit, so the checked-in Go libraries embed the release
version and are present under the tag.

Upgrade Notes

• Existing Rust, CLI, signal, PID, timeout, and process-tree consumers are unaffected.
• TypeScript consumers can add runSetsid() and runNohup() without changing existing imports.
• Bun consumers need Bun >=1.3 for the supported Node-API binding surface.
• runNohup() callers should supervise by returned pid, not returned pgid.
• FFI consumers must rebuild against the v0.1.17 header and libraries to access the new session
  exports.
• Go consumers should wait for the v0.1.17 Go-bindings artifact PR and tags before go get
  testing the final release.

References

• ADR-0011: PID Validation Safety
• ADR-0016: Session Spawn FFI Contract
• Language Bindings Guide
• Platform Support Matrix

v0.1.16

v0.1.16 - Windows ARM64 Go Bindings

Release Date: 2026-04-18
Status: Released

Summary

v0.1.16 closes the long-standing limitation that kept Go consumers off Windows arm64. sysprims
now ships a prebuilt libsysprims_ffi.a for aarch64-pc-windows-gnullvm via
llvm-mingw, alongside the existing windows-amd64
binding built with msys2/MinGW-w64. Consumers installing llvm-mingw locally can go get
sysprims and link cgo code on Windows arm64 the same way they already do on every other
supported platform. The release also finalizes the feature-branch / PR workflow and retires
the guardian-hook commit gate.

Highlights

• Windows arm64 Go bindings: Prebuilt libsysprims_ffi.a built from
  aarch64-pc-windows-gnullvm via llvm-mingw. Go cgo links successfully on
  Windows arm64 for the first time.
• Shared-mode cgo parity on arm64: cgo_windows_arm64_shared.go and
  cgo_windows_arm64_shared_local.go close the gap between shipped shared libraries and Go
  linker directives, enabling go build -tags=sysprims_shared on windows/arm64.
• CI regression coverage: test-go matrix gains a native windows-latest-arm64-s leg
  with llvm-mingw so arm64-specific cgo/linker regressions are caught on every PR.
• Release-pipeline consistency: windows-arm64 release bundle artifacts now use the GNU
  ABI path matching Go cgo's expectations (previously shipped MSVC .lib, unusable by Go).
• PR-based change control: Repository moves to feature-branch / PR with squash-merge
  default. Guardian-hook commit gate retired. make pr-final added as the merge-readiness
  gate.

Changes

Windows ARM64 Go Support

The pre-v0.1.16 documentation claimed that "Go cgo on Windows requires MinGW, and MinGW does
not support arm64." Technically correct about msys2/MinGW-w64, but the ecosystem moved past
that limitation:

• aarch64-pc-windows-gnullvm graduated to Rust Tier 2 with host tools. This is the
  llvm-mingw-flavored Windows GNU-ABI target that produces .a and .dll.a artifacts
  consumable by Go cgo.
• llvm-mingw (mstorsjo/llvm-mingw) ships an aarch64-w64-mingw32-gcc driver that Go's
  cgo accepts just like msys2/MinGW-w64's x86_64 driver.
• GitHub Actions windows-latest-arm64-s runners are already in active use across our
  release pipelines for CLI and TypeScript. No new runner plumbing required.

Combined: install llvm-mingw on the arm64 runner, build sysprims-ffi for
aarch64-pc-windows-gnullvm, ship the resulting libsysprims_ffi.a. Consumers do the
mirror-image dance on their own build host.

Consumer Requirement

Go code building against sysprims on Windows arm64 needs llvm-mingw installed locally with
aarch64-w64-mingw32-gcc on PATH:

# Download llvm-mingw latest release (*-ucrt-aarch64.zip) and extract
$env:PATH = "C:\tools\llvm-mingw\bin;$env:PATH"
$env:CC = "aarch64-w64-mingw32-gcc"
go build ./...

This is analogous to the existing windows-amd64 requirement for msys2/MinGW-w64 — just a
different toolchain distribution for a different architecture. Linux and macOS consumers
need no extra toolchain.

Full consumer documentation: Language Bindings Guide — Windows: Go cgo toolchain.

Artifact Changes

Artifact	Before v0.1.16	In v0.1.16
bindings/go/sysprims/lib/windows-arm64/libsysprims_ffi.a	Not shipped	GNU-ABI via llvm-mingw
Release bundle static/windows-arm64/libsysprims_ffi.a	MSVC .lib (unusable for Go)	GNU-ABI .a
Release bundle shared/windows-arm64/sysprims_ffi.dll	MSVC-built	llvm-mingw-built
Release bundle shared/windows-arm64/libsysprims_ffi.dll.a	Not present	GNU import library
CI Go matrix	No arm64 leg	windows-latest-arm64-s + llvm-mingw

CLI binaries on Windows arm64 continue to ship MSVC-built (aarch64-pc-windows-msvc) since
CLI does not involve cgo. No change to the CLI on any platform.

Workflow Updates

• .github/workflows/go-bindings.yml: New build-windows-arm64 job on
  windows-latest-arm64-s. Installs llvm-mingw, builds for aarch64-pc-windows-gnullvm,
  uploads artifact. update-go-bindings PR body now lists windows-arm64 with the toolchain
  distinction.
• .github/workflows/release.yml: build-windows-arm64 now installs llvm-mingw and
  builds the FFI for aarch64-pc-windows-gnullvm alongside the existing MSVC CLI. The
  copy_static_windows_msvc shim is deleted; windows-arm64 flows through the standard
  copy_static path. copy_shared_windows also bundles the GNU import library
  (libsysprims_ffi.dll.a).
• .github/workflows/ci.yml: test-go matrix gains a windows-latest-arm64-s entry
  with rust_target: aarch64-pc-windows-gnullvm and win_toolchain: llvm-mingw. Matrix
  flags now drive per-entry toolchain install and build.

Documentation Updates

• docs/standards/platform-support.md: Windows arm64 fully "Supported"; FFI list includes
  windows-arm64/libsysprims_ffi.a; CI runner note updated.
• docs/decisions/ADR-0012-language-bindings-distribution.md: Platform matrix Go cell for
  Windows arm64 flips ❌ → ✅; library-naming table gains a windows-arm64 row; notes document
  the llvm-mingw consumer requirement.
• docs/guides/language-bindings.md: Previous "Windows: MinGW Requirement" section rewritten
  as "Windows: Go cgo toolchain" with a per-arch install table; troubleshooting updated;
  licensing table includes llvm-mingw (Apache 2.0).
• README.md: Supported-platform table adds Windows arm64 with a footnote pointing to the
  consumer install guide.
• RELEASE_CHECKLIST.md: CLI artifact inventory now includes windows-arm64; Windows cgo
  assertion expanded to cover both architectures.
• bindings/go/sysprims/README.md: New "Windows toolchain" section with msys2 (x64) and
  llvm-mingw (arm64) install pointers.

Release Workflow Hardening

Maintainer-facing but worth noting: v0.1.16 finalizes the shift to PR-based change control.

• Repository now requires PRs to merge into main (squash default, rebase allowed, merge
  commits disabled by policy).
• Guardian-hook browser-approval gate is retired in favor of PR review and protected-branch
  controls.
• make pr-final wraps prepush as the merge-readiness gate and is referenced from
  RELEASE_CHECKLIST.md as a prerequisite before starting any release.

Upgrade Notes

• Additive across the board — no breaking changes. Existing binding consumers on other
  platforms see no behavioral change.
• Windows arm64 Go consumers need llvm-mingw installed locally (see Consumer Requirement
  above). Without it, go build fails at link time with a missing-GCC-driver error — an
  expected failure mode, not a regression.
• Windows amd64 Go consumers continue to use msys2/MinGW-w64 exactly as before.
• TypeScript bindings on Windows arm64 continue to ship MSVC-built .node addons; no
  toolchain change for TS consumers.
• Python bindings on Windows arm64 remain unsupported.

Follow-ups

• Pin llvm-mingw version: All three workflows (go-bindings.yml, release.yml,
  ci.yml) currently resolve llvm-mingw via GitHub's releases/latest API at CI time. Two
  runs against the same sysprims commit can therefore link against different toolchains if
  mstorsjo publishes a new release between runs. Pinning to a specific tag is tracked as
  reproducibility debt and will land as a dedicated follow-up PR.

References

• ADR-0012: Language Bindings Distribution
• Platform Support Matrix
• Language Bindings Guide
• llvm-mingw project
• Rust aarch64-pc-windows-gnullvm target

v0.1.15

v0.1.15 - Guard Automation & Provenance

Release Date: TBD
Status: Draft

Summary

v0.1.15 turns the recurring VSCodium runaway-plugin incident into a first-class sysprims workflow.
The release adds a reusable one-shot guard primitive, subtree-aware remediation, a managed guard
loop for long-lived watchdogs, a new ancestors surface for provenance, and operational guard
controls for background execution and discovery.

Highlights

• GuardStep: one-shot guard evaluation and optional remediation across Rust, FFI, Go, and
  TypeScript.
• Cascade remediation: kill-descendants --cascade and guard actions can expand each matched
  offender to its subtree so cleanup does not leave child work behind.
• GuardRunner: managed long-running guard loop with drift-resistant scheduling and clean stop
  semantics.
• Ancestors provenance: new ancestors APIs across Rust, CLI, FFI, Go, and TypeScript for
  answering "what spawned this?"
• Daemonized guard operations: sysprims guard now supports --daemon, --pidfile,
  --status, and --stop on Unix.
• Self-discovery: running guards are discoverable through sysprims itself via normalized
  sysprims-guard:<root_pid> naming.
• Shared runtime primitives: Tick, now_rfc3339(), and GuardSignals provide common timing,
  timestamp, and shutdown behavior for long-running loops.

Changes

GuardStep and Guard CLI

GuardStep provides the shared per-tick remediation kernel behind the new guard workflow. It
evaluates a guard rule, can expand a matched descendant to its subtree with cascade targeting,
applies an action only when explicitly enabled, and emits a structured event suitable for logs and
metrics.

sysprims guard now acts as a thin orchestrator over shared primitives rather than owning bespoke
loop logic in the CLI.

GuardRunner and Binding Support

GuardRunner in sysprims-proc extracts long-running watchdog behavior into a reusable Rust API.
It includes:

• drift-free scheduling via Tick
• signal-aware shutdown via GuardSignals
• cloneable stop handles
• max-iteration stop support
• summary stop reasons
• preset-driven interval and sample defaults

Bindings now have access to the same release surface:

• FFI: polling-style runner lifecycle with create, tick, stop, and free
• Go: GuardPreset, GuardRunnerConfig, NewGuardRunner, Tick(), Stop(), and Close()

TypeScript gets the one-shot guardStep() surface in this release; the managed runner remains a
Rust/FFI/Go surface for now.

The FFI and Go runner surfaces were hardened during devrev to ensure synchronized lifecycle access
and fail-fast validation of static guard configuration.

Provenance: ancestors

The release adds a new provenance surface for tracing parent chains:

sysprims ancestors <pid> --max-depth 10 --json

This closes the gap between "which descendant is hot?" and "what launched it?" without requiring
operators to leave sysprims.

Daemon Mode and Pidfiles

For long-running hosts and edge agents, sysprims guard now supports background operation on Unix:

sysprims guard 27776 --daemon --preset watchdog --yes
sysprims guard 27776 --status
sysprims guard 27776 --stop

Behavior highlights:

• --daemon detaches with setsid() and redirects stdio to null
• --pidfile <PATH> overrides the default /tmp/sysprims-guard-<root-pid>.pid
• stale or invalid pidfiles are cleaned up rather than trusted blindly
• --status and --stop verify that the pidfile target is actually a live sysprims guard process
• daemon startup waits for initialization to complete before reporting success

Windows daemon mode remains intentionally unsupported in v0.1.15; the CLI returns a clear
not-supported message directing operators to a service manager.

Self-Discovery

Running guards now set a best-effort platform title where supported, and sysprims process
inspection rewrites matching guard cmdlines to sysprims-guard:<root_pid> for ergonomic lookup.

Example workflows:

sysprims descendants 1 --name sysprims-guard --max-levels all
sysprims pstat --name sysprims-guard:27776 --table

On Linux, the kernel-visible thread name remains truncated by PR_SET_NAME, so the full identity
primarily comes from cmdline-backed discovery inside sysprims itself.

Shared Runtime Foundation

This release also adds shared runtime primitives in sysprims-core:

• now_rfc3339() for consistent timestamp rendering
• Tick for drift-resistant periodic scheduling
• GuardSignals for signal-aware shutdown with consistent stop semantics

These give future long-running sysprims workflows a common timing and shutdown contract.

Release Hardening

Release prep for v0.1.15 also tightened delivery discipline:

• stronger release preflight guidance
• explicit TypeScript binding validation in the release path
• clean prepush validation restored before release cut
• clearer CI-only policy for prebuilt native binding artifacts

Schema Versions

Schema	v0.1.14	v0.1.15	Change
process-info.schema.json	v1.1.0	v1.1.0	No change
process-info-sampled.schema.json	v1.1.0	v1.1.0	No change
descendants-result.schema.json	v1.0.0	v1.0.0	No change
descendants-result-sampled.schema.json	v1.1.0	v1.1.0	No change
batch-kill-result.schema.json	v1.0.0	v1.0.0	No change; cascade uses existing result shape
ancestors-result.schema.json	-	v1.0.0	New provenance chain contract
guard-event.schema.json	-	v1.0.0	New one-shot guard event contract

Upgrade Notes

• sysprims guard gains additive new flags only; existing foreground guard invocations continue to
  work.
• kill-descendants --cascade is additive; existing non-cascade behavior stays the default.
• Unix daemon mode is new; Windows remains intentionally unsupported in this release.
• ancestors is additive across all supported surfaces.
• FFI consumers must rebuild shared/static libraries to pick up new guard runner exports.
• Go verification for the new runner surface currently uses a freshly built local sysprims-ffi
  artifact during development until release workflows refresh checked-in prebuilt libraries.

References

• docs/decisions/ADR-0004-ffi-design.md
• docs/decisions/ADR-0005-schema-contracts.md
• docs/decisions/ADR-0011-pid-validation-safety.md
• docs/standards/platform-support.md
• RELEASE_CHECKLIST.md

v0.1.14

v0.1.14 - Process Intelligence & Go Team Depth

Release Date: 2026-02-24
Status: Released

Summary

v0.1.14 closes the gap between what sysprims knows about a process and what it exposes to
callers. The headline capability is proc_ext: environment variables and thread count surfaced
through the Rust library, FFI, and Go/TypeScript bindings. The release also brings CPU measurement
parity to process-tree workflows and fixes a schema contract violation in pstat --pid --json.

Highlights

• proc_ext: env and thread_count on ProcessInfo, opt-in via ProcessOptions.
• CPU parity on tree commands: descendants and kill-descendants now support
  --cpu-mode {lifetime|monitor} with --sample.
• Schema compliance fix: pstat --pid --json now emits the required snapshot envelope with
  schema_id.
• Contextual hints: one-line stderr guidance for --cpu-above in lifetime mode (suppressible
  via SYSPRIMS_NO_HINTS=1 and suppressed for --json).
• CLI help depth: sysprims help <topic> (cpu-mode, signals, safety) and expanded
  after_help examples on high-complexity commands.

Changes

proc_ext: Environment Variables and Thread Count

ProcessInfo now includes these optional fields:

pub env: Option<BTreeMap<String, String>>,
pub thread_count: Option<u32>,

Collection is runtime opt-in and zero-cost by default:

use sysprims_proc::{get_process_with_options, ProcessOptions};

let info = get_process_with_options(
    pid,
    ProcessOptions::default().with_env().with_threads(),
)?;

Go binding equivalent:

info, err := sysprims.ProcessGetWithOptions(pid, &sysprims.ProcessOptions{
    IncludeEnv:     true,
    IncludeThreads: true,
})

Platform behavior:

Platform	env	thread_count
Linux	/proc/[pid]/environ	/proc/[pid]/status (Threads)
macOS	sysctl(KERN_PROCARGS2) env block	proc_taskinfo.pti_threadnum
Windows	Not supported v0.1.14 (null)	Toolhelp32

CPU Mode Parity on descendants and kill-descendants

Tree commands now support monitor sampling like pstat:

sysprims descendants 14796 --cpu-mode monitor --sample 3s --cpu-above 80 --tree
sysprims kill-descendants 14796 --cpu-mode monitor --sample 3s --cpu-above 80 --signal KILL --yes

This addresses a dogfooding gap where lifetime averaging missed actively spinning descendants.

Schema Compliance: pstat --pid --json

pstat --pid --json now emits the snapshot envelope (schema_id, timestamp, processes).
Missing PID behavior remains non-zero exit while still returning valid JSON (processes: []).

Hints and Help

• Added contextual hint for --cpu-above in lifetime mode.
• Added sysprims help <topic> for concept-level guidance.
• Added high-signal after_help examples for pstat, descendants, and kill-descendants.

Post-Feature Release Hardening

• make fmt, make fmt-check, and make lint now include goneat multi-language checks while
  retaining strict Rust gates.
• Non-markdown formatting sweep applied to stabilize formatter/linter output.
• rsfulmen dependency updated from 0.1.2 to 0.1.4.
• Stale deny.toml source allowlists removed to eliminate false-medium security findings.

Schema Versions

Schema	v0.1.13	v0.1.14	Change
process-info.schema.json	v1.0.0	v1.1.0	Added optional env, thread_count
process-info-sampled.schema.json	v1.0.0	v1.1.0	Sampled process schema aligned with proc_ext fields
descendants-result.schema.json	v1.0.0	v1.0.0	No change (lifetime mode)
descendants-result-sampled.schema.json	-	v1.1.0	New sampled descendants contract
batch-kill-result.schema.json	v1.0.0	v1.0.0	No change

Upgrade Notes

• Changes are additive for most consumers.
• pstat --pid --json shape changed to the standard envelope; flat-object parsers must update.
• proc_ext fields default to null/None unless explicitly requested.

Documentation Artifacts

• docs/guides/replace-shell-outs-go.md
• docs/guides/process-intelligence-without-shell-outs.md
• docs/one-pagers/go-team-adoption-v0.1.14.md
• docs/one-pagers/go-team-adoption-v0.1.14.pdf

References

• docs/decisions/ADR-0002-crate-structure.md
• docs/decisions/ADR-0004-ffi-design.md
• docs/decisions/ADR-0005-schema-contracts.md
• docs/decisions/ADR-0011-pid-validation-safety.md

v0.1.13

v0.1.13 - macOS Command-Line Fidelity Fix & Binding Coverage

Release Date: 2026-02-13
Status: macOS Command-Line Fidelity Fix & Binding Coverage

Summary

This release fixes a high-severity bug where processList() returned truncated cmdline on macOS (just the process name instead of the full argument vector), breaking downstream consumers that filter by command-line arguments. It also exports v0.1.12 process tree capabilities to the FFI layer and Go/TypeScript bindings.

Highlights

• macOS cmdline fix: cmdline now returns the full argument vector (e.g. ["bun", "run", "scripts/dev.ts", "--root", "/path"]) instead of ["bun"]
• FFI coverage: descendants and kill-descendants now available through C-ABI FFI
• Go binding: Descendants() and KillDescendants() with option pattern
• TypeScript binding: descendants() and killDescendants() via N-API

Changes

Bug Fix: macOS cmdline Truncation

Before (v0.1.12):

{"pid": 12345, "name": "bun", "cmdline": ["bun"]}

After (v0.1.13):

{"pid": 12345, "name": "bun", "cmdline": ["bun", "run", "scripts/dev.ts", "--root", "/some/path"]}

Root cause: The macOS implementation used proc_name() as a placeholder for cmdline, which only returns the process name (16 chars max). The fix uses sysctl(CTL_KERN, KERN_PROCARGS2) — the same kernel API that ps uses — to read the actual argv.

Impact: Any consumer filtering by cmdline arguments on macOS was affected. Known affected: kitfly discoverOrphans() which filters by p.cmdline.some(arg => arg.includes("scripts/dev.ts")).

Implementation details:

• Two-stage sysctl call: first with null buffer to query required size, then with allocated buffer to read data
• Parses the KERN_PROCARGS2 buffer format: [argc: i32][exec_path\0][padding \0s][argv[0]\0][argv[1]\0]...
• Uses String::from_utf8_lossy() for non-UTF-8 safety (matches Linux /proc/[pid]/cmdline pattern)
• On any error (ESRCH, EPERM, EINVAL, buffer issues), returns empty Vec — best-effort, consistent with the ProcessInfo.cmdline contract: "May be empty if command line cannot be read"

Safety hardening (devrev):

• PID 0 and overflow-range PIDs (> i32::MAX) rejected before sysctl call
• argc capped at MAX_ARGC = 4096 to prevent pathological allocation from malformed kernel data
• Empty argv entries filtered (consistent with Linux /proc/[pid]/cmdline behavior)

FFI: descendants and kill-descendants Exports

v0.1.12 added descendants and kill-descendants to the CLI and Rust crates. This release makes them available through the C-ABI FFI layer:

int32_t sysprims_proc_descendants(const char *config_json, char **result_json_out);
int32_t sysprims_proc_kill_descendants(const char *config_json, char **result_json_out);

Safety enforcement happens in the FFI layer — bindings get PID 1 protection, self-exclusion, and parent protection for free.

Go Binding: Descendants() and KillDescendants()

result, err := sysprims.Descendants(pid, &sysprims.DescendantsOptions{
    MaxLevels: 2,
    Filter: &sysprims.ProcessFilter{Name: "Helper"},
})

killResult, err := sysprims.KillDescendants(pid, &sysprims.KillDescendantsOptions{
    Signal: sysprims.SIGTERM,
    Filter: &sysprims.ProcessFilter{CpuAbove: 80},
    Yes: true,
})

TypeScript Binding: descendants() and killDescendants()

const result = descendants(pid, { maxLevels: 2, filter: { name: "Helper" } });

const killResult = killDescendants(pid, {
    signal: "TERM",
    filter: { cpuAbove: 80 },
    yes: true,
});

Validation

macOS cmdline Fix

Tested on macOS arm64 (Darwin 25.2.0):

# Start a background process with known arguments
$ sleep 999 &
$ cargo run -p sysprims-cli -- pstat --pid $! --json | jq '.processes[0].cmdline'
["sleep", "999"]

# Multi-argument process
$ python3 -c "import time; time.sleep(999)" &
$ cargo run -p sysprims-cli -- pstat --pid $! --json | jq '.processes[0].cmdline'
["python3", "-c", "import time; time.sleep(999)"]

Automated test: test_own_process_has_cmdline — verifies the test runner's own process has non-empty cmdline via snapshot.

Binding Coverage

Function	FFI	Go	TypeScript
descendants()	New	New	New
killDescendants()	New	New	New

Platform Notes

macOS

• sysctl(CTL_KERN, KERN_PROCARGS2) requires no special privileges for processes owned by the current user
• For other users' processes, may return empty cmdline (EPERM) — this is expected and consistent with ps behavior
• The exec path in the KERN_PROCARGS2 buffer is intentionally skipped; only the actual argv entries are returned

Linux

• No changes — /proc/[pid]/cmdline already worked correctly
• The new test_own_process_has_cmdline test is gated to #[cfg(target_os = "macos")] since Linux cmdline was never broken

Windows

• Not in scope for this fix — Windows uses vec![name] placeholder, same as the old macOS behavior
• Windows cmdline via NtQueryInformationProcess is a separate effort

Safety Considerations

PID Validation (ADR-0011)

The read_cmdline() function enforces:

• PID 0 rejected (signals caller's process group)
• PID > i32::MAX rejected (would overflow pid_t cast)
• argc validation: Capped at 4096 to prevent memory exhaustion from malformed data

Error Handling

All errors in read_cmdline() result in an empty Vec<String> return — no panics, no error propagation. This is consistent with the ProcessInfo.cmdline field contract which documents that cmdline may be empty.

Upgrade Notes

• No breaking changes — all changes are additive
• macOS consumers will immediately see full cmdline data where previously truncated
• Consumers filtering by cmdline may see more matches than before (this is correct behavior)
• FFI shared library must be rebuilt for all platform targets to include new exports

Files Changed

• crates/sysprims-proc/src/macos.rs — Added read_cmdline() function using sysctl(CTL_KERN, KERN_PROCARGS2), replaced placeholder at call site
• crates/sysprims-proc/src/lib.rs — Added test_own_process_has_cmdline test
• ffi/sysprims-ffi/src/lib.rs — Added descendants and kill-descendants FFI exports
• ffi/sysprims-ffi/src/proc.rs — FFI implementation for new exports
• bindings/go/sysprims/proc.go — Go binding functions
• bindings/go/sysprims/include/sysprims.h — C header for new FFI functions
• bindings/typescript/sysprims/native/src/lib.rs — N-API native module
• bindings/typescript/sysprims/src/ffi.ts — TypeScript FFI declarations
• bindings/typescript/sysprims/src/index.ts — TypeScript public API exports
• bindings/typescript/sysprims/src/types.ts — TypeScript type definitions

References

• Bug report: kitfly/.plans/memos/sysprims/processlist-cmdline-truncated.md
• Fix plan: .plans/active/v0.1.13/process-name-fidelity.md
• Feature brief: .plans/active/v0.1.13/feature-brief.md
• ADR-0011: PID Validation Safety

v0.1.12

v0.1.12 - Process Tree Operations & Enhanced Discovery

Release Date: 2026-02-06
Status: Process Tree Operations & Enhanced Discovery Release

Summary

This release adds process tree traversal capabilities, ASCII tree visualization, and enhanced filtering for surgical process management. Operators can now inspect process hierarchies, identify runaway descendants, and terminate specific subtrees without affecting parent processes or critical system processes.

Highlights

• Process Tree Visibility: New descendants command with ASCII art visualization shows instant, human-readable process trees
• Targeted Cleanup: kill-descendants enables surgical subtree termination with filter support (--cpu-above, --running-for, --name)
• Age-Based Filtering: --running-for option on all process commands helps distinguish long-running spinners from recent spikes
• Parent PID Filtering: --ppid option on pstat and kill for filtering by process parent
• Safety by Design: Filter-based kills always preview unless --yes provided; never targets self, PID 1, parent, or root without --force
• Depth-Controlled Traversal: --max-levels N limits tree depth (default 1 = direct children only, accepts "all" for full subtree)

Changes

CLI: sysprims descendants Command

New subcommand to list child processes of a given root PID:

# Show direct children only (level 1)
sysprims descendants 7825 --table

# Show 2 levels deep (children + grandchildren)
sysprims descendants 7825 --max-levels 2 --table

# Show full subtree with ASCII art
sysprims descendants 7825 --max-levels all --tree

# Filter by CPU usage
sysprims descendants 7825 --cpu-above 80 --tree

# Filter by process age (long-running spinners)
sysprims descendants 7825 --running-for "1h" --tree

Options:

Option	Description
--max-levels <N>	Maximum traversal depth (1 = direct children, "all" = full subtree)
--json	Output as JSON (default)
--table	Human-readable table format (flat, grouped by level)
--tree	ASCII art tree with hierarchy visualization
--name <NAME>	Filter by process name (substring match)
--user <USER>	Filter by username
--cpu-above <PERCENT>	Filter by minimum CPU usage
--memory-above <KB>	Filter by minimum memory usage
--running-for <DURATION>	Filter by minimum process age (e.g., "5s", "1m", "2h")

Example output (ASCII tree):

7825 Electron [0.1% CPU, 160M, 7d18h]
├── 985 VSCodium Helper [0.0% CPU, 63M, 1d13h]
├── 986 VSCodium Helper (Plugin) [0.0% CPU, 84M, 1d13h]
│   ├── 1066 VSCodium Helper (Plugin) [0.0% CPU, 56M, 1d13h]
│   └── 5404 VSCodium Helper (Plugin) [0.0% CPU, 58M, 1d13h]
├── 5495 VSCodium Helper (Renderer) [0.0% CPU, 119M, 16h47m]
└── 5500 VSCodium Helper [0.0% CPU, 60M, 16h47m]

Total: 4 processes in subtree, 4 matched filter

CLI: sysprims kill-descendants Command

Send signals to descendants of a process without affecting the parent or root:

# Preview what would be killed
sysprims kill-descendants 7825 --cpu-above 80 --dry-run

# Kill all high-CPU descendants (requires --yes for filter-based selection)
sysprims kill-descendants 7825 --cpu-above 80 --yes

# Kill direct children only (level 1)
sysprims kill-descendants 7825 --max-levels 1 --yes

# Use SIGKILL for hung processes
sysprims kill-descendants 7825 --cpu-above 90 --signal KILL --yes

# Kill full subtree (all descendants)
sysprims kill-descendants 7825 --max-levels all --yes

Safety behaviors:

• Preview mode: Filter-based selection defaults to --dry-run unless --yes is explicitly provided
• Self exclusion: Never targets CLI's own process
• Parent protection: Never targets the parent process of selected descendants (unless --force)
• PID 1 protection: Never targets init/launchd (unless --force)
• Root protection: Never targets system root without --force

Options:

Option	Description
--max-levels <N>	Maximum traversal depth (same as descendants)
-s, --signal <SIGNAL>	Signal name or number (default: TERM)
--name <NAME>	Filter by process name
--user <USER>	Filter by username
--cpu-above <PERCENT>	Filter by minimum CPU usage
--memory-above <KB>	Filter by minimum memory usage
--running-for <DURATION>	Filter by minimum process age
--dry-run	Print matched targets but do not send signals
--yes	Proceed with kill (required for filter-based selection)
--force	Proceed even if CLI safety checks would normally refuse
--json	Output as JSON

CLI: Enhanced sysprims pstat Options

New filter options for process discovery:

# Filter by parent PID
sysprims pstat --ppid 7825 --table

# Filter by process age (long-running processes only)
sysprims pstat --cpu-above 80 --running-for "1h" --table

# Combine multiple filters
sysprims pstat --ppid 7825 --cpu-above 90 --running-for "10m" --table

New filter options:

Option	Available on
--ppid <PID>	pstat, kill
--running-for <DURATION>	pstat, kill, descendants, kill-descendants

CLI: Enhanced sysprims kill Options

The kill command now accepts all filter options in addition to explicit PIDs:

# Kill by parent PID filter
sysprims kill --ppid 7825 --signal TERM

# Kill by combined filters (requires --yes for filter-based selection)
sysprims kill --ppid 7825 --cpu-above 80 --yes

# Preview before killing (dry-run mode)
sysprims kill --ppid 7825 --cpu-above 80 --dry-run

# Force override for protected targets
sysprims kill --ppid 7825 --yes --force

Validation

Process Tree Operations

Tested on macOS arm64 (Darwin 25.2.0):

Descendants command:

$ sysprims descendants 7825 --max-levels 1 --table
--- Level 1 ---
    PID    PPID   CPU%    MEM(KB)    STATE USER             NAME
--------------------------------------------------------------------------------
   985    7825    0.0      62720        R davethompson     VSCodium Helper
   986    7825    0.0      83408        R davethompson     VSCodium Helper (Plugin)
   ... (40 total descendants)

ASCII tree visualization:

$ sysprims descendants 7825 --tree | head -15
7825 Electron [0.1% CPU, 160M, 7d18h]
├── 985 VSCodium Helper [0.0% CPU, 63M, 1d13h]
├── 986 VSCodium Helper (Plugin) [0.0% CPU, 84M, 1d13h]
├── 5495 VSCodium Helper (Renderer) [0.0% CPU, 119M, 16h47m]
└── ...

Kill-descendants safety:

# Parent excluded by default
$ sysprims kill-descendants 7825 --dry-run
# Output: 40 descendants (no parent PID)

# With --force, parent included
$ sysprims kill-descendants 7825 --dry-run --force
# Output: 41 processes (includes parent PID)

Filter Validation

Parent PID filter:

$ sysprims pstat --ppid 7825 --table
# Shows 32 direct children of VSCodium Electron process

Age-based filtering:

# Find processes >90% CPU running >1 hour
$ sysprims pstat --cpu-above 90 --running-for "1h" --table
# Distinguishes long-running spinners from brief spikes

Real-World Use Cases

Scenario: Identify and terminate runaway Electron helper processes

# 1. Find high CPU processes in tree
$ sysprims descendants 7825 --cpu-above 80 --tree

# 2. Preview what would be killed
$ sysprims kill-descendants 7825 --cpu-above 80 --dry-run --json

# 3. Terminate runaway descendants (parent VSCodium survives)
$ sysprims kill-descendants 7825 --cpu-above 80 --yes

Scenario: Chrome renderer runaway

# Chrome has many helper processes; find the one spinning
$ sysprims descendants 67566 --name "Helper (Renderer)" --cpu-above 100 --tree

# Kill just the runaway renderer (not entire browser)
$ sysprims kill-descendants 67566 --name "Helper (Renderer)" --cpu-above 100 --max-levels 2 --yes

Platform Notes

macOS

Process tree traversal works correctly with libproc:

• Uses proc_pidinfo(PROC_PIDTBSDINFO) for parent-child relationships
• BFS traversal respects --max-levels depth limit
• Parent process exclusion enforced for kill-descendants

Age filtering availability:

• Process start time available via proc_pidinfo()
• start_time_unix_ms field populated for all processes
• --running-for filters work on macOS

ASCII tree visualization:

• Requires terminal supporting box-drawing characters (UTF-8)
• Falls back gracefully on terminals without tree line support
• Uses ├──, │ , └── for tree structure

Linux

Full visibility: /proc/[pid]/stat provides complete process tree without restrictions.
All features work identically to macOS.

Windows

Process tree traversal: Supported via CreateToolhelp32Snapshot.
Depth limiting and filtering work as on Unix.

ASCII tree visualization: Box-drawing characters may not render correctly on some terminals.
Consider using --table or --json on Windows for reliability.

Schema Additions

process-filter.schema.json

New filter fields:

{
  "properties": {
    "ppid": {
      "description": "Filter by parent process ID",
      "type": "integer",
      "minimum": 1
    },
    "running_for_at_least_secs": {
      "description": "Filter by minimum process age in seconds",
      "type": "number",
      "minimum": 0
    }
  }
}

descendants-result.schema.json (NEW)

New schema for descendants command output:

{
  "schema_id": "https://schemas.3leaps.dev/sysprims/process/v1.0.0/descendants-result.schema.json",
  "root_pid": "integer",
  "max_levels": "integer",
  "levels": [
    {
      "level": "integer",
      "processes": [{ /* Process objects */ }]
    }
  ],
  "total_found": "integer",
  "matched_by_filter": "integer"
}

Safety Considerations

PID Validation (ADR-0011)

All tree traversal and kill operations enforce ADR-0011 PID safety:

• **PI...

v0.1.11

v0.1.11 - macOS Port Discovery & Bun Runtime Support

Release Date: 2026-02-04
Status: macOS Port Discovery & Bun Runtime Support Release

Summary

This release fixes listeningPorts() returning empty results on macOS, adds a new ports CLI command for listing listening port bindings, and enables Bun runtime support for TypeScript bindings.

Highlights

• macOS Port Discovery Fixed: listeningPorts() now works on macOS
• New CLI Command: sysprims ports for listing listening port bindings
• Bun Runtime Support: TypeScript bindings now work under Bun

Changes

CLI: sysprims ports Command

New subcommand to list listening port bindings:

# Table output
sysprims ports --table

# Filter by protocol
sysprims ports --protocol tcp --table

# Filter by specific port (JSON output)
sysprims ports --protocol tcp --local-port 8080 --json

Options:

Option	Description
--json	Output as JSON (default)
--table	Human-readable table format
--protocol <tcp|udp>	Filter by protocol
--local-port <PORT>	Filter by local port number

Example output (table):

PROTO LOCAL                  STATE        PID NAME
--------------------------------------------------------------------------------
  tcp [::1]:9999             listen     54659 bun
  tcp 0.0.0.0:9000           listen     41721 ssh
  tcp 127.0.0.1:8080         listen     40672 namelens
  ...

Example output (JSON):

{
  "schema_id": "https://schemas.3leaps.dev/sysprims/process/v1.0.0/port-bindings.schema.json",
  "bindings": [
    {
      "protocol": "tcp",
      "local_addr": "127.0.0.1",
      "local_port": 8080,
      "state": "listen",
      "pid": 40672,
      "process": {
        "pid": 40672,
        "name": "namelens",
        "exe_path": "/Users/.../namelens",
        "cmdline": ["namelens"]
      }
    }
  ],
  "warnings": [...]
}

macOS listeningPorts() Fix

The listeningPorts() function was returning empty results on macOS due to incorrect socket fdinfo parsing. This release fixes the underlying issues:

Problem: SDK struct layout mismatch caused proc_pidfdinfo(PROC_PIDFDSOCKETINFO) parsing to fail silently.

Solution:

1. UID Filtering: Scan current-user processes only

   • Uses proc_pidinfo(PROC_PIDTBSDINFO) to read UID cheaply
   • Skips other users' PIDs (reduces EPERM volume)
   • Significantly improves performance and reduces noise

2. Heuristic Layout Detection: Handle SDK variations

   • vinfo_stat size varies across macOS SDKs (136 vs 144 bytes)
   • New select_socket_info_layout() tries common sizes and validates
   • Offset-based parsing instead of fixed struct assumptions

3. Strict TCP Listener Filtering: Only return actual listeners

   • Checks tcpsi_state == TSI_S_LISTEN for TCP sockets
   • UDP bindings included (UDP has no "listen" state)

Before (v0.1.10):

const result = listeningPorts();
// result.bindings.length === 0  (empty!)

After (v0.1.11):

const result = listeningPorts();
// result.bindings.length === 68  (working!)

TypeScript Bindings: Bun Runtime Support

Removed the explicit Bun block from bindings/typescript/sysprims/src/native.ts:

// REMOVED in v0.1.11:
if ((process as unknown as { versions?: { bun?: string } }).versions?.bun) {
  throw new Error(
    "sysprims TypeScript bindings are not yet validated on Bun. " +
      "Run under Node.js or add a fallback path for Bun.",
  );
}

Bun's N-API compatibility is mature enough for production use.

Validation

macOS Port Discovery

Tested on macOS arm64 (Darwin 25.2.0):

$ sysprims ports --protocol tcp --table
PROTO LOCAL                  STATE        PID NAME
--------------------------------------------------------------------------------
  tcp [::1]:9999             listen     54659 bun
  tcp 0.0.0.0:9000           listen     41721 ssh
  tcp 127.0.0.1:8080         listen     40672 namelens
  ... (31 TCP listeners found)

Self-listener test passes:

$ cargo test -p sysprims-proc test_listening_ports_self_listener_tcp
test test_listening_ports_self_listener_tcp ... ok

Bun Runtime

Validated by kitfly team:

Feature	Status
Module loading	Works
procGet()	Works
terminate()	Works
listeningPorts()	Works (with macOS fix)

Platform Notes

macOS Visibility

Port discovery on macOS is limited to current-user processes due to SIP/TCC restrictions:

• Visible: Processes owned by the current user
• Not visible: System processes, other users' processes
• Warnings: Indicate how many entries were filtered

This is inherent to macOS security model and cannot be bypassed without elevated privileges.

Linux

Full visibility via /proc/net/* - no restrictions for same-user processes.

Windows

Not yet implemented for listeningPorts().

Upgrade Notes

• No breaking changes
• macOS users will now see port bindings that were previously invisible
• Bun users can use sysprims directly without workarounds
• New ports CLI command available

Files Changed

• crates/sysprims-cli/src/main.rs - Added ports subcommand (+138 lines)
• crates/sysprims-proc/src/macos.rs - Fixed socket fdinfo parsing (~200 lines changed)
• crates/sysprims-proc/tests/port_bindings.rs - Tightened macOS self-listener test
• bindings/typescript/sysprims/src/native.ts - Removed Bun guard (-6 lines)

References

• Feature briefs:
  • .plans/active/v0.1.11/01-macos-listening-ports-reliability.md
  • .plans/active/v0.1.11/02-bun-runtime-support.md
• Commits:
  • b14b68a - fix(proc/macos): make listening port discovery reliable
  • 4ca6469 - fix(proc/macos): harden socket fdinfo parsing
  • 96d8c11 - feat(cli): add ports command

v0.1.10

v0.1.10 - 2026-02-03

Status: Go Shared Library Mode Polish Release

Fast-follow polish release improving Go shared-library mode developer experience and clarifying multi-Rust FFI collision guidance.

Highlights

• sysprims_shared_local Tag: New opt-in build tag for local development workflows
• Cleaner Default Shared Mode: sysprims_shared no longer references non-existent local paths
• Clearer Multi-Rust Guidance: README explicitly documents duplicate symbol _rust_eh_personality failure mode

New Build Tag: sysprims_shared_local

For developers who need to link against locally-built shared libraries:

# Local development with custom shared libs
# (libs must be in bindings/go/sysprims/lib-shared/local/<platform>/)
go test -v -tags="sysprims_shared,sysprims_shared_local" ./...

This tag re-enables the local override paths that were previously searched by default, which caused confusing linker warnings when the directory didn't exist.

Cleaner Default: sysprims_shared

The default shared mode now only searches shipped prebuilt libraries:

# Standard shared mode (no local paths searched)
# glibc/macOS/Windows
go test -v -tags=sysprims_shared ./...

# Alpine/musl
go test -v -tags="musl,sysprims_shared" ./...

This eliminates the linker warnings that previously appeared when lib-shared/local/ didn't exist.

Multi-Rust FFI Collision Guidance

The README now explicitly documents the "multiple Rust FFI libs in one Go binary" failure mode:

Symptom: Link errors mentioning duplicate symbols like _rust_eh_personality

Cause: Linking multiple Rust static libraries (via cgo //#cgo LDFLAGS: -l...) in a single Go binary causes duplicate Rust runtime symbols.

Solution: Use sysprims as a shared library:

Platform	Build Tags
glibc/macOS/Windows	-tags=sysprims_shared
Alpine/musl	-tags="musl,sysprims_shared"
Local dev override	-tags="sysprims_shared,sysprims_shared_local"

When to Use Shared Mode

Default (static linking):

go test ./...

• Recommended unless you hit Rust staticlib collisions
• Links against prebuilt libsysprims_ffi.a static library

Shared mode (avoids duplicate symbols):

# Standard platforms
go test -tags=sysprims_shared ./...

# Alpine/musl
go test -tags="musl,sysprims_shared" ./...

• Required when linking multiple Rust staticlibs via cgo
• Links against prebuilt shared library (.so/.dylib/.dll)

Local development override:

go test -tags="sysprims_shared,sysprims_shared_local" ./...

• Links against locally-built shared library in lib-shared/local/
• Useful for testing local changes to the FFI layer

Upgrade Notes

• No breaking changes for existing sysprims_shared workflows using prebuilt libraries
• If you were relying on lib-shared/local/... implicitly, add the sysprims_shared_local tag explicitly
• No changes needed for standard consumers using shipped prebuilt libs

References

• Commit: 3b004b7 - adds sysprims_shared_local, removes local-path warnings, updates docs
• Go bindings: bindings/go/sysprims/

v0.1.9

sysprims v0.1.9

GPL-free, cross-platform process utilities with group-by-default tree management.

Installation

Download the appropriate archive for your platform and extract.

Verification

Note: This release is unsigned. Signed checksums will be uploaded after manual signing.

Once signed artifacts are available:

# Verify checksum signature
minisign -Vm SHA256SUMS -p sysprims-minisign.pub

# Verify file checksums
shasum -a 256 -c SHA256SUMS

Platform Matrix

Platform	CLI	FFI	Go Bindings
Linux x64 (glibc 2.17+)	sysprims-*-linux-amd64.tar.gz	In FFI bundle	Supported
Linux x64 (musl)	sysprims-*-linux-amd64-musl.tar.gz	In FFI bundle	Supported
Linux arm64 (glibc 2.17+)	sysprims-*-linux-arm64.tar.gz	In FFI bundle	Supported
Linux arm64 (musl)	sysprims-*-linux-arm64-musl.tar.gz	In FFI bundle	Supported
macOS x64	sysprims-*-darwin-amd64.tar.gz	In FFI bundle	Supported
macOS arm64	sysprims-*-darwin-arm64.tar.gz	In FFI bundle	Supported
Windows x64	sysprims-*-windows-amd64.zip	In FFI bundle	Supported
Windows arm64	sysprims-*-windows-arm64.zip	In FFI bundle	Not supported

Note: Windows arm64 Go bindings are not supported because MinGW does not support the arm64 target.

What's Changed

• feat(bindings): update Go prebuilt libs for v0.1.8 by @github-actions[bot] in #8
• feat(bindings): update Go prebuilt libs for v0.1.9 by @github-actions[bot] in #9
• feat(bindings): update Go prebuilt libs for v0.1.9 by @github-actions[bot] in #10

Full Changelog: v0.1.7...v0.1.9