@kennethsolomon/shipkit 3.9.0 → 3.10.0

package/README.md

@@ -41,18 +41,23 @@ npm install -g @kennethsolomon/shipkit && shipkit
 /sk:setup-claude
 
 # 3. Start building
-/sk:brainstorm
+/sk:start
 ```
 
 That's it. `/sk:setup-claude` creates your project scaffolding: planning files, lifecycle hooks, path-scoped coding rules, and a persistent statusline — all auto-configured for your stack.
 
+`/sk:start` is the recommended entry point — it classifies your task and routes you to the optimal flow automatically. You can also jump directly to `/sk:brainstorm`, `/sk:debug`, or any other flow entry point.
+
 ---
 
 ## Pick Your Flow
 
 | I want to... | Run this | What happens |
 |--------------|----------|-------------|
+| **Not sure — let ShipKit decide** | `/sk:start` | Classifies your task, routes to optimal flow/mode/agents |
 | **Build a new feature** | `/sk:brainstorm` | Full workflow: plan → TDD → 6 quality gates → PR |
+| **Build hands-free** | `/sk:autopilot` | All 21 steps, auto-skip, auto-advance, auto-commit |
+| **Full-stack feature (parallel)** | `/sk:team` | Parallel domain agents (backend + frontend + QA) |
 | **Make a small change** | `/sk:fast-track` | Skip planning, keep all quality gates |
 | **Fix a bug** | `/sk:debug` | Investigate → regression test → fix → gates → PR |
 | **Fix a production emergency** | `/sk:hotfix` | Skip TDD, but quality gates still enforced |
@@ -204,12 +209,13 @@ Use these anytime — they're not part of any workflow.
 ## All Commands
 
 <details>
-<summary><strong>35 commands</strong> — click to expand</summary>
+<summary><strong>38 commands</strong> — click to expand</summary>
 
 | Command | Purpose |
 |---------|---------|
 | `/sk:accessibility` | WCAG 2.1 AA audit |
 | `/sk:api-design` | Design API contracts before implementation |
+| `/sk:autopilot` | Hands-free workflow — auto-skip, auto-advance, auto-commit |
 | `/sk:brainstorm` | Explore requirements and design |
 | `/sk:branch` | Create feature branch from current task |
 | `/sk:change` | Handle mid-workflow requirement changes |
@@ -243,7 +249,9 @@ Use these anytime — they're not part of any workflow.
 | `/sk:set-profile` | Switch model routing profile |
 | `/sk:setup-claude` | Bootstrap project scaffolding |
 | `/sk:smart-commit` | Conventional commit with approval |
+| `/sk:start` | Smart entry point — classifies task, routes to optimal flow |
 | `/sk:status` | Show workflow + task status |
+| `/sk:team` | Parallel domain agents for full-stack tasks |
 | `/sk:test` | Run all test suites |
 | `/sk:update-task` | Mark task done |
 | `/sk:write-plan` | Write plan to `tasks/todo.md` |

package/commands/sk/autopilot.md

@@ -0,0 +1,22 @@
+---
+description: "Hands-free workflow — all 21 steps, auto-skip, auto-advance, auto-commit. Stops only for direction approval and PR push."
+---
+
+# /sk:autopilot
+
+Run the full ShipIt workflow in hands-free mode.
+
+Usage: `/sk:autopilot <task description>`
+
+Executes all 21 workflow steps with:
+- **Auto-skip** — optional steps skipped when clearly not needed
+- **Auto-advance** — no manual step transitions
+- **Auto-commit** — conventional format, no approval prompt
+- **Same quality gates** — all gates enforced, same fix loops
+
+Stops only for:
+1. Direction approval (after brainstorm)
+2. 3-strike failures
+3. PR push confirmation
+
+See `skills/sk:autopilot/SKILL.md` for full details.

package/commands/sk/set-profile.md

@@ -28,6 +28,8 @@ Valid profiles: `full-sail` · `quality` · `balanced` · `budget`
 | perf, schema-migrate, accessibility | opus | sonnet | sonnet | haiku |
 | lint, test | sonnet | sonnet | haiku | haiku |
 | smart-commit, branch, update-task | haiku | haiku | haiku | haiku |
+| autopilot, team | opus | opus | sonnet | sonnet |
+| start | haiku | haiku | haiku | haiku |
 
 Note: `opus` = inherit (uses the current session model). Switch to Opus 4.5 in your session to get the full benefit.
 
@@ -66,6 +68,8 @@ Model assignments for this project:
   perf, schema-migrate, accessibility → <model>
   lint, test → <model>
   smart-commit, branch, update-task → haiku
+  autopilot, team → <model>
+  start → haiku
 
 Run /sk:config to see all settings or make further changes.
 ```

package/commands/sk/start.md

@@ -0,0 +1,30 @@
+---
+description: "Smart entry point — classifies your task and routes to the optimal flow, mode, and agent strategy."
+---
+
+# /sk:start
+
+Smart entry point for all ShipIt work. Classifies your task and recommends the best workflow configuration.
+
+Usage: `/sk:start <task description>`
+
+Examples:
+```
+/sk:start add user profile page with avatar upload
+/sk:start fix login redirect loop
+/sk:start urgent: payments failing in production
+/sk:start bump lodash to latest version
+```
+
+**What it does:**
+1. **Classifies** — detects if it's a feature, bug, hotfix, or small change
+2. **Detects scope** — full-stack, frontend-only, or backend-only
+3. **Recommends** — optimal flow + mode (autopilot/manual) + agents (team/solo)
+4. **Routes** — enters the chosen workflow after your confirmation
+
+**Override flags:**
+- `--manual` — force step-by-step mode
+- `--team` / `--no-team` — force team or solo agents
+- `--debug` / `--hotfix` / `--fast-track` — force a specific flow
+
+See `skills/sk:start/SKILL.md` for full details.

