configs-all 1.0.0

package/docker/mcp/registry.yaml

@@ -0,0 +1,37 @@
+registry:
+  aws-cdk-mcp-server:
+    ref: ""
+  aws-documentation:
+    ref: ""
+  awslabs-ccapi:
+    ref: ""
+  awslabs-cloudtrail:
+    ref: ""
+  awslabs-cost-explorer:
+    ref: ""
+  awslabs-iam:
+    ref: ""
+  context7:
+    ref: ""
+  desktop-commander:
+    ref: ""
+  docker:
+    ref: ""
+  dockerhub:
+    ref: ""
+  github-chat:
+    ref: ""
+  grafana:
+    ref: ""
+  neo4j-memory:
+    ref: ""
+  node-code-sandbox:
+    ref: ""
+  perplexity-ask:
+    ref: ""
+  puppeteer:
+    ref: ""
+  wikipedia-mcp:
+    ref: ""
+  youtube_transcript:
+    ref: ""

package/docs/context/2026-03-02-configs.md

@@ -0,0 +1,142 @@
+# Context Snapshot: configs
+
+_Date: 2026-03-02_
+_Verified against: commit 8203206_
+
+## Overview
+
+Centralized config repo managing shell, git, IDE, SSH, Claude Code, Docker, and app configs across 4 machines (mikmac, mikbook, duplo, mikpc). Git-based sync — each machine has its own Dropbox clone. Mac is source of truth.
+
+## Tech Stack
+
+- **Shell**: Zsh scripts (.zsh/.sh) — entire codebase
+- **Linting**: mikey-pro (Prettier + ESLint + Stylelint) via package.json
+- **JSON processing**: jq (config transforms Mac↔Windows)
+- **Validation**: plutil (plist), yq (YAML), jq (JSON), zsh -n (shell syntax)
+- **Terminals**: Ghostty, WezTerm, iTerm2
+- **IDE**: VS Code (stable + insiders), Cursor
+- **AI**: Ollama on mikpc (RTX 5090), Docker GPU services (ComfyUI, Speaches, ACE-Step)
+
+## Project Structure
+
+```
+configs/
+├── shell/           # .zshrc, aliases (8 categories), p10k, powershell
+├── git/config/      # base + personal/work/chiefmikey gitconfigs
+├── ide/             # VS Code, Cursor settings/keybindings/mcp
+├── ssh/             # Host-specific SSH configs
+├── gh/              # GitHub CLI config
+├── claude/          # Settings, hooks, commands (38), templates, scripts, desktop
+├── docker/          # ai-stack compose, MCP registry/catalog, CLI config
+├── ghostty/         # Ghostty terminal config
+├── wezterm/         # WezTerm config (Lua)
+├── iterm/           # iTerm2 plist + font
+├── wsl/             # .wslconfig, wsl.conf
+├── apps/            # Rectangle, iStat Menus, Synergy
+├── scripts/
+│   ├── sync/        # push/pull-configs.zsh, config-common.zsh (THE core engine)
+│   ├── ai/          # deploy-ai-stack.sh, fix-ai-proxy.sh
+│   ├── mcp/         # MCP wrapper scripts (.sh + .ps1)
+│   ├── install/     # fresh.zsh machine setup
+│   ├── docker/      # Cleanup + cron management
+│   ├── git/         # Git helper scripts
+│   ├── gh/          # GitHub CLI management
+│   ├── mac/         # VPN, dock, sudo-askpass
+│   ├── brew/        # Homebrew management
+│   ├── linux/       # codedeploy, coredns, wifi
+│   ├── npm/         # Upgrade helpers
+│   ├── qmk/         # Keyboard firmware build/sync
+│   └── input/       # Reusable shell input helpers
+├── docs/            # Persistent artifacts (research, context, plans, spikes, incidents, handoff, retros)
+└── templates/       # .envrc examples
+```
+
+## Development Workflow
+
+```bash
+# Deploy configs from repo → system
+./scripts/sync/push-configs.zsh
+
+# Backup system → repo
+./scripts/sync/pull-configs.zsh
+
+# Validate shell syntax
+zsh -n <file>
+
+# Validate JSON
+jq empty <file>
+
+# Docker cleanup
+./scripts/docker/cleanup/docker-cleanup.sh --dry-run
+
+# Deploy AI stack to mikpc
+./scripts/ai/deploy-ai-stack.sh
+
+# Fix WSL port proxy after restart
+./scripts/ai/fix-ai-proxy.sh
+```
+
+## Machine Registry
+
+| Machine | SSH Host | CONFIG_DIR | Git Config | SSH Config |
+|---------|---------|-----------|-----------|-----------|
+| mikmac | — | `~/Dropbox/dev/configs` | personal | config |
+| mikbook | mikbook | `~/Dropbox/mikbook/dev/configs` | personal | config |
+| duplo | duplo | `~/Dropbox/duplo/dev/chiefmikey/configs` | work | config.duplo |
+| mikpc | mikpc | `~/Dropbox/mikpc/dev/configs` | personal | config.mikpc |
+
+## Architecture
+
+### Sync Engine (config-common.zsh)
+
+Core abstractions:
+- `get_config_dest(file)` → destination path (platform/host-aware, 50+ mappings)
+- `get_validation_func(file)` → validator function
+- `safe_copy(src, dest, validator)` → validate → backup → copy (returns 0 on error)
+- `transform_mcp_mac_to_windows()` → Path/command transforms for Cursor MCP
+- `transform_cursor_settings_mac_to_windows()` → Strip Mac-only keys
+
+Claude Code special handling:
+- `push_claude_dirs()` → Sync commands/templates/scripts with stale cleanup
+- `push_mcp_servers()` → Merge into .claude.json (preserves OAuth/state), host-specific overlay
+- `enforce_claude_preferences()` → Force remoteControl + autoCompact settings
+
+### Shell Init Chain
+
+.zshrc → variables → options → completion → keybindings → plugins → functions → alias dispatcher → 8 category files (+ conditional duplo aliases)
+
+### AI Stack Split
+
+- **wolfe-server**: Web UIs (Open WebUI :3003, Perplexica :3002, n8n :5678, SearXNG :4000, Qdrant :6333)
+- **mikpc**: GPU compute (Ollama :11434, ComfyUI :8188, ACE-Step :7860, Speaches :8000)
+- Cross-machine: LAN IP 192.168.0.5 (Tailscale ACL blocks tag:wolfe)
+
+## Testing
+
+No automated test suite. Verify by:
+1. `./scripts/sync/push-configs.zsh` — check output for errors
+2. `zsh -n <file>` — syntax check shell scripts
+3. `jq empty <file>` — validate JSON configs
+
+## Recent Trajectory (last 30 commits)
+
+Major themes in reverse chronological order:
+1. **Shell aliases** — Claude shorthand aliases (c, cr, cs, claude-resume, claude-skip)
+2. **AI stack split** — Separated GPU compute (mikpc) from web UIs (wolfe-server), ACE-Step checkpoint persistence
+3. **Command suite buildout** — 38 slash commands for autonomous Claude Code operation (/partymode, /prep, /go, /research, /plans, /spike, /incident, /ship, /guard, etc.)
+4. **Plan/doc system** — Status tracking, resumability, execution journals, staleness verification
+5. **Local AI** — Ollama aliases with native API + glow, AI stack deployment scripts, WSL port proxy
+6. **MCP improvements** — GitHub MCP switched from Docker to npx, statusline metrics (cache %, cost, tokens)
+
+## Gotchas
+
+1. **duplo path** is `chiefmikey/configs` not `configs`
+2. **No `set -e`** in sync scripts — intentionally removed for graceful failures
+3. **Mac is source of truth** for Cursor/MCP — never pull from Windows
+4. **Windows backups** go to `~/.config/config-backups` (NTFS issues)
+5. **WINDOWS_USER** hardcoded to "wolfe" in config-common.zsh
+6. **WSL IP changes** on restart — run fix-ai-proxy.sh
+7. **Port 3000** taken by AdGuard on wolfe-server — Open WebUI uses 3003
+8. **Perplexica config** resets on restart — run configure.sh
+9. **SCP broken** on mikpc — use rsync
+10. **MCP merge** preserves .claude.json state — only overwrites mcpServers key

