@kennethsolomon/shipkit 3.9.0 → 3.10.1

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:setup-optimizer/lib/discover.py

@@ -1,7 +1,8 @@
 """Intelligent project structure, documentation, and workflow discovery."""
 
+import json
 from pathlib import Path
-from typing import Dict, List, Tuple
+from typing import Dict, List
 
 
 # Directories to exclude from discovery
@@ -174,16 +175,14 @@ def _extract_makefile_targets(root_path: Path) -> List[str]:
                 target = line.split(':')[0].strip()
                 if target and not target.startswith('.'):
                     targets.append(target)
-    except Exception:
-        pass
+    except (OSError, UnicodeDecodeError) as e:
+        print(f"Warning: Could not parse Makefile: {e}")
 
     return list(set(targets))[:10]  # Limit to 10 targets
 
 
 def _extract_npm_scripts(root_path: Path) -> List[str]:
     """Extract scripts from package.json."""
-    import json
-
     package_json = root_path / 'package.json'
     if not package_json.exists():
         return []
@@ -191,14 +190,14 @@ def _extract_npm_scripts(root_path: Path) -> List[str]:
     scripts = []
     try:
         content = json.loads(package_json.read_text())
-        if 'scripts' in content:
+        if isinstance(content, dict) and 'scripts' in content:
             # Include common scripts, exclude default ones
             exclude = {'test', 'start', 'dev', 'build'}
             for script_name in content['scripts'].keys():
                 if script_name not in exclude:
                     scripts.append(script_name)
-    except Exception:
-        pass
+    except (OSError, json.JSONDecodeError, UnicodeDecodeError) as e:
+        print(f"Warning: Could not parse package.json scripts: {e}")
 
     return scripts[:8]  # Limit to 8 scripts
 
@@ -215,7 +214,7 @@ def _find_github_workflows(root_path: Path) -> List[str]:
             workflows.append(workflow_file.stem)
         for workflow_file in workflows_dir.glob('*.yaml'):
             workflows.append(workflow_file.stem)
-    except Exception:
-        pass
+    except OSError as e:
+        print(f"Warning: Could not read GitHub workflows: {e}")
 
     return workflows[:5]  # Limit to 5 workflows

package/skills/sk:skill-creator/scripts/generate_report.py

@@ -6,6 +6,8 @@ showing each description attempt with check/x for each test case.
 Distinguishes between train and test queries.
 """
 
+from __future__ import annotations
+
 import argparse
 import html
 import json

package/skills/sk:skill-creator/scripts/improve_description.py

@@ -5,6 +5,8 @@ Takes eval results (from run_eval.py) and generates an improved description
 using Claude with extended thinking.
 """
 
+from __future__ import annotations
+
 import argparse
 import json
 import re

package/skills/sk:skill-creator/scripts/package_skill.py

@@ -93,6 +93,10 @@ def package_skill(skill_path, output_dir=None):
             for file_path in skill_path.rglob('*'):
                 if not file_path.is_file():
                     continue
+                # Skip symlinks to prevent path traversal
+                if file_path.is_symlink():
+                    print(f"  Skipped (symlink): {file_path}")
+                    continue
                 arcname = file_path.relative_to(skill_path.parent)
                 if should_exclude(arcname):
                     print(f"  Skipped: {arcname}")

package/skills/sk:skill-creator/scripts/run_eval.py

@@ -5,6 +5,8 @@ Tests whether a skill's description causes Claude to trigger (read the skill)
 for a set of queries. Outputs results as JSON.
 """
 
+from __future__ import annotations
+
 import argparse
 import json
 import os
@@ -221,7 +223,7 @@ def run_eval(
             try:
                 query_triggers[query].append(future.result())
             except Exception as e:
-                print(f"Warning: query failed: {e}", file=sys.stderr)
+                print(f"Warning: query failed for '{query[:60]}': {type(e).__name__}: {e}", file=sys.stderr)
                 query_triggers[query].append(False)
 
     for query, triggers in query_triggers.items():

package/skills/sk:skill-creator/scripts/run_loop.py

@@ -6,6 +6,8 @@ and returning the best description found. Supports train/test split to prevent
 overfitting.
 """
 
+from __future__ import annotations
+
 import argparse
 import json
 import random

package/skills/sk:skill-creator/scripts/utils.py

@@ -1,5 +1,7 @@
 """Shared utilities for skill-creator scripts."""
 
+from __future__ import annotations
+
 from pathlib import Path
 
 

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.