skill-brain 2.1.0__tar.gz

skill_brain-2.1.0/.agents/AGENTS.md

@@ -0,0 +1,194 @@
+# Skill Brain — Master Engineering Protocol
+
+This is the master rule file. It loads automatically in every session. Read it before anything else.
+
+---
+
+## Philosophy
+
+We build real engineering products. Not AI-generated slop. Not template defaults. Not the average of everything the model has seen.
+
+Every decision here is a deliberate, mathematically grounded choice made for this project and this project only.
+
+---
+
+## Dollar Commands & Trigger Keywords ($)
+
+You can trigger specific categories, dedicated planners, and capabilities instantly using dollar commands (`$` prefix) or shorthand keywords:
+
+| Command | Keyword Trigger | Target Orchestrator / Skill | Action |
+|---|---|---|---|
+| `$orchestrate` | `brain:` | `supreme-orchestrator` | Evaluates multi-domain requests, selects category routing, gates execution. |
+| `$plan-frontend`| `plan-ui:` | `frontend-planner` | Formulates complete UI design & dual-viewport responsive blueprint before coding. |
+| `$frontend` | `ui:`, `fe:` | `frontend-master` | Activates frontend suite with Taste Kill + Anti-SOP + Dynamic Sizing baselines. |
+| `$plan-backend` | `plan-api:` | `backend-planner` | Formulates domain models, responsive API contracts, and TDD plan before coding. |
+| `$backend` | `api:`, `be:` | `backend-master` | Activates backend suite with Karpathy simplicity + TDD + Responsive contracts. |
+| `$plan-debug` | `plan-fix:` | `debug-planner` | Mandatory diagnostic plan first: symptom, hypothesis, evidence roadmap. |
+| `$debug` | `fix:` | `debug-master` | Executes diagnostic plan, isolates root cause, requires evidence before fixes. |
+| `$plan-anti-slop`| `audit-plan:` | `anti-slop-planner` | Scans for AI tells, outputs itemized remediation plan across 6 dimensions. |
+| `$anti-slop` | `gate:`, `audit:` | `anti-ai-sop-agent` | Generates 6-category quality gate scorecard (PASS / WARN / FAIL) with `--fix`. |
+| `$architect` | `arch:`, `isolate:` | `architecture-master` | Isolates workspace via worktree, maps decision tickets, or dispatches sub-agents. |
+| `$plan` | `plan:` | Domain Planner (`frontend-planner`, `backend-planner`, `debug-planner`, `implementation-planner`) | Formulates in-chat blueprint for task with zero disk writes. |
+| `$memory` | `memory:` | `memory-master` | Creates master plan & phase files, renders Live Chat Dashboard, user-controlled. |
+| `$taste` | `kill-slop:` | `design-taste-frontend` | Runs the 247-site study art direction: palette from subject, no template defaults. |
+| `$typography` | `type:` | `typography-master` | Selects domain font archetype (Swiss, Editorial, Mono, Humanist), clamp scale. |
+| `$icon` | `svg:` | `svg-icon-craftsman` | Crafts clean 24×24 grid-snapped vector geometry with 1.5px/2.0px stroke. |
+| `$test`, `$verify` | `test:`, `evidence:` | `test-verifier` | Runs tests and verification ONLY when explicitly asked by the user ($test). |
+| `$git` | `git:` | `git-master` | Apex Git orchestrator: branch lifecycle, atomic commit splitting, phase gates. |
+| `$commit` | `commit:` | `git-atomic-committer` | Analyzes diffs, splits into 2+ atomic commits across domains, Conventional format. |
+| `$branch` | `branch:` | `git-branch-manager` | Kebab branch taxonomy (`feat/`, `fix/`, `phase/`), clean tree, rebase workflow. |
+| `$phase-commit` | `phase-commit:` | `git-phase-committer` | Automatic memory phase commit hook with embedded verification proof. |
+
+---
+
+## The Master Skill Protocol
+
+**Rule 1 — Supreme Orchestration & Ask Before Acting:**
+The top orchestrator is `supreme-orchestrator`.
+Skill Brain reads `.agents/brain/config.json` for the confirmation policy (`"confirm": "always" | "multi-skill" | "never"`, default `"always"`):
+- `"always"`: Always present proposed skills and ask confirmation before executing:
+  > *"I propose using `[skill-a]` + `[skill-b]` via `.agents/brain/decisions/[category].md`. Shall I proceed?"*
+- `"multi-skill"`: Ask confirmation only when coordinating 2 or more skills; single-skill tasks proceed directly.
+- `"never"`: Autonomous execution without interactive confirmation prompts.
+
+**Rule 2 — Categorical Dispatch & Planning Fast-Paths:**
+When the user explicitly invokes a planning command (e.g. `$plan-frontend`, `$plan-backend`, `$plan-debug`, `$plan-anti-slop`):
+Formulate the architecture plan, present it to the user, and request confirmation before touching code.
+
+**Rule 3 — Mandatory Frontend Baseline Bundle:**
+For all frontend tasks:
+- `frontend-baseline` (≤ 4 KB) is the mandatory active baseline bundle, condensing Taste Kill v2 (`design-taste-frontend`), Anti-AI SOP (`ui-tells-eliminator`), and Dynamic Responsive Sizing (`phone-layout-master` + `desktop-ui-architect`).
+- Individual full skills remain accessible on demand from references.
+
+**Rule 4 — Mandatory Backend Responsive Contracts:**
+When designing or reviewing backend APIs and data structures:
+- `responsive-contract-enforcer` is active.
+- Forbids fixed pixel dimensions in API payloads; mandates explicit aspect ratios and responsive srcsets.
+
+**Rule 5 — Debugging Planning Gate:**
+When the user says *"debug"* or triggers `$debug`, **NEVER** edit code immediately.
+1. Formulate a diagnostic plan using `debug-planner` and `.agents/brain/decisions/debugging.md`.
+2. Present the plan (symptom, reproduction, hypotheses, investigation steps) to the user.
+3. Ask the user: *"Here is my diagnostic plan. Shall I proceed with the investigation?"*
+
+**Rule 6 — User-Controlled Virtual Memory & $plan Routing:**
+The user has 100% control over memory.
+- **DO NOT** write casual tasks or single-turn edits into disk memory.
+- `$plan` produces an in-chat plan with **zero disk writes** (routing to `frontend-planner`, `backend-planner`, `debug-planner`, or `implementation-planner`).
+- Activate `.agents/memory/plans/` and `.agents/memory/phases/` **ONLY** when the user explicitly commands `$memory` or *"add to memory"*.
+- When active, render the Live Phase Status Dashboard in the chat.
+- Clean and archive to `.agents/memory/archive/` once all phases pass verification.
+
+**Rule 7 — Token Efficiency (Max 3 Task Skills + Baseline Bundle):**
+Never load more than 3 task skills + the baseline bundle (`frontend-baseline`) at the same time. Never attempt a monolithic pass.
+
+**Rule 8 — Mandatory Atomic Git Commits & Branch Hygiene:**
+When committing changes or managing branches:
+- **Inspect Before Staging:** Run `git status --porcelain` and `git diff --stat`. Never blind-stage with `git add .`.
+- **Multi-Commit Splitting:** When changes cross domain boundaries (e.g. backend core logic, UI, tests, memory phases), split them into 2 or more sequential atomic commits.
+- **Conventional Commits Standard:** `<type>(<scope>): <imperative summary>` (<= 72 chars), body explaining *what* and *why*, and footer with verification proof (`Verified: <test output>`).
+- **Phase Memory Hook:** When a virtual memory phase reaches `FINISHED` in `.agents/memory/phases/`, automatically trigger `git-phase-committer` (`$phase-commit`) before advancing to the next phase.
+- **Branch Hygiene:** Never work directly on `main` for multi-step features. Branch with `feat/`, `fix/`, or `phase/`, rebase against `main`, and clean up merged branches.
+
+**Rule 9 — Test-On-Demand Protocol (Never Test Unless Explicitly Asked):**
+DO NOT write tests, run test suites, or execute logic test scripts unless the user explicitly requests it or invokes `$test` / `$verify`. Never block, delay, or clutter implementation with unsolicited test loops or speculative test suites unless explicitly commanded.
+
+---
+
+## The Skill Map
+
+### Apex Orchestrator
+| Skill | Command | Purpose |
+|---|---|---|
+| `supreme-orchestrator` | `$orchestrate` | Top-level router for any user request, category routing & confirmation gate |
+
+### Category Orchestrators & Dedicated Planners
+| Orchestrator / Planner | Command | Decision File | Purpose |
+|---|---|---|---|
+| `frontend-master` | `$frontend` | `.agents/brain/decisions/frontend.md` | All UI, design, typography, icons, animation |
+| `frontend-planner` | `$plan-frontend` | `.agents/brain/decisions/frontend.md` | Pre-build UI design & dual-viewport responsive blueprint |
+| `backend-master` | `$backend` | `.agents/brain/decisions/backend.md` | API, data, logic, TDD, Swift, Karpathy simplicity |
+| `backend-planner` | `$plan-backend` | `.agents/brain/decisions/backend.md` | Domain schema, responsive API contract, and TDD plan |
+| `debug-master` | `$debug` | `.agents/brain/decisions/debugging.md` | Diagnostic planning, root-cause isolation, verification |
+| `debug-planner` | `$plan-debug` | `.agents/brain/decisions/debugging.md` | Diagnostic symptom, reproduction, and hypothesis roadmap |
+| `anti-slop-planner`| `$plan-anti-slop`| `.agents/brain/decisions/anti-ai-sop.md` | 6-dimension code scanner & itemized remediation plan |
+| `architecture-master` | `$architect` | `.agents/brain/decisions/architecture.md` | Worktree isolation, sub-agents, multi-session mapping |
+| `memory-master` | `$memory` | `.agents/brain/decisions/memory.md` | User-controlled virtual memory plans & phases |
+| `git-master` | `$git` | `.agents/brain/decisions/git.md` | Apex Git orchestrator: branch management, atomic commits, phase sync |
+| `git-atomic-committer` | `$commit` | `.agents/brain/decisions/git.md` | Multi-commit splitting (2+ commits), Conventional Commits crafting |
+
+### Frontend Skills
+- `frontend-baseline` (`$frontend-baseline`) — Mandatory unified frontend bundle: Taste Kill + Anti-AI SOP + Dynamic Sizing
+- `frontend-planner` (`$plan-frontend`) — Pre-build UI design & dual-viewport blueprint
+- `phone-layout-master` — Mobile phone perfection (320px–480px, 100svh, 44px targets, bottom sheets)
+- `desktop-ui-architect` — Desktop application UI (768px–2560px, container queries, max bounds)
+- `dynamic-ui-engine` — Master dynamic responsive sizing engine (fluid clamp math, zero CLS)
+- `design-taste-frontend` (`$taste`) — Full Taste Kill v2 engine (247 award sites study, no-slop house style)
+- `ui-taste-enforcer` — Anti-slop art direction: no generic defaults, subject-matter inventory
+- `ui-design-principles` — 2-pass design: plan → review against brief → build → critique
+- `typography-master` (`$typography`) — Domain-tailored font archetypes, fluid clamp scales, tracking math
+- `svg-icon-craftsman` (`$icon`) — 24×24 grid, 1.5px/2.0px uniform stroke, zero-slop clean vectors
+- `animation-builder` — Build purposeful web animations from scratch with proper easing
+- `animation-reviewer` — Review existing motion against craft standards
+- `animation-auditor` — Full codebase animation audit + improvement roadmap
+- `animation-performance` — Fix janky animations; GPU composite layer tuning (16.6ms budget)
+- `animation-opportunities` — Find what should animate but doesn't
+- `apple-feel` — Apple-style spring physics, gesture UI, fluid momentum motion
+- `mobile-native-feel` — Make web apps feel native on mobile: 100svh, tap lag fixes, safe areas
+- `ui-stress-tester` — Feed worst-case data, find layout breaks and truncation failures
+- `ui-library-picker` — Opinionated library selection: Radix, Sonner, cmdk, TanStack Table
+- `ui-prototyper` — Build 3 genuinely different UI variants behind a live visual picker
+- `design-engineering` — Emil Kowalski's invisible polish: 9 states, micro-interactions
+- `canvas-art` — Static art, posters, PNG/PDF design output
+- `theme-system` — Apply or generate visual themes (Obsidian, Paper, Blueprint)
+- `web-artifact-builder` — Multi-component React/Tailwind/shadcn applications
+- `webapp-tester` — Playwright browser automation testing for web UIs
+
+### Backend Skills
+- `backend-planner` (`$plan-backend`) — Pre-implementation domain, contract, and TDD blueprint
+- `responsive-contract-enforcer` — Mandatory backend responsive contract (no pixel widths, explicit aspect ratios)
+- `karpathy-coder` — Surgical code implementation: minimal blast radius, YAGNI, think first
+- `tdd-implementer` — Test-driven development: red → green → refactor loop
+- `implementation-planner` — Detailed implementation plan before touching code
+- `spec-writer` — Synthesize conversation into a formal technical specification
+- `ticket-breaker` — Break spec into tracer-bullet tickets with dependency graph
+- `spec-implementer` — Implement from a spec or tickets with incremental commits
+- `domain-modeler` — Build and sharpen domain model and GLOSSARY.md
+- `codebase-designer` — Deep module design, interface deepening, seam placement
+- `architecture-improver` — Scan codebase for architectural debt and circular dependencies
+- `swift-writer` — Modern Swift 6, strict concurrency, @MainActor, Swift Testing
+- `pr-writer` — Write clear, complete pull request descriptions with test steps
+- `mcp-builder` — Build MCP servers to connect LLMs with external APIs
+
+### Debugging Skills
+- `debug-planner` (`$plan-debug`) — Mandatory diagnostic symptom, reproduction, and hypothesis plan
+- `root-cause-debugger` (`$debug`) — Find root cause FIRST before attempting any fix
+- `bug-diagnoser` — Systematic diagnosis loop for hard bugs, bisecting, regressions
+- `test-verifier` (`$verify`) — Evidence before claims: run verification commands before saying "done"
+- `code-reviewer` — Review against repo standards + spec in parallel
+- `issue-triager` — Move issues through triage, verify reproduction, write agent briefs
+
+### Architecture Skills
+- `subagent-executor` — Dispatch fresh sub-agents per task with isolated context
+- `git-isolator` — Create isolated workspace via git worktrees before feature work
+- `large-task-mapper` — Map project-level work as decision tickets across sessions
+- `research-agent` — Investigate questions against primary sources with citations
+- `setup-wizard` — Interactive bash wizard for human-only configuration steps
+- `skill-creator` — Create, benchmark, and evaluate new skills
+
+### Memory Skills (User-Controlled)
+- `phase-planner` — Master plan (`plans/`) + phase files (`phases/`) + live chat board + cleanup
+- `session-continuity` — Recover state from memory files across sessions
+- `context-handoff` — Compact session state into a cold-start handoff document
+
+### Anti-AI SOP Skills & Standalone Agent
+- `anti-slop-planner` (`$plan-anti-slop`) — Pre-remediation 6-dimension code scanner & plan
+- `anti-slop-enforcer` — Master kill-list for synthetic text filler and generic UI defaults
+- `text-tone-enforcer` — Calibrate prose to direct, authoritative senior-engineer standard
+- `ui-tells-eliminator` — Code-level scanner for pill badges, eyebrows, blob gradients
+- `anti-ai-sop-agent` (`$anti-slop`) — Standalone quality-gate agent: 6-category scorecard (PASS / WARN / FAIL)
+
+### Git Skills
+- `git-atomic-committer` (`$commit`) — Multi-domain commit splitting engine (2+ commits based on blast radius & type)
+- `git-branch-manager` (`$branch`) — Strict branch lifecycle, kebab taxonomy, rebase sync, merge readiness
+- `git-phase-committer` (`$phase-commit`) — Automatic phase completion commits with embedded verification proof

