Most agents flatten feeling into sad / happy / angry. This pack teaches them to route a beat into a real emotional braid — dominant feeling, what's under it, where it lives in the body, and the humor that can carry it without cheapening it.

Not a library you call. Not prose you paste. A context pack a foreign agent reads to learn a skill it doesn't have. You don't run it; your agent walks it.

Free MIT pack

Repo: https://github.com/TheFortThatHolds/emotions-and-humor

Start at CONTEXT_GRAPH.md. Required model essay: THE_FIELD.md — there is no pure emotion; skip it and dense beats collapse to one flat note.

Inside: 13 family maps, humor partners, somatic attachers, worked braid examples, graph.json + offline viz, and tools/build_graph.py so the machine view can't drift from the maps.

One person's map, not the map. Built from lived experience as a discipline for depth — not a verdict to diagnose humans with. Re-tune it for the person you're serving.

Soft second door

If you want written Selfware routes later, browse the bazaar rack at https://thefortthatholds.xyz — no invented SKU; the MIT pack is the whole tool.

"I'm fine." is always a complete sentence. It is rarely a complete truth. F.I.N.E. reads the gap.

You type what you're carrying — messy, half-formed, a wall of text at 2am — and it figures out what's going on underneath the words. Then it gives it back in a form that helps: a song, a poem, prose, a protocol of steps, or language for a hard boundary conversation.

Not a chatbot. It doesn't interview you. Feeling in → useful artifact out.

Free MIT CLI

Repo: https://github.com/TheFortThatHolds/fine-framework

git clone https://github.com/TheFortThatHolds/fine-framework
cd fine-framework
pip install openai
python fine.py "I don't know what I'm feeling but something is wrong"
python fine.py "I need to tell my manager I can't keep doing this" --target boundary

Point it at a local model (Ollama / LM Studio) or OpenAI via FINE_LLM_URL / FINE_MODEL.

Four passes: LOOK IN → SPIRAL UP → FLOW OUT → RETURN. Thirty-two emotional voice families in plain JSON under assets/voices/. Gaps land in reports/growth/ so the library can grow honestly.

Deeper architecture: TECHNICAL.md. MCP wrap notes in skills/mcp_setup_guide.md.

Soft second door

If you want written Selfware routes later, browse the bazaar rack at https://thefortthatholds.xyz — no invented F.I.N.E. SKU; the MIT repo is the whole tool.

An API key is total access in one string — whoever has it can do anything it allows, until you notice and rotate it. That's what we often hand AI agents today.

Fort Card treats your keys like credit cards. The real key is sealed in your lockbox — a Worker on your Cloudflare that holds your master key and is the only thing that ever touches plaintext. Agents get a card: scoped to one host, capped to N uses, freezable with one call. When the card is charged, the lockbox injects the real key server-side and returns only the response — the agent gets the result, not the key.

Free OSS (run it yourself)

• Control plane / worker: https://github.com/TheFortThatHolds/fort-card
• Lockbox worker: https://github.com/TheFortThatHolds/fort-card-lockbox

MIT. Audit the code. Deploy your own lockbox. Your keys stay on infrastructure you control.

There's a 2-minute local demo (demo/card-demo.mjs) with plain Node — seal a key, issue a host-locked card, watch an "agent" call succeed, then see declines for wrong-host and frozen cards.

Soft second door (optional hosted)

If you'd rather not self-host, an existing hosted Fort Card is available at https://thefortthatholds.com/fort-card ($8/mo). The MIT repos above are the whole system either way — hosted is optional, not required.

Why this shape

Banks solved "let someone spend on your behalf without handing over the vault" decades ago. Fort Card teaches that pattern to API keys — especially as agents talk MCP and need caps, host locks, freezes, and a statement instead of god-tokens in chat logs.

Fort Kitchen is a household kitchen operating system you run yourself — not a recipe-box SaaS.

You and your chosen AI agent share a durable model of the kitchen: what you actually eat, what is in the house, what gear you own, what you planned, what you cooked, and what needs restocking.

Fork the repo, hand it to your agent, answer the onboarding questions, and it configures around your household.

