@kennethsolomon/shipkit 3.8.0 → 3.10.0

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/SKILL.md

@@ -27,6 +27,7 @@ After bootstrapping a project, the recommended workflow becomes:
 - `tasks/progress.md` — chronological work log + test results
 - `tasks/lessons.md` — durable “don’t repeat mistakes” log (**never overwrite**)
 - `tasks/security-findings.md` — security audit results from `/sk:security-check` (**never overwrite**)
+- `tasks/cross-platform.md` — changes that need replication in companion codebase (web <-> mobile) (**never overwrite**)
 
 ### Project Commands (in `.claude/commands/`)
 - `brainstorm.md` — invokes the global `brainstorming` skill
@@ -88,6 +89,7 @@ Never overwrite `tasks/lessons.md` — always append.
 - `tasks/progress.md`
 - `tasks/lessons.md`
 - `tasks/security-findings.md`
+- `tasks/cross-platform.md`
 - `CHANGELOG.md`
 - custom `CLAUDE.md` (anything not marked `<!-- Generated by /sk:setup-claude -->`)
 

package/skills/sk:setup-claude/scripts/apply_setup_claude.py

@@ -443,6 +443,7 @@ def apply(
     add("templates/tasks/lessons.md.template", "tasks/lessons.md", "missing")
     add("templates/tasks/security-findings.md.template", "tasks/security-findings.md", "missing")
     add("templates/tasks/workflow-status.md.template", "tasks/workflow-status.md", "missing")
+    add("templates/tasks/cross-platform.md.template", "tasks/cross-platform.md", "missing")
 
     # commands (update if generated)
     add("templates/commands/brainstorm.md.template", ".claude/commands/brainstorm.md", "generated")

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] ---
@@ -272,6 +280,21 @@ Use `run_in_background: true` for tasks that don't block your next step:
 ```
 <!-- END:sub-agent-patterns -->
 
+## Cross-Platform Tracking
+
+This project may have a companion codebase (web <-> mobile). During implementation, **log every change that affects the other platform** to `tasks/cross-platform.md`.
+
+**When to log:**
+- API contract changes (new/modified endpoints, payload shapes, auth)
+- Data model changes (new fields, type changes, validation rules)
+- Business logic that must behave identically on both platforms
+- UI/UX flows that should have parity
+- Platform-specific deviations (intentional differences)
+
+**How to log:** Append a new section using the template in `tasks/cross-platform.md`. Include enough context that a developer in the other codebase can implement without guessing.
+
+**When to review:** At the start of every task, check `tasks/cross-platform.md` for pending items targeting this codebase.
+
 ## Project Memory
 
 Read these files at the start of every task:
@@ -279,12 +302,14 @@ Read these files at the start of every task:
 - `tasks/lessons.md` — past mistakes and how to avoid them
 - `tasks/todo.md` — current plan
 - `tasks/tech-debt.md` — known shortcuts, deferred work, and areas to revisit
+- `tasks/cross-platform.md` — pending changes from the other codebase
 
 Write to these files continuously:
 - `tasks/progress.md` — every attempt, error, and resolution
 - `tasks/findings.md` — anything important discovered mid-task
+- `tasks/cross-platform.md` — any change that impacts the other platform
 
-**Never overwrite** `tasks/lessons.md` or `tasks/security-findings.md`.
+**Never overwrite** `tasks/lessons.md`, `tasks/security-findings.md`, or `tasks/cross-platform.md`.
 
 ## Lessons Capture
 
@@ -329,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-claude/templates/tasks/cross-platform.md.template

@@ -0,0 +1,31 @@
+# Cross-Platform Changes
+
+Track changes that need to be replicated in the other codebase (web <-> mobile).
+
+<!--
+  Format: One section per feature/task.
+  Each entry should have enough context for a developer (or Claude session)
+  in the other codebase to implement without guessing.
+-->
+
+<!-- TEMPLATE — copy this block for each new feature:
+
+## [Feature Name] (YYYY-MM-DD)
+Source: [web|mobile] — the codebase where this was implemented first
+
+### API Changes
+- [ ] Description of endpoint/payload/auth changes
+
+### Data Model Changes
+- [ ] New fields, renamed fields, type changes, validation rules
+
+### Behavior Changes
+- [ ] Business logic that must match across platforms
+
+### UI/UX Parity
+- [ ] Screens, flows, or interactions that should match
+
+### Platform-Specific Notes
+- [ ] Anything that differs intentionally between web and mobile
+
+-->

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

@@ -39,11 +39,13 @@ The single command to keep your CLAUDE.md current. Diagnoses problems, updates t
 
 Before making any changes, runs a diagnostic pass on the existing CLAUDE.md:
 
-- **Missing sections** — checks for essential sections (Workflow, Sub-Agent Patterns, Project Memory, Lessons Capture, Testing, Commands, etc.)
+- **Missing sections** — checks for essential sections (Workflow, Sub-Agent Patterns, Cross-Platform Tracking, Project Memory, Lessons Capture, Testing, Commands, etc.)
 - **Stale content** — detects outdated info (stale model/route counts, removed dependencies, old command names like `/laravel-lint` instead of `/sk:lint`)
 - **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,18 +59,20 @@ 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)
 - Bug fix flow section
 - Sub-Agent Patterns section (if missing)
+- Cross-Platform Tracking section (if missing)
 - Project Memory section (if missing)
 - Lessons Capture section (if missing)
 - Testing TDD section (if missing)
 - 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