qwen-seed 1.0.0

package/README.md

@@ -0,0 +1,210 @@
+# Qwen-SEED **Structured Evaluation & Engineering Design** — Your AI project incubator for Qwen Code.
+
+```bash
+npx qwen-seed
+```
+
+**Works on Mac, Windows, and Linux.**
+
+*"The coach, not the interrogator."*
+
+[What SEED Does](#what-seed-does) · [Commands](#commands) · [Project Types](#project-types) · [How It Works](#how-it-works) · [Architecture](#architecture) · [The PAUL Connection](#the-paul-connection) · [Install](#install)
+
+---
+
+## What SEED Does
+
+You have an idea. Maybe it's an app, a workflow, a client site, a utility, or a content campaign. Before you start building, you need to answer the right questions — and the right questions depend on what type of project it is.
+
+SEED is a typed project incubator for Qwen Code. It guides you through collaborative exploration shaped by your project type, produces a structured PLANNING.md, and graduates mature plans into buildable project directories. If you use PAUL, it can initialize a managed build from your plan without re-asking questions you already answered.
+
+**The coach, not the interrogator.** SEED brainstorms alongside you, offers suggestions when you're stuck, and pushes toward decisions when it's time. It doesn't fire questions at you — it thinks with you.
+
+---
+
+## Commands
+
+| Command | What It Does |
+|---------|-------------|
+| `/seed` | Start a guided ideation session (default) |
+| `/seed graduate` | Move completed ideation to `apps/` with git repo and synthesized README |
+| `/seed launch` | Graduate + initialize PAUL for managed build (one command) |
+| `/seed status` | Show all projects in the ideation pipeline |
+| `/seed add-type` | Create a custom project type for SEED's data layer |
+
+---
+
+## Project Types
+
+SEED ships with 5 default types. Each type shapes the conversation differently:
+
+| Type | Rigor | Sections | What It's For |
+|------|-------|----------|---------------|
+| **Application** | Deep | 10 | Software with UI, data model, API, deployment |
+| **Workflow** | Standard | 8 | Qwen Code commands, hooks, CARL domains, skills |
+| **Client** | Standard | 7 | Client websites — business context, conversion, content |
+| **Utility** | Tight | 6 | Small tools, scripts, single-purpose — resists expansion |
+| **Campaign** | Creative | 7 | Content, marketing, launches — timeline-driven |
+
+**Rigor adapts behavior:**
+- **Tight** — Move fast, resist scope creep, done in one session
+- **Standard** — Balanced exploration with clear boundaries
+- **Deep** — Thorough, architecture matters, don't rush
+- **Creative** — Loose and generative, but always anchored to a measurable goal
+
+Types are composable. Run `/seed add-type` to create your own — just drop files in `data/{type}/` and it works immediately. No code changes needed.
+
+---
+
+## How It Works
+
+```
+  /seed                          /seed graduate              /seed launch
+    │                                  │                          │
+    ▼                                  ▼                          ▼
+ Select type ──▶ Guided ──▶ PLANNING.md ──▶ apps/{name}/ ──▶ .paul/ init
+ (or discover)   ideation    (populated)     git + README      (headless)
+    │                │
+    ▼                ▼
+ Load data/     Coach persona
+ {type}/        adapts rigor
+```
+
+1. **Type first.** SEED determines your project type before anything else. Type shapes everything downstream.
+2. **Guided exploration.** Conversation sections load from `data/{type}/guide.md`. Each section has prompts and suggestions.
+3. **PLANNING.md output.** When you're ready, SEED populates a type-specific template.
+4. **Graduate.** Moves the project to `apps/{name}/` with git init and a synthesized README.
+5. **Launch.** Wraps graduation + headless PAUL init. Zero re-asking.
+
+---
+
+## Architecture
+
+```
+commands/qwen-seed/
+├── seed.md                         Entry point (routing + persona)
+├── tasks/
+│   ├── ideate.md                   Type-first guided ideation
+│   ├── graduate.md                 Project graduation to apps/
+│   ├── launch.md                   Graduate + PAUL init wrapper
+│   ├── status.md                   Pipeline visibility
+│   └── add-type.md                 User-extensible type system
+├── data/                           Composable per-type data
+│   ├── application/
+│   │   ├── guide.md
+│   │   ├── config.md
+│   │   └── skill-loadout.md
+│   ├── workflow/                   Same structure
+│   ├── client/                     Same structure
+│   ├── utility/                    Same structure
+│   └── campaign/                   Same structure
+├── templates/
+│   ├── planning-application.md
+│   ├── planning-workflow.md
+│   ├── planning-client.md
+│   ├── planning-utility.md
+│   └── planning-campaign.md
+└── checklists/
+    └── planning-quality.md         Quality gate for graduation
+```
+
+**The key design decision:** Type-specific content lives in `data/{type}/` files, not hardcoded in task files. Adding a new type = dropping 3 files in a new `data/` directory.
+
+---
+
+## The PAUL Connection — Ideation to Managed Build
+
+This is where SEED pays off. The entire ideation flow is designed so that the PLANNING.md it produces contains everything [PAUL](https://github.com/tylergriffin1350/qwen-paul) needs to set up a structured build — without asking you anything twice.
+
+### How SEED Solves It
+
+`/seed launch` runs the full graduation flow and then initializes PAUL with **headless context**:
+
+1. SEED produces a rich PLANNING.md during ideation (type-aware, quality-gated)
+2. `/seed launch` graduates the project to `apps/{name}/` with git
+3. PAUL reads the PLANNING.md and derives its entire project structure from it
+4. PAUL proposes milestones, phases, and tech stack — you review and approve
+5. You're immediately ready to run `/paul:plan` for Phase 1
+
+**No re-asking.** PAUL doesn't ask "What's this project?" or "What's the tech stack?" — those answers are already in the PLANNING.md.
+
+### Without PAUL
+
+Don't use PAUL? `/seed graduate` works standalone — you get a clean `apps/{name}/` directory with git and a synthesized README. Build however you want. PAUL is additive, not required.
+
+---
+
+## Install
+
+```bash
+npx qwen-seed
+```
+
+The installer prompts you to choose:
+
+1. **Global** (recommended) — Available in all Qwen Code projects
+2. **Local** — Available in current project only
+
+### What Gets Installed
+
+```
+~/.qwen/commands/qwen-seed/
+├── seed.md              Entry point (routing + persona)
+├── tasks/               5 task files
+├── data/                15 type-specific data files (5 types × 3 files)
+├── templates/           5 PLANNING.md output templates
+└── checklists/          Planning quality gate
+```
+
+No hooks, no MCP servers, no workspace data. SEED is pure markdown — zero runtime dependencies.
+
+---
+
+## Ecosystem
+
+SEED works standalone but integrates with the broader Qwen ecosystem:
+
+| Tool | How SEED Uses It |
+|------|-----------------|
+| **qwen-paul** | `/seed launch` initializes PAUL with headless context from PLANNING.md — zero-friction handoff from ideation to managed build |
+| **carl-qwen** | Type-specific CARL domains load automatically during build |
+| **qwen-skillsmith** | SEED follows Skillsmith format — compliant entry point + tasks |
+| **qwen-aegis** | Recommended post-build audit for application-type projects |
+| **qwen-base** | Graduate updates workspace-level project tracking |
+
+All integrations are additive. SEED works without any of them installed.
+
+---
+
+## Quick Workflow
+
+```
+# 1. Start ideation session
+/seed
+
+# 2. Shape your idea with type-specific guidance
+# (guided conversation → PLANNING.md)
+
+# 3. Graduate to buildable project
+/seed graduate
+
+# OR graduate + PAUL in one step:
+/seed launch
+```
+
+---
+
+## License
+
+MIT License.
+
+---
+
+## Author
+
+**Chris Kahler** — [Chris AI Systems](https://github.com/ChristopherKahler)
+Adapted for Qwen Code by [tylergriffin1350](https://github.com/tylergriffin1350)
+
+---
+
+**Qwen Code is powerful. SEED makes it strategic.**

package/bin/install.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Colors
+const green = '\x1b[32m';
+const cyan = '\x1b[36m';
+const yellow = '\x1b[33m';
+const dim = '\x1b[2m';
+const reset = '\x1b[0m';
+
+// Get version from package.json
+const pkg = require('../package.json');
+
+const banner = `
+${green}  \u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557
+  \u2588\u2588\u2554\u2550\u2550\u2550\u255d\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255d\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557
+  \u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551
+  \u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u255d  \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551
+  \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255d\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551
+  \u255a\u2550\u2550\u2550\u2550\u2550\u255d \u255a\u2550\u255d  \u255a\u2550\u255d\u255a\u2550\u2550\u2550\u2550\u2550\u2550\u255d\u255a\u2550\u2550\u2550\u2550\u2550\u255d${reset}
+
+  SEED ${dim}v${pkg.version}${reset}
+  Structured Evaluation & Engineering Design
+  for Qwen Code
+`;
+
+// Parse args
+const args = process.argv.slice(2);
+const hasHelp = args.includes('--help') || args.includes('-h');
+const hasLocal = args.includes('--local') || args.includes('-l');
+
+// Parse --config-dir argument
+function parseConfigDirArg() {
+  const idx = args.findIndex(arg => arg === '--config-dir' || arg === '-c');
+  if (idx !== -1) {
+    const nextArg = args[idx + 1];
+    if (!nextArg || nextArg.startsWith('-')) {
+      console.error(`  ${yellow}--config-dir requires a path argument${reset}`);
+      process.exit(1);
+    }
+    return nextArg;
+  }
+  const configDirArg = args.find(arg => arg.startsWith('--config-dir=') || arg.startsWith('-c='));
+  if (configDirArg) {
+    return configDirArg.split('=')[1];
+  }
+  return null;
+}
+
+/**
+ * Expand ~ to home directory
+ */
+function expandTilde(filePath) {
+  if (filePath && filePath.startsWith('~/')) {
+    return path.join(os.homedir(), filePath.slice(2));
+  }
+  return filePath;
+}
+
+/**
+ * Recursively copy directory, skipping .paul/, .git/, node_modules/, bin/
+ */
+function copyDir(srcDir, destDir, skipDirs = []) {
+  fs.mkdirSync(destDir, { recursive: true });
+  const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (skipDirs.includes(entry.name)) continue;
+    const srcPath = path.join(srcDir, entry.name);
+    const destPath = path.join(destDir, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath, skipDirs);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+/**
+ * Count files recursively
+ */
+function countFiles(dir, ext) {
+  let count = 0;
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      count += countFiles(fullPath, ext);
+    } else if (!ext || entry.name.endsWith(ext)) {
+      count++;
+    }
+  }
+  return count;
+}
+
+console.log(banner);
+
+// Show help
+if (hasHelp) {
+  console.log(`  ${yellow}Usage:${reset} npx qwen-seed [options]
+
+  ${yellow}Options:${reset}
+    ${cyan}-l, --local${reset}              Install to ./.qwen/commands/ instead of global
+    ${cyan}-c, --config-dir <path>${reset}  Specify custom Qwen config directory
+    ${cyan}-h, --help${reset}               Show this help message
+
+  ${yellow}Examples:${reset}
+    ${dim}# Install globally (default) — available in all workspaces${reset}
+    npx qwen-seed
+
+    ${dim}# Install to current project only${reset}
+    npx qwen-seed --local
+
+  ${yellow}What gets installed:${reset}
+    ${cyan}commands/qwen-seed/${reset}
+      seed.md              Entry point (routing + persona)
+      tasks/               5 task files (ideate, graduate, launch, status, add-type)
+      data/                15 type-specific data files (5 types x 3 files)
+      templates/           5 PLANNING.md output templates
+      checklists/          Planning quality gate
+`);
+  process.exit(0);
+}
+
+// Determine install target
+const explicitConfigDir = parseConfigDirArg();
+const configDir = expandTilde(explicitConfigDir) || expandTilde(process.env.QWEN_CONFIG_DIR);
+const globalDir = configDir || path.join(os.homedir(), '.qwen');
+const qwenDir = hasLocal ? path.join(process.cwd(), '.qwen') : globalDir;
+const seedDest = path.join(qwenDir, 'commands', 'qwen-seed');
+
+const locationLabel = hasLocal
+  ? seedDest.replace(process.cwd(), '.')
+  : seedDest.replace(os.homedir(), '~');
+
+// Check if already installed
+if (fs.existsSync(seedDest)) {
+  console.log(`  ${yellow}Existing installation found at ${locationLabel}${reset}`);
+  console.log(`  Updating...`);
+  fs.rmSync(seedDest, { recursive: true, force: true });
+}
+
+console.log(`  Installing to ${cyan}${locationLabel}${reset}\n`);
+
+// Copy skill files
+const src = path.join(__dirname, '..');
+
+// Copy entry point
+fs.mkdirSync(seedDest, { recursive: true });
+fs.copyFileSync(path.join(src, 'seed.md'), path.join(seedDest, 'seed.md'));
+console.log(`  ${green}+${reset} seed.md ${dim}(entry point)${reset}`);
+
+// Copy tasks
+const tasksSrc = path.join(src, 'tasks');
+const tasksDest = path.join(seedDest, 'tasks');
+copyDir(tasksSrc, tasksDest);
+const taskCount = countFiles(tasksSrc, '.md');
+console.log(`  ${green}+${reset} tasks/ ${dim}(${taskCount} task files)${reset}`);
+
+// Copy data
+const dataSrc = path.join(src, 'data');
+const dataDest = path.join(seedDest, 'data');
+copyDir(dataSrc, dataDest);
+const dataCount = countFiles(dataSrc, '.md');
+const typeCount = fs.readdirSync(dataSrc, { withFileTypes: true }).filter(e => e.isDirectory()).length;
+console.log(`  ${green}+${reset} data/ ${dim}(${typeCount} types, ${dataCount} files)${reset}`);
+
+// Copy templates
+const templatesSrc = path.join(src, 'templates');
+const templatesDest = path.join(seedDest, 'templates');
+copyDir(templatesSrc, templatesDest);
+const templateCount = countFiles(templatesSrc, '.md');
+console.log(`  ${green}+${reset} templates/ ${dim}(${templateCount} planning templates)${reset}`);
+
+// Copy checklists
+const checklistsSrc = path.join(src, 'checklists');
+const checklistsDest = path.join(seedDest, 'checklists');
+copyDir(checklistsSrc, checklistsDest);
+console.log(`  ${green}+${reset} checklists/ ${dim}(planning quality gate)${reset}`);
+
+console.log(`
+  ${green}Done!${reset} Open Qwen Code and type ${cyan}/seed${reset} to start.
+`);

package/checklists/planning-quality.md

@@ -0,0 +1,55 @@
+# Planning Quality Checklist
+
+Quality gate for `/seed graduate` and `/seed launch`. Determines if a PLANNING.md is rich enough for clean graduation and headless PAUL initialization.
+
+## Universal Checks (All Types)
+
+- [ ] **Type metadata** present in header (Application, Workflow, Client, Utility, Campaign, or custom)
+- [ ] **Problem statement** is specific — names the problem, the audience, and why it matters
+- [ ] **Design decisions** documented — at least 1 resolved decision with rationale
+- [ ] **Open questions** section exists (even if "None")
+- [ ] **Next actions** defined — at least 1 concrete next step
+- [ ] **Skill Loadout** noted — which ecosystem tools apply to this build
+
+## Type-Specific Checks
+
+Reference `data/{type}/config.md` for the authority on required vs optional sections.
+
+- [ ] **All required sections** (per config.md) have substantive content — not just headers or placeholders
+- [ ] **Optional sections** either covered or explicitly marked as N/A
+- [ ] **Section depth matches rigor** — tight types (utility) can be brief; deep types (application) need thorough coverage
+
+### Quick Reference
+
+| Type | Required Sections | Rigor |
+|------|------------------|-------|
+| Application | 8 of 10 | deep — thorough coverage expected |
+| Workflow | 6 of 8 | standard — balanced |
+| Client | 6 of 7 | standard — business-focused |
+| Utility | 6 of 6 | tight — all required, but brief |
+| Campaign | 6 of 7 | creative — can be loose, but measurable goal required |
+
+## PAUL-Readiness Checks (for /seed launch)
+
+These are only required if the user intends to run `/seed launch` (graduate + PAUL init). Skip for `/seed graduate` alone.
+
+- [ ] **Phase breakdown** exists with independently shippable milestones
+- [ ] **Each phase** has build, testable, and outcome defined
+- [ ] **Tech stack decisions** are resolved — no critical "TBD" items
+- [ ] **Enough detail** that PAUL can derive milestones, phases, and structure without re-asking questions
+
+## Assessment
+
+| Result | Criteria | Action |
+|--------|----------|--------|
+| **Pass** | All universal checks + all required type-specific sections | Proceed with graduation |
+| **Warn** | Missing optional sections or thin content in some areas | Note gaps, ask user if they want to flesh out or proceed |
+| **Fail** | Missing required sections or no problem statement | Recommend returning to `/seed` to complete ideation |
+
+## Usage
+
+This checklist is referenced by:
+- `tasks/graduate.md` — step `quality_check` (before creating app directory)
+- `tasks/launch.md` — inherited via graduate delegation
+
+It is NOT a scorecard with numbers. It's a qualitative assessment that the coach persona uses to decide whether to warn the user or proceed.

package/data/application/config.md

@@ -0,0 +1,21 @@
+# Application — Configuration
+
+| Setting | Value |
+|---------|-------|
+| Rigor | deep |
+| Demeanor | Thorough and architectural — explore trade-offs, push for clarity on data model and deployment before moving on. Applications have the highest complexity ceiling, so don't rush. |
+| Sections | 10 |
+
+## Required Sections
+- Problem Statement
+- Tech Stack
+- Data Model
+- API Surface
+- Deployment Strategy
+- Security Considerations
+- UI/UX Needs
+- Phase Breakdown
+
+## Optional Sections
+- Integration Points
+- Skill Loadout

package/data/application/guide.md

@@ -0,0 +1,51 @@
+# Application — Conversation Guide
+
+## Section 1: Problem Statement
+**Explore:** What does this solve? Who's it for — just you, a team, the public? Why build it instead of buying something off the shelf? What's the pain point that makes this worth the effort?
+**Suggest:** If the user is vague, try: "What's the one thing a user would do in their first 5 minutes?" If they're solving their own problem, that's valid — note it as "dogfooding" and move on.
+**Depth:** required
+
+## Section 2: Tech Stack
+**Explore:** Do you have a stack in mind, or are you exploring? What's the deployment target — local, cloud, edge? Any constraints from the team or existing infrastructure? Why this stack over alternatives?
+**Suggest:** For solo builders: Next.js + SQLite is fast to ship. For teams: consider what everyone knows. If they mention unfamiliar tech, suggest `/paul:discover` for research before committing.
+**Depth:** required
+
+## Section 3: Data Model
+**Explore:** What are the core things this app tracks? How do they relate to each other? What's the most important entity — the one everything else connects to?
+**Suggest:** Start with 3-5 entities max. Draw the relationships: "A User has many X, each X belongs to one Y." If it's getting complex, suggest starting with the minimum viable schema and evolving.
+**Depth:** required
+
+## Section 4: API Surface
+**Explore:** What endpoints does this need? Is there auth? Internal-only or public API? REST, GraphQL, or tRPC? What's the most critical endpoint — the one that delivers core value?
+**Suggest:** For MVPs: REST is fastest to build. Auth: start with JWT or session-based, don't over-engineer. If they need real-time: consider SSE over WebSockets for simplicity.
+**Depth:** required
+
+## Section 5: Deployment Strategy
+**Explore:** Where does this run? Local dev setup, staging, production — what's the plan for each? Docker or bare metal? CI/CD pipeline needed?
+**Suggest:** For solo projects: Railway or Vercel for zero-config deploys. For Docker: suggest a compose file early. If they need a database: managed > self-hosted for MVPs.
+**Depth:** required
+
+## Section 6: Security Considerations
+**Explore:** What's the auth model? What data is sensitive? Any compliance requirements (HIPAA, SOC2, GDPR)? What are the OWASP risks specific to THIS app?
+**Suggest:** At minimum: input validation, parameterized queries, CSRF protection, rate limiting. If handling PII: encryption at rest. Don't over-engineer security for internal tools.
+**Depth:** required
+
+## Section 7: UI/UX Needs
+**Explore:** What does the user see? Key views/pages? Design system or freestyle? Mobile-responsive needed? Any real-time UI requirements (dashboards, notifications)?
+**Suggest:** For MVPs: Tailwind + shadcn/ui gets you 80% there. If they have design ideas, suggest ui-ux-pro-max for implementation. If not, suggest starting with a wireframe conversation.
+**Depth:** required
+
+## Section 8: Integration Points
+**Explore:** What external systems does this talk to? APIs, webhooks, MCP servers, third-party services? What happens if an integration is down?
+**Suggest:** List each integration with: what data flows, which direction, what auth is needed. For MCP servers: check if one already exists in the workspace before building new.
+**Depth:** optional
+
+## Section 9: Phase Breakdown
+**Explore:** What's the minimum slice that proves the concept? What comes after that? Can you ship something useful in 3-5 phases? What's the "it works" moment for each phase?
+**Suggest:** Phase 1 should be the smallest thing that delivers value. Each phase should be independently testable. If they're planning more than 7 phases, the scope might be too big.
+**Depth:** required
+
+## Section 10: Skill Loadout
+**Explore:** Which ecosystem tools make sense for this build? Need code quality scanning? UI design help? Structured development workflow?
+**Suggest:** Load skill-loadout.md recommendations. For most applications: PAUL (required for managed build), AEGIS (recommended post-build audit), ui-ux-pro-max (if frontend-heavy).
+**Depth:** optional

package/data/application/skill-loadout.md

@@ -0,0 +1,11 @@
+# Application — Skill Loadout
+
+## Recommended Tools
+
+| Tool | Priority | Why |
+|------|----------|-----|
+| PAUL | required | Structured milestones and phases for managed build — applications are too complex for ad-hoc development |
+| AEGIS | recommended | Post-build security and quality audit — catches OWASP issues, scalability gaps |
+| ui-ux-pro-max | recommended | Frontend design system, component patterns, responsive layouts — if the app has a UI |
+| sonarqube | optional | Continuous code quality scanning — useful for larger codebases or team projects |
+| use-railway | optional | If deploying to Railway — handles project creation, env vars, domains |

package/data/campaign/config.md

@@ -0,0 +1,18 @@
+# Campaign — Configuration
+
+| Setting | Value |
+|---------|-------|
+| Rigor | creative |
+| Demeanor | Loose and generative — let ideas flow, explore angles, brainstorm freely. But always anchor back to the measurable goal. Campaigns are timeline-driven, not architecture-driven. |
+| Sections | 7 |
+
+## Required Sections
+- Strategy & Goal
+- Audience
+- Deliverables List
+- Channels & Platforms
+- Timeline
+- Success Metrics
+
+## Optional Sections
+- Skill Loadout

package/data/campaign/guide.md

@@ -0,0 +1,36 @@
+# Campaign — Conversation Guide
+
+## Section 1: Strategy & Goal
+**Explore:** What's the specific measurable objective? Not "grow the channel" — something like "launch 10 shorts in 2 weeks" or "generate 50 leads from webinar." What's the thesis?
+**Suggest:** If the goal is vague, push for a number: "How will you know this worked? What's the metric?" If they can't answer, the campaign isn't ready to plan — it needs more strategic thinking first.
+**Depth:** required
+
+## Section 2: Audience
+**Explore:** Who is this for — existing audience or new acquisition? What are their pain points? What language do they use? Where do they hang out online?
+**Suggest:** Be specific: "Agency owners who use GoHighLevel and feel overwhelmed by AI" is better than "business owners." If targeting existing audience, note the platform where they already are.
+**Depth:** required
+
+## Section 3: Deliverables List
+**Explore:** Enumerate EVERY output. For each: format, length, platform, due date. What gets created first? What depends on what?
+**Suggest:** Table it: Deliverable | Format | Platform | Length | Due Date. If the list is longer than 15 items, consider splitting into multiple campaigns. If it's under 3, it might not need SEED — just do it.
+**Depth:** required
+
+## Section 4: Channels & Platforms
+**Explore:** Where does each deliverable go? Cross-posting strategy? Platform-specific adaptations needed? What's the primary channel vs amplification?
+**Suggest:** Pick one primary channel and 2-3 amplification channels. Don't try to be everywhere. For shortform: IG Reels → TikTok → YT Shorts → FB Reels is the standard cross-post chain.
+**Depth:** required
+
+## Section 5: Timeline
+**Explore:** What are the dates? What depends on what? What's the critical path? Any external deadlines (launches, events, partner commitments)?
+**Suggest:** Work backwards from the launch date. Build in buffer for content creation (it always takes longer). If there are dependencies (e.g., "can't post until site launches"), mark them as blockers.
+**Depth:** required
+
+## Section 6: Success Metrics
+**Explore:** Define metrics BEFORE execution, not after. What's the baseline? What's the target? How will you measure?
+**Suggest:** Pick 2-3 metrics max. For content: views, engagement rate, conversion to next step. For launches: signups, revenue, retention. Don't track everything — track what matters.
+**Depth:** required
+
+## Section 7: Skill Loadout
+**Explore:** Which ecosystem tools help with this campaign? Content strategy? Distribution optimization? Script writing?
+**Suggest:** Load skill-loadout.md recommendations. For most campaigns: content-flywheel-strategist (for multi-platform strategy), content-manager (for pipeline tracking), revops-expert (for conversion copy).
+**Depth:** optional

package/data/campaign/skill-loadout.md

@@ -0,0 +1,10 @@
+# Campaign — Skill Loadout
+
+## Recommended Tools
+
+| Tool | Priority | Why |
+|------|----------|-----|
+| content-flywheel-strategist | recommended | Multi-platform content strategy — transform core content into platform-specific formats |
+| revops-expert | recommended | Conversion copywriting frameworks for landing pages, emails, webinar scripts |
+| content-manager | recommended | Pipeline tracking — manage scripts through triage → recording → editing → publishing |
+| PAUL | optional | Only if the campaign has a complex build component (e.g., landing page + email sequence + webinar) |

package/data/client/config.md

@@ -0,0 +1,18 @@
+# Client — Configuration
+
+| Setting | Value |
+|---------|-------|
+| Rigor | standard |
+| Demeanor | Business-focused and practical — understand the client's goals, push for conversion clarity, keep tech decisions simple. The client cares about results, not architecture. |
+| Sections | 7 |
+
+## Required Sections
+- Business Context
+- Competitor Analysis
+- Conversion Strategy
+- Content Needs
+- Tech Approach
+- Timeline & Deliverables
+
+## Optional Sections
+- Skill Loadout

package/data/client/guide.md

@@ -0,0 +1,36 @@
+# Client — Conversation Guide
+
+## Section 1: Business Context
+**Explore:** Who's the client? What industry? Who's the target audience? What's the brand personality? Do they have an existing site?
+**Suggest:** If they have an existing site, suggest running `business-context-extractor` to pull structured context automatically. If not, build the context from conversation: industry, audience demographics, competitive positioning.
+**Depth:** required
+
+## Section 2: Competitor Analysis
+**Explore:** Who are 3-5 competitors? What are they doing well? Where's the positioning opportunity — what gap can this client fill? What's the differentiator?
+**Suggest:** Focus on positioning, not feature comparison. "They all do X, but none of them do Y" is the goal. If the user doesn't know competitors, suggest searching the client's industry + location.
+**Depth:** required
+
+## Section 3: Conversion Strategy
+**Explore:** What's the primary CTA? What's the funnel — visitor → lead → customer? What objections does the audience have? How does the site overcome them?
+**Suggest:** Every page needs a clear next step. For service businesses: contact form or calendar booking. For products: add to cart or free trial. Map the objection → response pairs.
+**Depth:** required
+
+## Section 4: Content Needs
+**Explore:** What content exists already? What needs to be written? Who writes it — the client, you, AI-assisted? Any brand guidelines or tone requirements?
+**Suggest:** Start with the minimum: hero copy, about section, service descriptions, testimonials. Don't plan a blog unless the client will actually write posts. Real content > placeholder content.
+**Depth:** required
+
+## Section 5: Tech Approach
+**Explore:** site-launcher-wp or custom build? What's the hosting situation? Domain owned? Any existing tech constraints (CMS, hosting provider)?
+**Suggest:** For most client sites: site-launcher-wp is fastest to production. Custom only if the client needs something the template can't handle. Always ask about domain and hosting first.
+**Depth:** required
+
+## Section 6: Timeline & Deliverables
+**Explore:** What's the deadline? Are there client review checkpoints? What are the deliverables at each stage? Who approves what?
+**Suggest:** Suggest a 3-phase approach: (1) Design/content draft → client review, (2) Build → client review, (3) Launch prep → go live. Build in buffer for client feedback cycles.
+**Depth:** required
+
+## Section 7: Skill Loadout
+**Explore:** Which ecosystem tools will speed up this project? Need business context extraction? Conversion copywriting help? Design system?
+**Suggest:** Load skill-loadout.md recommendations. For most client sites: business-context-extractor (required if existing site), revops-expert (for conversion copy), ui-ux-pro-max (for design).
+**Depth:** optional