cokit-cli 1.2.6 → 1.3.0

package/skills/fix/references/workflow-quick.md

@@ -1,18 +1,28 @@
 # Quick Workflow
 
-Fast debug-fix-review cycle for simple issues.
+Fast scout-diagnose-fix-verify cycle for simple issues.
 
 ## Steps
 
-### Step 1: Debug
-Activate `debug` skill. Find root cause quickly. Verify the root cause with multiple `Explore` agents in parallel.
+### Step 1: Scout (Minimal)
+Locate affected file(s) and their direct dependencies only.
+- Read error message → identify file path
+- Check direct imports/dependencies of affected file
+- Skip full codebase mapping
+
+**Output:** `✓ Step 1: Scouted - [file], [N] direct deps`
+
+### Step 2: Diagnose (Abbreviated)
+Activate `debug` skill. Activate `sequential-thinking` for structured analysis.
+
 - Read error message/logs
-- Locate affected file(s)
-- Identify exact fix needed
+- **Capture pre-fix state:** Record exact error output (this is your verification baseline)
+- Identify root cause (usually obvious for simple issues)
+- Skip parallel hypothesis testing for trivial cases
 
-**Output:** `✓ Step 1: Root cause - [brief description]`
+**Output:** `✓ Step 2: Diagnosed - Root cause: [brief description]`
 
-### Step 2: Fix & Verify
+### Step 3: Fix & Verify
 Implement the fix directly.
 - Make minimal changes
 - Follow existing patterns
@@ -24,36 +34,49 @@ Task("Bash", "Run typecheck", "Verify types")
 Task("Bash", "Run lint", "Verify lint")
 ```
 
+**Before/After comparison:** Re-run the EXACT command from pre-fix state capture. Compare output.
+
 See `references/parallel-exploration.md` for patterns.
 
-**Output:** `✓ Step 2: Fixed - [N] files, verified (types/lint passed)`
+**Output:** `✓ Step 3: Fixed - [N] files, verified (types/lint passed)`
 
-### Step 3: Verify
-Use `code-reviewer` agent for quick review.
+### Step 4: Review + Prevent
+Use `code-reviewer` subagent for quick review.
 
 Prompt: "Quick review of fix for [issue]. Check: correctness, security, no regressions. Score X/10."
 
+**Prevention (abbreviated for Quick):**
+- Type errors/lint: type system IS the test → regression test optional
+- Bug fixes: add at least 1 test covering the fixed scenario
+- Still require before/after comparison of verification output
+
 **Review handling:** See `references/review-cycle.md`
 
-**Output:** `✓ Step 3: Review [score]/10 - [status]`
+**Output:** `✓ Step 4: Review [score]/10 - [prevention measures]`
 
-### Step 4: Complete
+### Step 5: Complete
 Report summary to user.
 
-**If autonomous mode:** Ask to commit via `git-manager` agent if score >= 9.0
+**If autonomous mode:** Ask to commit via `git-manager` subagent if score >= 9.0
 **If HITL mode:** Ask user next action
 
-**Output:** `✓ Step 4: Complete - [action]`
+**Output:** `✓ Step 5: Complete - [action]`
+
+## Skills/Subagents Activated
 
-## Skills/Agents Activated
+| Step | Skills/Subagents |
+|------|------------------|
+| 1 | `scout` (minimal) or direct file read |
+| 2 | `debug`, `sequential-thinking` |
+| 3 | Parallel `Bash` for verification |
+| 4 | `code-reviewer` subagent |
+| 5 | `git-manager` subagent |
 
-- `debug` - Always (Step 1)
-- Parallel `git-manager` - Verification (Step 2)
-- `code-reviewer` agent - Always (Step 3)
-- `context-engineering` - If dealing with AI/LLM code
+**Extra:** `context-engineering` if dealing with AI/LLM code
 
 ## Notes
 
 - Skip if review fails → escalate to Standard workflow
-- Total steps: 4 (vs 5-6 in Standard/Deep)
+- Total steps: 5
 - No planning phase needed
+- Pre-fix state capture is STILL mandatory (even for quick fixes)

package/skills/fix/references/workflow-standard.md

@@ -1,21 +1,28 @@
 # Standard Workflow
 
-Full pipeline for moderate complexity issues.
+Full pipeline for moderate complexity issues. Uses native Tasks for phase tracking.
 
-## Steps
+## Task Setup (Before Starting)
+
+Create all phase tasks upfront with dependencies. See `references/task-orchestration.md`.
 
-### Step 1: Debug & Investigate
-Activate `debug` skill. Use `debugger` agent if needed.
+```
+T1 = TaskCreate(subject="Scout codebase",        activeForm="Scouting codebase")
+T2 = TaskCreate(subject="Diagnose root cause",    activeForm="Diagnosing root cause")
+T3 = TaskCreate(subject="Implement fix",          activeForm="Implementing fix",    addBlockedBy=[T1, T2])
+T4 = TaskCreate(subject="Verify + prevent",       activeForm="Verifying fix",       addBlockedBy=[T3])
+T5 = TaskCreate(subject="Code review",            activeForm="Reviewing code",      addBlockedBy=[T4])
+T6 = TaskCreate(subject="Finalize",               activeForm="Finalizing",          addBlockedBy=[T5])
+```
 
-- Read error messages, logs, stack traces
-- Reproduce the issue
-- Trace backward to root cause
-- Identify all affected files
+## Steps
 
-**Output:** `✓ Step 1: Root cause - [summary], [N] files affected`
+### Step 1: Scout Codebase
+`TaskUpdate(T1, status="in_progress")`
 
-### Step 2: Parallel Scout
-Launch multiple `Explore` agents in parallel to scout and verify the root cause.
+**Mandatory skill chain:**
+1. Activate `scout` skill OR launch 2-3 parallel `Explore` subagents.
+2. Map: affected files, module boundaries, dependencies, related tests, recent git changes.
 
 **Pattern:** In SINGLE message, launch 2-3 Explore agents:
 ```