skill_brain-2.1.0/.agents/brain/config.json

@@ -0,0 +1,3 @@
+{
+  "confirm": "always"
+}

skill_brain-2.1.0/.agents/brain/decisions/anti-ai-sop.md

@@ -0,0 +1,22 @@
+# Anti-AI SOP Skills — Decision Making Matrix
+
+This document dictates how the agent monitors, purges, and audits AI tells across prose, visual design, vectors, and code.
+
+---
+
+## 1. Zero Tolerance Mandate
+
+Before ANY response, code snippet, SVG, or UI is returned to the user, run the anti-slop check.
+If an output contains synthetic tells, rewrite it before sending.
+
+---
+
+## 2. Specialized Skill Selection Matrix
+
+| Content Being Produced | Selected Skills | Enforced Restrictions |
+|---|---|---|
+| **Plan an Anti-AI audit before fixing** | `anti-slop-planner` (`$plan-anti-slop`) | Catalogs all AI tells across 6 dimensions with file:line citations; drafts surgical remediation plan. |
+| **Formal quality gate audit of repo/PR** | `agents/anti-ai-sop-agent` (`$anti-slop`) | Produces formal 6-category scorecard (PASS / WARN / FAIL) with concrete citations and optional `--fix` mode. |
+| **Text, explanations, answers, PRs** | `text-tone-enforcer` + `anti-slop-enforcer` | No sycophantic openers, no filler transitions ("Furthermore"), no bullet-point abuse; direct senior engineer cadence. |
+| **Frontend UI (CSS, Tailwind, JSX, HTML)** | `ui-tells-eliminator` + `anti-slop-enforcer` | No cream/terracotta Anthropic clone, no pill badges above headlines, no tracked uppercase eyebrows, no 3-card centered icon grids. |
+| **SVG Icons and Vector Graphics** | `svg-icon-craftsman` (`$icon`) | No wandering bezier curves, standard 24×24 viewBox, uniform 1.5px/2.0px stroke, integral pixel snapping. |

