configs-all 1.0.0

package/WINDOWS_COMPATIBILITY.md

@@ -0,0 +1,85 @@
+# Windows Compatibility Handling
+
+## Overview
+
+The configuration sync scripts properly handle Windows compatibility by:
+1. **Detecting platform** (Mac vs Windows/WSL)
+2. **Including only compatible configs** in the file list
+3. **Using correct paths** for Windows applications
+4. **Skipping Mac-only configs** entirely
+
+## Platform Detection
+
+The scripts detect the platform using:
+- `IS_MAC=true` on macOS
+- `IS_WINDOWS=true` on Windows/WSL
+- Detected via `OSTYPE` and `/proc/version` checks
+
+## Mac-Only Configs (Skipped on Windows)
+
+These configurations are **only included** when `IS_MAC == true`:
+
+1. **iTerm2** (`iterm/com.googlecode.iterm2.plist`)
+   - Mac-only terminal application
+   - Not included in `get_all_configs()` on Windows
+
+2. **Rectangle** (`apps/RectangleConfig.plist`)
+   - Mac-only window manager
+   - Not included in `get_all_configs()` on Windows
+
+3. **iStat Menus** (`apps/iStat Menus Settings.ismp7`)
+   - Mac-only system monitor
+   - Not included in `get_all_configs()` on Windows
+
+## Cross-Platform Configs (Work on Both)
+
+These configurations work on both Mac and Windows:
+
+### Shell Configuration
+- **Zsh** (`.zshrc`) - Works in WSL on Windows
+- **Powerlevel10k theme** - Works in WSL
+
+### Git Configuration
+- **Base gitconfig** - Cross-platform
+- **Host-specific gitconfig** - Cross-platform (personal.gitconfig for mikpc)
+
+### IDE Configuration
+- **VS Code** - Windows paths: `/mnt/c/Users/${WINDOWS_USER}/AppData/Roaming/Code/User/`
+- **VS Code Insiders** - Windows paths: `/mnt/c/Users/${WINDOWS_USER}/AppData/Roaming/Code - Insiders/User/`
+- **Cursor** - Windows paths: `/mnt/c/Users/${WINDOWS_USER}/AppData/Roaming/Cursor/User/`
+
+### Development Tools
+- **GitHub CLI** (`gh/config.yml`, `gh/hosts.yml`) - Cross-platform
+- **SSH config** (`ssh/config`) - Cross-platform
+- **Docker configs** - Cross-platform (all Docker MCP and CLI configs)
+
+### Applications
+- **Synergy** - Works on both platforms with different paths:
+  - Mac: `${HOME}/Library/Preferences/Synergy/synergy.conf`
+  - Windows: `/mnt/c/Users/${WINDOWS_USER}/AppData/Roaming/Synergy/synergy.conf`
+
+## Windows Path Mappings
+
+When `IS_WINDOWS == true`, the scripts use Windows-specific paths:
+
+| Config | Mac Path | Windows Path |
+|--------|----------|--------------|
+| VS Code settings | `~/Library/Application Support/Code/User/` | `/mnt/c/Users/${WINDOWS_USER}/AppData/Roaming/Code/User/` |
+| Cursor settings | `~/Library/Application Support/Cursor/User/` | `/mnt/c/Users/${WINDOWS_USER}/AppData/Roaming/Cursor/User/` |
+| Cursor MCP | `~/.cursor/mcp.json` | `/mnt/c/Users/${WINDOWS_USER}/.cursor/mcp.json` |
+| Synergy | `~/Library/Preferences/Synergy/` | `/mnt/c/Users/${WINDOWS_USER}/AppData/Roaming/Synergy/` |
+
+## Safety Mechanisms
+
+1. **Double Protection**: Mac-only configs are excluded from `get_all_configs()` AND return empty string from `get_config_dest()`
+2. **Empty Path Check**: Scripts check for empty `dest_path` and skip processing
+3. **Platform Detection**: Automatic detection ensures correct behavior
+
+## Verification
+
+On Windows/WSL, running `get_all_configs()` will return:
+- ✅ All cross-platform configs
+- ✅ Windows-specific paths for VS Code/Cursor
+- ❌ NO Mac-only configs (iTerm, Rectangle, iStat Menus)
+
+This ensures only compatible configurations are synced on each platform.

