@arthai/agents 1.0.0

package/dist/plugins/sentinel/skills/restart/SKILL.md

@@ -0,0 +1,70 @@
+---
+name: restart
+description: "Kill and restart local dev servers. Reads service config from CLAUDE.md. Usage: /restart [service]"
+user-invocable: true
+arguments: "<service>"
+---
+
+# Restart Servers Skill
+
+Kill and restart local dev servers using the configuration from CLAUDE.md.
+
+## Instructions
+
+1. **Read CLAUDE.md** in the project root. Look for the **Local Dev Services** table:
+
+```markdown
+## Local Dev Services
+
+| Service  | Port | Directory | Start Command |
+|----------|------|-----------|---------------|
+| Frontend | 3000 | frontend/ | npm run dev |
+| Backend  | 8000 | backend/  | uvicorn app.main:app --reload --port 8000 |
+```
+
+If CLAUDE.md doesn't have this section, scan the project:
+- `package.json` scripts → find dev/start commands
+- `requirements.txt` / `pyproject.toml` → look for uvicorn/gunicorn/flask
+- `docker-compose.yml` → extract service ports
+- Common ports: frontend 3000, backend 8000
+
+2. **Kill existing processes** for the target service(s):
+
+```bash
+# Kill by port
+lsof -ti:<port> | xargs kill -9 2>/dev/null
+
+# Wait for ports to free
+sleep 2
+```
+
+3. **Start each server** in background using the configured start command:
+
+```bash
+# Run in background
+<start_command> &
+```
+
+Use `run_in_background: true` on the Bash tool.
+
+4. **Health check** after startup:
+
+```bash
+# Check each service
+curl -sf http://localhost:<port>/health > /dev/null 2>&1 && echo "<service>:UP" || echo "<service>:DOWN"
+```
+
+5. **Report** status of all servers.
+
+## Argument Patterns
+
+| User Input | Action |
+|-----------|--------|
+| `/restart` (no args) | Kill and restart all configured servers |
+| `/restart backend` | Kill and restart only the backend service |
+| `/restart frontend` | Kill and restart only the frontend service |
+| `/restart <service>` | Kill and restart the named service |
+
+## If CLAUDE.md Is Missing Service Config
+
+Report: "No Local Dev Services table found in CLAUDE.md. Add a table with Service, Port, Directory, and Start Command columns. Or specify the services manually."

package/dist/plugins/sentinel/skills/sre/SKILL.md