skill_brain-2.1.0/.agents/brain/decisions/architecture.md

@@ -0,0 +1,35 @@
+# Architecture Skills — Decision Making Matrix
+
+This document dictates how the agent handles system design, workspace isolation, sub-agent dispatch, and large project planning.
+
+---
+
+## 1. Mandatory Baseline
+
+Before structural or multi-module changes:
+- Evaluate workspace isolation: if a feature branch or worktree is appropriate, activate `git-isolator`.
+- Keep the main branch clean and unpolluted with in-progress experiments.
+
+---
+
+## 2. Specialized Skill Selection Matrix
+
+| Architectural Goal | Selected Skills | Why This Combination |
+|---|---|---|
+| **Isolate workspace for feature work** | `git-isolator` | Creates native worktree (`git worktree add -b feature/...`), verifies isolation, keeps main tree clean. |
+| **Dispatch parallel task execution** | `subagent-executor` | Dispatches fresh sub-agents with isolated prompts per task; reviews each task output before merging. |
+| **Map huge project spanning sessions** | `large-task-mapper` | Deconstructs big goals into decision tickets (blocking forks in the road) before implementation tickets. |
+| **Research API / library from sources** | `research-agent` | Restricts investigation strictly to primary sources (official docs, repo source); cites URLs and file lines. |
+| **Human credential / dashboard setup** | `setup-wizard` | Generates idempotent, color-coded interactive bash wizard for human-only secrets, dashboards, or DNS steps. |
+| **Author or optimize an agent skill** | `skill-creator` | Benchmarks trigger descriptions, runs eval matrices, refines procedural instructions. |
+
+---
+
+## 3. Sub-Agent vs. Single Pass Decision
+
+- **Use `subagent-executor` when:**
+  - Tasks are embarrassingly parallel (e.g. 5 independent UI components or 4 separate API endpoints).
+  - Context window would be overwhelmed by reviewing all implementations at once.
+- **Use single pass when:**
+  - Tasks are tightly coupled sequentially (e.g. database schema change followed immediately by dependent query update).
+