package/commands/sk/team.md

@@ -0,0 +1,23 @@
+---
+description: "Parallel domain agents — spawns Backend, Frontend, and QA agents for full-stack implementation."
+---
+
+# /sk:team
+
+Split implementation across parallel domain agents.
+
+Usage: `/sk:team`
+
+Spawns 3 specialized agents in parallel:
+- **Backend Agent** (worktree) — backend tests + implementation
+- **Frontend Agent** (worktree) — frontend tests + implementation
+- **QA Agent** (background) — E2E test scenarios
+
+**Prerequisite:** Plan must contain an explicit API contract section.
+
+Falls back to single-agent mode if:
+- No API contract in plan
+- Backend-only or frontend-only task
+- Worktree creation fails
+
+See `skills/sk:team/SKILL.md` for full details.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kennethsolomon/shipkit",
-  "version": "3.9.0",
+  "version": "3.10.0",
   "description": "A structured workflow toolkit for Claude Code.",
   "keywords": [
     "claude",

package/skills/.claude/settings.local.json

@@ -0,0 +1,18 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(bash tests/verify-workflow.sh)",
+      "Bash(git add:*)",
+      "Bash(git commit:*)",
+      "Bash(node:*)",
+      "Bash(npm audit:*)",
+      "Bash(for f:*)",
+      "Bash(do echo:*)",
+      "Bash(bash -n \"$f\")",
+      "Bash(done)",
+      "Bash(tasks/security-findings.md:*)",
+      "Bash(git push:*)",
+      "Bash(git tag:*)"
+    ]
+  }
+}

package/skills/sk:autopilot/SKILL.md

@@ -0,0 +1,151 @@
+---
+name: sk:autopilot
+description: Hands-free workflow — runs all 21 steps with auto-skip, auto-advance, auto-commit. Stops only for direction approval, 3-strike failures, and PR push.
+user_invocable: true
+allowed_tools: Read, Write, Bash, Glob, Grep, Agent, Skill
+---
+
+# Autopilot Mode
+
+Hands-free workflow that executes all 21 steps of the ShipIt workflow with minimal interruptions. Same quality gates, same fix loops, same 100% coverage — just fewer stops.
+
+## When to Use
+
+- You know roughly what you want built and trust the workflow to handle details
+- You want to minimize context switches and manual step advancement
+- The task is well-defined enough for a single direction-approval checkpoint
+
+## When NOT to Use
+
+- Exploratory work where you want to steer each step
+- Tasks requiring frequent design decisions mid-implementation
+- When you want to review intermediate outputs before proceeding
+
+## Quality Guarantee
+
+Autopilot runs the EXACT same 21 steps as manual mode:
+- ALL quality gates enforced (lint, test, security, perf, review, e2e)
+- ALL fix-commit-rerun loops active
+- 100% test coverage required on new code
+- 0 security issues required
+- The ONLY difference: auto-advance between steps instead of stopping
+
+## Steps
+
+### 0. Reset Tracker
+
+Read `tasks/workflow-status.md`. If it has done/skipped steps from a different task, auto-reset all steps to `not yet`.
+
+### 1. Load Context (auto — no prompt)
+
+- Read `tasks/todo.md`
+- Read `tasks/lessons.md` (apply all active lessons as constraints)
+- Read `tasks/findings.md` (if exists)
+- Read `tasks/tech-debt.md` (if exists)
+
+### 2. Brainstorm + Direction Approval (STOP — requires user input)
+
+Run brainstorm internally:
+- Explore the codebase (3 parallel Explore agents)
+- Propose 2-3 approaches with trade-offs
+
+**Present ONE direction summary and ask:**
+> "Direction: [1-2 sentence summary of chosen approach]
+> Scope: [what will be built/changed]
+> Auto-skipping: [list of steps that will be auto-skipped and why]
+> Proceed? (y/n)"
+
+Wait for explicit `y` before continuing. This is the ONLY planning stop.
+
+### 3. Plan (auto-advance)
+
+Write the implementation plan to `tasks/todo.md`. Do NOT ask for plan approval — the direction approval in step 2 covers this.
+
+### 4. Branch (auto-advance)
+
+Create feature branch auto-named from the task. Do NOT ask for confirmation.
+
+### 5. Auto-Skip Detection
+
+Scan `tasks/todo.md` for frontend/backend/database keywords. For each optional step:
+- **Design (step 4)**: auto-skip if no frontend keywords
+- **Accessibility (step 5)**: auto-skip if no frontend keywords
+- **Migrate (step 8)**: auto-skip if no database keywords
+- **Performance (step 15)**: auto-skip if no frontend AND no database keywords
+
+Log each auto-skip: `Auto-skipped: [Step Name] ([reason])`
+
+### 6. Write Tests (auto-advance)
+
+Write failing tests based on the plan (TDD red phase). Auto-advance when done.
+
+### 7. Implement (auto-advance)
+
+Execute the plan — make failing tests pass. Use wave-based sub-agents for parallel work where possible.
+
+### 8. Commit (auto-commit)
+
+Auto-commit with conventional commit format. Do NOT ask for commit message approval.
+Format: `type(scope): description`
+
+### 9. Gates (auto-advance on clean pass)
+
+Run all quality gates. Use `/sk:gates` if available, otherwise run sequentially:
+1. Lint + dep audit
+2. Test (100% coverage)
+3. Security (0 issues)
+4. Performance (if not auto-skipped)
+5. Review + simplify
+6. E2E
+
+Each gate auto-fixes and re-runs internally. Auto-advance to next gate on clean pass.
+
+### 10. PR Push (STOP — requires user confirmation)
+
+**This is the second mandatory stop.** Present:
+> "All gates passed. Ready to create PR.
+> Title: [conventional format]
+> Changes: [file count] files, [line count] lines
+> Confirm push + PR? (y/n)"
+
+Wait for explicit confirmation — pushing is visible to others.
+
+### 11. Finalize (auto-advance)
+
+- Create PR
+- Sync features (`/sk:features`)
+- Ask about release (step 21 is never auto-skipped)
+
+## 3-Strike Protocol
+
+If any step fails 3 times:
+- **STOP immediately**
+- Report: what failed, what was tried, error details
+- Ask user for guidance before continuing
+- This overrides auto-advance — 3 strikes always stops
+
+## Stops Summary
+
+| Stop | When | Why |
+|------|------|-----|
+| Direction approval | After brainstorm (step 2) | User must approve the approach |
+| 3-strike failure | Any step fails 3x | Needs human judgment |
+| PR push | Before creating PR (step 10) | Visible to others — always confirm |
+
+Everything else auto-advances.
+
+## Model Routing
+
+Read `.shipkit/config.json` from the project root if it exists.
+
+- If `model_overrides["sk:autopilot"]` is set, use that model — it takes precedence.
+- Otherwise use the `profile` field. Default: `balanced`.
+
+| Profile | Model |
+|---------|-------|
+| `full-sail` | opus (inherit) |
+| `quality` | opus (inherit) |
+| `balanced` | sonnet |
+| `budget` | sonnet |
+
+> `opus` = inherit. When spawning sub-agents via the Agent tool, pass `model: "<resolved-model>"`.

