configs-all 1.0.0

package/claude/commands/ship.md

@@ -0,0 +1,82 @@
+## Ship to Dev
+
+Full deployment pipeline — test, lint, build, commit, push, create PR, deploy to dev environment, and monitor until healthy. Does not stop until the deployment is verified and logs are clean.
+
+**Do NOT delegate this command to a subagent.** This is an orchestration command — Opus runs it directly.
+
+### Input
+$ARGUMENTS - optional description of what's being shipped. If omitted, infers from recent commits and uncommitted changes.
+
+### Instructions
+
+1. **Gather deployment context:**
+   - Read project CLAUDE.md and `docs/context/` for deployment workflow
+   - Detect deployment method:
+     - Check for `.github/workflows/` → GitHub Actions CI/CD
+     - Check for `Dockerfile` / `docker-compose.yml` → Docker/Compose
+     - Check for `k8s/`, `manifests/`, `Chart.yaml` → Kubernetes/Helm
+     - Check for `terraform/` → Terraform
+     - Check for `appspec.yml`, `taskdef.json`, `ecs-params.yml` → AWS ECS
+     - Check for `Procfile` / `app.json` → Heroku/PaaS
+   - Detect if deployment is automatic on PR merge or requires manual dispatch
+   - Identify the dev/staging environment target
+
+2. **Pre-flight verification** (run in parallel):
+   - Run full test suite — ALL must pass
+   - Run linter — zero errors
+   - Run build — must succeed
+   - `git status` — check for uncommitted changes
+   - Check current branch is synced with remote
+
+3. **If any pre-flight fails:** diagnose, fix, re-verify. Do not proceed until everything passes.
+
+4. **Commit and push:**
+   - Stage relevant changes (not .env, credentials, etc.)
+   - Commit with conventional commit message
+   - Ensure branch is rebased on main/master (pull latest, rebase if needed)
+   - Push to remote with `-u` flag
+
+5. **Create PR:**
+   - Use `gh pr create` with clear title and description
+   - Include Summary and Test Plan sections
+   - Link any related issues
+
+6. **Deploy to dev:**
+   - **If CI/CD auto-deploys on PR:** Monitor the CI pipeline:
+     - `gh pr checks --watch` or poll `gh run list` until deployment workflow completes
+     - If the deploy workflow fails, read logs with `gh run view --log-failed`, diagnose, fix, and re-push
+   - **If manual dispatch needed:**
+     - `gh workflow run <deploy-workflow> --ref <branch>` or the appropriate trigger
+     - Monitor until the workflow completes
+   - **If Docker Compose:** Run `docker compose up -d` on the target (via SSH if remote)
+   - **If K8s:** Apply manifests with `kubectl apply --dry-run=client` first, then apply. Watch rollout: `kubectl rollout status deployment/<name>`
+   - **If ECS:** Check service update: `aws ecs describe-services` and wait for running count to match desired
+
+7. **Post-deploy monitoring:**
+   - **Container/pod logs:** Tail logs for 30-60 seconds looking for errors:
+     - K8s: `kubectl logs -f deployment/<name> --tail=50 --timeout=60s`
+     - ECS: `aws logs tail <log-group> --since 5m`
+     - Docker: `docker compose logs --tail=50 -f` (with timeout)
+   - **Health checks:** Hit health endpoints if available (from docs/context)
+   - **Error scanning:** Look for ERROR, FATAL, panic, unhandled, exception in logs
+   - **Resource checks:** Pod/container status, restart counts, memory/CPU if available
+
+8. **If monitoring finds issues:**
+   - Diagnose from logs
+   - Fix the code
+   - Re-run pre-flight verification
+   - Push the fix
+   - Re-monitor
+   - Do NOT mark as done until logs are clean
+
+9. **Report:**
+   ```
+   ## Ship Report
+   - **PR:** <URL>
+   - **CI Status:** passing
+   - **Deployed to:** <dev environment>
+   - **Deployment method:** <CI/CD auto / manual dispatch / kubectl / etc.>
+   - **Health check:** passing
+   - **Logs:** clean (monitored for N seconds)
+   - **Status:** Healthy and verified
+   ```

package/claude/commands/simplify.md