Runs with no accounts, no cloud keys, and no paid services required: Clone and start locally on port 8787 (Node 22.6+), or ship your own Worker with KV. Commands are in the README.

What it covers

• Tonight — picks a meal from what the house permits and can actually make
• Week — meal plan + shopping list from the gap between recipes and pantry
• Recipes / Pantry / Gear — structured records, quantities, locations, substitutions, appliance links
• Capture — paste, photo, screenshot, or natural language into structured records (adapters)
• Agent bridge — explicit tools so a voice/text companion can cook with you without owning the truth

Central rule: you own the kitchen truth; the agent helps maintain it. Inferences may be proposed; only confirmed facts become durable state. Zone Law (FULL / PARTIAL / ASK) gates what the agent may do — allergies and spend stay ASK by default.

No hidden dependency on Fort infrastructure. Sample household data is clearly sample; live pantry, recipes, and secrets never belong in the public repo.

Repo

MIT: https://github.com/TheFortThatHolds/fort-kitchen

Tell your agent: read AGENT_INSTALL.md, interview only for facts it cannot safely infer, configure this fork as my kitchen. Do not keep the example diet, voice, or branding unless I ask.

Other Fort organs released the same way (mail, beta reader). If you want written Selfware routes later, browse the bazaar rack at https://thefortthatholds.xyz — no Kitchen seed SKU yet; the MIT repo is the whole tool.

Written beta notes are slow and vague, so a lot of readers never send them. Talking is fast, so they do.

Beta Reader is a free, MIT tool open-sourced for that loop:

1. You hand someone a link to your manuscript (Markdown or plain text)
2. They listen (TTS through your Worker, or the browser's free voice)
3. When something lands — good or bad — they tap the passage and say it (or type)
4. Notes pin to that exact passage and commit to a branch per reader in your GitHub repo
5. You pull every reader's notes into one passage-by-passage view and hand that Markdown to your agent

No accounts, no analytics, no database, no build step, no framework. One HTML file + one Cloudflare Worker. Your API key stays in Worker secrets; manuscripts stay in local storage on the device that opened them. There's a replaceable twenty-question debrief at the end.

It's meant to be agent-installed: point Claude Code / Cursor / Codex / whatever at the repo, say "read AGENTS.md and set this up," and it stands the static app, Worker, secrets, notes repo, and reader links. Skills included for Claude Code users (/setup-beta-reader, /beta-feedback). Or about ten minutes by hand from AGENTS.md.

Repo

MIT: https://github.com/TheFortThatHolds/beta

If you'd rather have the written route, there's an optional Beta Selfware seed on the bazaar ($9.99) as a soft second door — the MIT repo is the whole tool either way: https://thefortthatholds.xyz

Fortmail gives your AI agent a real email client: every mailbox you own, aggregated and triaged, with send-as for those same boxes — so you stop living in the inbox.

It is one Cloudflare Worker (~550 lines, zero deps). Free-tier friendly. No framework, no server to babysit. No LLM inside the worker itself.

What it does

• Owns Gmail (API/OAuth) and any IMAP/SMTP provider over raw TLS — no forwarding middleman
• Seals mailbox credentials in the worker (AES-GCM); you do not store plaintext passwords
• Triages with a deterministic regex classifier into desk / record / ignore (no model cost, no hallucination in the plumbing)
• Speaks MCP at /mcp — connect Claude, Cursor, ChatGPT, Gemini, or your own harness
• Optional steward bridge: mail to an agent address → GitHub PR with TRUSTED/UNTRUSTED stamp so the agent knows instructions vs data
• Newsletter lists live in your KV (double opt-in, one-click unsub); relay is just a pipe

Trust rule baked in: only OWNER_EMAILS may issue commands; everything else is data to triage, never obeyed.

Repo

MIT: https://github.com/TheFortThatHolds/mail

Point any coding agent at AGENTS.md and it can stand the whole thing up; you only do the human-gated steps (Cloudflare login, OAuth, mailbox passwords).

If you want the written route these organs came from — same stack, documented for your own agent — the free repos and optional Selfware seeds live at https://thefortthatholds.xyz. The code above is complete without that.