package/skills/sk:setup-claude/templates/.claude/agents/backend-dev.md

@@ -0,0 +1,63 @@
+---
+name: backend-dev
+model: sonnet
+description: Backend development agent — writes backend tests and implements API/services/models against the API contract.
+allowed_tools: Bash, Read, Edit, Write, Glob, Grep
+---
+
+# Backend Development Agent
+
+You are the Backend Agent in a team workflow. Your job is to write backend tests and implement backend code based on the plan and API contract.
+
+## Context
+
+You are working in an **isolated worktree** — a separate copy of the repository. Another agent (Frontend Agent) is working in parallel on frontend code. A QA Agent is writing E2E scenarios in the background.
+
+The **API contract** in `tasks/todo.md` is your shared interface with the Frontend Agent. Implement endpoints that match the contract exactly.
+
+## Behavior
+
+### 1. Read the Plan
+
+- Read `tasks/todo.md` — find the API contract section and all backend tasks
+- Read `tasks/lessons.md` — apply all active lessons
+- Identify: models, migrations, controllers, services, validation, routes
+
+### 2. Write Backend Tests (TDD Red Phase)
+
+Write failing tests for all backend behavior:
+- **Controller tests**: HTTP method, route, request validation, response shape
+- **Model tests**: Relationships, scopes, accessors, mutators
+- **Service tests**: Business logic, edge cases, error handling
+- **Validation tests**: All form request / input validation rules
+- Follow existing test conventions (read 1-2 existing test files first)
+
+### 3. Implement Backend Code (TDD Green Phase)
+
+Implement in dependency order:
+1. Migrations (if needed)
+2. Models + relationships
+3. Services / business logic
+4. Controllers + form requests
+5. Routes
+
+Make each test pass before moving to the next.
+
+### 4. Verify
+
+Run the backend test suite:
+- All new tests must pass
+- Existing tests must not break
+- Report: test count, pass/fail, coverage %
+
+### 5. Auto-Commit
+
+Commit with: `feat(backend): [description]`
+
+## Rules
+
+- ONLY touch backend files (models, controllers, services, migrations, routes, backend tests)
+- Do NOT touch frontend files (components, views, CSS, frontend tests)
+- Do NOT modify the API contract in `tasks/todo.md`
+- Follow the API contract exactly — request/response shapes must match
+- 3-strike protocol: if something fails 3 times, stop and report

package/skills/sk:setup-claude/templates/.claude/agents/frontend-dev.md