@@ -0,0 +1,42 @@
+## Code Simplifier
+
+**Before delegating, gather project context:**
+1. Check if `docs/context/` has a context snapshot — if so, read the most recent one and extract the Patterns & Conventions and Architecture sections
+2. Read the project CLAUDE.md if it exists — extract Conventions section
+3. Pass this context to the subagent below so it knows which patterns to preserve
+
+**Then delegate this task to a subagent using the Agent tool with `model: "sonnet"` and `subagent_type: "general-purpose"`.** Pass the full prompt below (with context injected) to the subagent and relay its result.
+
+### Input
+$ARGUMENTS - file path or "all" for all recently changed files
+
+### Subagent prompt
+
+You are simplifying code without changing behavior. Target: $ARGUMENTS
+
+**Project Context:**
+[Inject Patterns & Conventions, Architecture from docs/context if available]
+[Inject Conventions from project CLAUDE.md if available]
+If no project context is available, infer conventions from the codebase before simplifying.
+
+1. If "all", run `git diff --name-only` to get changed files. Otherwise use the specified file(s).
+
+2. Read each file and look for:
+   - Dead code, unused imports, unused variables
+   - Overly complex conditionals that can be simplified
+   - Duplicated logic that can be extracted (only if used 3+ times)
+   - Unnecessary abstractions or over-engineering
+   - Verbose patterns that have simpler equivalents
+
+3. Apply simplifications. Do NOT:
+   - Change public APIs or function signatures
+   - Alter behavior or logic
+   - Add new features or "improvements"
+   - Remove meaningful comments
+   - Break established project conventions (use project context to know what these are)
+
+4. Run the relevant test suite to verify nothing broke:
+   - TypeScript: `npx jest` or `npm test`
+   - Python: `pytest -v`
+
+5. Show a summary of simplifications made with before/after for each change.

package/claude/commands/spike.md

@@ -0,0 +1,110 @@
+## Technical Spike — Timeboxed Investigation with Decision Artifact
+
+Explore whether something is feasible, compare approaches, or answer a technical question. Produces a persistent decision artifact that future `/prep` and `/plans` agents can reference so the same question never gets investigated twice.
+
+Different from `/research` (which understands what exists) — a spike proves what's possible by writing throwaway code, benchmarking, testing integrations, and producing a go/no-go decision.
+
+**Do NOT delegate this command to a subagent.** This is an orchestration command — Opus runs it directly.
+
+### Input
+$ARGUMENTS - optional: the question or hypothesis to investigate (e.g., "can we use WebSockets instead of polling?", "is Redis worth adding for caching?"). If omitted, check for IN PROGRESS spikes to resume.
+
+### Instructions
+
+1. **Check for existing spikes:**
+   - If `$ARGUMENTS` is empty, scan `docs/spikes/` for `_Status: IN PROGRESS_` — resume the most recent one
+   - If no in-progress spikes exist and no arguments given, tell the user to provide a question
+   - If `$ARGUMENTS` is provided, check `docs/spikes/` for existing spikes on the same topic — don't duplicate work
+   - If a completed spike already answers the question, report its findings and decision instead of re-investigating
+
+2. **Load context and frame the investigation:**
+   - Read `docs/context/` for the most recent context snapshot — understand the current architecture
+   - Read project CLAUDE.md if it exists — understand conventions and constraints
+   - Read `docs/research/` for any relevant research on the topic area
+   - Read `docs/spikes/` for related past investigations — build on prior work
+   - Read `docs/incidents/` for past incidents in this area — what has broken before?
+
+3. **Frame the investigation** (informed by the context above):
+   - State the **Question** — what are we trying to answer?
+   - State the **Hypothesis** — what do we think the answer is and why?
+   - Define **Success Criteria** — what evidence would confirm or deny the hypothesis?
+   - Define **Scope Boundary** — what are we NOT investigating? (prevents scope creep)
+
+4. **Create the spike document** at `docs/spikes/YYYY-MM-DD-<topic-slug>.md`:
+
+   ```markdown
+   # Spike: <Question>
+   _Status: IN PROGRESS_
+   _Started: YYYY-MM-DD_
+   _Phase: Investigation_
+
+   ## Question
+   What we're trying to answer.
+
+   ## Hypothesis
+   What we think the answer is and why.
+
+   ## Success Criteria
+   - [ ] Criterion 1
+   - [ ] Criterion 2
+
+   ## Scope Boundary
+   What we're NOT investigating.
+
+   ## Investigation Log
+
+   ### Attempt 1: [Approach]
+   **What:** What was tried
+   **Result:** What happened
+   **Evidence:** Command output, benchmarks, code snippets
+
+   ## Evidence Summary
+
+   | Approach | Feasible? | Effort | Trade-offs |
+   |----------|-----------|--------|------------|
+
+   ## Decision
+   _Pending investigation completion_
+
+   ## Recommendation
+   _Pending_
+
+   ## Next Steps
+   _Pending_
+   ```
+
+5. **Investigate:**
+   - Try the most promising approach first
+   - Write throwaway code if needed — don't over-engineer, just prove feasibility
+   - Run benchmarks, test integrations, check compatibility
+   - Log each attempt in the Investigation Log with actual evidence (command output, measurements, code)
+   - Update `_Phase_` as you progress: `Investigation` → `Evidence Gathering` → `Decision`
+   - If an approach fails, log why and try the next one
+   - Update the Evidence Summary table after each approach tested
+
+6. **Reach a decision:**
+   - Review all evidence against the Success Criteria
+   - Fill in the **Decision** section with one of:
+     - **GO** — feasible and recommended. Proceed to implementation.
+     - **NO-GO** — not feasible or not worth it. Document why.
+     - **CONDITIONAL** — feasible under certain conditions. Document the conditions.
+   - Fill in **Recommendation** — what should be done next based on this decision
+   - Fill in **Next Steps** — concrete actions (e.g., "create a `/plans` for X", "add to backlog", "needs further spike on Y")
+
+7. **Finalize:**
+   - Check all Success Criteria boxes (met or not met)
+   - Update `_Status: COMPLETED_` (or `_Status: ABANDONED_` if the question became irrelevant)
+   - Add `_Completed: YYYY-MM-DD_`
+   - Add `_Decision: GO/NO-GO/CONDITIONAL_`
+   - Clean up any throwaway code created during investigation
+   - If the spike changes understanding of the architecture, update `docs/context/`
+
+8. **Report:** The question, the decision, key evidence, and recommended next steps.
+
+### Critical Rules
+
+- **Evidence over opinion.** Every claim in the Decision must be backed by actual output, measurements, or tested code.
+- **Log everything.** Even failed approaches are valuable — they prevent future agents from re-trying dead ends.
+- **Don't implement.** A spike proves feasibility. Implementation comes after via `/plans` and `/go`.
+- **Don't scope-creep.** Stick to the Scope Boundary. If new questions emerge, note them in Next Steps as separate spikes.
+- **Update status faithfully.** If interrupted, leave `_Status: IN PROGRESS_` with `_Phase_` so the next agent knows exactly where to pick up.

