@c0x12c/spartan-ai-toolkit 1.2.0 → 1.3.0

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, 53 commands, 11 rules, 19 skills, 4 agents — organized in 11 packs with dependencies",
       "source": "./toolkit",
-      "version": "1.2.0"
+      "version": "1.3.0"
     }
   ]
 }

package/.claude-plugin/plugin.json

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

package/README.md

@@ -66,7 +66,8 @@ After install, open any project, run `claude`, then type `/spartan`.
 **Direct commands** — one command, one job. Best when you know what step you need. Saves tokens.
 
 ```
-/spartan:quickplan "task"   ← just the planning step
+/spartan:spec "feature"    ← write the spec
+/spartan:plan "feature"    ← plan the implementation
 /spartan:review             ← just the code review
 /spartan:pr-ready           ← just the PR creation
 /spartan:migration "desc"   ← just the migration
@@ -135,7 +136,7 @@ npx @c0x12c/spartan-ai-toolkit@latest --all
 
 | Pack | Category | Depends on | What you get |
 |------|----------|------------|--------------|
-| **core** | Core | — | Always installed. Workflows (build, fix, onboard), quickplan, pr-ready, daily, safety commands |
+| **core** | Core | — | Always installed. Workflows (build, fix, onboard), spec, plan, pr-ready, daily, safety commands |
 | **backend-micronaut** | Backend | database, shared-backend | Kotlin service scaffold, code review, testcontainers, API/DB/Kotlin rules, 5 skills, 2 agents |
 | **backend-nodejs** | Backend | database, shared-backend | Coming soon |
 | **backend-python** | Backend | database, shared-backend | Coming soon |
@@ -151,7 +152,7 @@ Hidden packs (`database`, `shared-backend`) get pulled in as dependencies — yo
 
 ## Commands
 
-All commands start with `/spartan:` (e.g., `/spartan:quickplan "task"`).
+All commands start with `/spartan:` (e.g., `/spartan:spec "feature"`).
 
 Type `/spartan` to get the smart router — it asks what you need and picks the right command.
 
@@ -167,7 +168,8 @@ Type `/spartan` to get the smart router — it asks what you need and picks the
 ### Core (always installed)
 | Command | What it does |
 |---------|-------------|
-| `quickplan "task"` | Task < 1 day — spec + plan + branch in one shot |
+| `spec "feature"` | Write a feature spec — saves to `.planning/specs/` |
+| `plan "feature"` | Write implementation plan from spec — saves to `.planning/plans/` |
 | `daily` | Standup summary from git history |
 | `pr-ready` | Full checklist before creating any PR |
 | `init-project` | Auto-generate CLAUDE.md from codebase scan |

package/VERSION

@@ -1 +1,2 @@
-1.2.0
+1.3.0
+

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/00-header.md

@@ -34,6 +34,6 @@ What do you need?
 | Size | Use |
 |---|---|
 | < 30 min, ≤ 3 files | Just ask Claude (no command needed) |
-| < 1 day | `/spartan:quickplan` |
-| 1–3 days | `/spartan:project new` (lightweight lifecycle) |
+| < 1 day | `/spartan:spec` → `/spartan:build` |
+| 1–3 days | `/spartan:spec` → `/spartan:plan` → `/spartan:build` |
 | > 3 days, multi-session | `/spartan:project new` (full lifecycle) |

package/claude-md/01-core.md

@@ -3,16 +3,19 @@
 
 ## Core Principles (Always Enforce)
 
-### 1. Spec Before Code
-- Task < 1 day → `/spartan:quickplan` for fast spec + plan
+### 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:spec` + `/spartan:plan` + `/spartan:build`
 - 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,7 +49,7 @@ 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
+### 7. Safety Guardrails
 
 | Command | What it does |
 |---|---|
@@ -58,6 +61,19 @@ Auto mode is ideal for experienced users who trust the workflow and want maximum
 
 ## Core Commands (always available)
 
+### Feature Workflow
+```
+/spartan:epic → /spartan:spec → [/spartan:design] → /spartan:plan → /spartan:build → /spartan:pr-ready
+                     ↑                                    ↑                ↑                ↑
+                   Gate 1                               Gate 2         Gate 3            Gate 4
+```
+
+| Size | Path |
+|---|---|
+| Single feature | `/spartan:spec` → `/spartan:plan` → `/spartan:build` |
+| Batch of features (1-2 weeks) | `/spartan:epic` → then spec/plan/build each feature |
+| Multi-week project | `/spartan:project new` → milestones + phases |
+
 ### Workflows (start here)
 | Command | Purpose |
 |---|---|