package/docs/plans/2026-02-28-autonomous-command-suite-design.md

@@ -0,0 +1,250 @@
+# Design: Autonomous Command Suite (`/context`, `/plans`, `/prep`, `/go`, `/partyon`)
+
+_Date: 2026-02-28_
+
+## Goal
+
+Replace built-in Claude Code plan mode with a suite of commands that leverage bypass permissions for deeper research, autonomous decision-making, and full end-to-end execution. The system produces persistent documentation artifacts that reduce token costs across sessions and set Claude up for maximum autonomous work with minimum human input.
+
+## Architecture
+
+```
+Standalone (each works independently):
+  /research  → docs/research/    (pure understanding — already exists)
+  /context   → docs/context/     (repo/machine knowledge snapshot)
+  /plans     → docs/plans/       (implementation steps)
+
+Orchestration:
+  /prep      → updates research → validates context → creates plan
+  /go        → executes latest plan to 100% completion with full verification
+  /partyon   → /prep + /go — full autopilot, walk away and come back to done
+```
+
+### Artifact Flow
+
+```
+docs/
+├── research/     # /research output — pure understanding, no intent
+├── context/      # /context output — implementation-scoped knowledge snapshot
+└── plans/        # /plans output — actionable implementation steps
+```
+
+Each artifact type serves a different purpose:
+
+- **Research** answers: "How does this work?"
+- **Context** answers: "What do I need to know to change this?"
+- **Plans** answers: "What exactly will I do?"
+
+Future sessions read existing artifacts first, verify against current code, and skip redundant exploration — saving significant tokens on already-understood areas.
+
+---
+
+## Command Designs
+
+### `/context` — Repo & Machine Knowledge Snapshot
+
+**Purpose:** Build a comprehensive context document for the current repo so Claude always has deep understanding without burning tokens on re-exploration every session.
+
+**Input:** None required (repo-scoped). Optional `$ARGUMENTS` to focus on a specific area.
+
+**What it gathers:**
+
+- Project CLAUDE.md (conventions, commands, architecture)
+- All `docs/research/*.md` artifacts
+- All `docs/context/*.md` (previous context snapshots — updates, doesn't duplicate)
+- Key file structure (not just listing — roles of key dirs/files)
+- Tech stack detection (package.json, requirements.txt, Makefile, etc.)
+- Recent git history (last 20-30 commits for trajectory)
+- Current machine/environment context (hostname, platform, available tools)
+- Test infrastructure (what test framework, how to run, what coverage looks like)
+- Build/deploy pipeline (CI config, deploy scripts, infra)
+- Known gotchas from MEMORY.md if relevant
+
+**Output:** `docs/context/YYYY-MM-DD-<repo-name>.md`
+
+**Key behavior:** If a context doc already exists, reads it first, verifies against current state, and updates it rather than creating a new one. The file becomes a living document that gets cheaper to maintain over time.
+
+---
+
+### `/plans` — Implementation Plan Generator
+
+**Purpose:** Generate a detailed, step-by-step implementation plan based on existing research, context, and its own code understanding. Usable standalone when you already have good context and just need the plan.
+
+**Input:** `$ARGUMENTS` — task description
+
+**What it does:**
+
+1. Reads existing `docs/context/` and `docs/research/` for the repo (doesn't re-explore — trusts these as starting context)
+2. Does targeted code reading for the specific area the task touches (file bodies, not just signatures)
+3. Makes all architectural and implementation decisions autonomously with documented rationale
+4. Writes the plan to `docs/plans/YYYY-MM-DD-<task-slug>.md`
+
+**Plan format:**
+
+```markdown
+# Plan: <Task>
+_Date: YYYY-MM-DD_
+_Context: docs/context/<file>.md_
+_Research: docs/research/<file>.md (if applicable)_
+
+## Goal
+What this plan accomplishes in 1-2 sentences.
+
+## Decisions & Rationale
+Every non-obvious choice made, with reasoning.
+
+## Steps
+1. [Step title]
+   - File: exact/path/to/file.ts
+   - What: specific change description
+   - Why: reasoning if non-obvious
+   - Verify: how to confirm this step worked
+
+## Verification Plan
+- [ ] Tests to run (unit, e2e, integration)
+- [ ] Lint/build commands
+- [ ] Manual checks (browser, API, CLI)
+- [ ] Edge cases to validate
+
+## Risks
+Known risks and mitigation for each.
+```
+
+**Key behavior:** Each step is 2-5 minutes of work, concrete enough for a subagent with zero prior context. Does NOT execute anything.
+
+---
+
+### `/prep` — The Orchestrator
+
+**Purpose:** Full preparation pipeline — updates research, validates context, creates plan. Composes the three standalone commands with added intelligence.
+
+**Input:** `$ARGUMENTS` — task description
+
+**Phases:**
+
+1. **Research phase** — deep exploration scoped to the task
+   - Reads ALL existing `docs/research/*.md` and `docs/context/*.md` first
+   - Verifies findings against actual current code (never trusts docs blindly)
+   - Updates existing research docs if stale, creates new ones if area isn't covered
+   - Writes/updates `docs/research/YYYY-MM-DD-<topic>.md`
+
+2. **Context phase** — repo snapshot
+   - If `docs/context/` exists, reads and validates against current repo state
+   - Updates the context doc with any new understanding from research phase
+   - Adds task-specific context that future agents will need
+   - Writes/updates `docs/context/YYYY-MM-DD-<repo-name>.md`
+
+3. **Plan phase** — implementation planning
+   - Has full benefit of freshly verified research + context
+   - Makes all decisions autonomously with documented rationale
+   - Writes `docs/plans/YYYY-MM-DD-<task-slug>.md`
+   - References the research and context docs in the plan header
+
+4. **Report** — outputs the three file paths and a brief summary
+
+**Key advantage over running commands separately:** `/prep` carries verified context across phases in a single session. Running them separately means each starts somewhat fresh.
+
+---
+
+### `/go` — Execute Plan to Completion
+
+**Purpose:** Read the latest plan and execute it autonomously to 100% completion, including all verification.
+
+**Input:** Optional `$ARGUMENTS` — a specific plan file path. If omitted, finds the most recent `docs/plans/*.md`.
+
+**Execution flow:**
+
+1. **Load & validate plan** — reads the plan file, checks it's well-formed
+2. **Read context** — loads linked `docs/context/` and `docs/research/` files from plan header
+3. **Execute via subagent-driven development:**
+   - Dispatch implementer subagent with the step + full context
+   - Implementer implements, tests, commits
+   - Dispatch spec compliance reviewer
+   - Dispatch code quality reviewer
+   - Fix any issues before moving to next step
+4. **Verify after every step** — run the step's verification command
+5. **Full verification at the end:**
+   - Complete test suite (unit, integration, e2e)
+   - Linter/formatter
+   - Build
+   - Browser testing if frontend (playwright/chrome MCP)
+   - API testing if backend
+   - Dry-run if infrastructure (kubectl, terraform)
+   - Whatever else the verification plan specifies
+6. **Update artifacts:**
+   - Mark plan as completed with summary
+   - Update `docs/context/` if architecture changed
+   - Commit all changes with conventional commit messages
+
+**Key behaviors:**
+
+- Never claims done without fresh verification output as evidence
+- If blocked, tries alternative approaches before asking for help
+- If a test fails, debugs and fixes — doesn't skip
+- Runs `superpowers:verification-before-completion` before any success claim
+- Runs `superpowers:finishing-a-development-branch` at the end
+
+---
+
+### `/partyon` — Full Autopilot
+
+**Purpose:** `/prep` + `/go` chained. Give it a task, walk away, come back to done.
+
+**Input:** `$ARGUMENTS` — task description
+
+**Flow:**
+
+1. Runs the full `/prep` pipeline (research → context → plan)
+2. Presents the plan for review (**single checkpoint** — the only time it stops)
+3. On approval, immediately chains into `/go`
+
+**The one checkpoint:** After the plan is written, presents a summary and waits for approval. This is the single moment of human input. Everything before and after is autonomous.
+
+**Skip checkpoint:** Add "don't wait for approval" or similar to the task description to skip the checkpoint entirely.
+
+---
+
+## Global CLAUDE.md Changes
+
+### New Section: Leveraging Existing Documentation
+
+```markdown
+## Leveraging Existing Documentation
+
+Before exploring any codebase:
+1. Check for `docs/context/` — read the most recent context snapshot
+2. Check for `docs/research/` — read all research artifacts
+3. Check for `docs/plans/` — check for in-progress or recent plans
+4. Read the project CLAUDE.md
+
+These are trusted starting points. Verify against actual code for the specific area
+you're changing, but don't re-explore what's already documented. When you produce
+new understanding, update the relevant doc so future sessions benefit.
+```
+
+### Strengthen: Autonomous Execution
+
+```markdown
+## Autonomous Execution
+
+When given a task, the goal is maximum autonomous progress with minimum human input:
+- Make best-practice decisions 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
+```
+
+---
+
+## Implementation Notes
+
+- All five new commands are `.md` files in `claude/commands/`
+- `/research` already exists — no changes needed
+- `/context` runs at Opus level (deep understanding needed)
+- `/plans` runs at Opus level (architectural decisions)
+- `/prep` runs at Opus level (orchestrates the full pipeline)
+- `/go` runs at Opus level (manages subagent execution)
+- `/partyon` runs at Opus level (orchestrates everything)
+- Global CLAUDE.md updates go in `claude/CLAUDE.md` (deployed to `~/CLAUDE.md`)