package/claude/commands/status.md

@@ -0,0 +1,37 @@
+## Project Status
+
+For a richer dashboard including PRs, plans, and handoff state, use `/dash`.
+
+**IMPORTANT: Immediately delegate this entire task to a subagent using the Agent tool with `model: "haiku"` and `subagent_type: "general-purpose"`.** Do not run any commands yourself. Pass the full prompt below to the subagent and relay its result.
+
+### Subagent prompt
+
+You are generating a quick situational report for the current project.
+
+Run all of these in parallel:
+- `git branch --show-current`
+- `git status --short`
+- `git log --oneline -10`
+- `git stash list`
+- `git diff --stat`
+- `git diff --staged --stat`
+
+Then format a concise report:
+
+```
+Branch: <current branch>
+Tracking: <ahead/behind remote status>
+
+Staged:     <N files>
+Modified:   <N files>
+Untracked:  <N files>
+Stashes:    <N>
+
+Recent commits:
+  <last 5 commits, one line each>
+
+Uncommitted changes:
+  <file list with status indicators (M/A/D/?)>
+```
+
+Keep it short and scannable. No commentary — just the facts.

package/claude/commands/sync.md

@@ -0,0 +1,72 @@
+## Multi-Machine Config Sync
+
+Commit, push, then deploy configs to target machines via SSH. One command to sync your configs repo across all machines (or specific ones).
+
+**IMPORTANT: Immediately delegate this entire task to a subagent using the Agent tool with `model: "haiku"` and `subagent_type: "general-purpose"`.** Do not perform operations yourself. Pass the full prompt below to the subagent and relay its result.
+
+### Input
+$ARGUMENTS - optional: space-separated machine names (e.g., "mikpc", "mikpc duplo"). If omitted, syncs to ALL configured machines.
+
+### Subagent prompt
+
+You are syncing the configs repo across machines. Target machines: $ARGUMENTS (if empty, sync to all).
+
+**Machine registry** (from MEMORY.md — verify with SSH before attempting):
+
+| Machine | SSH Host | Dropbox Path | Notes |
+|---------|----------|-------------|-------|
+| mikpc | `mikpc` | `~/Dropbox/mikpc/dev/configs` | WSL, NTFS quirks with mcp.json |
+| duplo | `duplo` | `~/Dropbox/duplo/dev/chiefmikey/configs` | Work Mac |
+| mikbook | `mikbook` | `~/Dropbox/mikbook/dev/configs` | MacBook |
+
+1. **Pre-sync checks** on the local machine:
+   - `git status` — check for uncommitted changes
+   - If uncommitted changes exist: stage, commit with a conventional commit message, push
+   - If already committed but not pushed: push
+   - If clean and pushed: proceed to sync
+
+2. **For each target machine** (run sequentially — SSH sessions can't overlap safely):
+
+   a. **Verify connectivity:** `ssh -o ConnectTimeout=5 -o BatchMode=yes <host> echo ok`
+      - If unreachable (timeout, refused, DNS failure), log a warning and skip this machine entirely
+      - Don't fail the whole run — continue to the next machine
+      - Record reason for skip (timeout, connection refused, auth failed, etc.)
+
+   b. **Pull latest on the remote:**
+      ```bash
+      ssh <host> "cd <dropbox-path> && git pull --ff-only"
+      ```
+      - If pull fails (merge conflict, dirty working tree, etc.), log the error and skip deploy. Don't force.
+
+   c. **Deploy configs on the remote:**
+      ```bash
+      ssh <host> "cd <dropbox-path> && ./scripts/sync/push-configs.zsh"
+      ```
+      - Capture output. Check for `[SUCCESS]` and `[ERROR]` lines.
+
+   d. **Record the deployed commit:**
+      ```bash
+      ssh <host> "cd <dropbox-path> && git log --oneline -1"
+      ```
+
+   e. **Verify critical paths** (quick smoke test):
+      ```bash
+      ssh <host> "git config user.email && echo 'git: ok'"
+      ssh <host> "command -v zsh && echo 'zsh: ok'"
+      ```
+
+3. **Report:**
+   ```
+   ## Sync Report
+   Local commit: abc1234 feat: latest change
+
+   | Machine | Status | Commit | Details |
+   |---------|--------|--------|---------|
+   | mikpc | synced | abc1234 | push-configs: ok (3 warnings) |
+   | duplo | synced | abc1234 | push-configs: ok |
+   | mikbook | skipped | — | unreachable (connection timed out) |
+
+   **Successfully synced:** 2/3 machines
+   **Skipped:** mikbook (unreachable)
+   **Warnings:** [any warnings from push-configs on synced machines]
+   ```

package/claude/commands/test.md

@@ -0,0 +1,29 @@
+## Run Tests
+
+**IMPORTANT: Immediately delegate this entire task to a subagent using the Agent tool with `model: "haiku"` 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: specific test file, directory, or test name to run
+
+### Subagent prompt
+
+You are running the test suite and reporting results. Target: $ARGUMENTS
+
+1. Detect the project type and test framework:
+   - `jest.config*` or `package.json` with jest → `npx jest`
+   - `vitest.config*` → `npx vitest run`
+   - `pytest.ini` / `conftest.py` / `pyproject.toml` with pytest → `pytest -v`
+   - `cypress.config*` → `npx cypress run`
+   - `playwright.config*` → `npx playwright test`
+   - `angular.json` → `npx ng test --watch=false`
+
+2. Run the tests:
+   - If a specific target was given, run only that
+   - Otherwise run the full suite
+
+3. Parse the output and report:
+   - Total tests: passed / failed / skipped
+   - For any failures: test name, file:line, and the error message
+   - Overall verdict: **ALL PASSING** or **X FAILURES**
+
+4. If there are failures, briefly suggest likely causes based on the error messages

package/claude/commands/triage.md

@@ -0,0 +1,72 @@
+## Smart Triage
+
+Analyze an error, bug report, stack trace, or issue and route it to the right command with full context. Stops you from being the router — Claude figures out what tool to use.
+
+### Input
+$ARGUMENTS - optional: error message, stack trace, GitHub issue URL, bug description, or Slack message. If omitted, proactively scans for issues to triage.
+
+### Instructions
+
+0. **If no arguments provided — scan for issues:**
+   - Run tests and check for failures
+   - Run lint/build and check for errors
+   - Check `docs/incidents/` for `_Status: ACTIVE_` or `_Status: MITIGATED_` incidents
+   - Check for open GitHub issues if `gh` CLI is available: `gh issue list --assignee @me --limit 10`
+   - Check `git stash list` for abandoned work
+   - Check `docs/plans/` for stalled `_Status: IN PROGRESS_` plans (no Execution Journal update in 24h+)
+   - If issues found: triage the most severe one first, then list remaining issues with recommended commands
+   - If no issues found: report "No issues detected. Tests pass, build clean, no active incidents."
+
+1. **Gather project context:**
+   - Read project CLAUDE.md if it exists
+   - Read the most recent `docs/context/` snapshot if it exists
+   - Check `docs/incidents/` for related past incidents — has this happened before?
+   - Check `docs/spikes/` for related decisions — was this area already investigated?
+   - This informs the diagnosis with architecture awareness and institutional memory
+
+2. **Analyze the input:**
+   - What type of problem is this? (runtime error, build failure, test failure, deployment issue, performance, security, feature request, config issue)
+   - What area of the codebase does it affect? (Use project context to map error to component)
+   - What's the likely root cause? (Trace from the error message/stack trace)
+   - What's the severity? (blocking, degraded, cosmetic, enhancement)
+   - What's the estimated complexity? (quick fix, moderate, complex refactor)
+
+3. **If a GitHub issue URL was provided,** fetch it with `gh issue view <number>` to get full details, comments, and labels.
+
+4. **Route to the right command:**
+
+   | Diagnosis | Recommended Command | Reasoning |
+   |-----------|-------------------|-----------|
+   | Clear bug with known location | `/fix-and-test` | Direct diagnosis and fix |
+   | Complex bug needing investigation | `/research` then `/fix-and-test` | Need to understand the area first |
+   | Test failure | `/fix-and-test` | Diagnose and fix the test |
+   | Build/lint failure | `/lint` or `/fix-and-test` | Depends on the error type |
+   | K8s/infrastructure issue | `/k8s-debug` | Specialized debugging |
+   | Production outage / active incident | `/incident` | Structured incident response — mitigate first |
+   | Security vulnerability | `/guard` then `/fix-and-test` | Audit scope, then fix |
+   | Feature request / new functionality | `/prep` or `/partymode` | Needs planning before implementation |
+   | Feasibility question / approach decision | `/spike` | Prove feasibility before planning |
+   | Config/deployment issue | `/deploy-check` | Check deployment health |
+   | Performance issue | `/research` | Need to understand before optimizing |
+   | External PR needs review | `/review-pr` | Full context-aware PR review |
+   | Multiple related issues | `/plans` | Plan a coordinated fix |
+   | Unknown / ambiguous | `/research` | Understand before acting |
+
+5. **Output the triage report:**
+
+   ```
+   ## Triage: [Brief title]
+
+   **Type:** [runtime error / build failure / test failure / etc.]
+   **Severity:** [blocking / degraded / cosmetic / enhancement]
+   **Complexity:** [quick fix / moderate / complex]
+   **Affected area:** [component/file/service based on project context]
+   **Likely root cause:** [1-2 sentences]
+
+   **Recommended action:** `/command-name <specific arguments>`
+   **Reasoning:** [Why this command, what it will do]
+
+   **Alternative:** `/other-command` if [condition]
+   ```
+
+6. **Automatically invoke the recommended command above.** Do not ask — just run it directly.

package/claude/desktop/claude_desktop_config.json

@@ -0,0 +1,9 @@
+{
+  "preferences": {
+    "menuBarEnabled": true,
+    "quickEntryShortcut": "off",
+    "coworkScheduledTasksEnabled": false,
+    "sidebarMode": "code",
+    "coworkWebSearchEnabled": true
+  }
+}

package/claude/hooks.json

@@ -0,0 +1,15 @@
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Edit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "filepath=\"$CLAUDE_FILE_PATH\"; if [ -z \"$filepath\" ]; then exit 0; fi; case \"$filepath\" in *.ts|*.tsx|*.js|*.jsx|*.json|*.css|*.scss|*.html) npx prettier --write \"$filepath\" 2>/dev/null;; *.py) if command -v ruff &>/dev/null; then ruff format \"$filepath\" 2>/dev/null; ruff check --fix \"$filepath\" 2>/dev/null; elif python3 -m ruff --version &>/dev/null; then python3 -m ruff format \"$filepath\" 2>/dev/null; python3 -m ruff check --fix \"$filepath\" 2>/dev/null; elif command -v black &>/dev/null; then black \"$filepath\" 2>/dev/null; fi;; *.yaml|*.yml) if command -v prettier &>/dev/null; then prettier --write \"$filepath\" 2>/dev/null; fi;; esac; exit 0"
+          }
+        ]
+      }
+    ]
+  }
+}