skill_brain-2.1.0/.agents/brain/decisions/backend.md

@@ -0,0 +1,27 @@
+# Backend Skills — Decision Making Matrix
+
+This document dictates how the agent selects, combines, and sequences backend skills.
+
+---
+
+## 1. Mandatory Baseline (Always Active in Backend)
+
+Every backend implementation task **must** honor:
+1. `karpathy-coder` (minimal blast radius, zero speculative code, no unrequested abstractions).
+2. `tdd-implementer` (write test first, watch it fail, write minimal code to pass).
+3. `responsive-contract-enforcer` (all endpoints serving UI must declare responsive aspect ratios, multi-res srcsets, and zero fixed pixel widths).
+
+---
+
+## 2. Specialized Skill Selection Matrix
+
+| User Goal | Selected Skills | Why This Combination |
+|---|---|---|
+| **Plan backend architecture before coding** | `backend-planner` (`$plan-backend`) | Defines domain models, responsive API contracts, tracer-bullet ticket graph, and TDD plan. |
+| **Surgical bugfix or minimal tweak** | `karpathy-coder` + `tdd-implementer` | Touches only failing lines, adds a targeted regression test, leaves surrounding code pristine. |
+| **Build new feature from spec** | `spec-implementer` | Follows ticket dependency graph in strict order, committing after each ticket. |
+| **Design deep module / API boundary** | `codebase-designer` + `domain-modeler` | Maximizes information hiding (Ousterhout deep modules) and aligns naming to GLOSSARY.md. |
+| **Enforce responsive UI API contract** | `responsive-contract-enforcer` | Validates that payloads contain responsive layout hints, aspect ratios, and zero hardcoded pixel widths. |
+| **Modern Swift 6 / Apple backend** | `swift-writer` | Strict concurrency (@MainActor, actors, Sendable), value-type modeling, Swift Testing. |
+| **Build MCP tool server** | `mcp-builder` | FastMCP or TypeScript MCP SDK; clean tool schemas, error handling, deterministic outputs. |
+| **Write pull request description** | `pr-writer` | Generates summary, testing steps, before/after evidence, and reviewer checklist. |

