SomaHub

Inhale → hold → exhale. Auto-breathe at 50%/70%/85%. Commands: /exhale, /breathe, /rest, /inhale.

Community/public content must never contain private data. The channel-guard script catches leaks pre-push. This protocol covers the judgment — what to keep private, where it belongs.

When corrected, acknowledge without justifying, log old→new pattern, write a muscle if repeated. Third correction on same thing → escalate to protocol or identity.

Capture on corrections, preferences, 3+ patterns, knowledge gaps. Bubble-up: log → muscle → protocol → core.

Every .md file needs frontmatter: type, status, created, updated. Protocols get TL;DR; muscles get digest.

Soma loads protocols and muscles by temperature: cold (skip), warm (breadcrumb), hot (full). Heat auto-adjusts from usage patterns and decays when idle. /pin and /kill for manual control.

MAPS — My Automation Protocol Scripts. Before any task, check for a MAP. After any repeated task, build one. MAPS connect AMPS into repeatable processes. Refine on every use.

Maturation: Skills → Muscles → Protocols → Automations. Born from gaps and repeated friction. Not every pattern climbs the full ladder.

Plans rot. Frontmatter needs status, remaining, tooling. Empty remaining = complete → archive. Budget: ≤12 active. Verify on exhale.

Check what exists before creating. Verify assumptions before building.

Deletion is irreversible — move or archive. Tests cover NEW code, not just pass on old. Blast radius before editing — find every caller, test, and doc. Atomic commits — one concern each.

Prefer prose over bullets. Minimum formatting for the content. One question per response max. No hollow social scripts.

Soma can auto-commit .soma/ state on every exhale and surface git diffs on boot. Two tracks: .soma/ internal git (never pushed) and project code (squash before push).

One board: .soma/_kanban.md. Move cards in real time. Verify on exhale. A stale board is worse than no board.

Scripts first, then raw commands. Read before edit. Check .soma/amps/scripts/ before writing grep/find. Build a script when you do the same thing twice.

Test before commit, commit before moving on, push before walking away. Know your deploy branch. Unpushed work is invisible — treat it as unfinished.

Be direct — no ceremony. Lead with action. Know your tools before starting — name them, note gaps. Understand before you change, verify after you build AND after you ship. Maintain the tools — when code changes, verify scripts still produce correct output. Plans live in files, not in context.

plans rot. Update `remaining` on every touch. Empty → archive. After shipping, scan for stale docs. Verify docs match code before referencing.

browse icon libraries, extract SVGs, build numbered comparison pages, screenshot for visual AI review. Works with any SVG library (Lucide, Phosphor, etc).

never refactor blind. Phase: (1) scan → `soma-refactor.sh scan/refs/graph/tags` to map dependencies + references, (2) route audit → `soma-refactor.sh routes` if touching extensions (signals/capabi

after major completions, append `## HH:MM` summary to session log. One file per day, read first, never overwrite. Checkpoint within session, not a full exhale.

the match must be verified by `read` first.

Safe file operations — read before write, verify after edit, never delete without scanning dependencies.

Before touching code, name your tools. Map scripts, muscles, and MAPs for each phase of the task. Gaps are worth building for.

Validate tests aren't stale after any code removal, rename, or restructure. Run all suites, grep for orphaned references, check pass counts. Dead tests are worse than no tests.

Fast codebase navigator — find, map, refs, structure, and more

Intelligent doc discovery and scraping for SDK research

Canadian English spelling checker and fixer with project dictionary

Structure-focused agent for engineering teams — code review, standards enforcement, verification-first workflow

Default Soma setup — breath cycle, heat tracking, learning protocols, and clean memory structure. What every agent starts with.

Standard Soma setup — core protocols for session management, heat tracking, and workflow.

Ops-focused agent for deployment, CI/CD, and infrastructure — verify before deploy, maintain tooling, automate everything

Daily driver for web and app development — precision editing, safe operations, task awareness, doc hygiene, test discipline

Codebase steward — test hygiene, doc maintenance, dependency health, technical debt tracking

Customize how Soma writes preloads — override the default format with your own sections.

Migration and refactoring specialist — scan before touching, one file at a time, backward-compatible transitions, verify at every step

Writing-focused agent for technical content, blogging, and documentation — accuracy first, honest voice, learns your style