@@ -0,0 +1,362 @@
+---
+name: sre
+description: "Run SRE operations. Usage: /sre [command]. Commands: status, health, logs, deploy-check, ci, sleep, wake, debug, rebuild, dialog"
+user-invocable: true
+arguments: "<command> <options>"
+---
+
+# SRE Skill
+
+Wraps the SRE agent for infrastructure operations. Reads project context from CLAUDE.md to route to the right tools.
+
+## Project Context Discovery (Deep)
+
+Before ANY operation, discover the full infrastructure landscape. This runs on every /sre invocation
+to ensure context is current.
+
+### Step 1: Read existing context
+
+Read in this order (skip gracefully if missing):
+1. `CLAUDE.md` — Infrastructure table, services, health endpoints
+2. `.claude/project-profile.md` — Architecture, deploy platform (from /calibrate)
+3. `.claude/knowledge/agents/sre.md` — Past incidents, platform patterns learned
+4. `.claude/knowledge/shared/decisions.md` — Infrastructure decisions made
+5. `.claude/qa-knowledge/incidents/` — Past production incidents
+
+### Step 2: Detect deploy platform (if not in profile)
+
+Scan project files to identify the FULL infrastructure stack:
+
+**Cloud Provider Detection:**
+| Signal | Provider | What to check |
+|--------|----------|--------------|
+| `AWS_*` env vars, `~/.aws/`, `samconfig.toml`, `cdk.json` | AWS | Regions, services, IAM roles |
+| `GOOGLE_*` env vars, `app.yaml`, `cloudbuild.yaml` | GCP | Projects, regions, services |
+| `AZURE_*` env vars, `azure-pipelines.yml` | Azure | Subscriptions, resource groups |
+
+**Platform Detection:**
+| Signal | Platform | CLI | MCP Available |
+|--------|----------|-----|--------------|
+| `railway.json`, `railway.toml`, `Procfile` | Railway | `railway` | Railway MCP |
+| `vercel.json`, `.vercel/` | Vercel | `vercel` | Vercel MCP |
+| `fly.toml` | Fly.io | `flyctl` | — |
+| `render.yaml` | Render | `render` | — |
+| `heroku.yml`, `Procfile` + Heroku remote | Heroku | `heroku` | — |
+| `netlify.toml` | Netlify | `netlify` | — |
+| `terraform/`, `*.tf` | Terraform (IaC) | `terraform` | AWS/GCP MCP |
+| `pulumi/`, `Pulumi.yaml` | Pulumi (IaC) | `pulumi` | AWS/GCP MCP |
+| `cdk/`, `cdk.json` | AWS CDK | `cdk` | AWS MCP |
+| `k8s/`, `helm/`, `Chart.yaml`, `kustomize/` | Kubernetes | `kubectl`, `helm` | K8s MCP |
+| `docker-compose.yml` + no platform | Docker only | `docker` | Docker MCP |
+| `serverless.yml` | Serverless Framework | `sls` | AWS/GCP MCP |
+| `firebase.json` | Firebase | `firebase` | Firebase MCP |
+| `supabase/config.toml` | Supabase | `supabase` | Supabase MCP |
+
+**Database Detection:**
+| Signal | Database | Monitoring |
+|--------|----------|-----------|
+| `DATABASE_URL` contains `postgres` | PostgreSQL | pg_stat, connection pool health |
+| `DATABASE_URL` contains `mysql` | MySQL | slow query log, connection health |
+| `MONGODB_URI` | MongoDB | mongosh status, replica set health |
+| `REDIS_URL` | Redis | `redis-cli info`, memory, connections |
+| `ELASTICSEARCH_URL` | Elasticsearch | cluster health, index status |
+
+**Monitoring/Observability Detection:**
+| Signal | Tool | What it provides |
+|--------|------|-----------------|
+| `SENTRY_DSN` or `@sentry/` import | Sentry | Error tracking, performance |
+| `DATADOG_*` env vars | Datadog | APM, logs, metrics |
+| `NEW_RELIC_*` env vars | New Relic | APM, infrastructure |
+| `GRAFANA_*` or `grafana/` | Grafana | Dashboards, alerting |
+| `PROMETHEUS_*` or `prometheus/` | Prometheus | Metrics collection |
+| `PAGERDUTY_*` env vars | PagerDuty | Incident management |
+| `OPSGENIE_*` env vars | OpsGenie | Alert routing |
+
+**CI/CD Detection (used by /ci-fix but discovered here for completeness):**
+| Signal | CI Platform | CLI |
+|--------|------------|-----|
+| `.github/workflows/` | GitHub Actions | `gh run` |
+| `.gitlab-ci.yml` | GitLab CI | `glab ci` |
+| `Jenkinsfile` | Jenkins | Jenkins API |
+| `.circleci/config.yml` | CircleCI | `circleci` CLI |
+| `bitbucket-pipelines.yml` | Bitbucket Pipelines | Bitbucket API |
+| `.buildkite/` | Buildkite | `buildkite-agent` |
+| `azure-pipelines.yml` | Azure DevOps | `az pipelines` |
+| `.travis.yml` | Travis CI | Travis API |
+
+### Step 3: Recommend missing tools
+
+Based on what was detected, recommend tools the project SHOULD have:
+
+**Format:**
+```
+SRE Recommendations for {project}:
+
+Platform: {detected platform}
+Database: {detected databases}
+Monitoring: {detected or MISSING}
+CI/CD: {detected CI platform}
+
+Missing (recommended):
+  ⚠ No monitoring detected — recommend Sentry (free tier, 5K errors/mo)
+    Install: pip install sentry-sdk / npm install @sentry/node
+  ⚠ No Redis health monitoring — recommend redis-cli in health checks
+  ⚠ No MCP server for {platform} — would enable direct platform queries
+    /calibrate can install this automatically
+
+Data sources to connect:
+  • {platform} logs → available via {CLI/MCP}
+  • {database} metrics → available via {query/MCP}
+  • {monitoring tool} alerts → available via {API/MCP}
+  • Health endpoints: {list from CLAUDE.md or recommend adding}
+```
+
+### Step 4: Write discoveries to knowledge base
+
+After discovery, update these files (if `.claude/knowledge/` exists):
+- Append to `knowledge/agents/sre.md`: platform detected, services found, health endpoints
+- If first time: create the file with initial platform context
+
+## Argument Parsing
+
+Parse from the argument string:
+- `command`: Optional. One of: `status`, `health`, `logs`, `deploy-check`, `ci`, `sleep`, `wake`, `debug`, `rebuild`, `dialog`. Defaults to `status` if omitted.
+- Options vary by command (see below).
+
+## Commands
+
+### `/sre` or `/sre status`
+Full system status — all services, all environments.
+
+Spawn SRE agent:
+```
+subagent_type: "sre"
+model: "sonnet"
+prompt: "Run a full status check. Read CLAUDE.md ## Environments table. For each environment, check status using the appropriate method from the Access Methods table in project-profile.md.
+1. Check deployment platform service status (Railway MCP, Vercel CLI, etc.)
+2. Hit all health endpoints listed in CLAUDE.md
+3. Check latest GitHub Actions: gh run list --branch main --limit 3
+Report a structured pass/fail table."
+```
+
+### `/sre health`
+Quick health check — just hit endpoints.
+
+Spawn SRE agent:
+```
+subagent_type: "sre"
+model: "sonnet"
+prompt: "Quick health check. Read CLAUDE.md ## Environments table. Hit the health endpoint for every listed environment (URL + Health column). Report pass/fail per environment. Skip environments with <!-- TODO --> URLs."
+```
+
+### `/sre logs [service]`
+View recent deploy logs. Default service: first service in Infrastructure table.
+
+Spawn SRE agent:
+```
+subagent_type: "sre"
+model: "sonnet"
+prompt: "Get recent deploy logs for '{service or default}'. Read CLAUDE.md for infrastructure details. Use platform-appropriate tools (Railway MCP, Vercel CLI, etc.). Filter for errors and summarize issues found."
+```
+
+### `/sre deploy-check`
+Verify latest deployment succeeded end-to-end.
+
+Spawn SRE agent:
+```
+subagent_type: "sre"
+model: "sonnet"
+prompt: "Full deployment verification. Read CLAUDE.md for infrastructure.
+1. Check recent CI runs: gh run list --branch main --limit 5
+2. Check deployment platform for latest deploys
+3. Hit all health endpoints
+4. Compare migration state if applicable
+Report structured pass/fail for each step."
+```
+
+### `/sre ci`
+Check CI/CD pipeline status and diagnose failures.
+
+Spawn SRE agent:
+```
+subagent_type: "sre"
+model: "sonnet"
+prompt: "Check CI/CD status:
+1. gh run list --branch main --limit 5
+2. If any failed: gh run view <id> --log-failed
+3. Report which workflows passed/failed, failure details, suggested fixes."
+```
+
+### `/sre sleep`
+Sleep staging to save costs (platform-specific).
+
+Spawn SRE agent:
+```
+subagent_type: "sre"
+model: "sonnet"
+prompt: "Sleep the specified environment (default: first staging-type environment from CLAUDE.md ## Environments table). Read CLAUDE.md for environment details. Use platform-appropriate commands. Verify services scaled to 0. Report estimated savings."
+```
+
+### `/sre wake`
+Wake staging environment.
+
+Spawn SRE agent:
+```
+subagent_type: "sre"
+model: "sonnet"
+prompt: "Wake the specified environment (default: first staging-type environment from CLAUDE.md ## Environments table). Read CLAUDE.md for environment details. Use platform-appropriate commands. Wait for health checks to pass. Report status."
+```
+
+### `/sre debug [description]`
+Systematic debugging of a production issue.
+
+Spawn SRE agent:
+```
+subagent_type: "sre"
+model: "sonnet"
+prompt: "Debug this issue: '{description}'. Read CLAUDE.md for infrastructure.
+Read CLAUDE.md ## Environments table. For each environment, check status using the appropriate
+method from the Access Methods table in project-profile.md.
+
+Systematic approach:
+1. CONFIRM — check health endpoints + metrics for all environments in the Environments table
+2. SCOPE — which service(s) and environment(s) affected?
+3. DIAGNOSE — RED method (Rate/Errors/Duration) for API, USE method (Utilization/Saturation/Errors) for infra
+4. Check deployment logs for errors
+5. Check GitHub Actions for recent failures
+6. ROOT CAUSE — what specifically caused the issue?
+7. CLASSIFY FIX TYPE — determine if this is:
+   a. Infra-only fix (restart, config change, scale, DNS) → fix directly, verify health
+   b. Code bug → escalate to /fix (do NOT fix code directly — /fix has verification pipeline)
+8. IF INFRA FIX:
+   - Apply the fix (restart, config change, etc.)
+   - Verify health endpoints for affected environments
+   - Ask user to smoke-test if config was changed
+   - Write incident report
+9. IF CODE BUG:
+   - Document findings (root cause, affected files, evidence)
+   - Escalate to /fix with all context — /fix will handle QA, testing, and PR
+   - Do NOT write code or create PRs from /sre debug
+
+After root cause is identified, also write a QA incident file at
+.claude/qa-knowledge/incidents/{YYYY-MM-DD}-{slug}.md with root cause, how QA missed it, and regression test recommendation."
+```
+
+**Post-debug handoff:**
+
+After `/sre debug` completes:
+
+| Fix type | What happens next |
+|----------|------------------|
+| Infra fix applied | Verify health → ask user to smoke-test → "What's next?" |
+| Code bug identified | Route to `/fix {description} --severity {severity}` with all gathered evidence. `/fix` handles: root cause verification → scope lock → behavior contract → implement → QA → user test → PR |
+| Inconclusive | Present findings → ask user: "Should I investigate further, or route to /fix?" |
+
+**What's next (after infra fix):**
+```
+Fix applied and verified. Environments healthy.
+
+What's next?
+  [1] Monitor — /sre health in 5 min to confirm fix holds
+  [2] Investigate further — check related systems
+  [3] See project status — /onboard
+  [4] Done for now
+```
+
+### `/sre dialog`
+Analyze the latest local agent interview dialog. Checks verbosity, Q-tag leaks, NOTES leaks, and TTS filter activity.
+
+**Do NOT spawn an agent.** Run directly:
+
+1. Read `/tmp/agent.log`
+2. Extract all `Agent said:` lines (deduplicate — each appears twice in logs)
+3. Report:
+
+```
+## Interview Dialog Analysis
+
+| # | Turn | Response (truncated) | Words | Chars |
+|---|------|---------------------|-------|-------|
+| 1 | Intro | "Hi! I'm Sarah..." | 37 | 186 |
+| 2 | Reaction | "Great answer!..." | 12 | 58 |
+...
+
+**Verbosity**: avg X words/turn (target: <40, Feb 8 baseline: 15-20)
+**Q-tag leaks**: [Q1]-[Q5] found in raw output? YES/NO
+**NOTES leaks**: [NOTES] blocks in raw output? YES/NO
+**TTS filter**: [TTS-FILTER] log entries found? (shows filter activity)
+**Truncation**: Any responses cut off mid-sentence? (sign of token limit)
+**max_completion_tokens**: Read from agent/main.py line with max_completion_tokens
+```
+
+4. If verbosity avg > 40 words, recommend lowering `max_completion_tokens`
+5. If Q-tag leaks found, check if `[TTS-FILTER]` logs show they were stripped before TTS
+
+### `/sre rebuild`
+Clean rebuild of a monorepo — nuke caches, rebuild all packages, restart services.
+
+This is the nuclear option when turbo/next/tsc caching causes stale builds, phantom errors, or "works locally but not in dev server" issues.
+
+Steps to execute directly (do NOT spawn an agent — run these yourself):
+
+1. **Read CLAUDE.md** for project root, build commands, and Local Dev Services table.
+
+2. **Stop running services** using the stop/kill commands from CLAUDE.md:
+   ```bash
+   # Read Local Dev Services table for ports and kill running processes
+   lsof -ti:<port> | xargs kill -9 2>/dev/null
+   ```
+
+3. **Nuke all caches**:
+   ```bash
+   cd <project-root> && rm -rf node_modules/.cache .next .turbo packages/*/dist packages/*/.next packages/*/.turbo
+   ```
+
+4. **Rebuild from scratch** using the project's build command from CLAUDE.md:
+   ```bash
+   cd <project-root> && <build-command>
+   ```
+   For monorepos, if the top-level build fails, try building packages individually in dependency order (read `pnpm-workspace.yaml` or `package.json` workspaces to determine order).
+
+5. **Restart services** using start commands from CLAUDE.md Local Dev Services table.
+
+6. **Verify**:
+   - Hit health endpoints from CLAUDE.md (or the ports listed in Local Dev Services table)
+   - Check no build errors in output
+
+Report success/failure with before/after comparison (which packages rebuilt, any errors).
+
+## Knowledge Base Integration
+
+### On every /sre invocation:
+1. **Read** `.claude/knowledge/agents/sre.md` for past incidents and patterns
+2. **Read** `.claude/qa-knowledge/incidents/` for production issues in this area
+
+### After /sre debug:
+1. **Write** incident to `.claude/qa-knowledge/incidents/{date}-{slug}.md`
+2. **Append** to `.claude/knowledge/agents/sre.md`:
+   ```
+   ### {date} — {incident title}
+   **Platform**: {platform}
+   **Root cause**: {what happened}
+   **Fix**: {what was done}
+   **Prevention**: {how to avoid next time}
+   ```
+
+### After first discovery on a project:
+1. **Write** platform summary to `knowledge/agents/sre.md`
+2. **Update** `project-profile.md` if infrastructure section is incomplete
+3. **Recommend** MCP servers to /calibrate's recommendations
+
+## /calibrate Integration
+
+When `/calibrate` runs, it reads all agent definitions to build recommendations.
+The SRE skill contributes:
+
+1. **Platform detection results** → /calibrate uses for MCP server recommendations
+2. **Missing monitoring tools** → /calibrate includes in "recommended tools"
+3. **Health endpoint inventory** → /calibrate writes to project profile
+4. **CI/CD platform** → /calibrate uses for ci-fix configuration
+
+If `/calibrate` has already run, /sre reads `project-profile.md` instead of re-discovering.
+If `/calibrate` hasn't run, /sre does its own discovery and recommends running `/calibrate`.