skill_brain-2.1.0/.agents/brain/decisions/debugging.md

@@ -0,0 +1,45 @@
+# Debugging Skills — Decision Making Matrix
+
+This document dictates how the agent handles bugs, test failures, crashes, and regressions.
+
+---
+
+## 1. The Debugging Iron Law (Planning First)
+
+**When the user says "debug", NEVER edit code immediately.**
+1. Formulate a systematic diagnostic plan using debugging skills.
+2. State the observed symptom, reproduction steps, and candidate hypotheses.
+3. Ask the user for confirmation: *"Here is my diagnostic plan. Shall I proceed with isolating the root cause?"*
+4. Only after finding the root cause with verifiable evidence may a fix be designed.
+
+---
+
+## 2. Specialized Skill Selection Matrix
+
+| Problem Type | Selected Skills | Why This Combination |
+|---|---|---|
+| **Exception, crash, or clear error** | `root-cause-debugger` | Enforces the 5-step protocol: state symptom, gather evidence, form ONE falsifiable hypothesis, test hypothesis, isolate cause. |
+| **Intermittent bug / "works on my machine"** | `bug-diagnoser` | Systematically bisects problem space, instruments minimal logging, and isolates minimal reproduction. |
+| **Performance regression / slow API** | `bug-diagnoser` (perf mode) | Measures CPU/memory bottlenecks, queries profilers, identifies O(n²) or N+1 query patterns. |
+| **Validating a fix or claiming "done"** | `test-verifier` | Evidence before claims: runs actual test/lint commands and pastes raw terminal output before declaring success. |
+| **Reviewing branch / PR for flaws** | `code-reviewer` | Runs parallel reviews: Standards compliance (clean code) vs. Spec compliance (did we build what was asked?). |
+| **Triaging bug reports from users** | `issue-triager` | Moves issues through triage state machine (RAW → VERIFYING → CATEGORIZED → READY) and produces agent-ready briefs. |
+
+---
+
+## 3. Diagnostic Plan Template
+
+Before touching code, present this plan to the user:
+
+```markdown
+### 🔍 Diagnostic Plan
+1. **Symptom:** [Exact error message or unexpected behavior observed]
+2. **Reproduction:** [Exact command or steps to reproduce]
+3. **Hypothesis:** [What mechanism is suspected of causing this]
+4. **Investigation Steps:**
+   - [ ] Inspect stack trace / logs at [file:line]
+   - [ ] Run isolated regression test
+   - [ ] Verify root cause before proposing edits
+5. **Next Step:** Confirm to begin investigation.
+```
+