@@ -66,10 +82,16 @@ Auto mode is ideal for experienced users who trust the workflow and want maximum
 | `/spartan:fix "symptom"` | Bug workflow: reproduce → investigate → fix → PR |
 | `/spartan:onboard` | Codebase understanding: scan → map → setup |
 
+### Spec & Plan (saved artifacts)
+| Command | Purpose |
+|---|---|
+| `/spartan:spec "feature"` | Write a feature spec → saves to `.planning/specs/` → Gate 1 |
+| `/spartan:plan "feature"` | Write implementation plan from spec → saves to `.planning/plans/` → Gate 2 |
+| `/spartan:epic "name"` | Break big work into ordered features → saves to `.planning/epics/` |
+
 ### Individual Commands
 | Command | Purpose |
 |---|---|
-| `/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 |

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

@@ -27,7 +27,7 @@ See `templates/workflow-frontend-react.md` for the full workflow with:
 - File location guide (App Router conventions)
 - Parallel vs sequential task planning
 
-For small tasks (< 1 day), `/spartan:quickplan` covers spec + plan in one shot.
+For any feature, use `/spartan:spec` → `/spartan:plan` → `/spartan:build`.
 
 ### Frontend Skills
 
@@ -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/30-project-mgmt.md

@@ -5,6 +5,7 @@
 
 | Command | Purpose |
 |---|---|
+| `/spartan:epic "name"` | Break big work into ordered features → each goes through spec → plan → build |
 | `/spartan:project [action]` | Manage large projects: `new`, `status`, `milestone-new`, `milestone-complete`, `milestone-summary`, `manager` |
 | `/spartan:phase [action] [N]` | Manage phases: `discuss`, `plan`, `execute`, `verify` |
 | `/spartan:workstreams [action]` | Parallel workstreams: `list`, `create`, `switch`, `status`, `progress`, `complete`, `resume` |

package/claude-md/40-product.md

@@ -19,7 +19,9 @@ These commands help you think deep before writing code. Use them when starting a
        ↓
 /spartan:think "feature"          ← 6-phase deep thinking before code
        ↓
-/spartan:quickplan "task"         ← Then build it
+/spartan:spec "task"              ← Write the spec
+/spartan:plan "task"              ← Plan the work
+/spartan:build "task"             ← Then build it
 ```
 
 You don't have to use all of them. Pick what fits your stage.

package/commands/spartan/brownfield.md

@@ -154,4 +154,4 @@ This prevents scope creep and keeps each change independently reviewable.
 
 After analysis, present the Context Map summary and ask:
 "Analysis complete. What change would you like to make first?
-I'll create a change folder and use `/spartan:quickplan` for it."
+I'll create a change folder and use `/spartan:spec` → `/spartan:build` for it."

package/commands/spartan/build.md

@@ -52,13 +52,21 @@ ls .planning/PROJECT.md 2>/dev/null && echo "GSD_ACTIVE"
 
 ## Stage 1: Understand
 
-**Ask 3 forcing questions. Always. Even in auto mode.**
+**First, check for a saved spec:**
+```bash
+ls .planning/specs/*.md 2>/dev/null
+```
+
+If a spec exists for this feature (matching the feature name), read it and use it as the scope. Skip the 3 questions — the spec already answered them. Show:
+> "Found spec: `.planning/specs/{name}.md` — using it as scope."
+
+If no spec exists, **ask 3 forcing questions. Always. Even in auto mode.**
 
 1. **"What pain does this solve?"** — Not the feature. The pain. If the user says "add a profiles endpoint" ask what user problem it fixes.
 2. **"What's the narrowest version we can ship?"** — Force MVP thinking. Cut scope until it hurts.
 3. **"What assumption could be wrong?"** — Surface hidden risks early.
 
-After the user answers, produce a scope block:
+After the user answers (or after reading the spec), produce a scope block:
 
 ```markdown
 ## Scope: [feature name]
@@ -86,10 +94,21 @@ After the user answers, produce a scope block:
 
 ## Stage 2: Plan
 
+### Check for saved plan
+
+```bash
+ls .planning/plans/*.md 2>/dev/null
+```
+
+If a plan exists for this feature, read it and use it. Skip the inline planning — go straight to Stage 3 (Implement). Show:
+> "Found plan: `.planning/plans/{name}.md` — using it."
+
+If no plan exists, do the size check below.
+
 ### Size check
 
 Count the expected work:
-- **Small** (1-4 tasks, < 1 day): Inline plan right here. Like a mini-quickplan.
+- **Small** (1-4 tasks, < 1 day): Inline plan right here.
 - **Big** (5+ tasks, multi-day): Use `/spartan:phase plan` for a full wave-parallel plan.
 
 ### Inline plan format (small features)