EXTENSIONS

Manage FreeIPA user & host groups over the JSON-RPC API: snapshot the inventory, generic user-group CRUD (groupShow/groupAdd/groupMod/groupDel) plus a desired-state groupSync reconcile, ensure the FreeRADIUS radius-vlan-<id> group pair, and add/remove members — idempotent and auditable, with a confirm-guarded delete.

Issue, inspect, and revoke X.509 certificates for any FreeIPA principal (user/host/service) over the JSON-RPC API, with optional in-model RSA/EC keygen and vaulted private keys.

Manage a VyOS router over SSH: read the running config, apply set/delete commands via vbash, and run arbitrary op-/config-mode commands.

Swamp model for interacting with Lemonade AI server — chat, completions, streaming, model lifecycle, system health, audio, images, and backend management via OpenAI-compatible and Lemonade-specific APIs

Mirrors the career-ops job-application tracker into swamp with bidirectional status write-back, posting URL + legitimacy enrichment, and a pipeline funnel report.

Stores swamp runtime data in GitLab using the Terraform state HTTP API. Provides distributed locking via GitLab's native state locking mechanism and bidirectional sync between local cache and GitLab.

Stores swamp runtime data in PostgreSQL with row-based distributed locking. Compatible with AWS RDS, Aurora, and Aurora Serverless v2. Uses fencing tokens for split-brain safety across failover events.

Reddit moderation model for subreddit management.

One-shot bootstrap for @webframp/agentcore. Ships a provisioner model

Read and write GitLab data via GraphQL (REST fallback for branches and

Deterministically reproduce a governed data-science run — or replay someone else's captured Claude Science session. The headless runtime of the session-* suite: `run` executes a filled analysis template (R/qmd in a pinned nix R env), `run-targets` a targets pipeline via a harvester, `run-notebook` Python/ipynb via papermill in a locked conda/Docker env — each with the recorder armed and its swamp.returns contract verified. `replay` faithfully re-runs recorded R against frozen tolerance rules (nix preferred, docker fallback), and a Python host-replay shim serves a captured session's host.* calls offline (or falls through to the live API in hybrid mode). Same inputs, same environment, same result — reproducibility you can run, not just cite.

Let an AI fill in an analysis template without letting it touch the science. Governed parameter-fill: the AI fills ONLY the typed parameter slots of a frozen template, and `validate` is the deterministic gate that asserts the frozen structure was untouched and every fill satisfies its slot contract — bounded, validated, reproducible AI authoring, not free-form code generation. `author` builds Quarto (.qmd) or Jupyter (.ipynb) templates from structured cells (the writer owns the document layout and binds each param at its declared type) for R or Python; `init` wires an R project to record its work. The guarantee: what the AI can change is exactly the typed slots and nothing else — the template is the contract.

Never lose how a result was computed. A language-agnostic provenance ledger for interactive data-science sessions: append one immutable, content-checksummed record per executed cell/chunk — its code, value, figures, console output, warnings, packages, and even runtime-declared functions with their internal dependencies — from any client (R/RStudio, Python/Jupyter, targets, …). One append-only ledger, one record per cell, identical shape across languages: the foundation the rest of the session-* suite fills, seals, and replays. Capture the real computation as it happens, so a session can be audited, sealed (session-witness), or re-run later — not reconstructed from memory.

Prove a recorded data-science session hasn't been altered since you sealed it. The Master member of the session-* suite: a tamper-evident seal + authorship attestation, with no keypairs or infrastructure. `seal` chains the per-version content checksums of a session-record ledger (in sequence) into one sha256 session digest and attests its authors; `verify` recomputes the digest and reports whether a sealed session still matches. `seal_manifest` generalizes the primitive to ANY ordered {name, checksum} list — so a session-ingest bundle-manifest seals exactly the same way. Change one byte of any past record and the digest changes: the seal breaks, loudly. Ultralight integrity for governed, reproducible science — the trust layer under the whole suite.

GSSAPI initial-token producer (no mutual authentication or continuation): native-JS Kerberos 5 / SPNEGO client (no shell-out) — password → AS pre-auth → TGT → TGS → service ticket → SPNEGO `Negotiate` token, with session keys, tickets, and headers stored as vault-backed datastore resources (requires installing a vault named `krb5`; any backend). Drives GSSAPI-protected HTTP endpoints and hands single-use SPNEGO headers to other models via data + CEL. Pure WebCrypto + fetch over MS-KKDCP (works in a fetch-only sandbox); raw TCP/UDP KDC transports available where socket permissions allow.

Cross-account IAM observation model for role, user, and policy inventory.

Capture a PyLabRobot lab protocol ONCE as a sealed, citable IDENTITY, then lower that single intent onto whatever hardware you have — byte-exact, reproducible, provenance-tracked. `seal` freezes a `.patch.yaml` into a content-addressed bytestring (encoded as MIDI UMP/SysEx) and records the 64-hex patch sha you cite, plus its four sealed artifacts (patch/ump/syx/manifest) as a typed resource: the exact bytes of a scientific intent, pinned. `run` lowers ONE sealed sha through a chosen PLR driver and records the run — status, invocations, device calls, and the full NDJSON event stream — the provenance of how an intent became machine calls. `resource_model` captures the content-addressed deck layout (slots + role->labware) a run binds to; `init` scaffolds the store. The thesis in one line: the SAME sealed sha lowers to device-appropriate calls that DIFFER — a channel pipette runs pick_up_tips -> aspirate -> dispense -> drop_tips while a Labcyte Echo runs open_source_plate -> run_picklist -> close; same intent, transposed per device, 'the diff is the answer'. A pure-TypeScript codec/player makes identity byte-exact (flip one byte -> ContentHashError) and reproduces every run call-for-call.

Read Terraform and OpenTofu state via CLI and marshal into swamp data.

Query GitHub data using the gh CLI for repository, PR, issue, release, and workflow visibility.

AWS cost audit workflow — identifies infrastructure waste by combining

DNS and network probing model that generates diverse diagnostic events.

Unified cross-provider AI token usage monitoring — workflow, model, and

Brownfield adoption of existing AWS infrastructure into swamp models.

Local git operations model — clone, branch, read, commit, push. Designed for agent-driven development workflows where code changes are authored locally and pushed to a remote forge. Supports a configurable workspace layout (default: $HOME/{host}/{group}/{project}) and commit message format enforcement.