@@ -24,63 +31,90 @@ Task("Explore", "Find [area2] patterns/usage", "Scout area2")
 Task("Explore", "Find [area3] tests/dependencies", "Scout area3")
 ```
 
-- Only if unclear which files need changes
-- Find patterns, similar implementations, dependencies
-
 See `references/parallel-exploration.md` for patterns.
 
-**Output:** `✓ Step 2: Scouted [N] areas - Found [M] related files`
+`TaskUpdate(T1, status="completed")`
+**Output:** `✓ Step 1: Scouted [N] areas - [M] files, [K] tests found`
+
+### Step 2: Diagnose Root Cause
+`TaskUpdate(T2, status="in_progress")`
+
+**Mandatory skill chain:**
+1. **Capture pre-fix state:** Record exact error messages, failing test output, stack traces.
+2. Activate `debug` skill. Use `debugger` subagent if needed.
+3. Activate `sequential-thinking` — form hypotheses through structured reasoning.
+4. Spawn parallel `Explore` subagents to test hypotheses against codebase evidence.
+5. If 2+ hypotheses fail → auto-activate `problem-solving`.
+6. Trace backward to root cause (not just symptom location).
+
+See `references/diagnosis-protocol.md` for full methodology.
+
+`TaskUpdate(T2, status="completed")`
+**Output:** `✓ Step 2: Diagnosed - Root cause: [summary], Evidence: [brief], Scope: [N files]`
 
 ### Step 3: Implement Fix
-Fix the issue following debugging findings.
+`TaskUpdate(T3, status="in_progress")` — auto-unblocked when T1 + T2 complete.
+
+Fix the ROOT CAUSE per diagnosis findings. Not symptoms.
 
 - Apply `problem-solving` skill if stuck
 - Use `sequential-thinking` for complex logic
+- Minimal changes. Follow existing patterns.
+
+`TaskUpdate(T3, status="completed")`
+**Output:** `✓ Step 3: Implemented - [N] files changed`
 
-**After implementation - Parallel Verification:**
-Launch `Bash` agents in parallel to verify:
+### Step 4: Verify + Prevent
+`TaskUpdate(T4, status="in_progress")`
+
+**Mandatory skill chain:**
+1. **Iron-law verify:** Re-run the EXACT commands from pre-fix state capture. Compare before/after.
+2. **Regression test:** Add/update test(s) covering the fixed issue. Test MUST fail without fix, pass with fix.
+3. **Defense-in-depth:** Apply prevention layers where applicable (see `references/prevention-gate.md`).
+4. **Parallel verification:** Launch `Bash` agents:
 ```
 Task("Bash", "Run typecheck", "Verify types")
 Task("Bash", "Run lint", "Verify lint")
 Task("Bash", "Run build", "Verify build")