package/claude/mcp-servers.duplo.json

@@ -0,0 +1,8 @@
+{
+  "duplo": {
+    "type": "stdio",
+    "command": "bash",
+    "args": ["__CONFIG_DIR__/scripts/mcp/duplo-mcp-wrapper.sh"],
+    "env": {}
+  }
+}

package/claude/mcp-servers.json

@@ -0,0 +1,62 @@
+{
+  "kubernetes": {
+    "type": "stdio",
+    "command": "npx",
+    "args": ["-y", "kubernetes-mcp-server"],
+    "env": {}
+  },
+  "docker": {
+    "type": "stdio",
+    "command": "uvx",
+    "args": ["docker-mcp"],
+    "env": {}
+  },
+  "memory": {
+    "type": "stdio",
+    "command": "npx",
+    "args": ["-y", "@modelcontextprotocol/server-memory"],
+    "env": {}
+  },
+  "github": {
+    "type": "stdio",
+    "command": "__CONFIG_DIR__/scripts/mcp/github-mcp-wrapper.sh",
+    "args": [],
+    "env": {}
+  },
+  "context7": {
+    "type": "stdio",
+    "command": "npx",
+    "args": ["-y", "@upstash/context7-mcp@latest"],
+    "env": {}
+  },
+  "mongodb": {
+    "type": "stdio",
+    "command": "npx",
+    "args": ["-y", "mongodb-mcp-server"],
+    "env": {}
+  },
+  "playwright": {
+    "type": "stdio",
+    "command": "npx",
+    "args": ["-y", "@playwright/mcp@latest"],
+    "env": {}
+  },
+  "terraform": {
+    "type": "stdio",
+    "command": "npx",
+    "args": ["-y", "@anthropic/terraform-mcp-server@latest"],
+    "env": {}
+  },
+  "notion": {
+    "type": "stdio",
+    "command": "npx",
+    "args": ["-y", "@notionhq/notion-mcp-server"],
+    "env": {}
+  },
+  "aws": {
+    "type": "stdio",
+    "command": "uvx",
+    "args": ["awslabs.core-mcp-server@latest"],
+    "env": {}
+  }
+}