@@ -0,0 +1,65 @@
+---
+name: frontend-dev
+model: sonnet
+description: Frontend development agent — writes frontend tests and implements UI/components/pages using mocked API contract.
+allowed_tools: Bash, Read, Edit, Write, Glob, Grep
+---
+
+# Frontend Development Agent
+
+You are the Frontend Agent in a team workflow. Your job is to write frontend tests and implement UI code based on the plan and API contract.
+
+## Context
+
+You are working in an **isolated worktree** — a separate copy of the repository. Another agent (Backend Agent) is implementing the real API in parallel. A QA Agent is writing E2E scenarios in the background.
+
+The **API contract** in `tasks/todo.md` defines the endpoints you will consume. Mock these endpoints in your tests — the real backend will replace mocks after merge.
+
+## Behavior
+
+### 1. Read the Plan
+
+- Read `tasks/todo.md` — find the API contract section and all frontend tasks
+- Read `tasks/lessons.md` — apply all active lessons
+- Identify: components, pages, composables/hooks, forms, state management
+
+### 2. Write Frontend Tests (TDD Red Phase)
+
+Write failing tests for all frontend behavior:
+- **Component tests**: Rendering with props, conditional display, slots/children
+- **Interaction tests**: Click, type, submit, navigate
+- **Form tests**: Validation, submission, error display
+- **Hook/composable tests**: State changes, side effects
+- Mock API endpoints using the contract shapes
+- Use `@testing-library` conventions: prefer `getByRole`, `getByText`, `getByLabelText`
+- Follow existing test conventions (read 1-2 existing test files first)
+
+### 3. Implement Frontend Code (TDD Green Phase)
+
+Implement in dependency order:
+1. API client / service layer (typed from contract)
+2. Composables / hooks
+3. Components (smallest first)
+4. Pages (compose components)
+5. Routes / navigation
+
+Make each test pass before moving to the next.
+
+### 4. Verify
+
+Run the frontend test suite:
+- All new tests must pass
+- Existing tests must not break
+- Report: test count, pass/fail, coverage %
+
+### 5. Auto-Commit
+
+Commit with: `feat(frontend): [description]`
+
+## Rules
+
+- ONLY touch frontend files (components, pages, composables, CSS, frontend tests, API client)
+- Do NOT touch backend files (models, controllers, services, migrations, routes)
+- Do NOT modify the API contract in `tasks/todo.md`
+- Mock API responses based on the contract shapes — do NOT call the real backend
+- 3-strike protocol: if something fails 3 times, stop and report

package/skills/sk:setup-claude/templates/.claude/agents/qa-engineer.md

@@ -0,0 +1,66 @@
+---
+name: qa-engineer
+model: sonnet
+description: QA engineer agent — writes E2E test scenarios based on the plan while other agents implement.
+allowed_tools: Bash, Read, Write, Glob, Grep
+---
+
+# QA Engineer Agent
+
+You are the QA Agent in a team workflow. Your job is to write E2E test scenarios while the Backend and Frontend agents implement code in parallel.
+
+## Context
+
+You run in the **background** while other agents work. Your E2E scenarios will be executed AFTER the backend and frontend code is merged. Write scenarios that validate the integrated result from a user's perspective.
+
+## Behavior
+
+### 1. Read the Plan
+
+- Read `tasks/todo.md` — extract user-facing flows and acceptance criteria
+- Read `tasks/lessons.md` — apply all active lessons
+- Identify: user journeys, happy paths, error scenarios, edge cases
+
+### 2. Detect E2E Framework
+
+Check the project for:
+- `playwright.config.ts` → use Playwright
+- `cypress.config.ts` → use Cypress
+- Neither → write framework-agnostic scenario descriptions in markdown
+
+### 3. Write E2E Scenarios
+
+For each user flow identified in the plan:
+
+**If Playwright detected:**
+- Create `e2e/<feature>.spec.ts` files
+- Use `test.describe` / `test` blocks
+- Use role-based locators: `getByRole`, `getByLabel`, `getByText`
+- Use `test.beforeEach` for shared setup (auth, navigation)
+- Guard credential-dependent tests with `test.skip`
+
+**If no framework detected:**
+- Create `tasks/e2e-scenarios.md` with structured scenarios:
+  ```
+  ## Scenario: [name]
+  **Given** [precondition]
+  **When** [action]
+  **Then** [expected result]
+  ```
+
+### 4. Coverage Summary
+
+Report:
+- Total scenarios written
+- Happy path coverage: [list of flows covered]
+- Edge cases covered: [list]
+- NOT covered (out of scope): [list]
+
+## Rules
+
+- Do NOT run E2E tests — they will fail because code isn't implemented yet
+- Do NOT touch backend or frontend source files
+- ONLY create E2E test files or scenario documents
+- Write scenarios based on the PLAN, not on existing code
+- Focus on user-visible behavior, not implementation details
+- 3-strike protocol: if something fails 3 times, stop and report

package/skills/sk:setup-claude/templates/CLAUDE.md.template

@@ -99,9 +99,17 @@ Progress is tracked in `tasks/workflow-status.md`. This file persists across con
 
 3. **Optional steps** (4, 5, 8, 15, 21): Ask the user "Skip [step]?" and require explicit confirmation. Record the reason in Notes.
 
-4. **Gates own their commits.** Each hard gate (steps 12–17) is responsible for committing any fixes it produces before passing control to the next step. There are no separate conditional commit steps.
+4. **Auto-skip detection.** Optional steps (4, 5, 8, 15) are auto-skipped when detection criteria are met — no confirmation prompt needed, just a log line. Detection runs after the plan is written (step 6) by scanning `tasks/todo.md`:
+   - **Step 4 (Design)**: Auto-skipped if plan contains NO frontend keywords (component, view, page, CSS, template, blade, vue, react, svelte, UI, form, modal, button)
+   - **Step 5 (Accessibility)**: Auto-skipped if plan contains NO frontend keywords (same list as step 4)
+   - **Step 8 (Migrate)**: Auto-skipped if plan contains NO database keywords (migration, schema, table, column, model, database, foreign key, index, seed)
+   - **Step 15 (Performance)**: Auto-skipped if plan contains NO frontend keywords AND NO database keywords
+   - **Step 21 (Release)**: NEVER auto-skipped — always ask
+   - Output when auto-skipped: `Auto-skipped: [Step Name] ([reason])` — e.g., `Auto-skipped: Design (no frontend keywords detected in plan)`
 
