analyzthis_design 1.20.1 → 2.0.0

package/dist/supabase/migrations/001_persona_feedback.sql

@@ -0,0 +1,54 @@
+-- Persona feedback — anonymous community corrections for analyzthis_design
+-- Run in Supabase SQL editor or via supabase db push
+
+create table if not exists public.persona_feedback (
+  id uuid primary key default gen_random_uuid(),
+  created_at timestamptz not null default now(),
+
+  install_id text not null,
+  package_version text,
+  feedback_id text,
+
+  persona text not null,
+  satisfied boolean not null default false,
+  rating smallint check (rating is null or (rating >= 1 and rating <= 5)),
+  tags text[] not null default '{}',
+
+  user_comment text,
+  assistant_rejected text,
+  assistant_preferred text,
+  task_summary text,
+  problem_type text,
+  mode text,
+  recorded_at timestamptz
+);
+
+create index if not exists persona_feedback_persona_idx on public.persona_feedback (persona);
+create index if not exists persona_feedback_created_at_idx on public.persona_feedback (created_at desc);
+create index if not exists persona_feedback_tags_idx on public.persona_feedback using gin (tags);
+
+alter table public.persona_feedback enable row level security;
+
+-- Anonymous clients may INSERT only (no read/update/delete for anon)
+drop policy if exists "anon_insert_persona_feedback" on public.persona_feedback;
+create policy "anon_insert_persona_feedback"
+  on public.persona_feedback
+  for insert
+  to anon
+  with check (
+    char_length(coalesce(user_comment, '')) <= 2000
+    and char_length(coalesce(assistant_rejected, '')) <= 4000
+    and char_length(coalesce(assistant_preferred, '')) <= 4000
+    and persona ~ '^[a-z][a-z0-9_-]{0,31}$'
+  );
+
+-- Service role (dashboard) can read everything — use Supabase dashboard or service key
+drop policy if exists "service_read_persona_feedback" on public.persona_feedback;
+create policy "service_read_persona_feedback"
+  on public.persona_feedback
+  for select
+  to service_role
+  using (true);
+
+comment on table public.persona_feedback is
+  'Anonymous opt-in persona correction data from analyzthis_design CLI (feedback submit).';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "analyzthis_design",
-  "version": "1.20.1",
-  "description": "8 AI design personas — adversarial deliberation loops, opt-in community feedback, Kavi knowledge collection, DesignSpec producer path, wireframe skills, UX critique, Agent Skills for Cursor, Claude, Codex, Grok, Windsurf.",
+  "version": "2.0.0",
+  "description": "8 AI design personas — v2.0 chunked execution with frontier planner + free/cheap chunk models, adversarial deliberation loops, opt-in community feedback, Kavi knowledge collection, DesignSpec producer path, wireframe skills, UX critique, Agent Skills for Cursor, Claude, Codex, Grok, Windsurf.",
   "keywords": [
     "cursor",
     "cursor-skill",

package/skills/chunk-planner/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: chunk-planner
+description: Explain the chunked execution planner. The planner is a frontier/strong model that breaks a design task into small, sequential chunks and assigns each to the cheapest capable model.
+---
+
+# Chunk Planner
+
+In Analyzthis Design v2.0, the default `run` command uses **chunked execution**.
+
+## How it works
+
+1. **Planner** (frontier/strong model) reads the task + knowledge bank once.
+2. It produces a chunk graph: persona, goal, prompts, effort, and dependencies per chunk.
+3. **Router** picks the cheapest capable model for each chunk from:
+   - Local Ollama models (auto-detected)
+   - Free cloud APIs (Groq, Google Gemini, OpenRouter)
+   - Cheap cloud APIs (OpenAI GPT-4o-mini, DeepSeek, Together)
+4. **Executor** runs chunks sequentially by default, with retry + fallback.
+5. **Synthesis** merges outputs and produces a final verdict.
+
+## Planner policy
+
+- The planner **never** runs on a lower/cheap model.
+- If no frontier API key is available, it falls back to the host/Devi model with a warning.
+
+## Example plan
+
+```json
+{
+  "chunks": [
+    { "id": "ia", "persona": "noor", "effort": "standard", "depends_on": [] },
+    { "id": "visual", "persona": "arjun", "effort": "standard", "depends_on": ["ia"] },
+    { "id": "feasibility", "persona": "priya", "effort": "trivial", "depends_on": ["ia"] },
+    { "id": "synthesis", "persona": "raj", "effort": "hard", "depends_on": ["visual", "feasibility"] }
+  ]
+}
+```
+
+## Inspect a plan without running it
+
+```bash
+npx analyzthis_design run --task "..." --dry-run
+```
+
+This shows the planner output without calling any chunk models.

package/skills/getting-started/SKILL.md

@@ -7,6 +7,8 @@ description: First-run guide for Analyzthis Design — which slash command to us
 
 Welcome. This package gives you **8 design personas** as slash commands in Cursor, Claude Code, Grok, Windsurf, and Codex.
 
+> **v2.0 change:** the default `run` command now uses **chunked execution** — a frontier planner breaks your task into small chunks, and the cheapest capable model executes each chunk. Use `/run-unchunked` for the legacy single-pass orchestrator.
+
 ---
 
 ## 60-second setup (recommended once per project)
@@ -31,6 +33,11 @@ This runs **Kavi** — scans your repo, builds an Obsidian vault, and syncs a **
 | Review against PRDs and user stories | `/ux-story-gate` | Task map + routing before critique |
 | Index my codebase for personas | `/kavi` | Kavi → knowledge bank |
 | Run CLI orchestrator without API keys | `/devi` | Host LLM — voices personas from pending prompts |
+| Set visual direction with references + team debate | `/mood-board` | Collect web/DS references, tag, deliberate, converge |
+| Inspect the chunked execution planner | `/chunk-planner` | See how tasks are split into model-routed chunks |
+| Run legacy single-pass orchestrator | `/run-unchunked` | Skip planner overhead for quick single-expert tasks |
+| Make the team learn from accepted outputs | `npx analyzthis_design evolve --extract` | Harvests lessons + proposes prompt/reference/router patches |
+| Track whether a persona's advice actually shipped | `npx analyzthis_design outcome --confirm` | Labels outcome: shipped / revised / blocked / missed |
 
 ---
 
@@ -105,6 +112,9 @@ Assess only — do not implement changes.
 | `/anuj` | Power-user wireframe |
 | `/design-director` | Full producer — ideation → DesignSpec → build |
 | `/design-spec` | DesignSpec format + validation rules |
+| `/mood-board` | Visual direction setting — references + team deliberation |
+| `/chunk-planner` | Chunked execution planner explained |
+| `/run-unchunked` | Legacy single-pass orchestrator (skip chunked planner) |
 | `/persona-orchestrator` | Agentic critique (not wireframes) |
 | `/design-critic` | 4-persona critique |
 | `/ux-story-gate` | Task-first gate + router |
@@ -130,3 +140,5 @@ npx analyzthis_design welcome --target claude
 ```
 
 Docs: https://www.npmjs.com/package/analyzthis_design
+
+**Full step-by-step guide:** [HOW-TO-USE.md](https://github.com/rishikeshjoshi/analyzthis_design/blob/main/HOW-TO-USE.md)

package/skills/mood-board/SKILL.md

@@ -0,0 +1,113 @@
+---
+name: mood-board
+description: Build a visual/textual mood board from web references + design-system patterns, then run the persona team through adversarial deliberation to converge on a design direction. User can add references and rerun.
+---
+
+# Mood Board — Team-Based Visual Direction Setting
+
+Use `/mood-board` when you want to explore visual directions for a screen, flow, or product and have the persona team deliberate on which references fit the user, task, and design system.
+
+## What it does
+
+1. **Collects references** from URLs you provide, configured `moodboard.urls`, and optional web search stubs.
+2. **Tags each reference** with style, mood, surface, and heuristic keywords.
+3. **Pulls design-system guidance** from `skills/design-reference/*.csv` (ui-reasoning, colors, styles, typography, stack files) based on your task and detected tech stack.
+4. **Runs the team** (Arjun, Meera, Priya, Zara, Noor) through adversarial deliberation using the UX Honeycomb rigor matrix.
+5. **Writes artifacts** to:
+   - `~/.analyzthis_design/sessions/{projectId}/moodboard/{boardId}/board.json` (authoritative)
+   - `./moodboard/{boardId}.json` (workspace copy for the user to inspect)
+6. **Accepts user-contributed references** and reruns deliberation with the new input.
+
+## Entry commands
+
+```bash
+npx analyzthis_design moodboard create --task "B2B fintech dashboard, trustworthy, high-contrast" \
+  --url https://dribbble.com/shots/example --url https://example.com/article
+
+npx analyzthis_design moodboard create --task "SaaS onboarding landing page" --auto
+
+npx analyzthis_design moodboard critique --board <boardId>
+
+npx analyzthis_design moodboard add --board <boardId> \
+  --url https://dribbble.com/shots/new-ref \
+  --title "Alternative hero layout" \
+  --tags "landing,hero,trust" \
+  --note "I like the white space and the trust badge placement"
+
+npx analyzthis_design moodboard list
+```
+
+## v2.0 chunked execution
+
+`/mood-board` now runs internally through the v2.0 chunked executor:
+- Frontier planner scopes the board (personas, references, DS lookups).
+- Cheap/free models tag references, retrieve design-system rows, and run the deliberation loop.
+- Result is the same `board.json` artifact, but at lower average token cost.
+
+## How the personas use it
+
+| Persona | Lens |
+|---|---|
+| **Arjun** | Visual system fit, contrast, hierarchy, accessibility, WCAG |
+| **Meera** | Brand/category fit, GTM risk, competitive positioning |
+| **Priya** | Technical feasibility of implementing the style/pattern |
+| **Zara** | First impression, delight moment, emotional response |
+| **Noor** | IA clarity, progressive disclosure, surface structure |
+
+Each persona scores references with the Honeycomb rigor matrix:
+- Useful, Usable, Findable, Credible, Accessible, Desirable, Valuable
+- Then deliberates with low satisfaction until consensus or Raj escalation.
+
+## Output format
+
+`board.json` contains:
+
+```json
+{
+  "board_id": "abc123",
+  "task": "B2B fintech dashboard, trustworthy, high-contrast",
+  "references": [
+    {
+      "id": "def456",
+      "url": "https://dribbble.com/shots/example",
+      "title": "...",
+      "description": "...",
+      "source": "config",
+      "type": "visual",
+      "tags": ["dashboard", "trust", "dark", "data-dense"]
+    }
+  ],
+  "design_system_pack": [ { "file": "ui-reasoning.csv", "rows": [...] } ],
+  "deliberation": { "round_log": [...], "consensus_reached": true },
+  "synthesis": { "verdict": "SHIP", "top3": [...] }
+}
+```
+
+## User as "god"
+
+You can:
+- Add any URL or free-text note to the board.
+- Override tags.
+- Rerun critique after adding references.
+- Accept or reject the final direction with `session accept --persona arjun` etc.
+
+## Config
+
+In `~/.analyzthis_design/config.json`:
+
+```json
+{
+  "moodboard": {
+    "urls": ["https://dribbble.com/shots/example"],
+    "queries": ["fintech dashboard design"],
+    "limit": 12,
+    "workspace_dir": "./moodboard"
+  }
+}
+```
+
+## Notes
+
+- Image URLs are stored as references; alt-text/captions are added during tagging.
+- Web articles are fetched as plain text; image extraction from HTML is not yet implemented.
+- Router rule: `mood_board` signals route to the `mood-board` skill, not the critique chain.

package/skills/persona-orchestrator/SKILL.md

@@ -130,7 +130,7 @@ Run `ux-story-gate` Phase 5.5. If `mode: assess_only`, stop here — do not writ
 
 ---
 
-## Step 6.5 — Capture user corrections (v1.16)
+## Step 6.5 — Capture user corrections and outcomes (v1.16 / v1.21)
 
 When the user is **unhappy** with a persona's output or **rewrites/corrects** it, record that signal so future training can learn from mistakes:
 
@@ -152,6 +152,40 @@ Suggest this when the user says things like *"that's not what I meant,"* *"use o
 
 List or export later: `feedback list`, `feedback export --persona arjun --all`.
 
+**Track whether the advice actually shipped.** After the user implements changes, confirm the outcome so the evolution loop can learn:
+
+```bash
+npx analyzthis_design outcome --confirm --persona arjun --result shipped
+# or: revised, blocked_correctly, missed
+```
+
+**Default execution is chunked (v2.0).** `npx analyzthis_design run --task "..."` now uses a frontier planner + cheap chunk models. Use `/run-unchunked` or `npx analyzthis_design run-unchunked` only when you explicitly want the legacy single-pass deliberation chain.
+
+**Set visual direction with the team.** Use `/mood-board` when the user wants references and a team-deliberated direction:
+
+```bash
+npx analyzthis_design moodboard create --task "B2B fintech dashboard, trustworthy, high-contrast" --auto
+npx analyzthis_design moodboard critique --board <boardId>
+```
+
+References are tagged, design-system patterns are pulled, and Arjun/Meera/Priya/Zara/Noor deliberate with Honeycomb scoring until consensus.
+
+**Evolve the team.** Periodically (e.g., weekly), run:
+
+```bash
+npx analyzthis_design evolve --extract --dry-run   # preview proposed patches
+npx analyzthis_design evolve --extract             # write patch files for review
+npx analyzthis_design evolve --apply <patchId> --dry-run   # preview a patch
+npx analyzthis_design evolve --apply <patchId>    # apply after review
+```
+
+This harvests accepted outputs + confirmed outcomes, extracts lessons into `~/.analyzthis_design/lessons/`, and proposes patches to:
+- persona SKILL.md / cards (new canonical failure patterns),
+- `skills/design-reference/*.csv` rows (new product-type guidance),
+- `agents/router.json` rules (task_type → best-performing expert).
+
+Patches are **dry-run by default** and require human review before apply.
+
 **Share with maintainers (opt-in):** after recording, suggest `npx analyzthis_design feedback submit --yes` so anonymized corrections help improve personas for everyone. Preview first with `--dry-run`.
 
 ---

package/skills/run-unchunked/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: run-unchunked
+description: Run the legacy non-chunked orchestrator. Useful when the chunked planner overhead is not justified for a quick single-expert task.
+---
+
+# Run Unchunked — Legacy Orchestrator Mode
+
+Use `/run-unchunked` when you want the original single-pass deliberation orchestrator instead of the default v2.0 chunked execution.
+
+## When to use
+
+- Quick single-expert tasks
+- You already know exactly which personas to run
+- You want one model to execute the whole chain without planner overhead
+- Debugging or comparing against chunked output
+
+## How to run
+
+**Cursor / Claude / Grok:**
+
+```
+/run-unchunked --task "Fix contrast on the invoice table" --experts arjun
+```
+
+**Windsurf:**
+
+```
+@run-unchunked --task "Fix contrast on the invoice table" --experts arjun
+```
+
+**CLI:**
+
+```bash
+npx analyzthis_design run-unchunked --task "Fix contrast on the invoice table" --experts arjun
+```
+
+## Flags
+
+- `--task` — required
+- `--figma` — optional Figma URL
+- `--experts` — explicit persona list
+- `--full` / `--lite` — chain size
+- `--no-deliberate` — legacy sequential handoff
+- `--provider` — model provider
+- `--max-rounds`, `--satisfaction` — deliberation tuning
+
+## Note
+
+This is the v1.x behavior preserved for compatibility. The default `npx analyzthis_design run` now uses chunked execution (frontier planner + cheap chunk models) in v2.0.