@c0x12c/spartan-ai-toolkit 1.6.1 → 1.6.2

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "spartan-ai-toolkit",
       "description": "5 workflows, 56 commands, 12 rules, 22 skills, 7 agents — organized in 11 packs with dependencies",
       "source": "./toolkit",
-      "version": "1.6.1"
+      "version": "1.6.2"
     }
   ]
 }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "spartan-ai-toolkit",
-  "version": "1.6.1",
+  "version": "1.6.2",
   "description": "Engineering discipline layer for Claude Code — 5 workflows, 56 commands, 12 rules, 22 skills, 7 agents organized in 11 packs",
   "author": {
     "name": "Khoa Tran",

package/VERSION

@@ -1 +1 @@
-1.6.1
+1.6.2

package/commands/spartan/build.md

@@ -165,7 +165,7 @@ If user picks B → continue to Plan.
 
 If user picks C → read the Figma reference and use it as the design source.
 
-**Auto mode on?** → Skip for small UI changes (adding a column to a table, a toggle). Run for new screens/pages.
+**Auto mode on?** → Still ask this question. Design skipping is the user's call, not yours. The only exception: if the ONLY UI change is a single field addition to an existing component (e.g., adding a column to a table), skip silently.
 
 ---
 
@@ -243,33 +243,63 @@ Write the first failing test for Task 1. Show it fails.
 
 ## Stage 3: Implement
 
-### Agent Teams boost (if enabled)
+### Auto-parallelize with Agent Teams
 
 ```bash
 echo "${CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS:-not_set}"
 ```
 
-**If Agent Teams is enabled AND the plan has 4+ tasks AND the feature is full-stack:**
+**If Agent Teams is enabled:** Look at the plan and auto-detect parallelism. If 2+ tasks in the plan can run at the same time (no dependency between them), use Agent Teams automatically. Don't ask — just do it.
 
-Offer to parallelize implementation with Agent Teams:
-> "This has [N] tasks across backend and frontend. Want me to spin up a build team?
->
-> I'd go with **A** — parallel tracks save time on full-stack work.
->
-> - **A) Build team** — one backend agent + one frontend agent, working in parallel (uses more tokens)
-> - **B) Sequential** — I'll do all tasks one by one (cheaper, simpler)"
-
-If user picks A:
-1. Use `TeamCreate` with name `build-{feature-slug}`
-2. Create tasks from the plan — backend tasks assigned to `backend-dev`, frontend tasks to `frontend-dev`
-3. Set `addBlockedBy` for frontend tasks that need backend API first
-4. Spawn two agents with `isolation: "worktree"`:
-   - **backend-dev** — gets backend tasks, relevant Kotlin/Micronaut rules
-   - **frontend-dev** — gets frontend tasks, relevant React/Next.js rules
-5. Monitor progress. When both finish, merge worktrees and run full test suite.
-6. After completion, use `TeamDelete` to clean up.
-
-If user picks B (or Agent Teams not enabled), continue with sequential execution below.
+**When to parallelize (auto-trigger):**
+- Full-stack: backend + frontend tracks are always parallel (frontend blocked only by its API dependency, not all backend tasks)
+- Backend-only with 4+ tasks: data-layer tasks vs API-layer tasks can often run in parallel
+- Frontend-only with 4+ tasks: independent components/pages can run in parallel
+- Any mode where the plan has 2+ tasks with no dependency on each other
+
+**When NOT to parallelize:**
+- Only 1-3 small sequential tasks — overhead isn't worth it
+- All tasks depend on each other in a chain
+- Agent Teams env var is not set
+
+**How to run it:**
+
+1. Check for design doc:
+```bash
+ls .planning/designs/*.md 2>/dev/null
+```
+
+2. Use `TeamCreate` with name `build-{feature-slug}`.
+
+3. Create tasks from the plan. Set `addBlockedBy` for real dependencies only.
+
+4. Spawn agents with `isolation: "worktree"`. Split by mode:
+
+**Full-stack** — two agents:
+- **backend-dev** — backend tasks, Kotlin/Micronaut rules
+- **frontend-dev** — frontend tasks, React/Next.js rules, design doc
+
+**Backend-only** — split by layer:
+- **data-layer** — migration + entity + repository
+- **api-layer** — service + controller (blocked by data-layer)
+
+**Frontend-only** — split by concern:
+- **components-dev** — types + components + API client
+- **pages-dev** — pages + routing + integration (blocked by components-dev)
+
+**Design doc handoff (MANDATORY for frontend/UI agents):**
+If a design doc exists at `.planning/designs/`, EVERY frontend/UI agent MUST get this in its prompt:
+```
+Design doc: .planning/designs/{feature}.md — read this FIRST.
+Follow the screen designs, component specs, and visual details exactly.
+Do NOT invent your own layout or design. The design was already reviewed and approved.
+```
+
+5. Monitor progress. When all agents finish, merge worktrees and run full test suite.
+
+6. `TeamDelete` to clean up.
+
+**If Agent Teams is NOT enabled** (env var not set), continue with sequential execution below.
 
 ### Sequential execution (default)
 