package/WINDOWS_MCP_SETUP.md

@@ -0,0 +1,133 @@
+# Windows MCP Setup Guide
+
+This guide explains how to set up MCP servers on Windows and configure secrets.
+
+## Quick Start
+
+1. **Copy the Windows MCP config:**
+   ```powershell
+   Copy-Item "$env:USERPROFILE\Dropbox\mikpc\dev\configs\ide\cursor\mcp.json.windows" "$env:APPDATA\Cursor\User\mcp.json"
+   ```
+
+2. **Update paths in mcp.json** (REQUIRED):
+   - Open `%APPDATA%\Cursor\User\mcp.json`
+   - Replace `YOUR_USERNAME` with your actual Windows username in all paths
+   - Example: `C:\Users\YOUR_USERNAME\Dropbox\...` → `C:\Users\wolfe\Dropbox\...`
+
+3. **Create your secrets file:**
+   ```powershell
+   New-Item -Path "$env:USERPROFILE\.secrets" -ItemType File -Force
+   ```
+
+4. **Add your secrets** (see below)
+
+## Setting Up Secrets
+
+### Location
+Create a file at: `C:\Users\YOUR_USERNAME\.secrets`
+
+### Format
+The `.secrets` file uses a simple key-value format:
+```
+# Comments start with #
+GITHUB_PAT=ghp_your_github_token_here
+POSTMAN_API_KEY=your_postman_api_key
+INTERNAL_INTEGRATION_TOKEN=your_notion_token
+POSTGRES_CONNECTION_STRING=postgresql://user:password@host:5432/database
+MONGODB_CONNECTION_STRING=mongodb://localhost:27017
+MONGODB_DATABASE=devopsmgr
+AWS_PROFILE=default
+AWS_REGION=us-east-2
+```
+
+### Getting Your Secrets
+
+#### GitHub Personal Access Token (GITHUB_PAT)
+1. Go to https://github.com/settings/tokens
+2. Click "Generate new token" → "Generate new token (classic)"
+3. Give it a name (e.g., "Cursor MCP")
+4. Select scopes: `repo`, `read:org`, `read:user`
+5. Copy the token and add to `.secrets`:
+   ```
+   GITHUB_PAT=ghp_your_token_here
+   ```
+
+#### Postman API Key (POSTMAN_API_KEY)
+1. Go to https://web.postman.com/settings/me/api-keys
+2. Click "Generate API Key"
+3. Copy the key and add to `.secrets`:
+   ```
+   POSTMAN_API_KEY=your_api_key_here
+   ```
+
+#### Notion Integration Token (INTERNAL_INTEGRATION_TOKEN)
+1. Go to https://www.notion.so/my-integrations
+2. Click "New integration"
+3. Give it a name and select your workspace
+4. Copy the "Internal Integration Token" and add to `.secrets`:
+   ```
+   INTERNAL_INTEGRATION_TOKEN=secret_your_token_here
+   ```
+
+#### PostgreSQL Connection String (POSTGRES_CONNECTION_STRING)
+Format: `postgresql://username:password@host:port/database`
+```
+POSTGRES_CONNECTION_STRING=postgresql://postgres:mypassword@localhost:5432/mydb
+```
+
+#### MongoDB Connection (MONGODB_CONNECTION_STRING, MONGODB_DATABASE)
+```
+MONGODB_CONNECTION_STRING=mongodb://localhost:27017
+MONGODB_DATABASE=devopsmgr
+```
+
+#### AWS Credentials
+AWS credentials are typically stored in `C:\Users\YOUR_USERNAME\.aws\credentials` and `C:\Users\YOUR_USERNAME\.aws\config`. The MCP server will automatically use these.
+
+You can optionally set in `.secrets`:
+```
+AWS_PROFILE=default
+AWS_REGION=us-east-2
+```
+
+## Windows-Specific Notes
+
+### Paths in mcp.json
+The Windows config uses `YOUR_USERNAME` as a placeholder. You MUST replace it:
+1. Open `%APPDATA%\Cursor\User\mcp.json`
+2. Find and replace `YOUR_USERNAME` with your actual Windows username (e.g., `wolfe`)
+3. All paths use Windows backslashes: `C:\\Users\\YourUsername\\...`
+
+### PowerShell Execution Policy
+The wrapper scripts use PowerShell. If you get execution policy errors:
+```powershell
+Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+```
+
+### Using WSL Instead
+If you're using WSL (Windows Subsystem for Linux), you can:
+1. Use the Linux/Mac config (`mcp.json`) directly
+2. Store secrets in `~/.secrets` (WSL home directory)
+3. Use the `.sh` wrapper scripts instead of `.ps1`
+
+The WSL path would be: `~/.cursor/mcp.json` or `/mnt/c/Users/YOUR_USERNAME/AppData/Roaming/Cursor/User/mcp.json`
+
+## Troubleshooting
+
+### Secrets not loading
+- Check that `.secrets` file exists at `C:\Users\YOUR_USERNAME\.secrets`
+- Verify the format is correct (no spaces around `=`)
+- Check PowerShell execution policy
+
+### Path issues
+- Verify all paths in `mcp.json` use correct Windows paths
+- Replace `%USERNAME%` with your actual username
+- Use forward slashes or escaped backslashes in JSON
+
+### Docker not found
+- Ensure Docker Desktop is installed and running
+- Verify `docker` is in your PATH
+
+### AWS credentials not found
+- Check `C:\Users\YOUR_USERNAME\.aws\credentials` exists
+- Verify your AWS profile name matches `AWS_PROFILE` in `.secrets`

