@c0x12c/spartan-ai-toolkit 1.1.0 → 1.2.1

package/.claude-plugin/marketplace.json

@@ -8,9 +8,9 @@
   "plugins": [
     {
       "name": "spartan-ai-toolkit",
-      "description": "5 workflows, 48 commands, 11 rules, 18 skills, 4 agents — organized in 11 packs with dependencies",
+      "description": "5 workflows, 51 commands, 11 rules, 19 skills, 4 agents — organized in 11 packs with dependencies",
       "source": "./toolkit",
-      "version": "1.1.0"
+      "version": "1.2.1"
     }
   ]
 }

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "spartan-ai-toolkit",
-  "version": "1.1.0",
-  "description": "Engineering discipline layer for Claude Code — 5 workflows, 48 commands, 11 rules, 18 skills, 4 agents organized in 11 packs",
+  "version": "1.2.1",
+  "description": "Engineering discipline layer for Claude Code — 5 workflows, 51 commands, 11 rules, 19 skills, 4 agents organized in 11 packs",
   "author": {
     "name": "Khoa Tran",
     "url": "https://github.com/spartan-stratos"

package/VERSION

@@ -1 +1 @@
-1.1.0
+1.2.1

package/bin/cli.js

@@ -48,11 +48,15 @@ function blue(s) { return `${C.blue}${s}${C.reset}`; }
 
 // ── Pack definitions (loaded from YAML manifests) ───────────────
 import { PACKS, PACK_ORDER } from '../lib/packs.js';
-import { assembleCLAUDEmd } from '../lib/assembler.js';
-import { resolve as resolveDeps, resolveAliases, loadManifests } from '../lib/resolver.js';
+import { assembleCLAUDEmd, assembleAGENTSmd } from '../lib/assembler.js';
+import { resolve as resolveDeps, resolveAliases, loadManifests, loadExternalPacks } from '../lib/resolver.js';
+import { detectStacks } from '../lib/detector.js';
 
 const manifests = loadManifests(join(PKG_ROOT, 'packs'));
 
+// Maps community pack names to their source directory (for file resolution)
+const externalPackSources = {};
+
 // ── Parse args ──────────────────────────────────────────────────
 const args = process.argv.slice(2);
 
@@ -61,12 +65,18 @@ let packsArg = '';
 let installAll = false;
 let mode = 'global';  // default for claude-code
 let showHelp = false;
+let format = '';  // '' = default, 'agents-md' = export AGENTS.md
+let autoDetect = false;
+let packDirArg = '';  // external community pack directory
 
 for (const arg of args) {
   if (arg === '--help' || arg === '-h') showHelp = true;
   else if (arg.startsWith('--agent=')) agent = arg.split('=')[1];
   else if (arg.startsWith('--packs=')) packsArg = arg.split('=')[1];
+  else if (arg.startsWith('--format=')) format = arg.split('=')[1];
+  else if (arg.startsWith('--pack-dir=')) packDirArg = arg.split('=')[1];
   else if (arg === '--all') installAll = true;
+  else if (arg === '--auto') autoDetect = true;
   else if (arg === '--global') mode = 'global';
   else if (arg === '--local') mode = 'local';
 }
@@ -100,6 +110,9 @@ if (showHelp) {
                     Choices: claude-code, cursor, windsurf, codex, copilot
     --packs=LIST    Comma-separated packs (claude-code only)
                     Example: --packs=backend-micronaut,product
+    --auto          Auto-detect tech stack and suggest packs (no menu)
+    --pack-dir=DIR  Load community packs from an external directory
+    --format=NAME   Output format: agents-md (exports AGENTS.md for cross-tool use)
     --all           Install all packs
     --global        Install to home dir (default for claude-code/codex)
     --local         Install to current project dir
@@ -124,6 +137,12 @@ ${lines.join('\n')}`).join('\n')}
 
     ${cyan('npx spartan-ai-toolkit@latest --agent=cursor')}
       Install rules for Cursor (rules + AGENTS.md only)
+
+    ${cyan('npx spartan-ai-toolkit@latest --auto')}
+      Auto-detect your tech stack and install matching packs
+
+    ${cyan('npx spartan-ai-toolkit@latest --format=agents-md --packs=backend-micronaut')}
+      Export AGENTS.md for any AI coding tool
 `);
   process.exit(0);
 }