package/commands/spartan/phase.md

@@ -61,29 +61,22 @@ If the user has multiple Claude Code tabs available, suggest:
 
 Running the planned tasks wave by wave.
 
-### Agent Teams boost (if enabled)
+### Auto-parallelize with Agent Teams
 
 ```bash
 echo "${CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS:-not_set}"
 ```
 
-**If Agent Teams is enabled AND the wave plan has 2+ parallel work units in any wave:**
+**If Agent Teams is enabled AND the current wave has 2+ parallel work units:** Use Agent Teams automatically. Don't ask — just do it. This replaces manual multi-tab work.
 
-Offer to use Agent Teams for wave execution:
-> "Wave 1 has [N] parallel work units. Want me to use Agent Teams?
->
-> I'd go with **A** — it automates what you'd do manually across tabs.
->
-> - **A) Agent Teams** — one agent per WU, worktree isolation, auto-advance between waves
-> - **B) Manual** — I'll execute sequentially, or you open multiple tabs yourself"
-
-If user picks A → run `/spartan:team wave` internally. This:
+Run `/spartan:team wave` internally. This:
 1. Creates a team from the wave plan
 2. Spawns one agent per WU with worktree isolation
-3. Verifies tests pass between waves
-4. Auto-advances to the next wave
+3. Passes design docs to any UI-related WUs (check `.planning/designs/`)
+4. Verifies tests pass between waves
+5. Auto-advances to the next wave
 
-If user picks B (or Agent Teams not enabled) → continue with default execution:
+**If Agent Teams is NOT enabled** (env var not set) → continue with default execution:
 
 **Run:** `/gsd:execute-phase {{ args[1] | default: "N" }}`
 

package/commands/spartan/team.md

@@ -364,13 +364,16 @@ Spin up a parallel implementation team for a feature.
 
 ### Step 1: Understand the feature
 
-Check for existing spec/plan:
+Check for existing artifacts:
 ```bash
 ls .planning/specs/ .planning/PLAN.md 2>/dev/null
+ls .planning/designs/*.md 2>/dev/null
 ```
 
 If no spec exists, tell user: "No spec found. Run `/spartan:spec` first, or describe the feature and I'll split it into parallel work."
 
+If a design doc exists, note its path — you'll pass it to frontend/UI agents in Step 5.
+
 ### Step 2: Detect stack and split work
 
 ```bash
@@ -402,6 +405,7 @@ Each builder agent gets:
 - Instructions to follow TDD
 - References to relevant rules from installed packs
 - `.memory/` context
+- **Design doc path** (if `.planning/designs/*.md` exists) — frontend/UI agents MUST read the design doc before building. Include in prompt: "Read `.planning/designs/{feature}.md` FIRST. Follow screen designs and component specs exactly."
 
 ### Step 6: Integration
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c0x12c/spartan-ai-toolkit",
-  "version": "1.6.1",
+  "version": "1.6.2",
   "description": "Engineering discipline layer for AI coding agents — commands, rules, skills, agents, and packs for Claude Code",
   "type": "module",
   "bin": {