-5. **Loop steps are HARD GATES** (12, 13, 14, 16, 17): These steps BLOCK all forward progress until they pass clean. Fix issues immediately and re-run. Do NOT ask the user to re-run — fix and re-run automatically. Track attempt number in Notes (e.g., "clean on attempt 3").
+5. **Gates own their commits.** Each hard gate (steps 12–17) is responsible for committing any fixes it produces before passing control to the next step. There are no separate conditional commit steps.
+
+6. **Loop steps are HARD GATES** (12, 13, 14, 16, 17): These steps BLOCK all forward progress until they pass clean. Fix issues immediately and re-run. Do NOT ask the user to re-run — fix and re-run automatically. Track attempt number in Notes (e.g., "clean on attempt 3").
    - **Step 12 (Lint)**: All detected linting tools must pass — every single one.
    - **Step 13 (Verify Tests)**: All detected test suites (BE + FE) must pass with 100% coverage on new code.
    - **Step 14 (Security)**: 0 issues across all severities.
@@ -110,15 +118,15 @@ Progress is tracked in `tasks/workflow-status.md`. This file persists across con
    - **Step 15 (Performance)**: Optional gate — if run, loop until critical/high findings = 0. Can be skipped with explicit confirmation.
    - **DO NOT mark these steps as `done` until every check passes.** If even one tool fails, the step is NOT done. Never proceed to the next step with errors remaining.
 
-6. **Never skip steps without confirmation.** Steps cannot run out of order. Hard gate steps (12, 13, 14, 16, 17) can NEVER be skipped. Optional gate step (15) requires explicit confirmation to skip.
+7. **Never skip steps without confirmation.** Steps cannot run out of order. Hard gate steps (12, 13, 14, 16, 17) can NEVER be skipped. Optional gate step (15) requires explicit confirmation to skip.
 
-7. **Requirements change mid-workflow?** Stop the current step and run `/sk:change` immediately. It will classify the scope (behavior tweak / new requirements / scope shift) and tell you exactly where to re-enter the workflow. Never continue implementing stale requirements.
+8. **Requirements change mid-workflow?** Stop the current step and run `/sk:change` immediately. It will classify the scope (behavior tweak / new requirements / scope shift) and tell you exactly where to re-enter the workflow. Never continue implementing stale requirements.
 
-7. **Never auto-advance.** When one step completes, stop and tell the user which step is next. Do not proceed automatically.
+8. **Never auto-advance.** When one step completes, stop and tell the user which step is next. Do not proceed automatically.
 
-8. **Never write code during design or plan phases.** Steps 1-6 are reading/exploring/planning/design only — no code, no file edits (except `tasks/` files).
+9. **Never write code during design or plan phases.** Steps 1-6 are reading/exploring/planning/design only — no code, no file edits (except `tasks/` files).
 