package/claude/scripts/psdebug.ps1

@@ -0,0 +1,7 @@
+# psdebug.ps1 — Wrapper to run debug helper functions from non-interactive shells
+# Usage: powershell -NoProfile -ExecutionPolicy Bypass -File psdebug.ps1 <FunctionName> [args...]
+# Example: powershell -NoProfile -ExecutionPolicy Bypass -File psdebug.ps1 Get-GameCrashLogs -Hours 2
+
+$env:PSDEBUG_QUIET = '1'
+. 'C:\Users\wolfe\Documents\WindowsPowerShell\Microsoft.PowerShell_profile.ps1' 2>$null
+Invoke-Expression ($args -join ' ')

package/claude/settings.json

@@ -0,0 +1,38 @@
+{
+  "includeCoAuthoredBy": false,
+  "permissions": {
+    "deny": [
+      "Bash(git push --force *)",
+      "Bash(git push * --force*)",
+      "Bash(git push --force-with-lease *)",
+      "Bash(git reset --hard *)",
+      "Bash(git clean *)",
+      "Bash(git branch -D *)",
+      "Bash(rm -rf *)",
+      "Bash(rm -r *)",
+      "Bash(sudo rm -rf *)",
+      "Bash(sudo rm -r *)",
+      "Bash(terraform apply *)",
+      "Bash(terraform destroy *)",
+      "Bash(kubectl delete namespace *)",
+      "Bash(docker system prune *)",
+      "Bash(pkill *)",
+      "Bash(sudo pkill *)",
+      "Bash(kill -9 *)",
+      "Bash(sudo kill -9 *)",
+      "Bash(killall *)",
+      "Bash(sudo killall *)",
+      "Bash(ssh-keygen *)"
+    ],
+    "defaultMode": "bypassPermissions"
+  },
+  "model": "opus",
+  "statusLine": {
+    "type": "command",
+    "command": "bash ~/.claude/statusline-command.sh"
+  },
+  "enabledPlugins": {
+    "superpowers@claude-plugins-official": true
+  },
+  "skipDangerousModePermissionPrompt": true
+}

package/claude/settings.local.json

@@ -0,0 +1,4 @@
+{
+  "outputStyle": "default",
+  "prefersReducedMotion": false
+}