skill_brain-2.1.0/.agents/brain/decisions/frontend.md

@@ -0,0 +1,38 @@
+# Frontend Skills — Decision Making Matrix
+
+This document dictates how the agent selects, combines, and sequences frontend skills.
+
+---
+
+## 1. Mandatory Baseline Bundle (`frontend-baseline`)
+
+Every frontend task **must** load `frontend-baseline` (≤ 4 KB), which condenses:
+1. **Art Direction:** `design-taste-frontend` + `ui-taste-enforcer` (Taste Kill v2, 247-site study, subject palette).
+2. **Anti-AI SOP:** `ui-tells-eliminator` + `anti-slop-enforcer` (kills pill badges, eyebrows, 3-card grids).
+3. **Dynamic Responsive Sizing:** `phone-layout-master` + `desktop-ui-architect` + `dynamic-ui-engine` (flawless adaptation from 320px phone to 2560px desktop).
+
+Full skills can be loaded on demand from references when deeper guidance is required.
+
+---
+
+## 2. Specialized Skill Selection Matrix
+
+| User Goal | Selected Skills | Why This Combination |
+|---|---|---|
+| **Plan UI architecture before building** | `frontend-planner` (`$plan-frontend`) | Creates complete blueprint: subject inventory, fluid tokens, phone layout, desktop layout, anti-slop check. |
+| **Build new component or page** | `design-taste-frontend` + `dynamic-ui-engine` + `typography-master` | Directs composition, token ratios, fluid clamp scales, and tailored typography. |
+| **Phone / Mobile layout perfection** | `phone-layout-master` + `mobile-native-feel` | 320px–480px optimization: 100svh, 44px touch targets, bottom sheets, safe-area insets. |
+| **Desktop / Wide-screen UI workstation** | `desktop-ui-architect` + `design-engineering` | 768px–2560px optimization: multi-pane hierarchy, container queries (`@container`), max-width bounds. |
+| **Typography & font archetype selection**| `typography-master` (`$typography`) | Selects Swiss, Editorial, Mono, or Humanist font stacks; establishes mathematical clamp scales. |
+| **Craft SVG icons or glyphs** | `svg-icon-craftsman` (`$icon`) | Snaps vector paths to 24×24 grid, 1.5px/2.0px stroke, eliminates AI curve spaghetti. |
+| **Add micro-interactions & polish** | `design-engineering` + `animation-builder` | Emil Kowalski polish standard: 9 interactive states, physical spring curves. |
+| **Fix dropped frames or janky UI** | `animation-performance` | Keeps animations on composite-only GPU properties (transform, opacity); 16.6ms frame budget. |
+| **Stress-test layout breaks** | `ui-stress-tester` | Feeds extreme strings, non-Latin text, negative numbers, empty arrays behind a demo toggle. |
+| **Compare multiple UI directions** | `ui-prototyper` | Generates 3 genuinely different compositions behind a live switcher. |
+
+---
+
+## 3. The Baseline Bundle + 3 Task Skills Rule
+
+- Rule 7 standard: Load `frontend-baseline` plus up to **3 specialized task skills** at the same time (e.g. `svg-icon-craftsman`, `animation-builder`, `webapp-tester`).
+- Respect `.agents/brain/config.json` confirmation settings before executing.