+Task("Bash", "Run tests", "Verify tests")
 ```
 
-**Output:** `✓ Step 3: Implemented - [N] files, verified (types/lint/build passed)`
-
-### Step 4: Test
-Use `tester` agent to run tests.
-
-- Write new tests if needed
-- Run existing test suite
-- If fail → use `debugger`, fix, repeat
+**If verification fails:** Loop back to Step 2 (re-diagnose). Max 3 attempts.
 
-**Output:** `✓ Step 4: Tests [X/X passed]`
+`TaskUpdate(T4, status="completed")`
+**Output:** `✓ Step 4: Verified + Prevented - [before/after], [N] tests added, [M] guards`
 
-### Step 5: Review
-Use `code-reviewer` agent.
+### Step 5: Code Review
+`TaskUpdate(T5, status="in_progress")`
+Use `code-reviewer` subagent.
 
 See `references/review-cycle.md` for mode-specific handling.
 
+`TaskUpdate(T5, status="completed")`
 **Output:** `✓ Step 5: Review [score]/10 - [status]`
 
 ### Step 6: Finalize
-- Report summary to user
-- Ask to commit via `git-manager` agent
+`TaskUpdate(T6, status="in_progress")`
+- Report summary: root cause, changes, prevention measures, confidence score
+- Activate `project-management` for task sync-back and plan status updates
 - Update docs if needed via `docs-manager`
+- Ask to commit via `git-manager` subagent
+- Run `/ck-journal`
 
+`TaskUpdate(T6, status="completed")`
 **Output:** `✓ Step 6: Complete - [action]`
 
-## Skills/Agents Activated
+## Skills/Subagents Activated
 
-| Step | Skills/Agents |
+| Step | Skills/Subagents |
 |------|------------------|
-| 1 | `debug`, `debugger` agent |
-| 2 | Multiple `Explore` agents in parallel (optional) |
-| 3 | `problem-solving`, `sequential-thinking`, parallel `Bash` for verification |
-| 4 | `tester` agent |
-| 5 | `code-reviewer` agent |
-| 6 | `git-manager`, `docs-manager` agents |
+| 1 | `scout` OR parallel `Explore` subagents |
+| 2 | `debug`, `sequential-thinking`, `debugger` subagent, parallel `Explore`, (`problem-solving` auto) |
+| 3 | `problem-solving` (if stuck), `sequential-thinking` (complex logic) |
+| 4 | `tester` subagent, parallel `Bash` verification |
+| 5 | `code-reviewer` subagent |
+| 6 | `project-management`, `git-manager`, `docs-manager` subagents |
 
 **Rules:** Don't skip steps. Validate before proceeding. One phase at a time.
-**Frontend:** Use `agent-browser` or browser automation tools to verify.
-**Visual Assets:** Use ImageMagick/FFmpeg CLI for image/video processing.
+**Frontend:** Use `chrome`, `chrome-devtools` (if available) or any relevant skills/tools to verify.
+**Visual Assets:** Use `ai-multimodal` (if available) for visual assets generation, analysis and verification.

package/skills/fix/references/workflow-test.md

@@ -1,25 +1,64 @@
 # Test Failure Fix Workflow
 
-For fixing failing tests and test suite issues.
+For fixing failing tests and test suite issues. Uses native Tasks for phase tracking.
+
+## Task Setup (Before Starting)
+
+```
+T1 = TaskCreate(subject="Compile & collect failures", activeForm="Compiling and collecting failures")
+T2 = TaskCreate(subject="Debug root causes",          activeForm="Debugging test failures",       addBlockedBy=[T1])
+T3 = TaskCreate(subject="Plan fixes",                 activeForm="Planning fixes",                addBlockedBy=[T2])
+T4 = TaskCreate(subject="Implement fixes",             activeForm="Implementing fixes",            addBlockedBy=[T3])
+T5 = TaskCreate(subject="Re-test",                     activeForm="Re-running tests",              addBlockedBy=[T4])
+T6 = TaskCreate(subject="Code review",                 activeForm="Reviewing code",                addBlockedBy=[T5])
+```
 
 ## Workflow
 
-1. **Compile first** with `tester` agent
-   - Fix all syntax errors before running tests
+### Step 1: Compile & Collect Failures
+`TaskUpdate(T1, status="in_progress")`
+Use `tester` agent. Fix all syntax errors before running tests.
+
+- Run full test suite, collect all failures
+- Group failures by module/area
+
+`TaskUpdate(T1, status="completed")`
+
+### Step 2: Debug
+`TaskUpdate(T2, status="in_progress")`
+Use `debugger` agent for root cause analysis.
+
+- Analyze each failure group
+- Identify shared root causes across failures
+
+`TaskUpdate(T2, status="completed")`
+
+### Step 3: Plan
+`TaskUpdate(T3, status="in_progress")`
+Use `planner` agent for fix strategy.
+
+- Prioritize fixes (shared root causes first)
+- Identify dependencies between fixes
 
-2. **Run tests** and collect failures
+`TaskUpdate(T3, status="completed")`
 
-3. **Debug** with `debugger` agent for root causes
+### Step 4: Implement
+`TaskUpdate(T4, status="in_progress")`
+Implement fixes step by step per plan.
 
-4. **Plan** fix with `planner` agent
+`TaskUpdate(T4, status="completed")`
 
-5. **Implement** fixes step by step
+### Step 5: Re-test
+`TaskUpdate(T5, status="in_progress")`
+Use `tester` agent. If tests still fail → keep T5 `in_progress`, loop back to Step 2.
 
-6. **Re-test** with `tester` agent
+`TaskUpdate(T5, status="completed")`
 
-7. **Review** with `code-reviewer` agent
+### Step 6: Review
+`TaskUpdate(T6, status="in_progress")`
+Use `code-reviewer` agent.
 
-8. **Iterate** if tests still fail, repeat from step 2
+`TaskUpdate(T6, status="completed")`
 
 ## Common Commands
 ```bash

