aitherium/awskills

Drive any external ACP agent from your agent. The Agent Client Protocol lets one agent drive another. When your task needs a different model, a different tool surface, or a sandbox your loop doesn't have, you can hand a sub-problem to an external ACP agent — Claude Code (claude-agent-acp), Codex (codex-acp), Gemini CLI (gemini-cli), or any binary that speaks ACP on stdio — and read back its answer. Your memory, faculties and approval gate stay in charge; the external agent runs its own loop underneath.

Expose an AitherOS agent to ACP editors. ACP editors — JetBrains IDEs, Zed, VS Code, neovim, Obsidian — drive coding agents over the Agent Client Protocol. adk acp serve makes any AitherOS agent one of those agents: the editor spawns it as a subprocess, and every prompt, permission request and tool round-trip goes over stdio JSON-RPC. Your agent's approval gate maps onto ACP permission requests.

Fill-in-the-middle, repo packing, and a reward that can fail. DeepSeek-Coder is two useful things at once, and most people only take the first.

One shell that drives every coding shell. Your agent can hand a task to another coding agent's real product — Claude Code, Codex, Gemini CLI, Aider, OpenCode — and read back one answer.

Local training and serving, wired to your agent. [Unsloth](https://github.com/unslothai/unsloth) trains LoRA/QLoRA 2x faster with ~70% less VRAM and serves GGUF locally. Pairing it with the ADK gives you a loop that runs entirely on your own hardware: your agent serves from a local model, you fine-tune on what it produced, you swap the adapter, you measure again.

Stop grading your own homework. There is one failure that costs more agent-hours than any bug: the agent reads its own diff, decides it is correct, and reports success. Every expensive incident has that shape. A green healthcheck. An HTTP 200. A passing import. A test that goes green. All true, all at the same time as the feature being completely inert.

Your coding agents are quietly eating your disk. Nobody tells you this when you start running agents at scale: they generate enormous amounts of disk garbage, in places you will never think to look. Not model weights — *debris*. Throwaway git worktrees, build tarballs, ISO output, caches inside caches.

Integrate awdk and AitherOS with mainstream coding agent harnesses (Claude Code, Cursor, Aider, Cline, Codex, Hermes, Roo Code) — both as a CLIENT of cloud providers (OpenRouter, DeepSeek, Anthropic, Moonshot) and as a BACKEND that other agents can use. Two-way integration.

The standing instructions, tool order and hook wiring one team runs its coding agents under -- no false blockers, a 150-word report cap, search-then-graph, awgit in a shared worktree, and the PreToolUse/Stop gates that make each rule real. Rendered from the team's own AGENTS.md and settings.json by a generator; every number was measured on that fleet.

Turn an agent idea into a verified, shareable Aitherium tool across awdk, awsh, MCP, WebMCP, PWA, Codex, Claude Code, and other agent CLIs. Use when bootstrapping local inference, connecting existing agents, or packaging a reusable agent tool.

Turn 'build X' into a reviewable, re-runnable plan. A one-shot agent dispatch is a black box: it runs, it either worked or it didn't, and you can't see *why*, replay it with one input changed, or hand it to a human before it touches anything. An Agent Notebook (.anb) fixes that. It's AitherOS's executable, reviewable unit of agent work — an ordered list of typed cells that runs on the platform, records a cost-tracked run every time it executes, and can be replayed, diffed, reviewed, gated, and exported to a Jupyter .ipynb.

Install awdk and run an AI agent on your own machine, then find, inspect and install packs and skills with the adk CLI. Covers adk onboard --quick, adk doctor, the pack verbs (list, search, info, install, enable), the skills verbs (list, search, install, export), adk tools list, and running an agent locally with adk run. Every command here was run against the installed awdk CLI; flags that are not in each command's --help are not in this skill.

Stand up agent code-search, and prove it actually works. Three layers make an agent stop reading files it doesn't need: [prospector](aither-prospector.md) (*where* to look), [codegraph](aither-codegraph.md) (*which symbols*, and who calls them), [headroom](aither-headroom.md) (*shrink what's left*). Each has its own skill. This one is about running them for real — because the hard part isn't setup, it's noticing when they've quietly stopped working.