skill_brain-2.1.0/.agents/brain/decisions/git.md

@@ -0,0 +1,59 @@
+# Git Skills — Decision Making Matrix
+
+This document dictates how the agent handles version control operations, atomic commits, branch lifecycle management, and virtual memory phase commit synchronization.
+
+---
+
+## 1. Mandatory Baseline
+
+Before executing any git operations:
+- Never commit broken code, syntax errors, or unverified changes.
+- Never dump massive, unrelated multi-domain changes into a single generic commit.
+- Inspect `git status --porcelain` and `git diff --stat` before staging files.
+- Enforce Conventional Commits standard: `<type>(<scope>): <imperative summary>` (<= 72 chars), followed by a concise body and verification evidence footer.
+- When working within Virtual Memory (`.agents/memory/phases/`), every phase transition to `FINISHED` must trigger an atomic phase commit.
+
+---
+
+## 2. Specialized Skill Selection Matrix
+
+| Git Operational Goal | Selected Skills | Why This Combination |
+|---|---|---|
+| **User commands: `$commit`, `commit:`, or code ready to commit** | `git-atomic-committer` | Analyzes staged/unstaged changes, evaluates domain blast radius, splits into 2 or more atomic commits if changes span multiple domains, crafts Conventional Commit message with verification evidence. |
+| **User commands: `$branch`, `branch:`, or creating/syncing branches** | `git-branch-manager` | Enforces strict naming conventions (`feat/`, `fix/`, `phase/`, `refactor/`, `chore/`), checks working tree hygiene, performs rebase sync (`git pull --rebase origin main`), and handles branch cleanup. |
+| **A Virtual Memory Phase completes (`[VERIFY]` → `[FINISH]`)** | `git-phase-committer` | Hooks into Step 4 of `phase-planner`. Stages and splits phase code, test fixtures, and memory updates into atomic phase commits, recording verification proof in the commit body. |
+| **Feature isolation in separate workspace** | `git-branch-manager` + `git-isolator` | Creates an isolated worktree branch (`git worktree add ../feature-work -b feature/...`), keeping main branch unpolluted. |
+| **Preparing Pull Request / Merge readiness** | `git-atomic-committer` + `pr-writer` | Validates clean atomic commit history and synthesizes high-fidelity PR description from the commit log. |
+
+---
+
+## 3. Commit Splitting Decision Rule
+
+When analyzing workspace diffs:
+
+```
+Total Changed Files & Domains?
+│
+├── 1 domain, <= 3 tightly coupled files ──► SINGLE ATOMIC COMMIT
+│   └── Example: feat(auth): implement token refresh rotation
+│
+└── Multiple domains OR > 3 loosely coupled files ──► SPLIT INTO 2+ ATOMIC COMMITS
+    ├── Commit 1 (Core Domain / Backend): feat(...) or fix(...)
+    ├── Commit 2 (Tests & Verification Fixtures): test(...)
+    ├── Commit 3 (UI / Styling / Components): feat(ui) or style(...)
+    └── Commit 4 (Memory Phases / Config / Docs): chore(phase-N) or docs(...)
+```
+
+---
+
+## 4. Anti-AI SOP Commit Standard
+
+- **FORBIDDEN:**
+  - ❌ "Update files"
+  - ❌ "WIP" / "misc fixes" / "make code better"
+  - ❌ "Refactor code for improved readability and maintainability" (AI fluff)
+  - ❌ Monolithic 500-line commits combining UI, backend, tests, and config together.
+- **MANDATORY:**
+  - ✅ Imperative present tense in header ("add", "fix", "refactor", not "added" or "adds").
+  - ✅ Explicit scope in header: `feat(api): ...`, `fix(layout): ...`, `test(auth): ...`.
+  - ✅ Verification evidence in footer: `Verified: pytest passed (14 tests)`.

