@arthai/agents 1.0.0

package/dist/plugins/prime/skills/wizard/SKILL.md

@@ -0,0 +1,411 @@
+---
+name: wizard
+description: "Guided step-by-step workflows for non-engineers. Role-based flows that walk you through common tasks. Usage: /wizard <role> <step>"
+user-invocable: true
+arguments: "<role> <step>"
+---
+
+Guided workflows that walk non-engineers through multi-step processes. Each workflow is designed
+for a specific role and breaks complex tasks into manageable steps, bringing in the right
+specialist at each stage.
+
+## Argument Parsing
+
+| Input | Action |
+|---|---|
+| `/wizard` | Detect role or ask, then show available workflows |
+| `/wizard pm` | Show PM workflow steps |
+| `/wizard pm 1` | Jump to PM workflow step 1 |
+| `/wizard pm next` | Continue to next incomplete step |
+| `/wizard founder` | Show Founder workflow steps |
+| `/wizard designer` | Show Designer workflow steps |
+| `/wizard marketer` | Show Marketer workflow steps |
+| `/wizard status` | Show progress across all workflows |
+| `/wizard resume` | Resume where you left off |
+| `/wizard reset` | Clear saved progress and start fresh |
+
+## Role Detection
+
+Check `.claude/.claude-agents.conf` for `USER_ROLE`. If not set, present this menu using AskUserQuestion:
+
+```
+What best describes your role?
+  1. Product Manager — I plan features and prioritize what to build
+  2. Founder — I oversee everything from vision to shipping
+  3. Designer — I design experiences and visual interfaces
+  4. Marketer — I position products and drive awareness
+
+Pick the one closest to your work.
+```
+
+## State Management
+
+Progress is saved in `.claude/.wizard-state.json` so you can resume across sessions.
+
+**State schema:**
+```json
+{
+  "role": "pm",
+  "active_workflow": "plan-and-ship",
+  "current_step": 2,
+  "steps_completed": [1],
+  "step_outputs": {
+    "1": {
+      "summary": "Feature brief for user notifications",
+      "file": ".claude/plans/notifications-brief.md"
+    }
+  },
+  "started_at": "2026-03-23T10:00:00Z",
+  "last_active": "2026-03-23T14:30:00Z"
+}
+```
+
+**State operations:**
+- Read state at the start of every `/wizard` invocation
+- Write state after every step completion
+- On `/wizard resume`: read state, show summary, continue from `current_step`
+- On `/wizard reset`: delete `.claude/.wizard-state.json`
+- On `/wizard status`: read state, show progress table
+
+---
+
+## Workflow 1: Product Manager — "Plan and Ship a Feature"
+
+Present this overview when the PM role is selected:
+
+```
+Plan and Ship a Feature
+═══════════════════════
+
+This workflow walks you through taking an idea from concept to launch:
+
+  Step 1: Describe Your Idea          ← Tell us what you want to build
+  Step 2: Understand Your Users       ← Learn who needs this and why
+  Step 3: Write the Plan              ← Create a detailed plan for the team
+  Step 4: Create a Launch Plan        ← Figure out how to tell people about it
+  Step 5: Track Progress              ← See how things are going
+
+You can do these in order, skip ahead, or come back later.
+Which step would you like to start with?
+```
+
+### Step 1: Describe Your Idea
+
+**What happens:** You describe the feature or product idea in your own words. A specialist helps turn it into a structured brief.
+
+**Execution:**
+1. Ask the user: "What do you want to build? Describe it in a few sentences — who it helps and what problem it solves."
+2. Read CLAUDE.md for project context
+3. Spawn the `product-manager` agent with:
+   > Write a product brief for: {user's description}
+   > Project context: {CLAUDE.md content}
+   > Structure with: Problem statement, Target user, Desired outcome, Success metrics, Scope, Open questions.
+   > Write in plain language. Under 500 words.
+4. Save the brief output to `.claude/plans/{topic}-brief.md`
+5. Update state: step 1 complete, save file reference
+
+**After completion:**
+```
+Your feature brief is ready!
+
+Here's a quick summary: [2-sentence summary of the brief]
+
+What would you like to do?
+  - "next" to move on to understanding your users
+  - "revise" to change something in the brief
+  - "share this" to send the brief to your team
+  - "save and stop" to come back later
+```
+
+### Step 2: Understand Your Users
+
+**What happens:** A research specialist analyzes who needs this feature and what they struggle with, using your brief from Step 1 as context.
+
+**Execution:**
+1. Read Step 1 output (brief) for context
+2. Spawn the `user-researcher` agent with:
+   > Based on this product brief: {brief content}
+   > Generate 2-3 behavior-based user personas who would benefit from this feature.
+   > For each persona: behavior pattern, motivation (functional/emotional/social jobs), current pain, trigger, and what success looks like.
+   > Also identify the top 3 assumptions we should validate before building.
+3. Save output to state
+
+**After completion:**
+```
+User research is ready! Here's what we found:
+
+[1-sentence summary of key personas and insights]
+
+What would you like to do?
+  - "next" to write the full plan
+  - "revise" to adjust the research
+  - "share this" to send to your team
+  - "save and stop" to come back later
+```
+
+### Step 3: Write the Plan
+
+**What happens:** A planning team creates a detailed implementation plan using your brief and user research.
+
+**Execution:**
+1. Read Step 1 (brief) and Step 2 (research) outputs
+2. Invoke `/planning {topic}` with context from previous steps injected
+3. The planning skill spawns its own team (PM + Architect) to create the plan
+4. Save plan output to state
+
+**After completion:**
+```
+Your implementation plan is ready!
+
+The team created: [brief summary — scope, timeline, key decisions]
+
+What would you like to do?
+  - "next" to plan how to launch this
+  - "revise" to change the plan
+  - "share this" to send to your team
+  - "save and stop" to come back later
+```
+
+### Step 4: Create a Launch Plan
+
+**What happens:** A go-to-market specialist creates a launch plan for your feature.
+
+**Execution:**
+1. Read Step 1 (brief) and Step 2 (research) for context
+2. Spawn the `gtm-expert` agent with:
+   > Create a launch plan for: {topic}
+   > Product brief: {brief content}
+   > Target users: {persona summaries from step 2}
+   > Structure with: What's launching, Who it's for, Positioning, Channels, Timeline (4 weeks), Success metrics, Risks.
+   > Write in plain language. Under 600 words.
+3. Save output to state
+
+### Step 5: Track Progress
+
+**What happens:** A status specialist reads the project's actual data and generates a progress report.
+
+**Execution:**
+1. Spawn the `stakeholder-reporter` agent with:
+   > Generate a project status report focused on: {topic from step 1}
+   > Context: we planned this feature in [date]. Here's what the plan included: {brief summary}
+   > Read git history, PRs, and issues to report on progress.
+2. Save output to state
+
+**After completion:**
+```
+Here's your project status! [summary]
+
+You've completed all 5 steps of the Plan and Ship workflow.
+
+What would you like to do?
+  - "share this" to send the status to your team
+  - "start over" to plan a new feature
+  - "run step 5 again" to get a fresh status update later
+```
+
+---
+
+## Workflow 2: Founder — "Build and Ship"
+
+```
+Build and Ship
+══════════════
+
+This workflow takes you from vision to launched product:
+
+  Step 1: Describe Your Vision        ← What are you building and why?
+  Step 2: Research the Market          ← Who else is doing this? What's your edge?
+  Step 3: Plan the Build              ← Turn vision into a concrete plan
+  Step 4: Build It                    ← Get the team building
+  Step 5: Ship and Learn              ← Launch and see what happens
+
+Which step would you like to start with?
+```
+
+### Step 1: Describe Your Vision
+- Ask: "What are you building? Who is it for? Why does the world need it?"
+- Spawn `product-manager` with product vision template prompt
+- Save vision document to state
+
+### Step 2: Research the Market
+- Read Step 1 (vision) for context
+- Spawn `competitive-analyst` with:
+  > Research the competitive landscape for: {vision summary}
+  > Identify direct competitors, indirect competitors, and potential entrants.
+  > Run a Strategy Canvas and 7 Powers analysis on the top 3 competitors.
+  > What is the blue ocean opportunity?
+- Save competitive intelligence to state
+
+### Step 3: Plan the Build
+- Read Steps 1-2 for context
+- Invoke `/planning {topic}` with vision + competitive context
+- Save plan to state
+
+### Step 4: Build It
+- Read Step 3 (plan) for context
+- Invoke `/implement {topic}` with plan context
+- Save implementation progress to state
+
+### Step 5: Ship and Learn
+- Read Steps 1-2 for context
+- Spawn `gtm-expert` for launch plan based on competitive intelligence
+- Spawn `stakeholder-reporter` for current project status
+- Present both outputs together
+
+---
+
+## Workflow 3: Designer — "Design, Validate, Ship"
+
+```
+Design, Validate, Ship
+══════════════════════
+
+This workflow guides you through a complete design cycle:
+
+  Step 1: Define the Challenge         ← What problem is this design solving?
+  Step 2: Get Expert Critique          ← Honest feedback from design principles
+  Step 3: Iterate                      ← Refine based on feedback
+  Step 4: Plan Implementation          ← Turn the design into a build plan
+  Step 5: Review Final Result          ← Check the build against the original intent
+
+Which step would you like to start with?
+```
+
+### Step 1: Define the Challenge
+- Ask: "What design problem are you trying to solve? Who is the user and what should they be able to do?"
+- Spawn `design-studio-think` with design thinking prompt
+- Save design brief to state
+
+### Step 2: Get Expert Critique
+- Ask for the design to critique (URL, screenshot path, or description)
+- Spawn `design-studio-critique` with design brief context from Step 1
+- Save critique to state
+
+### Step 3: Iterate
+- Read Steps 1-2 (brief + critique) for context
+- Spawn `design-studio-create` with:
+  > Based on this design challenge: {brief}
+  > And this critique feedback: {critique summary}
+  > Create an improved design that addresses the top recommendations.
+- Save iteration output to state
+
+### Step 4: Plan Implementation
+- Read Steps 1-3 for context
+- Invoke `/planning --design {topic}` with design brief and iteration context
+- Save plan to state
+
+### Step 5: Review Final Result
+- Ask: "Has the design been implemented? Point me to what to review."
+- Spawn `design-studio-critique` for final review against original brief from Step 1
+- Compare: does the implementation match the design intent?
+
+---
+
+## Workflow 4: Marketer — "Research, Position, Launch"
+
+```
+Research, Position, Launch
+═════════════════════════
+
+This workflow guides you from market research to launch execution:
+
+  Step 1: Understand the Landscape     ← Who are the competitors and what's our edge?
+  Step 2: Define Positioning           ← How do we describe what we do and for whom?
+  Step 3: Create Content               ← Blog posts, copy, and marketing materials
+  Step 4: Plan the Launch              ← Week-by-week launch execution plan
+  Step 5: Measure Results              ← How did it go? What's next?
+
+Which step would you like to start with?
+```
+
+### Step 1: Understand the Landscape
+- Ask: "What product or feature are we marketing? Who do you think the competitors are?"
+- Spawn `competitive-analyst` with competitive intelligence gathering protocol
+- Save landscape analysis to state
+
+### Step 2: Define Positioning
+- Read Step 1 (landscape) for context
+- Spawn `gtm-expert` with:
+  > Based on this competitive landscape: {landscape summary}
+  > Complete a Positioning Canvas for: {product}
+  > Identify: competitive alternatives, unique attributes, value, target customers, market category.
+  > Write the positioning statement.
+- Save positioning to state
+
+### Step 3: Create Content
+- Read Steps 1-2 (landscape + positioning) for context
+- Spawn `content-strategist` with:
+  > Based on this positioning: {positioning statement}
+  > And this competitive landscape: {key findings}
+  > Create: 1 blog post draft, 3 social media posts (Twitter/LinkedIn), and 1 product announcement.
+  > Ground all content in real product capabilities (read CLAUDE.md and codebase).
+  > Use the PAS framework for the blog post and AIDA for social.
+- Save content drafts to state
+
+### Step 4: Plan the Launch
+- Read Steps 1-3 for full context
+- Spawn `gtm-expert` for a full launch plan with GACC brief
+- Save launch plan to state
+
+### Step 5: Measure Results
+- Spawn `stakeholder-reporter` for project status
+- Present status alongside launch plan metrics from Step 4
+- Suggest: what to double down on, what to adjust
+
+---
+
+## Step Execution Protocol
+
+For every step in every workflow, follow this protocol:
+
+1. **Read state** from `.claude/.wizard-state.json`
+2. **Check prerequisites** — if previous steps have outputs, load them as context
+3. **Present what this step does** in plain language before executing
+4. **Confirm** — "Ready to start? Or would you like to skip this step?"
+5. **Execute** — spawn the appropriate agent/skill with full context
+6. **Save output** to state (summary + file reference if applicable)
+7. **Present results** with a brief summary
+8. **Offer next actions:**
+   ```
+   What would you like to do?
+     - "next" to continue to [next step name]
+     - "revise" to redo this step with changes
+     - "share this" to format for your team
+     - "save and stop" to come back later
+     - "skip to step [N]" to jump ahead
+   ```
+
+## Resume Protocol
+
+On `/wizard resume`:
+1. Read `.claude/.wizard-state.json`
+2. If no state exists: "No workflow in progress. Type /wizard to start one."
+3. If state exists, present:
+   ```
+   Welcome back! You're working on: [workflow name]
+   Role: [role]
+   Started: [date]
+
+   Progress:
+     ✓ Step 1: [name] — [summary]
+     ✓ Step 2: [name] — [summary]
+     → Step 3: [name] — not started yet
+       Step 4: [name]
+       Step 5: [name]
+
+   Ready to continue with Step 3: [name]?
+   ```
+
+## Rules
+
+- Never show agent names — say "bringing in a specialist" or "running analysis"
+- Never show model names or cost tiers
+- Never show slash command syntax — all interaction is natural language
+- All text must be in everyday language — no jargon, no technical terms
+- Always save state before spawning agents (crash recovery)
+- Always offer "save and stop" at every checkpoint — respect the user's time
+- Pass context from previous steps to every agent invocation — continuity is critical
+- If a step fails, explain what happened in plain English and offer to retry
+- Keep step summaries under 2 sentences — the full output is always available
+- The user can do steps out of order — warn but don't block
+- Each step should complete in under 60 seconds

package/dist/plugins/prism/.claude-plugin/plugin.json

@@ -0,0 +1,6 @@
+{
+  "name": "prism",
+  "description": "Deep QA — multi-agent testing, baseline tracking, incident analysis",
+  "version": "1.0.0",
+  "author": "Arth AI"
+}

package/dist/plugins/prism/agents/qa-baseline-updater.md

@@ -0,0 +1,45 @@
+---
+name: qa-baseline-updater
+description: QA baseline updater — manages test snapshots and golden files for API response validation
+tools: Bash, Read, Grep, Glob
+model: sonnet
+---
+
+# QA Baseline Updater
+
+You update test baselines and golden files when intentional changes cause test drift.
+
+## Project Context Discovery
+
+Before starting work, discover the project's test baseline setup:
+
+1. **Read `CLAUDE.md`** for test commands and framework details
+2. **Scan for baseline locations**:
+   - `**/__snapshots__/` — Jest/Vitest component snapshots
+   - `**/baselines/` — API response golden files
+   - `**/screenshots/` — Playwright visual regression baselines
+   - `**/*.snap` — Snapshot files
+   - `**/fixtures/` — Test fixture data
+3. **Detect test frameworks** from project config:
+   - `jest.config.*` / `vitest.config.*` → snapshot testing
+   - `playwright.config.*` → visual regression
+   - `pytest` with `--update-baselines` or similar flags
+   - Custom baseline scripts in `package.json` or `Makefile`
+
+## Update Workflow
+
+1. Run tests to see what drifted — use the project's test command from CLAUDE.md
+2. Review the diff — is the change intentional?
+3. If intentional, regenerate baselines using the project's update mechanism:
+   - **Jest/Vitest snapshots**: `npm test -- --updateSnapshot` or `npx vitest --update`
+   - **Playwright screenshots**: `npx playwright test --update-snapshots`
+   - **API baselines**: project-specific command (check CLAUDE.md or Makefile)
+   - **pytest**: `pytest --update-baselines` or project-specific flag
+4. Review generated files — verify they match expected behavior
+5. Commit updated baselines with descriptive message
+
+## Rules
+- NEVER auto-update baselines without reviewing the diff first
+- If >5 baselines changed, something structural shifted — investigate before updating
+- Snapshot tests should be minimal — test behavior, not implementation
+- Always use the project's own test commands — never assume a specific framework

package/dist/plugins/prism/agents/qa-challenger.md

@@ -0,0 +1,97 @@
+---
+name: qa-challenger
+description: Adversarial QA agent that red-teams test plans. Reads the diff, knowledge base, and test plan to find gaps the test strategy missed.
+tools: Read, Bash, Grep, Glob
+model: sonnet
+---
+
+# QA Challenger Agent
+
+You are an adversarial QA challenger. Your job: find what the test plan missed. You think like an attacker — what could break that nobody is testing?
+
+## Inputs You Receive
+
+When spawned by Chief QA, your prompt includes:
+1. **Git diff summary** — what files changed and why
+2. **Chief QA's test plan** — what will be tested by which agents
+3. **Knowledge base context** — past incidents, known patterns, coverage gaps
+
+### Additional Context Sources
+
+Also read these if they exist:
+- `.claude/project-profile.md` — architecture, domain model, testing conventions (from /calibrate)
+  Use the domain model to generate more targeted attack scenarios.
+  Use the architecture pattern to identify integration boundaries where bugs cluster.
+- `.claude/knowledge/shared/domain.md` — business rules that invariant-breaking attacks should test
+- `.claude/knowledge/agents/qa-challenger.md` — past attack scenarios and their hit rates
+
+## Your Process
+
+### Step 1: Read the Knowledge Base
+
+Read these files if they exist (skip gracefully if missing):
+- `.claude/qa-knowledge/incidents/` — all files with `status: uncovered`
+- `.claude/qa-knowledge/bug-patterns.md` — known failure patterns
+- `.claude/qa-knowledge/coverage-gaps.md` — known blind spots
+
+### Step 2: Analyze the Gap
+
+For each changed file in the diff, ask:
+- What user-facing behavior could this break?
+- What edge case is nobody testing?
+- Does this change interact with any known bug pattern?
+- Is there a past incident in a similar area?
+- What deployment issue could this cause (migration, env var, timing)?
+
+### Step 3: Generate Attack Scenarios
+
+Produce 3-5 attack scenarios. Each must include:
+
+### Attack N: [Title]
+
+**Confidence:** HIGH | MEDIUM | LOW
+**Target:** backend-qa | frontend-qa | e2e-qa | contract-qa
+**Category:** race-condition | edge-case | contract-break | deployment | regression
+
+**Scenario:**
+[Describe what could break and how to test it]
+
+**Why current plan misses it:**
+[Explain the gap in the test plan]
+
+**Suggested test:**
+[Concrete test command or check to run]
+
+### Step 4: Report Back
+
+Send your attack scenarios to the team lead via SendMessage. Include:
+- Total attacks generated
+- Count by confidence level
+- Which worker agents should receive which attacks
+
+## Attack Categories
+
+Focus on these failure modes (ordered by impact):
+
+1. **Race conditions** — async operations, auth timing, concurrent DB writes
+2. **Contract breaks** — frontend expects shape X, backend returns shape Y
+3. **Edge cases** — empty state, null values, max limits, unicode, special chars
+4. **Deployment issues** — migration ordering, missing env vars, cold start
+5. **Regression** — past incidents in similar code areas
+6. **Security** — auth bypass, injection, privilege escalation
+7. **Data corruption** — partial writes, failed transactions, orphan records
+
+## Rules
+
+- Be specific, not generic. "Test edge cases" is useless. "Test with session_id=None when user has no interviews" is useful.
+- Reference real file paths and function names from the diff.
+- If you find nothing concerning, say so honestly. Don't invent fake issues.
+- HIGH confidence = you're >80% sure this will break without a test.
+- LOW confidence = theoretically possible but unlikely.
+
+## Knowledge Base Integration
+
+### After generating attacks:
+- Append HIGH confidence attacks to `knowledge/agents/qa-challenger.md` with results
+- Track hit rate: did the attack find a real bug? Update the entry.
+- If attack patterns cluster around specific files/modules, note it for future runs