@claude-code-mastery/starter-kit 1.0.0

package/.claude/commands/new-project.md

@@ -0,0 +1,244 @@
+---
+description: Create a new project with all scaffolding rules applied
+scope: starter-kit
+argument-hint: <path> [profile-or-options...]
+allowed-tools: Bash, Write, Read, AskUserQuestion
+---
+
+# New Project Scaffold
+
+Create a new project with all best practices from the Claude Code Mastery Guides.
+
+**Arguments:** $ARGUMENTS
+
+## Argument Parsing
+
+### Step 0 — Read the config file
+
+Before parsing arguments, read `claude-mastery-project.conf` (in the starter kit root or `~/.claude/claude-mastery-project.conf` as fallback).
+
+Extract the `[global]` section for `root_dir` and `default_profile`.
+
+- `root_dir` — Default parent directory for new projects
+- `default_profile` — Profile to use when no profile is specified in arguments (e.g., `default_profile = clean`). If not set, ask the user as before.
+
+### Step 0.0 — Global Claude Config (one-time setup)
+
+Check if the user already has the global Claude config installed:
+
+```bash
+# Check if global CLAUDE.md exists
+ls ~/.claude/CLAUDE.md 2>/dev/null
+```
+
+**If `~/.claude/CLAUDE.md` does NOT exist:**
+- ASK: "You don't have a global CLAUDE.md yet. Want me to install the Claude Code Mastery global config to `~/.claude/`? This sets up security rules, hooks, and standards that apply to ALL your projects. (This is a one-time setup.)"
+- If yes: copy `global-claude-md/CLAUDE.md` → `~/.claude/CLAUDE.md` and `global-claude-md/settings.json` → `~/.claude/settings.json`
+- Also copy hooks: `mkdir -p ~/.claude/hooks && cp .claude/hooks/verify-no-secrets.sh ~/.claude/hooks/`
+
+**If `~/.claude/CLAUDE.md` DOES exist:**
+- ASK: "You already have a global CLAUDE.md. Want me to check if the starter kit version has anything new to merge in?"
+- If yes: diff the two files and show what's different. Let the user decide what to merge.
+- If no: skip and continue.
+
+**This step typically only happens once.** After the first install, the global config persists across all projects.
+
+### Step 0.1 — Resolve the project path
+
+The **first argument** is the project name or path. Resolve it using `root_dir`:
+
+1. **Explicit path** (starts with `./`, `../`, `~/`, or `/`) → use as-is
+   - `/new-project ~/code/my-app` → creates at `~/code/my-app`
+   - `/new-project ./my-app` → creates at `./my-app`
+
+2. **Just a name** (no path separators) → prepend `root_dir` from `[global]`
+   - Config has `root_dir = ~/projects`
+   - `/new-project my-app` → creates at `~/projects/my-app`
+   - `/new-project tims-api` → creates at `~/projects/tims-api`
+
+3. **No argument at all** → ASK the user for the project name, then prepend `root_dir`
+
+Everything after the project name/path is shorthand options or a profile name.
+
+### Shorthand Arguments (after the path/name)
+
+Parse remaining $ARGUMENTS for these keywords:
+
+**Profiles:** `clean`, `default`, `api`, `static-site`, `quick`, `enterprise`, `go`, `vue`, `nuxt`, `svelte`, `sveltekit`, `angular`, `python-api`, `django`, `flask` (from `claude-mastery-project.conf`)
+**Special:** `clean` — Claude infrastructure only, zero coding opinions (see Clean Mode below)
+**Languages:** `go`, `golang` (triggers Go scaffolding — see Go Mode below) | `python`, `py` (triggers Python Mode below)
+**Project types:** `webapp`, `api`, `fullstack`, `cli`
+**Frameworks:** `vite`, `react`, `next`, `nextjs`, `astro`, `fastify`, `express`, `hono`, `vue`, `nuxt`, `svelte`, `sveltekit`, `angular`
+**Go Frameworks:** `gin`, `chi`, `echo`, `fiber`, `stdlib`
+**Python Frameworks:** `fastapi`, `django`, `flask`
+**Options:** `seo`, `ssr`, `tailwind`, `prisma`, `docker`, `ci`, `multiregion`
+**Hosting:** `dokploy`, `vercel`, `static`
+**Database:** `mongo`, `postgres`, `mysql`, `mssql`, `sqlite`
+**Analytics:** `rybbit`
+**MCP servers:** `playwright`, `context7`, `rulecatch`
+**NPM extras:** `ai-pooler` (installs @rulecatch/ai-pooler)
+**Package managers:** `pnpm`, `npm`, `bun`
+
+Examples:
+- `/new-project my-app` — creates at ~/projects/my-app (from root_dir), asks questions
+- `/new-project my-app clean` — Claude infrastructure only, no coding opinions
+- `/new-project my-app default` — creates at ~/projects/my-app with default profile
+- `/new-project my-app fullstack next seo tailwind pnpm` — ~/projects/my-app, skips all questions
+- `/new-project ./custom-path/my-app api fastify` — explicit path, ignores root_dir
+- `/new-project ~/code/my-app default` — explicit path, uses default profile
+- `/new-project my-app fullstack next mongo playwright context7 rulecatch` — full stack
+- `/new-project my-api go` — Go API with Gin, MongoDB, Docker
+- `/new-project my-api go chi postgres` — Go with Chi, PostgreSQL
+- `/new-project my-cli go cli` — Go CLI with Cobra
+- `/new-project my-app vue` — Vue 3 SPA with Tailwind
+- `/new-project my-app nuxt` — Nuxt full-stack with MongoDB, Docker
+- `/new-project my-app svelte` — Svelte SPA with Tailwind
+- `/new-project my-app sveltekit` — SvelteKit full-stack with MongoDB, Docker
+- `/new-project my-app angular` — Angular SPA with Tailwind
+- `/new-project my-api python-api` — FastAPI with PostgreSQL, Docker
+- `/new-project my-app django` — Django full-stack with PostgreSQL, Docker
+- `/new-project my-api flask` — Flask API with PostgreSQL, Docker
+- `/new-project my-api python fastapi postgres docker` — Python API with overrides
+
+Any keyword not provided = check `default_profile` in `[global]` first, then ask the user. If `default_profile` is set (e.g., `default_profile = clean`) and no profile was specified in the arguments, use that profile automatically.
+
+---
+
+## Project Registry — MANDATORY Final Step (ALL modes)
+
+**After EVERY successful project scaffold (Clean, Go, Python, or Node.js), register the project in `~/.claude/starter-kit-projects.json`.**
+
+This enables `/projects-created` and `/remove-project` to track all projects.
+
+### How to register
+
+1. Read `~/.claude/starter-kit-projects.json` (create if it doesn't exist)
+2. Append a new entry to the `projects` array:
+
+```json
+{
+  "name": "my-app",
+  "path": "/home/user/projects/my-app",
+  "profile": "default",
+  "language": "node",
+  "framework": "next",
+  "database": "mongo",
+  "createdAt": "2025-01-15T10:30:00Z"
+}
+```
+
+3. Write the updated file back
+
+**Field mapping:**
+- `name` — project directory name (last segment of path)
+- `path` — absolute path to the project directory
+- `profile` — profile name used (e.g., `clean`, `default`, `go`, `python-api`), or `custom` if built from shorthand args
+- `language` — `node`, `go`, or `python`
+- `framework` — the chosen framework (e.g., `next`, `gin`, `fastapi`), or `none` for clean mode
+- `database` — `mongo`, `postgres`, `mysql`, `mssql`, `sqlite`, or `none`
+- `createdAt` — ISO 8601 timestamp of creation
+
+**If the file doesn't exist yet**, create it with:
+
+```json
+{
+  "projects": []
+}
+```
+
+**This step happens AFTER git init and initial commit, as the very last action before displaying the verification checklist.**
+
+---
+
+
+---
+
+## Route to the Profile
+
+The detailed scaffolding lives in `.claude/.starter-kit/`, split so only the parts a run actually needs are loaded. Based on the resolved mode/language, read the matching profile file and follow it exactly:
+
+| Mode / language | Read and follow |
+| --- | --- |
+| `clean` | `.claude/.starter-kit/profiles/clean.md` |
+| `go` / `golang` / `gin`, `chi`, `echo`, `fiber`, `stdlib` | `.claude/.starter-kit/profiles/go.md` |
+| `python` / `py` / `fastapi`, `django`, `flask` | `.claude/.starter-kit/profiles/python.md` |
+| default / `node` / any JS-TS framework | `.claude/.starter-kit/profiles/node.md` |
+
+Read exactly one profile, the one the mode/language resolves to. Do NOT read the others.
+
+`.claude/.starter-kit/` is kit-internal scaffolding source. It is read while running `/new-project`, but it is **never copied into the scaffolded project** (the new project doesn't have `/new-project`). Copy only `skills/`, `hooks/`, `settings.json`, and `scope: project` commands, as the steps below specify.
+
+Every profile except `clean` builds its CLAUDE.md from `.claude/.starter-kit/shared/claude-md-base.md` plus its own rules; read the base first. For `clean`, the base *is* the CLAUDE.md.
+
+## Load Only the Shared Modules the Choices Require
+
+After the profile, read only the shared modules the user's selections call for, nothing more:
+
+| If the user selected | Also read and apply |
+| --- | --- |
+| a SQL database (`postgres`, `mysql`, `mssql`, `sqlite`) | `.claude/.starter-kit/shared/sql-setup.md` |
+| `mongo` | `.claude/.starter-kit/shared/mongo-setup.md` |
+| a web (HTML-serving) project | `.claude/.starter-kit/shared/seo.md` |
+| Dokploy hosting | `.claude/.starter-kit/shared/deployment-dokploy.md` |
+| Rybbit analytics | `.claude/.starter-kit/shared/analytics-rybbit.md` |
+| MCP servers or AI-Pooler | `.claude/.starter-kit/shared/mcp-and-pooler.md` |
+
+Profile presets (the `claude-mastery-project.conf` format) are documented in `.claude/.starter-kit/shared/profile-config.md`; read it only when creating or resolving a profile.
+
+**Example:** a `node` + `mongo` run reads `profiles/node.md`, `shared/claude-md-base.md`, `shared/mongo-setup.md`, and `shared/seo.md`. It never loads `go.md` or `python.md`.
+
+## Feature Manifest — MANDATORY Final Step (ALL modes except Clean)
+
+Follow `.claude/.starter-kit/shared/feature-manifest.md` to map the scaffolding choices to features and write the project's feature manifest.
+
+## Verification Checklist
+
+After creation, verify and report:
+
+**Core files:**
+- [ ] .env exists (empty)
+- [ ] .env.example exists (with placeholders)
+- [ ] .gitignore includes all required entries
+- [ ] .dockerignore exists
+- [ ] CLAUDE.md has all required sections (overview, stack, commands, ports)
+- [ ] package.json has ALL required scripts (dev, build, test, test:e2e, test:kill-ports)
+- [ ] Error handlers in entry point (gracefulShutdown for StrictDB projects)
+- [ ] TypeScript strict mode enabled
+
+**Testing:**
+- [ ] vitest.config.ts created and configured
+- [ ] playwright.config.ts created with test ports (4000/4010/4020) and webServer
+- [ ] test:kill-ports script kills test ports BEFORE E2E runs
+- [ ] tests/e2e/ directory exists
+- [ ] tests/unit/ directory exists
+- [ ] Example E2E test has minimum 3 assertions (URL, element, data)
+- [ ] `pnpm test` runs unit + E2E in sequence
+
+**Web projects:**
+- [ ] SEO meta tags in layout/head
+- [ ] JSON-LD structured data included
+- [ ] robots.txt created
+
+**Infrastructure:**
+- [ ] Dockerfile with multi-stage build (Docker projects)
+- [ ] scripts/deploy.sh created (Dokploy projects)
+- [ ] Multi-region deploy script (if multiregion selected)
+
+**Database (StrictDB projects):**
+- [ ] StrictDB installed as dependency
+- [ ] scripts/db-query.ts — Test Query Master
+- [ ] scripts/queries/ directory
+- [ ] db-query rules in CLAUDE.md
+
+**Content (if web project with articles/posts):**
+- [ ] scripts/build-content.ts
+- [ ] scripts/content.config.json
+- [ ] content/ directory
+
+**Extras:**
+- [ ] MCP servers installed (if selected)
+- [ ] claude-mastery-project.conf created (if using profiles)
+- [ ] No file > 300 lines
+- [ ] All independent awaits use Promise.all
+
+Report any missing items.

package/.claude/commands/optimize-docker.md

@@ -0,0 +1,352 @@
+---
+description: Analyze and optimize Docker builds for production
+scope: project
+argument-hint: [dockerfile-path]
+allowed-tools: Read, Write, Edit, Grep, Glob, Bash
+---
+
+# Optimize Docker Build
+
+Analyze and optimize the Docker setup for: **$ARGUMENTS**
+
+If no Dockerfile path provided, search for Dockerfiles in the project root.
+
+## Step 0 — Auto-Branch (if on main)
+
+Before modifying any files, check the current branch:
+
+```bash
+git branch --show-current
+```
+
+**Default behavior** (`auto_branch = true` in `claude-mastery-project.conf`):
+- If on `main` or `master`: automatically create a feature branch and switch to it:
+  ```bash
+  git checkout -b chore/docker-optimize
+  ```
+  Report: "Created branch `chore/docker-optimize` — main stays untouched."
+- If already on a feature branch: proceed
+- If not a git repo: skip this check
+
+**To disable:** Set `auto_branch = false` in `claude-mastery-project.conf`. When disabled, warn and ask the user before proceeding on main.
+
+## Step 1 — Find and Read All Docker Files
+
+Read these files (if they exist):
+- `Dockerfile` (or the path provided in $ARGUMENTS)
+- `docker-compose.yml` / `docker-compose.yaml`
+- `.dockerignore`
+- `package.json` (for build scripts and dependencies)
+
+## Step 2 — Audit Against Best Practices
+
+Check every rule below. For each violation, report:
+- What's wrong
+- Why it matters (performance impact or security risk)
+- The fix
+
+### RULE 1: Multi-Stage Builds (MANDATORY)
+
+Every production Dockerfile MUST use multi-stage builds. No exceptions.
+
+```dockerfile
+# CORRECT — multi-stage: build artifacts don't ship to production
+FROM node:20-alpine AS builder
+WORKDIR /app
+COPY package.json pnpm-lock.yaml ./
+RUN corepack enable && pnpm install --frozen-lockfile
+COPY . .
+RUN pnpm build
+
+FROM node:20-alpine AS runner
+WORKDIR /app
+COPY --from=builder /app/dist ./dist
+COPY --from=builder /app/node_modules ./node_modules
+COPY --from=builder /app/package.json ./
+CMD ["node", "dist/index.js"]
+
+# WRONG — single stage ships devDependencies, source code, build tools
+FROM node:20
+WORKDIR /app
+COPY . .
+RUN npm install
+RUN npm run build
+CMD ["node", "dist/index.js"]
+```
+
+**Why:** Single-stage images are 3-10x larger. They ship TypeScript source, devDependencies, build tools — none of which are needed at runtime.
+
+### RULE 2: Layer Caching — COPY package.json FIRST
+
+```dockerfile
+# CORRECT — package.json copied before source (cached unless deps change)
+COPY package.json pnpm-lock.yaml ./
+RUN pnpm install --frozen-lockfile
+COPY . .
+
+# WRONG — any source change busts the install cache
+COPY . .
+RUN pnpm install
+```
+
+**Why:** Docker caches layers top-down. If `package.json` hasn't changed, the `install` layer is cached. Copying all files first means every code change re-installs all dependencies.
+
+### RULE 3: Use Alpine Base Images
+
+```dockerfile
+# CORRECT — alpine is ~50MB
+FROM node:20-alpine
+
+# WRONG — full image is ~350MB
+FROM node:20
+```
+
+**Why:** Alpine is 7x smaller. Less attack surface, faster pulls, smaller registry storage.
+
+### RULE 4: Non-Root User
+
+```dockerfile
+# CORRECT — run as non-root
+RUN addgroup -S appgroup && adduser -S appuser -G appgroup
+USER appuser
+
+# WRONG — running as root
+CMD ["node", "dist/index.js"]
+```
+
+**Why:** Running as root inside a container means a container escape gives root on the host. Always drop privileges.
+
+### RULE 5: .dockerignore Exists and Is Complete
+
+Must include at minimum:
+```
+.env
+.env.*
+.git/
+node_modules/
+dist/
+coverage/
+test-results/
+playwright-report/
+.claude/
+CLAUDE.local.md
+*.log
+```
+
+**Why:** Without `.dockerignore`, `COPY . .` sends `.git/` (huge), `node_modules/` (reinstalled anyway), `.env` (secrets!), and test artifacts into the build context.
+
+### RULE 6: Frozen Lockfile for Installs
+
+```dockerfile
+# CORRECT — deterministic installs
+RUN pnpm install --frozen-lockfile
+RUN npm ci
+
+# WRONG — may resolve different versions
+RUN pnpm install
+RUN npm install
+```
+
+**Why:** `install` can resolve newer patch versions than what was tested. `--frozen-lockfile` / `ci` ensures exact versions from the lockfile.
+
+### RULE 7: Explicit EXPOSE
+
+```dockerfile
+# CORRECT — documents the port
+EXPOSE 3001
+CMD ["node", "dist/index.js"]
+
+# WRONG — no EXPOSE
+CMD ["node", "dist/index.js"]
+```
+
+**Why:** `EXPOSE` documents which ports the container listens on. Required for Docker networking and orchestrators.
+
+### RULE 8: No Secrets in Build Args (for runtime secrets)
+
+```dockerfile
+# CORRECT — runtime secrets via environment
+ENV DATABASE_URL=""
+# Set at runtime: docker run -e DATABASE_URL=...
+
+# WRONG — baked into image layer
+ARG DATABASE_URL
+RUN echo $DATABASE_URL > /app/.env
+```
+
+**Exception:** `NEXT_PUBLIC_*` variables for Next.js MUST be build args (they're baked into the JS bundle at build time). This is expected and safe — they're public values.
+
+### RULE 9: Health Check
+
+```dockerfile
+# CORRECT — Docker knows if the app is healthy
+HEALTHCHECK --interval=30s --timeout=3s --start-period=10s --retries=3 \
+  CMD wget --no-verbose --tries=1 --spider http://localhost:3001/health || exit 1
+```
+
+**Why:** Without HEALTHCHECK, Docker considers the container healthy as long as the process is running — even if it's deadlocked or returning 500s.
+
+### RULE 10: Minimize Layers
+
+```dockerfile
+# CORRECT — single RUN for related commands
+RUN corepack enable && \
+    corepack prepare pnpm@latest --activate && \
+    pnpm install --frozen-lockfile
+
+# WRONG — each RUN creates a layer
+RUN corepack enable
+RUN corepack prepare pnpm@latest --activate
+RUN pnpm install --frozen-lockfile
+```
+
+**Why:** Each `RUN` creates a cached layer. Fewer layers = smaller image and faster builds.
+
+### RULE 11: Production-Only Dependencies in Runner
+
+```dockerfile
+# CORRECT — only production deps in final image
+FROM node:20-alpine AS runner
+COPY --from=builder /app/package.json ./
+RUN pnpm install --prod --frozen-lockfile
+
+# OR: prune in builder stage
+FROM node:20-alpine AS builder
+RUN pnpm install --frozen-lockfile
+RUN pnpm build
+RUN pnpm prune --prod
+```
+
+**Why:** devDependencies (TypeScript, Vitest, Playwright, tsx) are only needed for building. Shipping them adds 100-500MB to the final image.
+
+### RULE 12: Pin Major Versions
+
+```dockerfile
+# CORRECT — predictable
+FROM node:20-alpine
+
+# WRONG — could be 20, 22, 24 tomorrow
+FROM node:alpine
+FROM node:latest
+```
+
+**Why:** `latest` or unversioned tags change without notice. Your build may suddenly break on a Node.js major version bump.
+
+## Step 3 — Generate Optimized Dockerfile
+
+If the current Dockerfile violates any rules above, generate a corrected version.
+
+Use this template as a starting point:
+
+```dockerfile
+# ============================================
+# Stage 1: Build
+# ============================================
+FROM node:20-alpine AS builder
+WORKDIR /app
+
+# Enable pnpm
+RUN corepack enable && corepack prepare pnpm@latest --activate
+
+# Install dependencies (cached unless package.json changes)
+COPY package.json pnpm-lock.yaml ./
+RUN pnpm install --frozen-lockfile
+
+# Build args for public env vars (Next.js only)
+# ARG NEXT_PUBLIC_RYBBIT_SITE_ID
+# ARG NEXT_PUBLIC_RYBBIT_URL
+
+# Copy source and build
+COPY . .
+RUN pnpm build
+
+# Prune dev dependencies
+RUN pnpm prune --prod
+
+# ============================================
+# Stage 2: Production
+# ============================================
+FROM node:20-alpine AS runner
+WORKDIR /app
+
+# Non-root user
+RUN addgroup -S appgroup && adduser -S appuser -G appgroup
+
+# Copy only what's needed
+COPY --from=builder --chown=appuser:appgroup /app/dist ./dist
+COPY --from=builder --chown=appuser:appgroup /app/node_modules ./node_modules
+COPY --from=builder --chown=appuser:appgroup /app/package.json ./
+
+# Runtime config
+ENV NODE_ENV=production
+EXPOSE 3001
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=10s --retries=3 \
+  CMD wget --no-verbose --tries=1 --spider http://localhost:3001/health || exit 1
+
+USER appuser
+CMD ["node", "dist/index.js"]
+```
+
+## Step 4 — Verify .dockerignore
+
+If `.dockerignore` is missing or incomplete, create/update it with all required entries.
+
+## Step 5 — Docker Local Test Gate (if enabled)
+
+Check `claude-mastery-project.conf` for `docker_test_before_push`:
+
+**When `docker_test_before_push = true`:**
+
+Before ANY `docker push` is allowed, you MUST run this verification sequence. If any step fails, STOP and fix the issue — do NOT push.
+
+```bash
+# 1. Build the image
+docker build -t $IMAGE_NAME .
+
+# 2. Run container locally
+docker run -d -p 3001:3001 --name test-container $IMAGE_NAME
+
+# 3. Wait for startup
+sleep 5
+
+# 4. Verify container is still running (didn't crash)
+docker ps --filter "name=test-container" --filter "status=running" -q
+
+# 5. Check health endpoint responds
+curl -sf http://localhost:3001/health || echo "HEALTH CHECK FAILED"
+
+# 6. Check container logs for fatal errors
+docker logs test-container 2>&1 | grep -iE "(error|fatal|exception|ENOENT|cannot find)" && echo "ERRORS FOUND IN LOGS"
+
+# 7. Clean up test container
+docker stop test-container && docker rm test-container
+```
+
+**Pass criteria — ALL must be true:**
+- Container is still running after 5 seconds (didn't exit with error)
+- Health endpoint returns HTTP 200
+- No fatal errors in container logs
+
+**If any check fails:** Report exactly what failed, show the logs, and do NOT push. Fix the issue first.
+
+**When `docker_test_before_push = false` (default):** Skip this step. The user manages their own testing.
+
+This gate applies to ALL docker push operations, not just `/optimize-docker`. Any command or workflow that pushes to Docker Hub must check this setting first.
+
+## Step 6 — RuleCatch Report
+
+After all changes are complete, check RuleCatch:
+
+- If the RuleCatch MCP server is available: query for violations in the modified Docker files
+- Report any violations found
+- If no MCP: suggest checking the RuleCatch dashboard
+
+## Step 7 — Report
+
+Output a summary:
+- Image size estimate (before vs after)
+- Number of violations found and fixed
+- Layer count (before vs after)
+- Security improvements made

package/.claude/commands/progress.md

@@ -0,0 +1,61 @@
+---
+description: Show project progress — what's done, what's pending, what's next
+scope: project
+allowed-tools: Read, Bash(find:*), Bash(ls:*), Bash(wc:*), Bash(git log:*)
+---
+
+# Project Progress
+
+Check the actual state of all components and report status.
+
+## Instructions
+
+1. Read `project-docs/ARCHITECTURE.md` for project context (if it exists)
+2. Check the `src/` directory structure
+3. Check the `tests/` directory for test coverage
+4. Check recent git activity
+
+## Shell Commands to Run
+
+```bash
+echo "=== Source Files ==="
+find src/ -name "*.ts" -o -name "*.tsx" | head -30 2>/dev/null || echo "No src/ directory"
+
+echo ""
+echo "=== Test Files ==="
+find tests/ -name "*.test.*" -o -name "*.spec.*" | head -30 2>/dev/null || echo "No test files"
+
+echo ""
+echo "=== Recent Activity (Last 7 Days) ==="
+git log --oneline --since="7 days ago" 2>/dev/null | head -15 || echo "No recent commits"
+
+echo ""
+echo "=== File Count by Type ==="
+find src/ -name "*.ts" 2>/dev/null | wc -l | xargs -I{} echo "TypeScript: {} files"
+find src/ -name "*.js" 2>/dev/null | wc -l | xargs -I{} echo "JavaScript: {} files"
+find tests/ -name "*.test.*" 2>/dev/null | wc -l | xargs -I{} echo "Tests: {} files"
+```
+
+## Output Format
+
+| Area | Files | Status | Notes |
+|------|-------|--------|-------|
+| Source code | N files | ... | ... |
+| Tests | N files | ... | ... |
+| Documentation | ... | ... | ... |
+
+### RuleCatch Report
+| Metric | Value |
+|--------|-------|
+| Violations (this session) | ... |
+| Critical violations | ... |
+| Most violated rule | ... |
+| Files with violations | ... |
+
+If the RuleCatch MCP server is available: query for session summary and populate the table above.
+If no MCP available: show "Install RuleCatch for violation tracking — `npx @rulecatch/mcp-server init`"
+
+### Next Actions (Priority Order)
+1. ...
+2. ...
+3. ...