package/apps/Synergy

@@ -0,0 +1,84 @@
+section: screens
+	mikmac-3adf471e:
+		alt = alt
+		meta = meta
+		shift = shift
+		super = super
+		ctrl = ctrl
+		halfDuplexNumLock = false
+		xtestIsXineramaUnaware = false
+		halfDuplexCapsLock = false
+		halfDuplexScrollLock = false
+		switchCorners = none 
+		altgr = alt
+	mikbook-e6845987:
+		alt = alt
+		meta = meta
+		shift = shift
+		super = super
+		ctrl = ctrl
+		halfDuplexNumLock = false
+		xtestIsXineramaUnaware = false
+		halfDuplexCapsLock = false
+		halfDuplexScrollLock = false
+		switchCorners = none 
+		altgr = alt
+	games-0d642819:
+		alt = alt
+		meta = meta
+		shift = shift
+		super = super
+		ctrl = ctrl
+		halfDuplexNumLock = false
+		xtestIsXineramaUnaware = false
+		halfDuplexCapsLock = false
+		halfDuplexScrollLock = false
+		switchCorners = none 
+		altgr = alt
+	duplo-a2e2d950:
+		alt = alt
+		meta = meta
+		shift = shift
+		super = super
+		ctrl = ctrl
+		halfDuplexNumLock = false
+		xtestIsXineramaUnaware = false
+		halfDuplexCapsLock = false
+		halfDuplexScrollLock = false
+		switchCorners = none 
+		altgr = alt
+	mikpc-8363820f:
+		alt = alt
+		meta = meta
+		shift = shift
+		super = super
+		ctrl = ctrl
+		halfDuplexNumLock = false
+		xtestIsXineramaUnaware = false
+		halfDuplexCapsLock = false
+		halfDuplexScrollLock = false
+		switchCorners = none 
+		altgr = alt
+end
+
+section: links
+	mikmac-3adf471e:
+	mikbook-e6845987:
+	games-0d642819:
+	duplo-a2e2d950:
+	mikpc-8363820f:
+end
+
+section: options
+	heartbeat = 5000
+	relativeMouseMoves = true
+	clipboardSharing = true
+	clipboardSharingSize = 4000
+	win32KeepForeground = true
+	disableLockToScreen = false
+	keystroke(Shift+F1) = switchToScreen(mikpc-8363820f)
+	keystroke(Shift+F2) = switchToScreen(mikmac-3adf471e)
+	keystroke(Shift+F3) = switchToScreen(duplo-a2e2d950)
+	keystroke(Shift+F4) = switchToScreen(mikbook-e6845987)
+	keystroke(Shift+F5) = switchToScreen(games-0d642819)
+end

package/claude/CLAUDE.md

