@arthai/agents 1.0.0

package/dist/plugins/counsel/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/cruise/.claude-plugin/plugin.json

@@ -0,0 +1,6 @@
+{
+  "name": "cruise",
+  "description": "Autopilot mode — autonomous task execution (requires forge+scalpel+sentinel)",
+  "version": "1.0.0",
+  "author": "Arth AI"
+}