-9. **Step completion summary is NON-NEGOTIABLE.** After finishing ANY step, you MUST output a summary block in this exact format before stopping:
+10. **Step completion summary is NON-NEGOTIABLE.** After finishing ANY step, you MUST output a summary block in this exact format before stopping:
 
 ```
 --- Step [#] [Name]: [done/skipped/partial] ---
@@ -346,28 +354,38 @@ Create entries in: `[ARCH_CHANGELOG_DIR]`
 
 | Command | Purpose |
 |---------|---------|
-| `/sk:brainstorm` | Explore requirements and design |
-| `/sk:frontend-design` | UI mockup before implementation. Prompts to create Pencil visual mockup |
-| `/sk:api-design` | Design API contracts (endpoints, payloads, auth, errors) before implementation |
 | `/sk:accessibility` | WCAG 2.1 AA audit — runs after design, before implementation |
-| `/sk:write-plan` | Write decision-complete plan into `tasks/todo.md` |
+| `/sk:api-design` | Design API contracts (endpoints, payloads, auth, errors) before implementation |
+| `/sk:autopilot` | Hands-free workflow — all 21 steps, auto-skip, auto-advance, auto-commit |
+| `/sk:brainstorm` | Explore requirements and design |
 | `/sk:branch` | Create feature branch auto-named from current task |
-| `/sk:write-tests` | TDD: Write failing tests before implementation |
-| `/sk:execute-plan` | Execute `tasks/todo.md` checkboxes in batches |
-| `/sk:smart-commit` | Conventional commit with approval |
-| `/sk:lint` | Auto-detect and run all project linters + dependency audits |
-| `/sk:test` | Auto-detect and run all project test suites |
+| `/sk:change` | Handle mid-workflow requirement changes — re-enter at correct step |
+| `/sk:context` | Load all context files + output session brief for fast session start |
+| `/sk:dashboard` | Read-only workflow Kanban board — localhost server, multi-worktree |
 | `/sk:debug` | Investigate and debug issues (bug fix entry point) |
-| `/sk:security-check` | OWASP security audit on changed files |
-| `/sk:perf` | Performance audit — bundle, N+1, Core Web Vitals, memory |
-| `/sk:review` | Self-review with simplify pre-pass + multi-dimensional review |
 | `/sk:e2e` | E2E behavioral verification using agent-browser (final quality gate) |
-| `/sk:hotfix` | Emergency fix workflow — skip design/TDD, quality gates enforced |
-| `/sk:change` | Handle mid-workflow requirement changes — re-enter at correct step |
-| `/sk:update-task` | Mark task done and log completion |
-| `/sk:finish-feature` | Changelog + PR creation |
+| `/sk:execute-plan` | Execute `tasks/todo.md` checkboxes in batches |
+| `/sk:fast-track` | Abbreviated workflow for small changes — skip planning, keep all gates |
 | `/sk:features` | Sync feature specs with shipped implementation |
+| `/sk:finish-feature` | Changelog + PR creation |
+| `/sk:frontend-design` | UI mockup before implementation. Prompts to create Pencil visual mockup |
+| `/sk:gates` | Run all quality gates in optimized parallel batches |
+| `/sk:hotfix` | Emergency fix workflow — skip design/TDD, quality gates enforced |
+| `/sk:lint` | Auto-detect and run all project linters + dependency audits |
+| `/sk:perf` | Performance audit — bundle, N+1, Core Web Vitals, memory |
 | `/sk:release` | Version bump + changelog + tag |
-| `/sk:status` | Show workflow + task status |
-| `/sk:context` | Load all context files + output session brief for fast session start |
+| `/sk:retro` | Post-ship retrospective: velocity, blockers, action items |
+| `/sk:reverse-doc` | Generate architecture/design docs from existing code |
+| `/sk:review` | Self-review with simplify pre-pass + multi-dimensional review |
+| `/sk:scope-check` | Compare implementation against plan, detect scope creep |
+| `/sk:security-check` | OWASP security audit on changed files |
+| `/sk:seo-audit` | SEO audit — dual-mode (source templates + dev server), ask-before-fix |
 | `/sk:setup-optimizer` | Diagnose + update workflow + enrich CLAUDE.md |
+| `/sk:smart-commit` | Conventional commit with approval |
+| `/sk:start` | Smart entry point — classifies task, routes to optimal flow/mode/agents |
+| `/sk:status` | Show workflow + task status |
+| `/sk:team` | Parallel domain agents (backend + frontend + QA) for full-stack tasks |
+| `/sk:test` | Auto-detect and run all project test suites |
+| `/sk:update-task` | Mark task done and log completion |
+| `/sk:write-plan` | Write decision-complete plan into `tasks/todo.md` |
+| `/sk:write-tests` | TDD: Write failing tests before implementation |

package/skills/sk:setup-optimizer/SKILL.md

@@ -44,6 +44,8 @@ Before making any changes, runs a diagnostic pass on the existing CLAUDE.md:
 - **Inconsistencies** — compares documented vs actual project state (directories, scripts, workflows)
 - **Section completeness** — flags sections that exist but are empty or have only placeholder text
 - **Outdated workflow** — checks if the workflow matches the current 21-step TDD flow with hard gates
+- **Missing commands** — checks for `sk:start`, `sk:autopilot`, `sk:team` in the Commands table
+- **Auto-skip rules** — checks for auto-skip detection rules in the workflow section
 
 Reports findings before proceeding. If issues are found, they inform subsequent steps.
 
@@ -57,7 +59,7 @@ Read → Explore → Design → Accessibility → Plan → Branch → Migrate
 ```
 
 **What gets updated:**
-- Workflow table (21 steps with correct commands: `/sk:write-tests`, `/sk:lint`, `/sk:test`, `/sk:accessibility`, `/sk:perf`, `/sk:e2e`)
+- Workflow table (21 steps with correct commands: `/sk:write-tests`, `/sk:lint`, `/sk:test`, `/sk:accessibility`, `/sk:perf`, `/sk:e2e`, `/sk:start`, `/sk:autopilot`, `/sk:team`)
 - Step details (TDD red/green/verify descriptions)
 - Tracker rules (hard gates at 12, 14, 16, 20, 17; optional steps 4, 5, 8, 18, 21)
 - Step completion summary rule (NON-NEGOTIABLE)
@@ -70,6 +72,7 @@ Read → Explore → Design → Accessibility → Plan → Branch → Migrate
 - 3-Strike Protocol (if missing)
 - Fix & Retest Protocol section (if missing)
 - Requirement Change Flow section (if missing)
+- Auto-skip detection rules (if missing)
 
 **What gets preserved:**
 - Everything marked with `<!-- LOCK -->` is never touched

package/skills/sk:start/SKILL.md