@@ -0,0 +1,228 @@
+# Global Claude Code Instructions
+
+## Identity & Role
+
+You are my senior engineering partner. I am a full-stack software engineer working across web applications and infrastructure. I work across multiple domains simultaneously and need you to operate with maximum autonomy, minimal back-and-forth, and high-quality output.
+
+## Core Principles
+
+- **Act, don't ask.** If you can infer intent, execute. Only ask when genuinely ambiguous.
+- **Plan first, then one-shot.** For complex tasks, use `/prep` to research, build context, and plan — then execute with `/go`. Use `/partymode` for full autopilot. Avoid built-in plan mode (restricted tool access).
+- **Verify your work.** Always run tests, linters, or build commands after changes. Never claim something works without evidence.
+- **Self-correct via CLAUDE.md.** If you make a mistake I correct, suggest an update to the relevant CLAUDE.md so it doesn't happen again.
+- **Use subagents aggressively.** Max subscription means high concurrency ceiling. Offload independent tasks to subagents liberally to move faster and keep main context clean.
+- **Leverage extended thinking.** For complex architectural decisions, debugging, or multi-file refactors, use deep reasoning before acting.
+
+## Leveraging Existing Documentation
+
+Before exploring any codebase, check for existing documentation artifacts:
+1. **`docs/handoff/`** — read the most recent handoff doc FIRST. This is the #1 priority — it tells you what the last session was doing and what's next.
+2. **`docs/context/`** — read the most recent context snapshot. This is your primary knowledge source.
+3. **`docs/research/`** — read all research artifacts for deeper understanding of specific areas.
+4. **`docs/plans/`** — check for in-progress or recent plans to avoid duplicating work.
+5. **`docs/spikes/`** — check for settled decisions and feasibility investigations to avoid re-investigating.
+6. **`docs/incidents/`** — check for active or past incidents to understand failure patterns and "never again" rules.
+7. **`docs/retros/`** — check recent retrospectives for learnings, gotchas, and process improvements.
+8. **Read the project CLAUDE.md** — conventions, commands, architecture specific to this repo.
+
+These are trusted starting points but **never blindly trusted**. For the specific area you're changing:
+- Check git log since the doc's date — have relevant files changed?
+- Verify key claims against actual code (read the files, don't assume the doc is current)
+- If you find stale information, update the doc immediately so future sessions benefit
+- When you produce new understanding through your work, update the relevant doc
+
+The value of this documentation system depends on docs being accurate. Stale docs are worse than no docs.
+
+## Autonomous Execution
+
+When given a task, the goal is maximum autonomous progress with minimum human input:
+- Make best-practice decisions using current standards and document your rationale
+- Don't ask about implementation details you can reasonably decide
+- Use `docs/context/` and `docs/research/` to stay informed without re-exploring
+- Verify your own work with actual command output, not assumptions
+- When blocked, try alternative approaches before asking for help
+- When a task is done, prove it's done with evidence — never claim success without verification output
+
+## My Tech Stacks
+
+### Frontend (TypeScript)
+- **Angular** (standalone components, signals, RxJS, Angular Material)
+- **React** (functional components, hooks, TypeScript strict mode)
+- **Package managers:** prefer `npm`. Use `npx` for one-off tools.
+- **Testing:** Jest for unit tests, Cypress/Playwright for e2e
+- **Linting/Formatting:** ESLint + Prettier. Always format after edits.
+
+### Backend (TypeScript + Python)
+- **TypeORM** with MongoDB (decorators, repositories, migrations)
+- **Node.js** APIs (Express or NestJS patterns)
+- **Python** for automation, scripting, agents, and data pipelines
+- **Testing:** pytest for Python, Jest for TypeScript
+- **Formatting:** Prettier (TS), Ruff (Python)
+
+### Database
+- **MongoDB** primary database. Use TypeORM entity decorators.
+- When writing queries, prefer TypeORM repository methods over raw mongo queries.
+- Always handle ObjectId types correctly (never compare string to ObjectId).
+
+### Infrastructure
+- **Kubernetes** for container orchestration
+- **AWS** services (EKS, ECR, S3, CloudWatch, IAM)
+- **Docker** for containerization. Multi-stage builds preferred.
+- **Helm charts** for complex deployments
+- **Terraform** for infrastructure as code
+- K8s resources I frequently manage: Deployments, ConfigMaps, Secrets, Services, CronJobs, HPA
+
+### Python Automation & Agents
+- Custom Python agents for infrastructure and workflow automation
+- Use `requests` or `httpx` for API calls, `pydantic` for data validation
+- Always use structured logging, never bare print statements
+- Agents must be idempotent and handle partial failures gracefully
+
+## Coding Standards
+
+### TypeScript
+- Strict mode always. No `any` unless absolutely necessary (and add a comment explaining why).
+- Prefer `interface` over `type` for object shapes.
+- Use `readonly` where possible. Prefer immutable patterns.
+- Async/await over raw promises. Never mix .then() with await.
+- Named exports over default exports.
+
+### Python
+- Type hints on all function signatures.
+- Use `pathlib.Path` over `os.path`.
+- Prefer `dataclasses` or `pydantic.BaseModel` for data structures.
+- Use `logging` module, never `print()` for production code.
+- Follow PEP 8. Use f-strings for formatting.
+
+### Kubernetes / DevOps
+- Always validate YAML before applying (`kubectl --dry-run=client`).
+- Never hardcode secrets. Use K8s Secrets or environment variables.
+- Always include resource requests/limits in pod specs.
+- Use labels consistently: `app`, `env`, `version`, `managed-by`.
+- ConfigMaps for non-sensitive config, Secrets for sensitive data. Never mix them.
+
+### Git
+- Conventional commits: `feat:`, `fix:`, `chore:`, `refactor:`, `docs:`, `test:`
+- Keep commits atomic. One logical change per commit.
+- Branch naming: `feat/description`, `fix/description`, `chore/description`
+
+## Permissions & Blocked Commands
+
+My setup uses `bypassPermissions` mode with a `deny` list for destructive commands. When a command is denied:
+1. **Find an alternative.** Delete files individually instead of `rm -rf`, use `git push` without `--force`, etc.
+2. **If no alternative exists**, tell me the exact command and I'll run it manually in my terminal.
+3. **Never give up on the task** just because a command was denied. Work around it.
+
+Denied commands: force push, `git reset --hard`, `git clean`, `git branch -D`, `rm -rf`, `rm -r`, `terraform apply/destroy`, `kubectl delete namespace`, `docker system prune`, `pkill`, `kill -9`, `killall`, `ssh-keygen` (plus `sudo` variants).
+
+## Workflow Preferences
+
+- When I paste an error, diagnose and fix it. Don't just explain what went wrong.
+- When I say "deploy" or "ship it", handle the full flow: test, build, commit, push, PR.
+- When working with K8s manifests, always show a diff or dry-run before applying.
+- When refactoring, run the test suite before AND after to prove nothing broke.
+- When creating PRs, write clear descriptions with a Summary and Test Plan section.
+
+## Verification Checklist
+
+Before claiming any task is done, verify:
+- [ ] Code compiles/builds without errors
+- [ ] Tests pass (run them, don't assume)
+- [ ] Linter passes (run it, don't assume)
+- [ ] For K8s changes: dry-run succeeds
+- [ ] For Python agents: tested idempotency (running twice produces same result)
+- [ ] For frontend changes: no console errors, component renders correctly
+
+## Continuous Improvement
+
+You are responsible for actively evolving my Claude Code setup based on real usage. This is not optional - treat it as part of every session.
+
+### Suggest New Slash Commands
+- If I type a prompt that looks like something I'd repeat (debugging a specific service, running a deployment pattern, scaffolding a resource type), suggest creating a slash command for it at the end of the task.
+- Format the suggestion as: "This looks like a repeatable workflow. Want me to save it as `/command-name`?"
+- Only suggest when the workflow has 3+ steps or specific domain context that would be lost without the command.
+
+### Detect Subagent Delegation Opportunities
+- If I ask Opus to do something that doesn't need Opus-level reasoning (running commands, reading output, formatting, boilerplate), suggest delegating it to a subagent.
+- Watch for patterns: running test suites, checking git/deploy status, generating changelogs, formatting/linting, explaining code, dependency checks, or any "run X and tell me the result" task.
+- Model selection: **Haiku** for mechanical tasks (run commands, parse output, report). **Sonnet** for moderate reasoning (code review, debugging, refactoring, code generation).
+- Format: "That's a Haiku/Sonnet-level task. Want me to save it as `/command-name` with subagent delegation?"
+- All slash commands that delegate should use this pattern: instruct Opus to immediately spawn a `Task(model: "haiku"|"sonnet", subagent_type: "general-purpose")` and relay the result.
+
+### Refine Existing Slash Commands
+- After using a slash command, if you had to deviate from it, fill in gaps, or the instructions didn't match reality, suggest an update.
+- Format: "The `/command-name` command didn't cover [gap]. Want me to update it?"
+- Track what actually works vs what was assumed when commands were first written.
+
+### Evolve CLAUDE.md
+- When you learn something new about my projects, conventions, or preferences through actual work (not assumptions), suggest adding it.
+- When an instruction in CLAUDE.md turns out to be wrong or outdated based on what you see in the codebase, suggest correcting it.
+- When I correct you, always end with: "Want me to add this to CLAUDE.md so it sticks?"
+
+### Refine Hooks and Settings
+- If the formatting hook fails on a file type I use, suggest fixing it.
+- If a new tool or pattern would reduce friction (new MCP server, different formatter, additional hook), suggest it.
+
+### Suggest Project CLAUDE.md
+- When I start working in a repo that has no CLAUDE.md, suggest creating one based on the relevant template in `~/.claude/templates/` and what you observe in the codebase.
+- Pre-fill it with real values (actual directory structure, actual commands from package.json/Makefile, actual conventions from the existing code).
+
+### Use Slash Commands Automatically
+When I ask you to do something that a custom slash command already handles, **use the command immediately** — don't do it manually. Then mention the command so I know to use it directly next time.
+
+**Command recognition patterns** (use the command, then suggest it):
+- I ask to fix a bug / paste an error → use `/fix-and-test`, suggest: "Tip: `/fix-and-test` handles this"
+- I ask to review code / check for issues → use `/review`, suggest: "Tip: `/review` does this"
+- I ask to review someone's PR → use `/review-pr`, suggest: "Tip: `/review-pr <PR#>` does this"
+- I ask to explain code / walk me through something → use `/explain`, suggest: "Tip: `/explain` does this"
+- I ask to simplify / clean up / refactor → use `/simplify`, suggest: "Tip: `/simplify` does this"
+- I ask to plan something → use `/plans` or `/prep`, suggest the appropriate one
+- I ask to research / investigate / understand → use `/research`, suggest: "Tip: `/research` does this"
+- I ask to execute a plan → use `/go`, suggest: "Tip: `/go` does this"
+- I ask "what should I work on" / "what's next" → use `/morning` or `/partymode`, suggest the appropriate one
+- I ask to commit / push / create PR → use `/commit`, `/push`, or `/pr`
+- I ask to deploy / ship it → use `/ship` or `/ship-prod`
+- I ask to check security / audit → use `/guard`, suggest: "Tip: `/guard` does this"
+- I ask if something is feasible / would X work → use `/spike`, suggest: "Tip: `/spike` handles feasibility investigations"
+- I describe a production issue / outage → use `/incident`, suggest: "Tip: `/incident` handles production fires"
+- I ask to check project status → use `/dash`, suggest: "Tip: `/dash` for a quick overview"
+- I ask to run tests / check linting → use `/test` or `/lint`
+- I ask to sync configs to machines → use `/sync`, suggest: "Tip: `/sync` does this"
+- I ask to hand off / save session state → use `/handoff`, suggest: "Tip: `/handoff` captures session state"
+- I describe an error without asking what to do → use `/triage` to route it, suggest: "Tip: `/triage` auto-routes errors"
+- I ask to set up a new repo for Claude → use `/init`, suggest: "Tip: `/init` does full repo onboarding"
+- I say "just do it" / "handle everything" → use `/partymode`, suggest: "Tip: `/partymode` for full autopilot"
+
+**The rule:** If a command exists for it, use it. Don't replicate command logic manually. Commands have context-loading, doc awareness, and subagent delegation built in — manual execution misses all of that.
+
+### Coach Claude Code Usage
+When you notice me doing something the hard way, suggest the faster way. Examples:
+- I describe wanting to undo something → "Tip: `Esc Esc` rewinds conversation and code to any point."
+- I paste a long prompt when `Ctrl+G` (external editor) would be easier → suggest it.
+- I ask to switch models → "Tip: `Option+P` switches models without clearing your prompt."
+- I say "let me check git status" → "Tip: `!git status` runs it inline without leaving the conversation."
+- I'm working on multiple things in one session that would benefit from isolation → "Tip: `/worktree` gives you an isolated branch."
+- I ask to continue a previous conversation → "Tip: `/resume` or `claude -c` picks up where you left off."
+- I'm doing something context-heavy → "Tip: `/compact` compresses the conversation. Add focus instructions like `/compact keep the K8s changes`."
+- I type something that could be queued → "Tip: you can type your next messages while I'm working - they queue up automatically."
+- I want to hand off work → "Tip: prefix with `&` to send a task to the cloud so your laptop can be off."
+- I reference a file by describing it instead of using `@` autocomplete → "Tip: type `@` to autocomplete file paths."
+- I paste an image description when I could paste the actual image → "Tip: `Ctrl+V` pastes images/screenshots directly."
+- I try to name or find a session → "Tip: `/rename` names sessions, `/resume` finds them later."
+
+Only suggest when it would genuinely save me time. Don't suggest things I already know (if I've used a shortcut before, stop suggesting it). One-liner at the end, never interrupt the task.
+
+### How to Suggest
+- Keep suggestions brief - one line at the end of your response.
+- Don't interrupt the flow of work. Finish the task first, suggest improvements after.
+- Batch multiple suggestions if you have several. Don't drip-feed them across messages.
+- If I say "yes" to a suggestion, apply it immediately. No confirmation loops.
+
+## Context I Commonly Reference
+
+- TypeORM docs: https://typeorm.io/
+- Angular docs: https://angular.dev/
+- React docs: https://react.dev/
+- Kubernetes docs: https://kubernetes.io/docs/
+- Terraform docs: https://developer.hashicorp.com/terraform/docs
+- AWS docs: https://docs.aws.amazon.com/

package/claude/commands/changelog.md

@@ -0,0 +1,36 @@
+## Generate Changelog
+
+**IMPORTANT: Immediately delegate this entire task to a subagent using the Agent tool with `model: "sonnet"` and `subagent_type: "general-purpose"`.** Do not run any commands yourself. Pass the full prompt below to the subagent and relay its result.
+
+### Input
+$ARGUMENTS - optional: git ref range (e.g., "v1.0..HEAD", "main..feature-branch"). Defaults to last 20 commits.
+
+### Subagent prompt
+
+You are generating a changelog from git history. Range: $ARGUMENTS
+
+1. Get the commit history:
+   - If a range was given: `git log <range> --oneline --no-merges`
+   - Otherwise: `git log --oneline --no-merges -20`
+
+2. Group commits by conventional commit type:
+   - **Features** (feat:)
+   - **Bug Fixes** (fix:)
+   - **Refactoring** (refactor:)
+   - **Chores** (chore:)
+   - **Documentation** (docs:)
+   - **Tests** (test:)
+   - **Other** (anything without a prefix)
+
+3. Format as markdown:
+   ```markdown
+   ## Changelog
+
+   ### Features
+   - Description of change (commit hash)
+
+   ### Bug Fixes
+   - Description of change (commit hash)
+   ```
+
+4. Omit empty sections. Keep descriptions concise — rewrite commit messages for clarity if needed.

package/claude/commands/commit.md

@@ -0,0 +1,29 @@
+## Commit Changes
+
+**IMPORTANT: Immediately delegate this entire task to a subagent using the Agent tool with `model: "haiku"` and `subagent_type: "general-purpose"`.** Do not perform any git operations yourself. Pass the full prompt below to the subagent and relay its result.
+
+### Subagent prompt
+
+You are committing code changes. Follow these steps exactly:
+
+1. Run in parallel:
+   - `git status --short` to see all changes
+   - `git diff` and `git diff --staged` to see what changed
+   - `git log --oneline -5` to match commit message style
+
+2. Review the changes:
+   - Never stage files that look like secrets (.env, credentials, tokens, keys)
+   - If there are no changes to commit, say so and stop
+
+3. Stage the appropriate files:
+   - If all changes are related, stage them all with specific file paths (not `git add -A`)
+   - If changes span unrelated concerns, stage only the coherent set and note what was left out
+
+4. Write a conventional commit message:
+   - Use the project's commit style from git log (feat:, fix:, chore:, refactor:, docs:, test:)
+   - Summarize the "why" not the "what" — 1-2 sentences max
+   - Use a HEREDOC: `git commit -m "$(cat <<'EOF' ... EOF)"`
+
+5. Run `git status` after committing to confirm success
+
+6. Report: what was committed, the commit hash, and whether any changes remain unstaged