package/skills/fix/references/workflow-ui.md

@@ -1,34 +1,72 @@
 # UI Fix Workflow
 
-For fixing visual/UI issues. Requires design skills.
+For fixing visual/UI issues. Requires design skills. Uses native Tasks for phase tracking.
 
 ## Required Skills (activate in order)
-1. `ui-styling` - Design patterns and components (ALWAYS FIRST)
-2. `frontend-design` - Implementation patterns
+1. `ui-ux-pro-max` (if available) - Design database (ALWAYS FIRST)
+2. `ui-ux-pro-max` (if available) - Design principles
+3. `frontend-design` - Implementation patterns
 
 ## Pre-fix Research
-Use `docs-seeker` skill to research:
-- Design patterns for the product type
-- Accessibility best practices
-- Component styling guidelines
+```bash
+```
+
+## Task Setup (Before Starting)
+
+```
+T1 = TaskCreate(subject="Analyze visual issue",    activeForm="Analyzing visual issue")
+T2 = TaskCreate(subject="Implement UI fix",         activeForm="Implementing UI fix",       addBlockedBy=[T1])
+T3 = TaskCreate(subject="Verify visually",          activeForm="Verifying visually",         addBlockedBy=[T2])
+T4 = TaskCreate(subject="DevTools check",           activeForm="Checking with DevTools",     addBlockedBy=[T3])
+T5 = TaskCreate(subject="Test compilation",         activeForm="Testing compilation",        addBlockedBy=[T4])
+T6 = TaskCreate(subject="Update design docs",       activeForm="Updating design docs",       addBlockedBy=[T5])
+```
 
 ## Workflow
 
-1. **Analyze** screenshots/videos visually
+### Step 1: Analyze
+`TaskUpdate(T1, status="in_progress")`
+Analyze screenshots/videos with `ai-multimodal` (if available) skill.
+
+- Read `./docs/design-guidelines.md` first
+- Identify exact visual discrepancy
+
+`TaskUpdate(T1, status="completed")`
+
+### Step 2: Implement
+`TaskUpdate(T2, status="in_progress")`
+Use `ui-ux-designer` agent.
 