package/dist/plugins/shield/.claude-plugin/plugin.json

@@ -0,0 +1,6 @@
+{
+  "name": "shield",
+  "description": "Safety guardrails — bash guards, edit protection, session bootstrap",
+  "version": "1.0.0",
+  "author": "Arth AI"
+}

package/dist/plugins/shield/hooks/hooks.json

@@ -0,0 +1,60 @@
+{
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/pre-bash-guard.sh",
+            "timeout": 5
+          }
+        ]
+      },
+      {
+        "matcher": "Edit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/pre-edit-guard.sh",
+            "timeout": 5
+          }
+        ]
+      },
+      {
+        "matcher": "Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/pre-edit-guard.sh",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "SessionStart": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/session-bootstrap.sh",
+            "timeout": 15
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/triage-router.sh",
+            "timeout": 5
+          }
+        ]
+      }
+    ]
+  }
+}

package/dist/plugins/shield/hooks/pre-bash-guard.sh

@@ -0,0 +1,142 @@
+#!/bin/bash
+# PreToolUse hook (Bash): Guard rails for dangerous commands.
+# Blocks known-destructive operations, warns on risky ones.
+#
+# Exit 0  = allow the command
+# Exit 2  = block the command (stdout shown as reason)
+# stdout  = injected as context (warnings)
+#
+# Reads CLAUDE.md "Critical Rules" section for project-specific guards.
+
+set -euo pipefail
+
+# The tool input is JSON — extract the command field
+COMMAND="${CLAUDE_TOOL_INPUT_COMMAND:-}"
+
+# If no command available, try parsing from CLAUDE_TOOL_INPUT JSON
+if [ -z "$COMMAND" ] && [ -n "${CLAUDE_TOOL_INPUT:-}" ]; then
+    COMMAND=$(echo "$CLAUDE_TOOL_INPUT" | python3 -c "import json,sys; print(json.load(sys.stdin).get('command',''))" 2>/dev/null) || true
+fi
+
+# Nothing to check
+[ -z "$COMMAND" ] && exit 0
+
+# ---------------------------------------------------------------------------
+# Hard blocks (exit 2 = block the tool call)
+# ---------------------------------------------------------------------------
+
+# Block: railway up (uploads untracked files — known to cause crashes)
+if echo "$COMMAND" | grep -qE '\brailway\s+up\b'; then
+    echo "⛔ BLOCKED: 'railway up' uploads untracked files and can crash services."
+    echo "Use 'git push' to deploy via Railway's auto-deploy instead."
+    exit 2
+fi
+
+# Block: git push directly to main/master (should use PR)
+if echo "$COMMAND" | grep -qE 'git\s+push\s+.*\b(main|master)\b' && ! echo "$COMMAND" | grep -q '\-\-dry-run'; then
+    # Allow if pushing a branch that happens to contain "main" in the name
+    if echo "$COMMAND" | grep -qE 'git\s+push\s+(origin\s+)?(main|master)\s*$'; then
+        echo "⛔ BLOCKED: Never push directly to main. Create a PR instead."
+        echo "Use the /pr skill to create a pull request."
+        exit 2
+    fi
+fi
+
+# Block: git push --force to main/master
+if echo "$COMMAND" | grep -qE 'git\s+push\s+--force' || echo "$COMMAND" | grep -qE 'git\s+push\s+-f\b'; then
+    if echo "$COMMAND" | grep -qE '\b(main|master)\b'; then
+        echo "⛔ BLOCKED: Force push to main is extremely dangerous."
+        exit 2
+    fi
+fi
+
+# Warn: pip uninstall (can break environments — but sometimes needed)
+if echo "$COMMAND" | grep -qE '\bpip\s+uninstall\b'; then
+    echo "⚠️ pip uninstall can break the environment. Verify this is intentional."
+    echo "If resolving a dependency conflict, consider using a fresh virtualenv instead."
+fi
+
+# Block: rm -rf on common important directories
+if echo "$COMMAND" | grep -qE 'rm\s+-rf\s+(/|~|\$HOME|\.git|node_modules/\.\.|backend|frontend|src|app)\b'; then
+    echo "⛔ BLOCKED: Destructive rm -rf on critical directory."
+    echo "This could delete important project files. Be more specific about what to remove."
+    exit 2
+fi
+
+# Block: git reset --hard (with nuance)
+# Allow: git reset --hard HEAD (reset working tree to current commit — safe)
+# Block: git reset --hard HEAD~N, origin/main, specific SHAs (loses commits)
+if echo "$COMMAND" | grep -qE 'git\s+reset\s+--hard'; then
+    # Allow bare "git reset --hard" or "git reset --hard HEAD" (both = reset to current)
+    if echo "$COMMAND" | grep -qE 'git\s+reset\s+--hard\s*$' || echo "$COMMAND" | grep -qE 'git\s+reset\s+--hard\s+HEAD\s*$'; then
+        echo "⚠️ git reset --hard HEAD — this discards all uncommitted changes."
+    else
+        echo "⛔ BLOCKED: git reset --hard to a different commit discards work."
+        echo "If this is intentional, the user should run this command manually."
+        exit 2
+    fi
+fi
+
+# Block: git clean -fd on root (too broad)
+if echo "$COMMAND" | grep -qE 'git\s+clean\s+-fd\s*$'; then
+    echo "⛔ BLOCKED: git clean -fd removes all untracked files."
+    echo "This could delete user's work-in-progress files. Be more specific."
+    exit 2
+fi
+
+# ---------------------------------------------------------------------------
+# Soft warnings (exit 0, but inject context)
+# ---------------------------------------------------------------------------
+
+# Warn: ruff --fix on broad scope
+if echo "$COMMAND" | grep -qE 'ruff\s+(check\s+)?--fix\s+\.' || echo "$COMMAND" | grep -qE 'ruff\s+format\s+\.'; then
+    echo "⚠️ Broad ruff --fix/format scope. Consider targeting specific files only."
+    echo "Broad auto-fixes can introduce unrelated changes."
+fi
+
+# Warn: commands that look like they target production
+if echo "$COMMAND" | grep -qiE '(prod|production)' && ! echo "$COMMAND" | grep -qiE '(staging|test|dev|local)'; then
+    echo "⚠️ This command appears to target production. Verify this is intentional."
+    echo "DO NOT proceed without explicit user confirmation."
+fi
+
+# Warn: database operations on what looks like prod URLs
+if echo "$COMMAND" | grep -qE 'psql.*railway\.net|pg_dump.*railway\.net|DATABASE_URL.*railway\.net'; then
+    echo "⚠️ Database command targeting Railway (possibly production). Double-check the target."
+    echo "DO NOT modify production data without explicit user confirmation."
+fi
+
+# Warn: CI/CD pipeline modifications
+if echo "$COMMAND" | grep -qiE '(mv|cp|rm|edit|cat\s*>).*\.(github|gitlab|circleci|buildkite)' || \
+   echo "$COMMAND" | grep -qiE '(mv|cp|rm|edit|cat\s*>).*(Jenkinsfile|azure-pipelines|bitbucket-pipelines)'; then
+    echo "⚠️ Modifying CI/CD pipeline configuration. This affects the entire team's workflow."
+    echo "Verify this change is intentional and won't break existing pipelines."
+fi
+
+# Warn: deploy target or infrastructure config changes
+if echo "$COMMAND" | grep -qiE '(mv|cp|rm|cat\s*>).*(railway\.(json|toml)|vercel\.json|fly\.toml|Dockerfile|docker-compose|terraform|k8s|helm)'; then
+    echo "⚠️ Modifying deployment/infrastructure configuration."
+    echo "Ask before changing deploy targets, service topology, or infrastructure."
+fi
+
+# Warn: npm/pip install of new packages (could affect lock files)
+if echo "$COMMAND" | grep -qE '\b(npm|pip)\s+install\s+[a-zA-Z]' && ! echo "$COMMAND" | grep -qE '\-r\s+requirements'; then
+    echo "ℹ️ Installing new package — this will modify lock files."
+fi
+
+# ---------------------------------------------------------------------------
+# Cascade detection: if .fix-attempt-count exists and is >= 3, warn
+# ---------------------------------------------------------------------------
+PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}"
+ATTEMPT_FILE="$PROJECT_DIR/.claude/.fix-attempt-count"
+if [ -f "$ATTEMPT_FILE" ]; then
+    ATTEMPTS=$(cat "$ATTEMPT_FILE" 2>/dev/null || echo "0")
+    if [ "${ATTEMPTS:-0}" -ge 3 ]; then
+        echo "🛑 CASCADE WARNING: ${ATTEMPTS} consecutive fix attempts detected."
+        echo "STOP chaining fixes. Step back and reassess the root cause from scratch."
+        echo "Read the original error, trace the code path, understand WHY before trying again."
+        echo "If this is intentional, delete .claude/.fix-attempt-count to reset."
+    fi
+fi
+
+exit 0