@@ -0,0 +1,156 @@
+---
+name: sk:start
+description: Smart entry point — classifies your task, detects scope, and routes to the optimal flow (feature/debug/hotfix/fast-track), mode (manual/autopilot), and agent strategy (solo/team).
+user_invocable: true
+allowed_tools: Read, Write, Bash, Glob, Grep, Agent, Skill
+---
+
+# Smart Start
+
+Single entry point that classifies your task and recommends the optimal workflow configuration. Replaces the need to know which command to run first.
+
+## Usage
+
+```
+/sk:start <task description>
+/sk:start --manual add user profile page
+/sk:start --team add profile page with API
+/sk:start --debug fix login redirect loop
+/sk:start --hotfix prod payments failing
+/sk:start --fast-track bump lodash dependency
+```
+
+## Steps
+
+### Step 1 — Classify (automatic, no prompt)
+
+Read the task description from arguments. Scan for signal keywords to determine flow and scope:
+
+**Flow detection:**
+
+| Signal Keywords | Detected Flow |
+|----------------|---------------|
+| bug, fix, broken, error, regression, failing, crash, wrong | `debug` (11 steps) |
+| urgent, prod down, hotfix, emergency, critical, production, incident | `hotfix` (11 steps) |
+| config, bump, typo, copy, rename, dependency, upgrade, version, docs | `fast-track` (10 steps) |
+| *(default — no special signals)* | `feature` (21 steps) |
+
+**Scope detection:**
+
+| Signal Keywords | Detected Scope |
+|----------------|----------------|
+| Frontend: component, page, view, CSS, UI, form, modal, button, sidebar, navbar, layout, style, tailwind, animation | `frontend` |
+| Backend: API, endpoint, controller, model, migration, service, queue, job, middleware, database, schema, route | `backend` |
+| Both frontend AND backend keywords present | `full-stack` |
+| Neither | `unknown` (ask user) |
+
+**Agent recommendation:**
+
+| Scope | Agents |
+|-------|--------|
+| `full-stack` | `team` (backend + frontend + QA agents) |
+| `frontend` only | `solo` |
+| `backend` only | `solo` |
+| `unknown` | `solo` (default) |
+
+### Step 2 — Recommend (one prompt, user confirms or overrides)
+
+Present the classification and recommendation:
+
+```
+Detected: [Full-stack feature / Backend bug fix / Frontend hotfix / Small config change / etc.]
+Recommended:
+  Flow:   [feature (21 steps) / debug (11 steps) / hotfix (11 steps) / fast-track (10 steps)]
+  Mode:   [autopilot / manual]
+  Agents: [team (backend + frontend + QA) / solo]
+
+Proceed? (y) or override: manual / no-team / --debug / --hotfix / --fast-track
+```
+
+Default mode recommendation:
+- `feature` flow → recommend `autopilot`
+- `debug` flow → recommend `autopilot`
+- `hotfix` flow → recommend `autopilot`
+- `fast-track` flow → recommend `autopilot`
+
+Wait for user response:
+- `y` or `yes` → proceed with recommendation
+- `manual` → use recommended flow but in manual mode (step-by-step)
+- `no-team` → use autopilot but single-agent (no team)
+- `--debug` → force debug flow
+- `--hotfix` → force hotfix flow
+- `--fast-track` → force fast-track flow
+- Any other override → apply it
+
+### Step 3 — Route (enters the chosen flow)
+
+1. Reset `tasks/workflow-status.md`:
+   - Set all steps to `not yet`
+   - Add metadata to the tracker header:
+     ```
+     > Mode: [autopilot/manual] | Agents: [team/solo] | Flow: [feature/debug/hotfix/fast-track]
+     ```
+
+2. Dispatch to the chosen flow:
+
+   **If autopilot mode:**
+   - Invoke `/sk:autopilot` with the task description
+   - Autopilot handles everything from here
+
+   **If manual mode + team:**
+   - Start the normal step-by-step workflow (`/sk:brainstorm`)
+   - Note in tracker: "Team mode active — activate `/sk:team` at step 9"
+   - User drives each step manually; team mode activates at write-tests/implement
+
+   **If manual mode + solo:**
+   - Start the normal step-by-step workflow (`/sk:brainstorm`)
+   - Standard manual behavior — no changes from current flow
+
+   **If debug flow:**
+   - Invoke `/sk:debug` with the task description
+
+   **If hotfix flow:**
+   - Invoke `/sk:hotfix` with the task description
+
+   **If fast-track flow:**
+   - Invoke `/sk:fast-track` with the task description
+
+## Override Flags
+
+| Flag | Effect |
+|------|--------|
+| `--manual` | Force manual mode (step-by-step, no auto-advance) |
+| `--no-team` | Force single-agent even if full-stack detected |
+| `--team` | Force team mode even if single-domain detected |
+| `--debug` | Force debug flow (bug fix) |
+| `--hotfix` | Force hotfix flow (production emergency) |
+| `--fast-track` | Force fast-track flow (small change) |
+
+Flags can be combined: `/sk:start --manual --team add profile page`
+
+## Relationship to Existing Commands
+
+- `/sk:start` is the **recommended** entry point for all new work
+- Old commands still work as direct entry points:
+  - `/sk:brainstorm` → manual feature workflow
+  - `/sk:debug` → bug fix flow
+  - `/sk:hotfix` → hotfix flow
+  - `/sk:fast-track` → fast-track flow
+  - `/sk:autopilot` → autopilot mode directly
+- `/sk:start` calls those same flows internally — it's a router, not a replacement
+
+## Model Routing
+
+Read `.shipkit/config.json` from the project root if it exists.
+
+- If `model_overrides["sk:start"]` is set, use that model — it takes precedence.
+- Otherwise use the `profile` field. Default: `balanced`.
+
+| Profile | Model |
+|---------|-------|
+| `full-sail` | haiku |
+| `quality` | haiku |
+| `balanced` | haiku |
+| `budget` | haiku |
+
+> Start is a lightweight classifier — haiku is sufficient for keyword matching and routing.

package/skills/sk:team/SKILL.md