-2. **Implement** fix with `ui-ux-designer` agent
+`TaskUpdate(T2, status="completed")`
 
-3. **Verify** with screenshot comparison
-   - Capture parent container, not whole page
-   - Compare to design guidelines
-   - Iterate until correct
+### Step 3: Verify Visually
+`TaskUpdate(T3, status="in_progress")`
+Screenshot + `ai-multimodal` (if available) analysis.
 
-4. **DevTools check** with `agent-browser` or browser automation tools
+- Capture parent container, not whole page
+- Compare to design guidelines
+- If incorrect → keep T3 `in_progress`, loop back to Step 2
 
-5. **Test** compilation with `tester` agent
+`TaskUpdate(T3, status="completed")`
 
-6. **Document** updates to `./docs/design-guidelines.md` if needed
+### Step 4: DevTools Check
+`TaskUpdate(T4, status="in_progress")`
+Use `chrome-devtools` (if available) skill.
+
+`TaskUpdate(T4, status="completed")`
+
+### Step 5: Test
+`TaskUpdate(T5, status="in_progress")`
+Use `tester` agent for compilation check.
+
+`TaskUpdate(T5, status="completed")`
+
+### Step 6: Document
+`TaskUpdate(T6, status="in_progress")`
+Update `./docs/design-guidelines.md` if needed.
+
+`TaskUpdate(T6, status="completed")`
 
 ## Tips
-- Read `./docs/design-guidelines.md` first
-- Use ImageMagick/FFmpeg CLI for image editing
+- Use `ai-multimodal` (if available) for generating visual assets
+- Use `ImageMagick` for image editing

package/skills/frontend-design/SKILL.md