skill_brain-2.1.0/.agents/brain/decisions/memory.md

@@ -0,0 +1,48 @@
+# Memory Skills — Decision Making Matrix
+
+This document dictates how the Virtual Memory system is invoked, controlled, and cleaned.
+
+---
+
+## 1. The User Control Gate (Strict Policy)
+
+**The agent does NOT write every casual turn or trivial task into memory.**
+- Virtual memory is disk-backed and persistent (`.agents/memory/plans/` and `.agents/memory/phases/`).
+- **Trigger Condition:** The agent activates `phase-planner` ONLY when:
+  1. The user explicitly requests: *"add to memory"*, *"save this in memory"*, or *"make a plan for this"*.
+  2. The user initiates a large multi-phase feature and explicitly approves creating a master plan and phase breakdown.
+- If the user has NOT requested memory tracking, execute in-context without cluttering memory folders.
+
+---
+
+## 2. Specialized Skill Selection Matrix
+
+| Memory Need | Selected Skills | Why This Combination |
+|---|---|---|
+| **User commands: "add to memory" / multi-phase plan** | `phase-planner` | Creates `.agents/memory/plans/main-plan.md`, breaks it into `.agents/memory/phases/phase-NN-[name].md`, pre-assigns skills, and prints chat dashboard. |
+| **User resumes session: "where were we?"** | `session-continuity` | Inspects `.agents/memory/plans/` and `phases/`, reconstructs active phase status, and renders the dashboard. |
+| **Context window near limit / session handoff** | `context-handoff` | Compacts session deltas, decisions, open blockers, and git diff states into `.agents/memory/handoff-[date].md`. |
+| **Phase completed & verified** | `git-phase-committer` (`$phase-commit`) | Automatically stages and commits phase code, tests, and memory phase files in atomic sequence with verification evidence. |
+| **Task completed & verified** | `phase-planner` (cleanup mode) | Moves `main-plan.md` and all phase files to `.agents/memory/archive/[Date]-[Task]/`, clearing active phase folder. |
+
+---
+
+## 3. The Live Chat Status Dashboard Protocol
+
+When memory mode is active, the agent **must** prepend the live status widget at the top of every response:
+
+```markdown
+┌─────────────────────────────────────────────────────────────┐
+│ 🚀 PHASE STATUS DASHBOARD                                   │
+├─────────────────────────────────────────────────────────────┤
+│ Task: [Feature Name]                                        │
+│ Phase 1: [Scaffold]         -> [FINISHED ✓]                 │
+│ Phase 2: [Core Logic]       -> [IN PROGRESS ⚙️]              │
+│ Phase 3: [UI & Polish]      -> [PENDING ⏳]                 │
+├─────────────────────────────────────────────────────────────┤
+│ Active Phase: Phase 2                                       │
+│ Active Skills: [skill-a] + [skill-b]                        │
+│ Stage: [APPLY] -> [EXECUTE 👈] -> [VERIFY] -> [FINISH]      │
+└─────────────────────────────────────────────────────────────┘
+```
+