@@ -0,0 +1,141 @@
+---
+name: sk:team
+description: Parallel domain agents for full-stack implementation — spawns Backend, Frontend, and QA agents in isolated worktrees.
+user_invocable: true
+allowed_tools: Read, Write, Bash, Glob, Grep, Agent
+---
+
+# Team Mode
+
+Splits implementation across specialized parallel agents when a task spans multiple domains (frontend + backend). Each agent works in an isolated worktree to avoid conflicts. Works in both manual and autopilot modes.
+
+## When to Use
+
+- Full-stack features with both backend API and frontend UI work
+- Tasks where frontend and backend have clear boundaries (separate directories)
+- Changes large enough that parallel implementation saves meaningful time
+
+## When NOT to Use
+
+- Backend-only or frontend-only tasks — single agent is faster
+- Tasks where frontend and backend share files (e.g., Inertia controllers returning views)
+- Small changes (<100 lines estimated) — worktree overhead exceeds time saved
+- Tasks without a clear API contract boundary
+
+## Agents
+
+| Agent | Role | Isolation | Model |
+|-------|------|-----------|-------|
+| **Backend Agent** | Writes backend tests + implements API/services/models | Isolated worktree | sonnet |
+| **Frontend Agent** | Writes frontend tests + implements UI/components/pages | Isolated worktree | sonnet |
+| **QA Agent** | Writes E2E test scenarios while others implement | Background | sonnet |
+
+## Prerequisites
+
+The plan in `tasks/todo.md` MUST contain an explicit **API contract** section defining:
+- Endpoint paths and HTTP methods
+- Request payload shapes (with types)
+- Response payload shapes (with types)
+- Authentication requirements
+- Error response formats
+
+If no API contract is found, team mode warns and falls back to single-agent sequential mode.
+
+## Steps
+
+### 0. Validate Prerequisites
+
+1. Read `tasks/todo.md` — scan for API contract section
+2. If no API contract found:
+   > "No API contract found in plan. Team mode requires explicit endpoint definitions as the shared boundary between agents. Falling back to single-agent mode."
+   - Exit team mode, proceed with normal sequential implementation
+3. If API contract found, continue
+
+### 1. Prepare Worktrees
+
+1. Get current branch name: `git branch --show-current`
+2. Verify working directory is clean: `git status --porcelain`
+3. Note: worktree creation is handled by the Agent tool's `isolation: "worktree"` parameter
+
+### 2. Spawn Agents (parallel)
+
+Launch all 3 agents simultaneously using the Agent tool:
+
+**Backend Agent** (`isolation: "worktree"`):
+- Task: "Read the API contract in tasks/todo.md. Write backend tests for all endpoints (controller tests, model tests, validation tests). Then implement: migrations, models, services, controllers, routes. Make all tests pass. Commit with `feat(backend): [description]`."
+- Receives: full plan from `tasks/todo.md`, `tasks/lessons.md`
+
+**Frontend Agent** (`isolation: "worktree"`):
+- Task: "Read the API contract in tasks/todo.md. Write frontend tests for all components/pages (component tests, interaction tests, form tests). Mock API endpoints using contract shapes. Then implement: API client, composables/hooks, components, pages, routes. Make all tests pass. Commit with `feat(frontend): [description]`."
+- Receives: full plan from `tasks/todo.md`, `tasks/lessons.md`
+
+**QA Agent** (`run_in_background: true`):
+- Task: "Read the plan in tasks/todo.md. Write E2E test scenarios covering all user flows. Do NOT run them — they'll be executed after merge. Report scenario count and coverage summary."
+- Receives: full plan from `tasks/todo.md`
+
+### 3. Wait for Completion
+
+Wait for Backend Agent and Frontend Agent to complete. The QA Agent runs in the background and will be collected later.
+
+For each completed agent, check:
+- Did it succeed or hit 3-strike failure?
+- What files were changed?
+- What tests pass?
+
+### 4. Merge Worktrees
+
+If both agents used worktree isolation and made changes:
+
+1. Check if worktree branches exist
+2. Merge backend worktree branch into feature branch:
+   ```bash
+   git merge <backend-worktree-branch> --no-edit
+   ```
+3. Merge frontend worktree branch into feature branch:
+   ```bash
+   git merge <frontend-worktree-branch> --no-edit
+   ```
+4. If merge conflicts occur:
+   - Attempt auto-resolution for non-overlapping changes
+   - If conflicts are in shared files (routes, config, types), resolve by combining both additions
+   - If conflicts are ambiguous, stop and ask user:
+     > "Merge conflict in [file]. Backend added [X], Frontend added [Y]. Which to keep, or combine?"
+
+### 5. Collect QA Agent Results
+
+Collect the QA Agent's E2E scenarios. These will be used in the E2E gate (step 17).
+
+### 6. Report Results
+
+```
+Team implementation complete:
+  Backend Agent: [N] files changed, [M] tests passing
+  Frontend Agent: [N] files changed, [M] tests passing
+  QA Agent: [N] E2E scenarios written
+  Merge: [clean / N conflicts resolved]
+
+Ready for commit and quality gates.
+```
+
+## Fallback
+
+If worktree creation fails (git state issues, disk space, etc.):
+> "Worktree creation failed: [error]. Falling back to single-agent sequential mode."
+
+Run normal sequential implementation (write-tests → implement) instead.
+
+## Model Routing
+
+Read `.shipkit/config.json` from the project root if it exists.
+
+- If `model_overrides["sk:team"]` is set, use that model — it takes precedence.
+- Otherwise use the `profile` field. Default: `balanced`.
+
+| Profile | Model |
+|---------|-------|
+| `full-sail` | opus (inherit) |
+| `quality` | opus (inherit) |
+| `balanced` | sonnet |
+| `budget` | sonnet |
+
+> `opus` = inherit. When spawning sub-agents via the Agent tool, pass `model: "<resolved-model>"`.