@@ -220,6 +239,11 @@ function copyDir(src, dest) {
   cpSync(src, dest, { recursive: true });
 }
 
+/** Get the source root for a pack (built-in uses PKG_ROOT, community uses pack-dir). */
+function getPackSource(packName) {
+  return externalPackSources[packName] || PKG_ROOT;
+}
+
 /** Get all items for a category across selected packs, deduplicated. */
 function gatherItems(selectedPacks, category) {
   const seen = new Set();
@@ -237,6 +261,24 @@ function gatherItems(selectedPacks, category) {
   return result;
 }
 
+/** Like gatherItems but includes the source root for each item (for community pack support). */
+function gatherItemsWithSource(selectedPacks, category) {
+  const seen = new Set();
+  const result = [];
+  for (const pack of selectedPacks) {
+    const def = PACKS[pack];
+    if (!def) continue;
+    const srcRoot = getPackSource(pack);
+    for (const item of def[category]) {
+      if (!seen.has(item)) {
+        seen.add(item);
+        result.push({ item, srcRoot });
+      }
+    }
+  }
+  return result;
+}
+
 // ── Pack selection (grouped menu) ───────────────────────────────
 async function selectPacks(targets) {
   // --all flag
@@ -253,6 +295,44 @@ async function selectPacks(targets) {
     return resolveDeps(aliased, manifests);
   }
 
+  // --auto flag: detect tech stack
+  if (autoDetect) {
+    const cwd = process.cwd();
+    console.log(`\n  ${blue('Scanning')} ${dim(cwd)} ${blue('for tech stack...')}\n`);
+    const { detected, comingSoon } = detectStacks(cwd);
+
+    if (detected.length > 0) {
+      console.log(`  ${bold('Detected stacks:')}`);
+      for (const d of detected) {
+        console.log(`    ${green('✓')} ${bold(d.pack)} ${dim(`(${d.reason})`)}`);
+      }
+
+      if (comingSoon.length > 0) {
+        console.log('');
+        for (const d of comingSoon) {
+          console.log(`    ${yellow('~')} ${d.pack} ${dim(`(${d.reason})`)} ${dim('— coming soon, skipped')}`);
+        }
+      }
+      console.log('');
+
+      const packNames = detected.map(d => d.pack);
+      const confirm = await ask(`  Install ${bold(packNames.join(' + '))}? [Y/n]: `);
+      if (confirm !== 'n' && confirm !== 'N') {
+        return resolveDeps(packNames, manifests);
+      }
+      // User said no — fall through to interactive menu
+      console.log('');
+    } else {
+      console.log(`  ${dim('No stacks detected.')}`);
+      if (comingSoon.length > 0) {
+        for (const d of comingSoon) {
+          console.log(`    ${yellow('~')} ${d.pack} ${dim(`(${d.reason})`)} ${dim('— coming soon')}`);
+        }
+      }
+      console.log(`  ${dim('Falling back to interactive menu...')}\n`);
+    }
+  }
+
   // Check saved packs
   if (existsSync(targets.packsFile)) {
     let saved = readFileSync(targets.packsFile, 'utf-8').trim().split('\n').filter(Boolean);
@@ -358,9 +438,9 @@ async function installFull() {
     cmdCount++;
   }
 
-  const selectedCommands = gatherItems(selectedPacks, 'commands');
-  for (const cmd of selectedCommands) {
-    const src = join(SRC.commandsSub, `${cmd}.md`);
+  const selectedCommands = gatherItemsWithSource(selectedPacks, 'commands');
+  for (const { item: cmd, srcRoot } of selectedCommands) {
+    const src = join(srcRoot, 'commands', 'spartan', `${cmd}.md`);
     if (existsSync(src)) {
       copyFile(src, join(targets.commands, `${cmd}.md`));
       console.log(`  ${green('+')} /spartan:${cmd}`);
@@ -372,14 +452,13 @@ async function installFull() {
   console.log(`  ${bold(cmdCount + ' commands')} installed\n`);
 
   // 3) Rules (now with subdirectory structure)
-  const selectedRules = gatherItems(selectedPacks, 'rules');
-  if (selectedRules.length > 0) {
+  const rulesWithSource = gatherItemsWithSource(selectedPacks, 'rules');
+  if (rulesWithSource.length > 0) {
     console.log(`${blue('[3/5]')} ${bold('Installing rules...')}`);
     let ruleCount = 0;
 
-    for (const rule of selectedRules) {
-      // Rules now have subdir paths like "database/SCHEMA.md"
-      const src = join(SRC.rules, rule);
+    for (const { item: rule, srcRoot } of rulesWithSource) {
+      const src = join(srcRoot, 'rules', rule);
       const dest = join(targets.rules, rule);
       if (existsSync(src)) {
         copyFile(src, dest);
@@ -393,14 +472,14 @@ async function installFull() {
   }
 
   // 4) Skills
-  const selectedSkills = gatherItems(selectedPacks, 'skills');
-  if (selectedSkills.length > 0) {
+  const skillsWithSource = gatherItemsWithSource(selectedPacks, 'skills');
+  if (skillsWithSource.length > 0) {
     console.log(`${blue('[4/5]')} ${bold('Installing skills...')}`);
     ensureDir(targets.skills);
     let skillCount = 0;
 
-    for (const skill of selectedSkills) {
-      const src = join(SRC.skills, skill);
+    for (const { item: skill, srcRoot } of skillsWithSource) {
+      const src = join(srcRoot, 'skills', skill);
       if (existsSync(src)) {
         copyDir(src, join(targets.skills, skill));
         console.log(`  ${green('+')} ${skill}`);
@@ -413,14 +492,14 @@ async function installFull() {
   }
 
   // 5) Agents
-  const selectedAgents = gatherItems(selectedPacks, 'agents');
-  if (selectedAgents.length > 0) {
+  const agentsWithSource = gatherItemsWithSource(selectedPacks, 'agents');
+  if (agentsWithSource.length > 0) {
     console.log(`${blue('[5/5]')} ${bold('Installing agents...')}`);
     ensureDir(targets.agents);
     let agentCount = 0;
 
-    for (const agentFile of selectedAgents) {
-      const src = join(SRC.agents, agentFile);
+    for (const { item: agentFile, srcRoot } of agentsWithSource) {
+      const src = join(srcRoot, 'agents', agentFile);
       if (existsSync(src)) {
         copyFile(src, join(targets.agents, agentFile));
         console.log(`  ${green('+')} ${agentFile.replace('.md', '')}`);
@@ -495,23 +574,15 @@ async function installRulesOnly() {
     console.log(`\n${blue('[1/2]')} ${bold('Rules')} — ${dim('no rule packs selected')}\n`);
   }
 
-  // Install AGENTS.md
+  // Install AGENTS.md — assembled from pack sections + agents
   console.log(`${blue('[2/2]')} ${bold('Installing AGENTS.md...')}`);
 
-  const allAgents = gatherItems([...PACK_ORDER], 'agents');
-  if (allAgents.length > 0 && targets.agentsMd) {
-    let agentsContent = '# Spartan AI Toolkit — Agents\n\n';
-    agentsContent += 'Expert agents for your AI coding assistant.\n\n---\n\n';
-    for (const agentFile of allAgents) {
-      const src = join(SRC.agents, agentFile);
-      if (existsSync(src)) {
-        agentsContent += readFileSync(src, 'utf-8') + '\n\n---\n\n';
-      }
-    }
-    writeFileSync(targets.agentsMd, agentsContent.trimEnd() + '\n', 'utf-8');
+  if (targets.agentsMd) {
+    const agentsContent = assembleAGENTSmd(SRC.claudeMd, SRC.agents, selectedPacks, PACKS);
+    writeFileSync(targets.agentsMd, agentsContent, 'utf-8');
     console.log(`  ${green('+')} AGENTS.md\n`);
   } else {
-    console.log(`  ${dim('No agents to install')}\n`);
+    console.log(`  ${dim('No AGENTS.md target')}\n`);
   }
 
   // Save selection
@@ -538,6 +609,49 @@ async function main() {
     process.exit(1);
   }
 
+  // Load community packs if --pack-dir is set
+  if (packDirArg) {
+    const packDirPath = pathResolve(process.cwd(), packDirArg);
+    const builtinNames = new Set(manifests.keys());
+    console.log(`\n  ${blue('Loading community packs from')} ${dim(packDirPath)}`);
+    const { loaded, errors } = loadExternalPacks(packDirPath, builtinNames);
+
+    if (errors.length > 0) {
+      for (const err of errors) {
+        console.log(`  ${yellow('!')} ${err}`);
+      }
+    }
+
+    if (loaded.size > 0) {
+      for (const [name, manifest] of loaded) {
+        manifests.set(name, manifest);
+        externalPackSources[name] = packDirPath;
+        // Add to PACKS and PACK_ORDER so menus and install work
+        PACKS[name] = {
+          description: manifest.description,
+          category: manifest.category || 'Community',
+          priority: manifest.priority ?? 500,
+          hidden: manifest.hidden || false,
+          comingSoon: manifest['coming-soon'] || false,
+          depends: manifest.depends || [],
+          commands: manifest.commands || [],
+          rules: manifest.rules || [],
+          skills: manifest.skills || [],
+          agents: manifest.agents || [],
+          claudeSections: manifest['claude-sections'] || [],
+        };
+        PACK_ORDER.push(name);
+      }
+      // Re-sort PACK_ORDER by priority
+      PACK_ORDER.sort((a, b) => (PACKS[a]?.priority ?? 999) - (PACKS[b]?.priority ?? 999));
+
+      const names = [...loaded.keys()].join(', ');
+      console.log(`  ${green('+')} Loaded: ${bold(names)}\n`);
+    } else {
+      console.log(`  ${dim('No valid community packs found')}\n`);
+    }
+  }
+
   let selectedPacks;
 
   try {
@@ -554,6 +668,16 @@ async function main() {
     closeRL();
   }
 
+  // Export AGENTS.md alongside normal install when --format=agents-md
+  if (format === 'agents-md' && (agent === 'claude-code' || agent === 'codex')) {
+    const cwd = process.cwd();
+    const agentsMdPath = join(cwd, 'AGENTS.md');
+    console.log(`${blue('[+]')} ${bold('Exporting AGENTS.md for cross-tool use...')}`);
+    const agentsContent = assembleAGENTSmd(SRC.claudeMd, SRC.agents, selectedPacks, PACKS);
+    writeFileSync(agentsMdPath, agentsContent, 'utf-8');
+    console.log(`  ${green('+')} AGENTS.md (works with Cursor, Copilot, Windsurf, Codex, and 20+ tools)\n`);
+  }
+
   // Success
   const userPacks = selectedPacks.filter(p => !PACKS[p]?.hidden);
   console.log(`${bold(green('================================================'))}`);

package/claude-md/01-core.md

@@ -3,16 +3,19 @@
 
 ## Core Principles (Always Enforce)
 
-### 1. Spec Before Code
+### 1. Match the User's Language
+**Detect the language of the user's message and respond entirely in that same language.** This is not optional — it overrides the default English behavior of all commands. If the user writes in Vietnamese, ALL output must be in Vietnamese. If in French, respond in French. If in English, respond in English. This applies to everything: explanations, questions, gate prompts, debug reports, summaries, and PR descriptions. Only code syntax, variable names, file paths, and command names (e.g., `/spartan:fix`) stay in their original form.
+
+### 2. Spec Before Code
 - Task < 1 day → `/spartan:quickplan` for fast spec + plan
 - Task > 1 day → `/spartan:project new` or `/spartan:project milestone-new`
 - Never write production code without a written spec or plan
 
-### 2. TDD is Non-Negotiable
+### 3. TDD is Non-Negotiable
 - Red → Green → Refactor, always
 - Write tests first, then the code that makes them pass
 
-### 3. Atomic Commits
+### 4. Atomic Commits
 Each commit = one task, tests passing:
 ```
 type(scope): what changed
@@ -21,7 +24,7 @@ type(scope): what changed
 ```
 Types: `feat` · `fix` · `test` · `refactor` · `chore` · `docs`
 
-### 4. Context Hygiene (Auto-Managed)
+### 5. Context Hygiene (Auto-Managed)
 Claude proactively manages its own context window:
 - When detecting context pressure (slow responses, forgetting earlier context, long conversation) → auto-run `/compact` to summarize and free space
 - If compaction isn't enough → auto-save critical state to `.handoff/` and `.memory/`, then tell user to start a fresh session
@@ -35,7 +38,7 @@ Claude proactively manages its own context window:
 - Response quality dropping → warn user + compact
 - Multi-step command taking unusually long → consider compacting between steps
 
-### 5. Auto Mode
+### 6. Auto Mode
 When user says **"auto on"** or **"auto mode"**, all Spartan commands skip confirmation prompts and execute straight through. Claude will:
 - Show the spec/plan/output but NOT pause to ask "does this match?" or "shall I proceed?"
 - Continue to the next step automatically after each step completes
@@ -46,49 +49,32 @@ Turn off with **"auto off"**. Default is **auto off** (commands ask for confirma
 
 Auto mode is ideal for experienced users who trust the workflow and want maximum velocity.
 
-### 6. Safety Guardrails
-Three levels of protection, activated on-demand:
+### 7. Safety Guardrails
 
 | Command | What it does |
 |---|---|
-| `/spartan:careful` | Warn + require confirm before destructive ops (rm -rf, DROP TABLE, force-push, etc.) |
-| `/spartan:freeze <dir>` | Lock file edits to ONE directory only (+ its test directory) |
-| `/spartan:guard <dir>` | Both careful + freeze at once. Maximum safety for production work. |
-
-**Careful mode overrides auto mode.** Even in auto mode, destructive operations always require "I confirm".
-
-**Freeze prevents scope creep.** Claude won't "helpfully" fix files outside your focus area.
-
-Deactivate: `/spartan:careful off`, `/spartan:unfreeze`, or `/spartan:guard off`.
+| `/spartan:careful` | Warn before destructive ops (rm -rf, DROP, force-push) |
+| `/spartan:freeze <dir>` | Lock edits to one directory only |
+| `/spartan:guard <dir>` | Both combined. Deactivate with `off` or `/spartan:unfreeze` |
 
 ---
 
 ## Core Commands (always available)
 
-### Build (daily task work)
-| Command | Purpose |
-|---|---|
-| `/spartan` | **Smart router** — asks what you need, routes to right command |
-| `/spartan:quickplan "task"` | Spec + plan + branch in one shot (< 1 day tasks) |
-| `/spartan:debug "symptom"` | 4-phase root-cause investigation + Debug Report |
-| `/spartan:init-project [name]` | Auto-generate project CLAUDE.md from codebase scan |
-
-### Ship
-| Command | Purpose |
-|---|---|
-| `/spartan:pr-ready` | Full pre-PR checklist + auto-generates PR description |
-
-### Ops (daily routine, session management)
+### Workflows (start here)
 | Command | Purpose |
 |---|---|
-| `/spartan:daily` | Standup summary from git log + GSD status |
-| `/spartan:context-save` | Smart context management: compact first, full save if needed |
-| `/spartan:update` | Check for updates and upgrade Spartan to latest version |
+| `/spartan` | **Smart router** — routes to the right workflow or command |
+| `/spartan:build [backend\|frontend] "feature"` | Full feature workflow: understand → plan → TDD → review → PR |
+| `/spartan:fix "symptom"` | Bug workflow: reproduce → investigate → fix → PR |
+| `/spartan:onboard` | Codebase understanding: scan → map → setup |
 
-### Safety (guardrails, on-demand)
+### Individual Commands
 | Command | Purpose |
 |---|---|
-| `/spartan:careful` | Warn + confirm before destructive ops (rm, DROP, force-push) |
-| `/spartan:freeze <dir>` | Lock file edits to one directory only |
-| `/spartan:unfreeze` | Remove directory lock |
-| `/spartan:guard <dir>` | Careful + freeze combined. Maximum safety. |
+| `/spartan:quickplan "task"` | Spec + plan + branch in one shot (< 1 day) |
+| `/spartan:pr-ready` | Pre-PR checklist + auto PR description |
+| `/spartan:daily` | Standup summary from git log |
+| `/spartan:init-project` | Auto-generate CLAUDE.md from codebase |
+| `/spartan:context-save` | Manage context: compact first, full save if needed |
+| `/spartan:update` | Upgrade Spartan to latest version |

package/claude-md/11-backend-micronaut.md

@@ -5,47 +5,9 @@
 
 **Stack:** Kotlin + Micronaut — coroutines, Either error handling, Exposed ORM
 
-Rules in `rules/backend-micronaut/` enforce coding standards:
-- `KOTLIN.md` — Null safety (`!!` banned), Either errors, enums, conversions, style
-- `CONTROLLERS.md` — Layered arch: Controller → Manager → Service/Repository, test patterns
-- `SERVICES_AND_BEANS.md` — Service vs Manager separation, 3-tier bean hierarchy
-- `API_DESIGN.md` — RPC-style, query params only (no path params), model location
-- `RETROFIT_PLACEMENT.md` — Never place Retrofit interfaces in kapt-enabled modules
+Rules in `rules/backend-micronaut/` and `rules/database/` are loaded automatically.
 
-> Full patterns: use /kotlin-best-practices or /backend-api-design skill
-
-### Feature Development Workflow (Backend)
-
-When building a backend feature, follow this pipeline:
-
-```
-Epic → Spec → Plan → Build → Review
-              ↑         ↑       ↑        ↑
-            Gate 1    Gate 2  Gate 3   Gate 4
-```
-
-**Build phases:** Database → Business Logic → API Layer → Tests
-
-See `templates/workflow-backend-micronaut.md` for the full workflow with:
-- Stack-specific quality gates (Kotlin rules, Exposed ORM checks, API conventions)
-- Concrete code patterns (Controller, Manager, Repository, Factory, DTO, Test)
-- Real file locations per module
-- Parallel vs sequential task planning
-
-For small tasks (< 1 day), `/spartan:quickplan` covers spec + plan in one shot.
-
-### Backend Skills
-
-- `/api-endpoint-creator` — Generate full Controller → Manager → Repository stack
-- `/backend-api-design` — RPC-style API design reference
-- `/kotlin-best-practices` — Null safety, Either, coroutines quick reference
-- `/testing-strategies` — Integration test patterns for Micronaut
-- `/security-checklist` — Auth, validation, OWASP prevention
-
-### Backend Agents
-
-- `micronaut-backend-expert` — Deep Micronaut framework expertise
-- `solution-architect-cto` — Strategic tech decisions, system design
+**Workflow:** `/spartan:build backend "feature"` handles the full pipeline (plan → migration → endpoint → tests → review → PR).
 
 ### Backend Commands
 
@@ -53,4 +15,5 @@ For small tasks (< 1 day), `/spartan:quickplan` covers spec + plan in one shot.
 |---|---|
 | `/spartan:kotlin-service [name]` | Scaffold Micronaut microservice |
 | `/spartan:review` | PR review with Kotlin/Micronaut conventions |
-| `/spartan:testcontainer [type]` | Setup Testcontainers (postgres/kafka/redis) |
+| `/spartan:testcontainer [type]` | Setup Testcontainers |
+| `/spartan:migration "desc"` | Create database migration |

package/claude-md/20-frontend-react.md

@@ -42,3 +42,4 @@ For small tasks (< 1 day), `/spartan:quickplan` covers spec + plan in one shot.
 | `/spartan:fe-review` | PR review with Next.js App Router conventions |
 | `/spartan:figma-to-code [url]` | Convert Figma screen to production code via MCP |
 | `/spartan:e2e [feature]` | Scaffold Playwright E2E testing |
+| `/spartan:qa [url] [feature]` | Real browser QA — opens Chromium, tests flows, finds bugs |

package/claude-md/60-research.md

@@ -3,73 +3,25 @@
 
 ## Startup Research Pipeline
 
-A 4-stage pipeline from idea to investor-ready materials. Each stage has a gate — don't skip ahead.
+**Workflows:**
+- `/spartan:startup "idea"` — Full pipeline: brainstorm → validate → research → pitch
+- `/spartan:research "topic"` — Deep research with source tracking and report
 
-**The pipeline:**
-```
-STAGE 1: DISCOVER     STAGE 2: FILTER      STAGE 3: DIG          STAGE 4: BUILD
-───────────────       ──────────────       ─────────────         ──────────────
-/spartan:kickoff      /spartan:validate    /spartan:research     /spartan:pitch
-/spartan:brainstorm                        /spartan:deep-dive    /spartan:outreach
-                                           /spartan:teardown     /spartan:fundraise
+**Stage shortcuts** (jump to a specific stage):
 
- 8-15 ideas     →     GO/TEST/PASS   →    Market + rivals  →    Deck + emails
- Pick top 3           Kill bad ones        Real numbers          Ready to send
-```
-
-### Combo Commands
-
-| Command | Stages | What It Does |
-|---|---|---|
-| `/spartan:kickoff "theme"` | 1 → 2 | Create project + brainstorm + validate top picks |
-| `/spartan:deep-dive "project"` | 3 | Market research + competitor teardowns + synthesis |
-| `/spartan:fundraise "project"` | 4 | Pitch deck + one-pager + investor emails |
-| `/spartan:full-run "theme"` | 1 → 4 | Whole pipeline with pauses at every gate |
-
-### Single Commands
-
-| Command | Purpose |
-|---|---|
-| `/spartan:research "topic"` | Deep research with web search and structured report |
-| `/spartan:pitch "type"` | Create investor materials (deck, memo, one-pager) |
-| `/spartan:outreach "investor"` | Draft personalized investor emails |
-| `/spartan:content "source"` | Turn research into platform-native content |
-| `/spartan:write "topic"` | Write blog posts and articles (human voice, no AI slop) |
-
-### Research Skills
-
-These skills are used by the commands above. You can also use them directly.
-
-| Skill | What It Does |
-|---|---|
-| `brainstorm` | Generate and filter startup ideas |
-| `idea-validation` | Score ideas: GO / TEST MORE / PASS |
-| `market-research` | TAM/SAM/SOM, trends, demand signals |
-| `competitive-teardown` | Deep competitor analysis |
-| `deep-research` | Web research with source checking |
-| `investor-materials` | Pitch decks, one-pagers, memos |
-| `investor-outreach` | Personalized investor emails |
-| `article-writing` | Blog posts and long-form content |
-| `content-engine` | Platform-native content from research |
-| `startup-pipeline` | Orchestrates the full pipeline |
-
-### Research Agents
-
-| Agent | Role |
+| Command | Stage |
 |---|---|
-| `research-planner` | Plans research before doing it |
-| `idea-killer` | Finds every flaw in your idea |
+| `/spartan:kickoff "theme"` | Brainstorm + validate |
+| `/spartan:deep-dive "project"` | Market research + teardowns |
+| `/spartan:fundraise "project"` | Pitch + outreach |
 
-### Frameworks & Templates
+**Other commands:** `pitch`, `outreach`, `content`, `write`
 
-Reference materials available in the toolkit:
-- **12 frameworks**: Lean Canvas, Design Sprint, Business Model Canvas, JTBD, Mom Test, Value Proposition Canvas, and more
-- **13 templates**: Idea canvas, competitor analysis, user interview, validation checklist, PRD, project readme, epic, feature spec, implementation plan, quality gates, design doc, workflow-backend-micronaut, workflow-frontend-react
+**Agents:** `research-planner` (plans research), `idea-killer` (stress-tests ideas)
 
 ### Rules
 
-- Be a brutal, honest startup advisor. No sugarcoating.
+- Be a brutal, honest advisor. No sugarcoating.
 - Ask tough questions when ideas are vague.
-- Always analyze competitors and risks.
 - Push for validation before building.
 - Save research outputs in the right stage folder.