@@ -1,77 +1,109 @@
----
-name: frontend-design
-description: Create polished frontend interfaces from designs/screenshots/videos. Use for web components, replicating UI designs, quick prototypes, 3D experiences, immersive interfaces, avoiding AI slop.
----
-
-Create distinctive, production-grade frontend interfaces. Implement real working code with exceptional aesthetic attention.
-
-## Workflow Selection
-
-Choose workflow based on input type:
-
-| Input | Workflow | Reference |
-|-------|----------|-----------|
-| Screenshot | Replicate exactly | `./references/workflow-screenshot.md` |
-| Video | Replicate with animations | `./references/workflow-video.md` |
-| Quick task | Rapid implementation | `./references/workflow-quick.md` |
-| Describe only | Document for devs | `./references/workflow-describe.md` |
-| 3D/WebGL request | Three.js immersive | `./references/workflow-3d.md` |
-| Complex/award-quality | Full immersive | `./references/workflow-immersive.md` |
-| From scratch | Design Thinking below | - |
-
-**All workflows**: Activate `ui-styling` skill FIRST for design patterns and component library.
-
-## Screenshot/Video Replication (Quick Reference)
-
-1. **Analyze** visually (use `ai-multimodal` skill if available) - extract colors, fonts, spacing, effects
-2. **Plan** with `ui-ux-designer` agent - create phased implementation
-3. **Implement** - match source precisely
-4. **Verify** - compare to original
-5. **Document** - update `./docs/design-guidelines.md` if approved
-
-See specific workflow files for detailed steps.
-
-## Design Thinking (From Scratch)
-
-Before coding, commit to a BOLD aesthetic direction:
-- **Purpose**: What problem does this interface solve? Who uses it?
-- **Tone**: Pick an extreme: brutally minimal, maximalist chaos, retro-futuristic, organic/natural, luxury/refined, playful/toy-like, editorial/magazine, brutalist/raw, art deco/geometric, soft/pastel, industrial/utilitarian, etc. There are so many flavors to choose from. Use these for inspiration but design one that is true to the aesthetic direction.
-- **Constraints**: Technical requirements (framework, performance, accessibility).
-- **Differentiation**: What makes this UNFORGETTABLE? What's the one thing someone will remember?
-
-**CRITICAL**: Execute with precision. Bold maximalism and refined minimalism both work - intentionality is key.
-
-## Aesthetics Guidelines
-
-- **Typography**: Avoid Arial/Inter; use distinctive, characterful fonts. Pair display + body fonts.
-- **Color**: Commit to cohesive palette. CSS variables. Dominant colors with sharp accents.
-- **Motion**: CSS-first, anime.js for complex (`./references/animejs.md`). Orchestrated page loads > scattered micro-interactions.
-- **Spatial**: Unexpected layouts. Asymmetry. Overlap. Negative space OR controlled density.
-- **Backgrounds**: Atmosphere over solid colors. Gradients, noise, patterns, shadows, grain.
-- **Assets**: Process with ImageMagick, FFmpeg, RMBG CLI tools (or `ai-multimodal`/`media-processing` skills if available)
-
-## Asset & Analysis References
-
-| Task | Reference |
-|------|-----------|
-| Generate assets | `./references/asset-generation.md` |
-| Analyze quality | `./references/visual-analysis-overview.md` |
-| Extract guidelines | `./references/design-extraction-overview.md` |
-| Optimization | `./references/technical-overview.md` |
-| Animations | `./references/animejs.md` |
-
-Quick start: `./references/asset-generation.md`
-
-## Anti-Patterns (AI Slop)
-
-NEVER use:
-- Overused fonts: Inter, Roboto, Arial, Space Grotesk
-- Cliched colors: purple gradients on white
-- Predictable layouts, cookie-cutter patterns
-
-DO:
-- Vary themes (light/dark), fonts, aesthetics per project
-- Match complexity to vision (maximalist = elaborate; minimalist = precise)
-- Make unexpected, context-specific choices
-
-Remember: The AI agent is capable of extraordinary creative work. Commit fully to distinctive visions.
+---
+name: frontend-design
+description: Create polished frontend interfaces from designs/screenshots/videos. Use for web components, 3D experiences, replicating UI designs, quick prototypes, immersive interfaces, avoiding AI slop.
+license: Complete terms in LICENSE.txt
+---
+
+Create distinctive, production-grade frontend interfaces. Implement real working code with exceptional aesthetic attention.
+
+## Workflow Selection
+
+Choose workflow based on input type:
+
+| Input | Workflow | Reference |
+|-------|----------|-----------|
+| Screenshot | Replicate exactly | `./references/workflow-screenshot.md` |
+| Video | Replicate with animations | `./references/workflow-video.md` |
+| Screenshot/Video (describe only) | Document for devs | `./references/workflow-describe.md` |
+| 3D/WebGL request | Three.js immersive | `./references/workflow-3d.md` |
+| Quick task | Rapid implementation | `./references/workflow-quick.md` |
+| Complex/award-quality | Full immersive | `./references/workflow-immersive.md` |
+| Existing project upgrade | Redesign Audit | `./references/redesign-audit-checklist.md` |
+| From scratch | Design Thinking below | - |
+
+**All workflows**: Activate `ui-ux-pro-max` skill (if available) FIRST for design intelligence.
+
+**Precedence:** When anti-slop rules (below) conflict with `ui-ux-pro-max` (if available) recommendations (e.g., Inter font, AI Purple palette, Lucide-only icons), substitute with alternatives from `./references/anti-slop-rules.md` unless the user explicitly requested the conflicting choice.
+
+## Screenshot/Video Replication (Quick Reference)
+
+1. **Analyze** with `ai-multimodal` (if available) skill - extract colors, fonts, spacing, effects
+2. **Plan** with `ui-ux-designer` subagent - create phased implementation
+3. **Implement** - match source precisely
+4. **Verify** - compare to original
+5. **Document** - update `./docs/design-guidelines.md` if approved
+
+See specific workflow files for detailed steps.
+
+## Design Dials
+
+Three configurable parameters that drive design decisions. Set defaults at session start or let user override via chat:
+
+| Dial | Default | Range | Low (1-3) | High (8-10) |
+|------|---------|-------|-----------|-------------|
+| `DESIGN_VARIANCE` | 8 | 1-10 | Perfect symmetry, centered layouts, equal grids | Asymmetric, masonry, massive empty zones, fractional CSS Grid |
+| `MOTION_INTENSITY` | 6 | 1-10 | CSS hover/active states only | Framer Motion scroll reveals, spring physics, perpetual micro-animations |
+| `VISUAL_DENSITY` | 4 | 1-10 | Art gallery — huge whitespace, expensive/clean | Cockpit — tiny paddings, 1px dividers, monospace numbers everywhere |
+
+**Usage:** These values drive specific rules. At `DESIGN_VARIANCE > 4`, centered heroes are overused — force split-screen or left-aligned layouts. At `MOTION_INTENSITY > 5`, embed perpetual micro-animations. At `VISUAL_DENSITY > 7`, remove generic cards and use spacing/dividers.
+
+See `./references/bento-motion-engine.md` for dial-driven SaaS dashboard implementation.
+
+## Design Thinking (From Scratch)
+
+Before coding, commit to a BOLD aesthetic direction:
+- **Purpose**: What problem does this interface solve? Who uses it?
+- **Tone**: Pick an extreme: brutally minimal, maximalist chaos, retro-futuristic, organic/natural, luxury/refined, playful/toy-like, editorial/magazine, brutalist/raw, art deco/geometric, soft/pastel, industrial/utilitarian, etc. There are so many flavors to choose from. Use these for inspiration but design one that is true to the aesthetic direction.
+- **Constraints**: Technical requirements (framework, performance, accessibility).
+- **Differentiation**: What makes this UNFORGETTABLE? What's the one thing someone will remember?
+
+**CRITICAL**: Execute with precision. Bold maximalism and refined minimalism both work - intentionality is key.
+
+## Aesthetics Guidelines
+
+- **Typography**: Avoid Arial/Inter; use distinctive, characterful fonts. Pair display + body fonts.
+- **Color**: Commit to cohesive palette. CSS variables. Dominant colors with sharp accents.
+- **Motion**: CSS-first, anime.js for complex (`./references/animejs.md`). Orchestrated page loads > scattered micro-interactions.
+- **Spatial**: Unexpected layouts. Asymmetry. Overlap. Negative space OR controlled density.
+- **Backgrounds**: Atmosphere over solid colors. Gradients, noise, patterns, shadows, grain.
+- **Assets**: Generate with `ai-multimodal` (if available), process with `media-processing`
+
+## Asset & Analysis References
+
+| Task | Reference |
+|------|-----------|
+| Generate assets | `./references/asset-generation.md` |
+| Analyze quality | `./references/visual-analysis-overview.md` |
+| Extract guidelines | `./references/design-extraction-overview.md` |
+| Optimization | `./references/technical-overview.md` |
+| Animations | `./references/animejs.md` |
+| Magic UI (80+ components) | `./references/magicui-components.md` |
+| Anti-slop forbidden patterns | `./references/anti-slop-rules.md` |
+| Redesign audit checklist | `./references/redesign-audit-checklist.md` |
+| Premium design patterns | `./references/premium-design-patterns.md` |
+| Performance guardrails | `./references/performance-guardrails.md` |
+| Bento motion engine (SaaS) | `./references/bento-motion-engine.md` |
+
+Quick start: `./references/ai-multimodal-overview.md`
+
+## Anti-Patterns (AI Slop)
+
+Strongly prefer alternatives to these LLM defaults. Full rules: `./references/anti-slop-rules.md`
+
+**Typography** — Avoid Inter/Roboto/Arial. Prefer: `Geist`, `Outfit`, `Cabinet Grotesk`, `Satoshi`
+
+**Color** — Avoid AI purple/blue gradient aesthetic, pure `#000000`, oversaturated accents. Use neutral bases with a single considered accent.
+
+**Layout** — Avoid 3-column equal card feature rows, centered heroes at high variance, `h-screen`. Use asymmetric grids, split-screen, `min-h-[100dvh]`.
+
+**Content** — Avoid "John Doe", "Acme Corp", round numbers, AI copy clichés ("Elevate", "Seamless", "Unleash"). Use realistic names, organic data, plain specific language.
+
+**Effects** — Avoid neon/outer glows, custom cursors, gradient text on headers. Use tinted inner shadows, spring physics.
+
+**Components** — Avoid default unstyled shadcn, Lucide-only icons, generic card-border-shadow pattern at high density. Always customize, try Phosphor/Heroicons, use spacing over cards.
+
+**Quick check:** See the "AI Tells" checklist in `./references/anti-slop-rules.md` before delivering any design.
+
+**Performance:** Animation and blur rules in `./references/performance-guardrails.md`
+
+Remember: The AI is capable of extraordinary creative work. Commit fully to distinctive visions.