A call-graph-aware code index your agents can query. Grep finds strings; CodeGraph finds *structure*. It parses a codebase into chunks (functions, classes, routes) with a real call graph — who calls what, who's affected by a change — and lets an agent ask 'where is auth enforced?' and get the symbol, its signature, its callers, and its callees. It's the difference between an agent that greps and one that understands the code.

Deploy your awdk agent as a Discord bot (automated onboarding). Your awdk agent already has an identity, tools, memory, and inference on your own machine. This skill turns it into a Discord bot with one automated onboarding command — adk onboard --discord — which installs your agent pack, validates your bot token live against Discord's API, prints the invite link, verifies your identity + tools, and can launch the bot. Every DM or @mention then runs your agent's own loop: its tools, its memory, its personality.

Cut agent token cost with reversible context compression. Agents burn most of their tokens re-sending bulky context every turn: verbose JSON tool output, retrieved documents, file dumps. [headroom](https://github.com/headroomlabs-ai/headroom) (headroom-ai) crushes that content with a SmartCrusher pipeline — measured ~46% token savings on an 87 KB lint blob — while *protecting* conversation and user text so answers don't degrade. AitherOS wires it in two ways: an automatic pre-send hook at the single LLM chokepoint, and agent-callable tools you invoke mid-loop.

Use Aither from Hermes Agent and other harnesses, in both directions. Add awskills as a Hermes skill tap, point Hermes at a local Aither gateway over MCP with awnode mcp-config --format hermes, install a Hermes or agentskills.io skill into adk with adk skills install hermes:<owner>/<repo>/<skill>, and call another agent over A2A with adk mesh ls / adk invoke. Includes the trust boundary for third-party packs and the two places each side stores skills.

Build a tool pack for awdk agents: scaffold it with adk pack new, write a tool the model can call, then validate, load-test and bundle it with adk pack validate, adk pack dev and adk pack build. Explains the .toolpack.yaml fields the loader actually reads, the PKA001-PKA009 checks, the reserved namespaces a community pack may not claim, and why validate imports nothing while dev does.

Set up any coding agent (Claude Code, Cursor, Aider, Cline) to use AitherOS as its brain — with automatic model switching, 1272 MCP tools, managed agent dispatch, and transparent failover between DeepSeek/Kimi/local models/Anthropic. Supplements awknowledge with the AitherOS-specific infrastructure. Use when someone says "connect my agent to aither", "use aither as my backend", or "set up adk with claude code".

A semantic file-explorer that tells agents WHERE to look. Before an agent greps a 4,000-directory monorepo, it should know the three dirs worth grepping. Prospector (Phase 1, the 'landmark map') clusters a codebase into semantic regions — auth, api, data, ui, service — and answers *'where is rate limiting enforced?'* with the directories to search first. It's the cheap scout that makes [CodeGraph](aither-codegraph.md)/grep pay off instead of scanning everything.

Aither Retrieval — one surface, every modality. The AitherOS retrieval surface answers one question and returns fused, ranked results from every modality you have — vector similarity, PostgreSQL full-text (tsvector), fuzzy (trigram), graph traversal, code-graph lookup and scoped memory recall. One base URL, one auth model, one error envelope, one cursor.

Zero-to-working-agent on your own machine, for someone who has never written code. Detects the hardware, installs the agent toolkit, downloads a model that actually fits, wires it into whatever agent you already use, and proves it works with a real round-trip. The front door to every other skill in this pack.

Give an agent its own browser on your machine: enable AitherBrowser as an addon, confirm it is serving, then drive a real Chromium with the pilot_* tools — open a page with a goal, read what it renders, click and type, extract structure, keep a login, and close out with a recipe. Use when an agent must browse, scrape, fill a form, check a live site, or watch a page change, and when the pages it touches must not pass through anyone else's hardware.

Awconnect — wire your machine, agent, and browser into AitherOS. Awconnect is the onboarding layer: it connects a box you own to AitherOS — detecting local LLMs, setting up the gateway, joining the desktop/agent mesh, and (optionally) linking your browser — so a node you stood up locally becomes reachable and usable from the rest of the fleet and the portal.

Stand up a private mesh and onboard nodes + agents to it. AitherMesh is a private overlay network (WireGuard, 10.77.0.0/16) that lets machines you own — anywhere, behind any NAT or firewall — reach each other as if they were on one LAN, and lets your agents run *across* them. This skill uses [AitherZero](aitherzero.md)'s automation-scripts to do the whole thing: create the control plane, join nodes to the overlay, and deploy mesh-native agents onto them — idempotent, one playbook, or step by step.

Awnode — turn a machine's hardware into something your agents can use. awnode is the body of AitherOS. It's a local [MCP](https://modelcontextprotocol.io) server that exposes a machine's real capabilities — GPU/CPU stats, local LLM inference (Ollama / LM Studio), image generation (ComfyUI: Flux, SDXL, Pony), and safe filesystem access — so Aither agents can *act* on that hardware instead of just talking about it. If awdk is the mind, awnode is the hands.

Provision any machine from one config file and a library of numbered PowerShell automation-scripts. Clone the public AitherZero repo, build the module, and run scripts or playbooks on Windows, Linux, or macOS under PowerShell 7. Covers the layered config model, the real command surface, and which pieces are public versus internal.

Wire your machine, agent, and browser into AitherOS. Awconnect is the onboarding layer: it connects a box you own to AitherOS — detecting local LLMs, setting up the gateway, joining the desktop/agent mesh, and (optionally) linking your browser — so a node you stood up locally becomes reachable and usable from the rest of the fleet and the portal.

Put the agent on someone's desk: install the Aither desktop companion from its release assets, keep it talking to a daemon, and use decision cards as the place a question actually reaches a person instead of scrolling past in a transcript. Use when an agent needs a human answer at the right moment, when a tray/avatar surface should show what the agent is doing, or when someone asks to "put it on my desktop".

Run your own AI agent, on your machine, in three commands. [awdk](https://github.com/Aitherium/awdk) is the agent toolkit: an agent runtime, a local shell, inference setup, and control-plane enrollment in one package. You run the model, the agent loop, the memory, and your data on your own box — Aitherium hosts only the control plane, and you manage everything from api.aitherium.com. Nothing about your inference or data leaves your machine.

Train an embedding model that knows your corpus. Your agents search your code, your docs, your tickets with an embedding model that has never seen any of it. A general-purpose embedder is right about two thirds of the time on a corpus it was not trained on. You can do better with a model thirteen times smaller, in an afternoon, on one GPU — and prove it on a split the model never saw.

The awgit workflow for Claude Code / an Aither adk agent — how to work when every commit is captured as a semantic edit-op: what to check after a commit, how to read the attribution ledger, how to teleport deltas to a peer node, and how to find/merge node-level conflicts.

Set up awgit (Aither World-Graph git) on a machine — the semantic version-control layer that turns every git commit into a function-level edit-op with a verified GitHub identity, a durable attribution record, and differential sync. Install, init, install the capture hooks, verify.

Install a measured operating doctrine for running an agentic coding tool at program scale — prompt shape, live-proof gates, plan documents, persistent memory, delegation, compaction and model routing. Mined from 27,939 prompts over 210 days plus a 34-day re-measurement, not invented.

Run a 27B model in ~3.8 GB on a plain CPU box. [Bonsai-27B](https://huggingface.co/prism-ml/Bonsai-27B-gguf) (by PrismML) is a 27-billion- parameter model quantized to 1 bit per weight (Q1_0, ~1.1 bit/weight) — the whole thing is a 3.8 GB GGUF that runs on an ordinary CPU with 8 GB of RAM. No GPU, no cloud. This skill takes a spare machine from nothing installed to a live OpenAI-compatible endpoint serving Bonsai.

Serve PrismML's Bonsai 2 27B (Ternary-Bonsai-2-27B, PTQ1_0 5.9 GB or PQ2_0 7.2 GB) as an OpenAI-compatible endpoint with the PrismML llama.cpp fork. Use on 'run Bonsai 2 locally', 'self-host a 27B on a GPU or CPU box', 'why does Bonsai 2 output gibberish'. Stock llama.cpp cannot serve it.

Character Forge — consistent characters, animation, talking avatars. The definitive procedure for making a character that stays the same character. Every trap below was paid for in real GPU hours and real off-model garbage. Read the Core Law first; it is the whole skill.

Make Claude Code hooks cheap, especially on Windows, where every shell-form hook quietly starts four processes on every tool call. Covers exec-form hooks, measuring a hook's real process count, the PowerShell Start-Job trap, fail-soft without || true, and pasting or auto-announcing screenshots.

Switch Claude Code between DeepSeek (native 1M context), Kimi, local AitherOS models, and stock Anthropic — one command, no manual config. Use when you hit Claude rate limits, want cheaper/faster models, or need to keep coding on alternative backends.

Renamed to awknowledge. Kept so existing references resolve; load awknowledge instead.

Compare two versions of a file, commit, or release and report structural and behavioral diffs

Commit safely in a worktree you do NOT have to yourself — several agents, a teammate, and a maintenance loop all editing and committing at once. The pathspec commit form, the four commands that silently destroy someone else's work, and the stat-dirty refresh that unblocks a merge git only THINKS is unsafe. Written from real incidents where a 10-line fix committed 270 lines and a reset --hard put a fixed security bug back into production.

Keep one master tech-debt ledger that actually gets written to — severity tables, collision-free ids via the bundled next_debt_id.py, and the discipline that debt found is debt recorded in the same turn. Includes the stop-hook that blocks finishing a code change without a debt check.

Decision Cards — structured asks that actually reach the owner. Decision cards surface a decision, blocker, or critical fact as a window the owner can click, type into, and answer — without burying it in terminal prose that stays unread.

Run ByteDance's DeerFlow — a LangGraph-based super-agent harness for autonomous research, coding and content creation with sub-agents, persistent memory and sandboxed execution. Covers Docker and local setup, pointing it at your own OpenAI-compatible endpoint via config.yaml, its MCP server support (extensions_config.json), and driving it from the AitherOS toolkit as a managed agent rather than a separate silo.

Manage project dependencies, check for updates, and scan for vulnerabilities

A 284B model at ~30 tok/s on one desk machine. Serve DeepSeek-V4-Flash-0731 — 284B parameters, 13B active, MoE — on a single NVIDIA DGX Spark (GB10, 121 GB unified memory, ARM64), with the vendor's own speculative-decoding drafter attached, and verify it is really working.

Do My Taxes — personal tax preparation workflow. Personal 1040 tax preparation using document ingestion, transaction categorization, deduction discovery, and CPA-ready output.

Diagnose container DNS and networking without fooling yourself. Container networking faults are latency-shaped, load-shaped and client-specific. Almost every instinctive way to measure them returns a confident wrong answer. This skill is the set of measurements that survive, plus the tool that runs them in the right order.

Stop bulk builds from killing Docker Desktop (and don't blame the disk). Docker Desktop on Windows runs its engine inside a WSL2 VM with a fixed memory ceiling. Build a lot of images while a lot of containers are resident and the VM's storage layer can collapse — taking every container down with it. The failure does not look like 'you ran out of memory'. It looks like your disk is dying.

Your drive is full and docker system df is lying to you. Docker Desktop on WSL2 stores everything in a dynamically-expanding VHDX that never shrinks. You delete 200GB of images, docker system df drops, and your drive stays exactly as full as before. People then go looking for the space in the wrong place — or buy a disk.

Detect, pin, and fix asyncio event-loop stalls in Python services — a synchronous call or CPU-bound work blocking the loop — including on the free-threaded python3.14t build where py-spy and gdb fail.

Review auth, tenancy, entitlement and cache-sharing code against six fail-closed defect classes that ruff and mypy cannot see — four checked mechanically by the bundled security_lint.py, three semantic ones you read against the diff. Every class was a real bug caught by review, not by lint.

Train your own model without making it worse. Most fine-tunes lose to the model they started from, and you cannot tell from the score. This is what we learned doing it wrong seven times in a row.

Exercise cloud automation (AWS/Azure/GCP/OCI) against local MIT-licensed emulators instead of real accounts — no credentials, no credit burn, no live instance at risk. Load before writing or testing anything that calls a cloud SDK: rental/provisioning code, S3 artifact sync, IAM or secrets paths, or any agent tool that touches a cloud API. Also load when a cloud probe "returns nothing" and you need to know whether that means empty or unreachable.

Run GitHub Actions image pipelines without rebuilding the same images on every push, or paying an hour-long cold build for a typo. The build-once/deploy-many architecture, why GitHub Actions' 10GB cache silently evicts your base image so every build is cold, the disk-reclaim step an ML base needs on a hosted runner, and the chain of never-exercised steps that each fail once your workflow finally runs. Written from a real deploy pipeline that went from 50-minute failing builds to seconds.

Use GitHub as the control plane for autonomous agents — issues as the task queue, PRs as the review gate, git as the conflict-resolution protocol, Actions on self-hosted runners as your own compute, and Projects as the board. Load when wiring agents to run unattended work with an audit trail, when deciding what belongs in a public vs private repo, or when someone is about to build a bespoke job queue, dashboard and log store that GitHub already gives away.

The storage limit that silently freezes your deploys. Your site stops updating. Not breaking — updating. Every page returns 200, every workflow reports green on the commits you looked at, and the content is days old.

Stand up, verify and repair a fleet of self-hosted GitHub Actions runners on one Windows host. Load when CI jobs sit queued while gh api .../actions/runners shows an online runner, when adding parallel capacity, when a workflow cannot get a runner, or before deleting any runner registration. Encodes the four failure modes measured 2026-08-12 — three of which each cost a failed attempt — plus the ghost-registration trap that makes a dead runner look like capacity.

When the platform cannot tell you who is using the GPU. You have one GPU and a dozen containers on it. Something is starving. You run nvidia-smi to find out who is holding the memory, and it tells you nothing useful. Now what?

Turn a repository OR a knowledge base into a graph an agent can actually answer from — pick the right embedder, stand it up, ingest, and PROVE both halves work (the vectors are the right dimension AND retrieval returns the ingested content). The operational runbook for the graphrag toolpack; pairs with graph-rag-agent (the toolkit) and aither-codegraph (code structure).

Build a knowledge graph and an agent that owns it. Point [awdk](awdk.md) at a folder of documents (or a codebase) and it builds a knowledge graph — chunked, embedded, and linked — then give a dedicated agent that graph as its memory so it answers from *your* material instead of guessing. This is graph RAG without standing up a vector database yourself: ingestion, storage, retrieval, and the agent are one toolkit.

Install Nous Research's Hermes agent and run it on your own model — a self-improving agent with persistent memory, autonomous skill creation, cron automation and multi-platform messaging. Covers pointing it at a local OpenAI-compatible endpoint, adding the AitherOS toolset over MCP, and the exact config shapes that silently fail if you get them wrong.

Provision bare metal and VPS directly into your mesh from Hetzner Cloud. Hetzner Cloud is a European VPS provider with a flat, pleasant API: one bearer token, no IAM, no service accounts. This skill wires it in as a provisioning target so a single deploy call spins up a server, attaches your SSH key, and registers it with your fleet.

Shape every answer, report, card and status line for a reader with ADHD: lead with the next action, number the steps, cap what is visible at five, restate state, make wins visible, end with one concrete next step. Use on /i-have-adhd, "adhd mode", or when a reader says the output buries the answer. Stays on until "stop adhd mode".

Install this skill pack into whatever agent you already use — Claude Code, OpenClaw, Hermes, Cursor, Goose, Codex, Gemini CLI, or any Agent-Skills-compatible client. Explains the two file layouts (flat slash-commands vs the SKILL.md folder standard), which agent wants which, and how to verify the agent can actually see them.

Fix a wired desktop or node that pings its own router at tens of milliseconds with jitter and zero NIC errors. The cause is NIC power saving (Energy-Efficient Ethernet, Green Ethernet, Advanced EEE, Power Saving Mode, Gigabit Lite). Covers the check, the fix via awsettings network apply, the Windows elevation trap, and the numbers that prove it worked.

Give an agent the ability to draw — generating images on the machine it is already running on, via ComfyUI, Sana, SD.Next/A1111 or an in-browser model. No hosted API, no key, no prompt leaving the box. Use when an agent needs a picture, when "add image generation" comes up, or when a local image backend is running and nothing is using it.

Run a language model on your own hardware for free — pick the right backend (Ollama, llama.cpp, or vLLM) for the machine you actually have, download and quantize a model that fits in memory, serve it on an OpenAI-compatible endpoint, and prove it works with a real round-trip. Covers tool-calling/function-calling setup and the failure modes that look like success.

Delegate codebase and web exploration to the local aither-local MCP server so frontier context stays small.

Open-core release hygiene — verify a build doesn't leak private code before publishing, and purge leaks that already shipped (GitHub releases/tags/history + index yank list)

Decide whether a candidate model is fit to run an agent stack, using hard oracles instead of vibes or vendor tables. Use when choosing between models for an orchestrator/router role, when a vendor benchmark says a model is good and you need to verify it on your own criteria, when a fine-tune needs a before/after that can actually move, or when a benchmark keeps returning the same score for every candidate.

Quantize an LLM to 4-bit with AutoRound — RTN runs free on local CPU+GPU; keeps lm_head/projectors in bf16 and dodges the new-architecture crashes

Give your agent current CUDA knowledge. CUDA is the worst possible subject to answer from a language model's memory. The API surface is large, version-skewed, and full of names that are *almost* right: cudaMallocAsync vs cudaMalloc, __grid_constant__ (12.x only), Nsight Compute metric names that changed between releases, occupancy rules that differ per compute capability.

Stand up ODS (Osmantic Deployment System) — one installer that turns a PC, Mac, or Linux box into a private AI server with local LLM inference, a chat UI, voice, agents, workflow automation, RAG and image generation, all in Docker with no cloud dependency. Use when someone wants the whole local AI stack rather than wiring individual services by hand.

Join the OmniNode P2P inference mesh in one command. Stand up an [OmniNode Protocol](https://github.com/SUM-INNOVATION/OmniNode-Protocol) node on any machine you own — Linux, macOS, or Windows/WSL2 — from nothing installed to a live, discoverable peer on the mesh. OmniNode is a trustless, peer-to-peer network (by SUM-INNOVATION) that pools consumer hardware into a fabric big enough to run models no single device could hold: any device with a chip can become a node.

Install OpenClaw (the local-first personal AI assistant) and wire it to your own hardware — point it at a local model instead of a paid API, connect the AitherOS toolset over MCP with one command, and install this skill pack into its workspace. Covers the automated adk integrate openclaw path and the manual config for when it isn't available.

Analyze and optimize application performance, identify bottlenecks

Run a model no single box can hold, across every tier you own. A 284B sparse MoE at Q4 is ~155 GB. No consumer box holds that. But a desktop with 128 GB DDR5 + a 32 GB GPU, plus a 128 GB unified-memory box, holds it three times over — if you can spread it. llama.cpp's RPC backend does exactly that, and it works.

The verification standard — green tests, a 200, and "deployed" are not proof. Require a check that can FAIL, hunt the silent no-op, and refuse to call anything done until the happy path is shown returning real data live. Includes an installable stop-hook that blocks a turn claiming done with no evidence.

Let an agent play a PS5 game you own: convert your own dumped PS5 executable with AnyPS5, start it with its Aither bridge switched on, and drive it with the ps5-bridge tool pack (watch frames, hold buttons, measure fps). Use when an agent should play, test, record or learn from a real PS5 title, or when wiring a game into an agent-training loop.

Generate realistic illustrations hand-coded entirely in HTML + CSS (the Diana Smith / "cyanharlow" technique — absolute-positioned divs, gradients, layered box-shadow, clip-path, transforms; no images, no SVG, no scripts). Brief → self-contained index.html + style.css → headless-Chromium render → vision-critique refine loop. The live HTML/CSS source is the deliverable; a PNG preview is rendered alongside. Load before bundling any exemplar artwork as a few-shot or training source — most of the well-known pieces are NOT openly licensed.

Stop writing careful prompts. Ramble to load intent, poke to steer, and put the precision in the harness instead — the measured prompt-shape law behind high-throughput agentic coding.

Hard-recover Docker Desktop from the WSL2 wedge (API 500 / "did not receive an exit event") and restart exited containers

Refactor code to improve structure, readability, and maintainability

Turn "I found this GitHub repo — integrate/adapt/adopt it" into a decided, recorded outcome instead of another unread folder in a research folder. Use whenever the owner drops a repo URL, a .zip, or a checked-out clone and asks to absorb it. Runs a no-execute census, mines the design seams, maps every idea against what AitherOS ALREADY has, and forces a per-idea verdict (ADOPT / ADAPT / REFERENCE / REJECT) with a license gate. Do NOT use for adding a normal dependency (that's /dependencies) or for reverse-engineering a customer SaaS from a HAR (that's integration-intake).

The architecture doctrine for agent-driven repos. Two rules. Both sound obvious. Both are violated by nearly every repo that has had agents working in it for a few months, and the violation is invisible until a disk fills at 3am.

Turn any GitHub repo into a real website on GitHub Pages — a proper landing page with your README's content, live at a URL, instead of a raw README. Free.

Reopen your killed Claude Code sessions — snapshot before a reboot, restore after, or pick from every project and resume as terminal tabs or tmux windows

Rename a token across hundreds or thousands of files in this shared worktree — a package, a directory, a product name — without corrupting load-bearing strings, without committing a peer's in-flight work, and without leaving dangling references. Load BEFORE the first sed of any rename touching more than ~20 files, before renaming a published package, and whenever a rename has to move a directory that other files reference by path. Do NOT load for a rename inside one file, or a symbol rename an LSP can do.

Build and run SalesCompel — an open-source, Apache-2.0 Salesforce replacement in Go and PostgreSQL — keeping its two database principals separate: migrate as the operator DSN, serve as the runtime DSN, create the first user from environment variables, and serve under TLS the moment the listener leaves loopback. Use when a team wants a CRM they own, is evaluating a Salesforce migration, or needs to stand up a record system on its own hardware.

Scan for leaked secrets and purge them from git history

Perform comprehensive security audits on code, dependencies, and configurations

Take an idea to a working app at a public URL using only free tiers — GitHub Pages for the site, GitHub Actions for the build, and a free serverless backend when the app needs one. Written for someone who has never deployed anything: what to choose, the exact commands, the settings that silently break a deploy, and how to verify the live URL actually serves your app.

Shard ONE model across MULTIPLE machines' GPUs with llama.cpp RPC — build with -DGGML_RPC=ON, start rpc-server on the backend hosts, launch the main server with --rpc, and PROVE the split is real instead of a silent local-only fallback. The reference topology is Bonsai-27B across the local 5090 and the DGX Spark over the ~1ms LAN.

Install and run Tau, a minimalist terminal coding agent in Python — point it at your own local model via ~/.tau/catalog.toml instead of a paid API, install this skill pack into its skills directory, and use the /skill: invocation. Covers the folder-only skill layout tau enforces and the fact that tau has no MCP support, so tools come from extensions rather than an MCP server.

Deploy a website as code — GitHub Pages frontend + Cloudflare Tunnel backend on any machine + an automated never-show-a-raw-error fallback. $0/month plus the domain.

Diagnose a Windows box where every program starts slowly (hooks time out, a bare cmd /c exit takes seconds) by measuring the kernel pool first. Covers reading pool tags without admin rights, finding the growing tag, a tag-filtered WPR trace, attributing un-freed allocations to processes and symbolized kernel paths, and the fix.

Make, list and retire agent git worktrees through awgit wt — never raw git worktree add/remove. Load before creating a worktree, when a drive is full of old ones, or to get back work from a retired one.

Render data charts (line/scatter/bar/heatmap/pie/histogram/density) to PNG/SVG/JPEG/WebP/PDF or self-contained interactive HTML via the xy engine — for metrics, benchmarks, report figures, dashboard panels, and any "turn these numbers into a picture" ask. Use INSTEAD of writing matplotlib code, ASCII tables, or reaching for mermaid/diffusion when the subject is data. Covers direct library use in scripts and the xy_render_chart / xy_chart_spec_help tools where they are available.

Run zeroauthy — an Apache-2.0, clean-room identity provider you host yourself — from its published container image: generate the TLS material and master key it refuses to start without, bring it up on :8443, create the first admin, and pin, upgrade or roll back the image deliberately. Use when a person or a small organisation needs sign-in, OIDC, MFA or social and enterprise connections without renting an auth vendor.