slashdev 1.0.0 → 1.1.0

package/CLAUDE.md

@@ -45,11 +45,12 @@ The skill runner loads the system prompt, gathers project context via `codebase.
 **Auth (`src/auth/`):** Interactive login with API key validation, stored separately in credentials config.
 
 **Claude Code integration (`src/commands/` + `hooks/` + `claude-skills/`):**
-- `src/commands/setup.js` — Prompts for `@slashdev.io` email, writes `~/.slashdev/config.json`, copies hooks to `~/.claude/hooks/`, copies skills to `~/.claude/skills/`, registers Stop hook in `~/.claude/settings.json`
-- `src/commands/update.js` — Re-copies hooks/skills without re-prompting for email, updates packageVersion in config
-- `src/commands/setup-internals.js` — Shared `installHooks()` and `installSkills()` used by both setup and update
+- `src/commands/setup.js` — Prompts for `@slashdev.io` email, writes `~/.slashdev/config.json`, copies hooks to `~/.claude/hooks/`, copies skills to `~/.claude/skills/`, registers Stop + PreToolUse hooks in `~/.claude/settings.json`, writes Slashdev rules section to `~/.claude/CLAUDE.md`
+- `src/commands/update.js` — Re-copies hooks/skills without re-prompting for email, updates packageVersion in config, refreshes the Slashdev rules section in `~/.claude/CLAUDE.md`
+- `src/commands/setup-internals.js` — Shared `installHooks()`, `installSkills()`, `installGstack()`, and `writeGlobalClaudeMd()` used by both setup and update. The global CLAUDE.md writer is idempotent — it manages a single section bracketed by `<!-- SLASHDEV:RULES:START -->` / `<!-- SLASHDEV:RULES:END -->` markers, leaving any other user content untouched.
 - `hooks/post-response.sh` — Claude Code Stop hook that reads JSON from stdin, extracts session/prompt/response, POSTs to Slashdev logging API (fire-and-forget, async curl)
-- `claude-skills/` — Claude Code skill files (SKILL.md with YAML frontmatter) copied to `~/.claude/skills/` during setup. Current skills: code-review, pr-description, scope-estimate, bug-diagnosis
+- `hooks/pre-install-guard.sh` — Claude Code PreToolUse hook for the Bash tool. Reads tool-call JSON from stdin, detects bare dependency install commands (`npm/pnpm/yarn/bun install`, `composer install`, `pip install`, etc.), and returns `{"permissionDecision":"deny","message":"..."}` to force a retry with the `sfw` (Socket Firewall) prefix. Strips leading `cd <dir> &&` and env-var prefixes before matching. Fails open on parse errors so it can never break Claude Code. Smoke tests: `echo '{"tool_name":"Bash","tool_input":{"command":"npm install lodash"}}' | bash hooks/pre-install-guard.sh`.
+- `claude-skills/` — Claude Code skill files (SKILL.md with YAML frontmatter) copied to `~/.claude/skills/` during setup. Current skills: agentswarm, code-review, pr-description, scope-estimate, bug-diagnosis, frontend-design, secure-deploy. The `secure-deploy` skill walks Claude through retrofitting CI/CD configs (GitHub Actions, Dockerfiles, GitLab CI, deploy scripts, package.json) to wrap dependency installs with `sfw`.
 - `bin/check-setup.js` — Postinstall script that prints setup reminder if `~/.slashdev/config.json` is missing
 
 **Connections system (`src/connections/`):**

package/GETTING-STARTED.md

@@ -0,0 +1,68 @@
+# Slashdev CLI — Getting Started
+
+## Install
+
+```bash
+npm install -g slashdev
+slashdev setup
+```
+
+You'll be prompted for your `@slashdev.io` email. After setup, all skills are immediately available in Claude Code.
+
+## The Big One: Agentswarm
+
+In any project, open Claude Code and run:
+
+```
+/agentswarm "describe your task here"
+```
+
+This launches a full agent team that automatically:
+1. **Analyzes** your codebase and detects the stack
+2. **Plans** the implementation with test coverage
+3. **Implements** the code (backend + frontend in parallel)
+4. **Reviews** code quality, security, and performance
+5. **QA tests** — verifies test quality and audits API request counts per page
+
+It works with Laravel, React, Flutter, and whatever else is in the project.
+
+## Other Slashdev Skills
+
+| Command | What it does |
+|---------|-------------|
+| `/frontend-design` | Distinctive UI design — avoids generic AI aesthetics |
+| `/code-review` | Security, performance, and maintainability review |
+| `/pr-description` | Generate PR descriptions from your diff |
+| `/scope-estimate` | Effort estimation for tasks |
+| `/bug-diagnosis` | Systematic root-cause analysis |
+
+## gstack Skills (Bundled)
+
+We've bundled [gstack](https://github.com/garrytan/gstack) — 29 additional skills from Garry Tan. Highlights:
+
+| Command | What it does |
+|---------|-------------|
+| `/plan-ceo-review` | CEO-level plan review — challenges premises, finds the 10-star product |
+| `/plan-eng-review` | Eng manager review — locks in architecture and edge cases |
+| `/qa` | Opens a real browser, finds bugs, fixes them, re-verifies |
+| `/ship` | Automates testing, review, version bump, and PR creation |
+| `/review` | Pre-landing PR review for production bugs |
+| `/cso` | Security audit with OWASP Top 10 and secrets archaeology |
+| `/investigate` | Systematic debugging — no fixes without root cause |
+| `/design-consultation` | Builds a complete design system from scratch |
+| `/retro` | Weekly engineering retrospective with metrics |
+| `/careful` | Warns before destructive commands |
+
+All gstack skills are available immediately after `slashdev setup`.
+
+## Heads Up: Prompt Logging
+
+All prompts and responses in Claude Code are logged to our API so we can run analytics and help improve the team's prompting. This happens automatically via a background hook — no action needed on your part.
+
+## Updating
+
+```bash
+slashdev update
+```
+
+This pulls the latest skills and hooks. If you run into issues, `slashdev setup` will re-initialize everything.

package/claude-skills/secure-deploy/SKILL.md

@@ -0,0 +1,219 @@
+---
+name: secure-deploy
+description: Retrofit a project's CI/CD pipelines, Dockerfiles, and deploy scripts to use Socket Firewall (sfw) for all dependency installs. Use when the user asks to "secure deploy", "set up sfw in CI", "add socket firewall to production", or whenever you're editing a CI workflow / Dockerfile / deploy script that installs dependencies.
+version: "1.0"
+owner: michael@slashdev.io
+---
+
+# Secure Deploy — Retrofit projects to use Socket Firewall in production
+
+Slashdev requires every dependency install — local AND production — to be wrapped
+with Socket Firewall (`sfw`). This protects against supply-chain attacks
+(compromised packages, typosquats, dependency confusion) by scanning every package
+against Socket's vulnerability/malware database before it's allowed to install.
+
+When a developer asks you to set up production deployment, edit a CI pipeline, write
+a Dockerfile, or deploy a project, **you must ensure every install command uses `sfw`**.
+
+This skill walks you through the retrofit systematically.
+
+## When to use this skill
+
+Trigger automatically (without being asked) whenever you're about to:
+- Create or edit a `.github/workflows/*.yml` file with an `npm`/`pnpm`/`yarn`/`bun`/`composer`/`pip` install step
+- Create or edit a `Dockerfile` that runs an install command
+- Create or edit `.gitlab-ci.yml`, `bitbucket-pipelines.yml`, `circleci/config.yml`, or any other CI config
+- Create or edit a `deploy.sh`, `Procfile`, or `Makefile` install target
+- Modify the `scripts` section of `package.json` to add an install-related step
+
+Trigger explicitly when the user says: "secure deploy", "add sfw to CI", "set up socket firewall in production", "retrofit production for socket firewall", "audit deploy for sfw".
+
+## Step-by-step retrofit playbook
+
+### Step 1 — Discover deployment surface
+
+Use Glob to find every file that could install dependencies in CI or production:
+
+```
+.github/workflows/*.yml
+.github/workflows/*.yaml
+.gitlab-ci.yml
+.gitlab/*.yml
+bitbucket-pipelines.yml
+.circleci/config.yml
+azure-pipelines.yml
+Jenkinsfile
+Dockerfile
+Dockerfile.*
+*.dockerfile
+docker-compose*.yml
+Procfile
+deploy.sh
+deploy/*.sh
+scripts/deploy*.sh
+Makefile
+package.json
+```
+
+For each file found, Read it and look for any of these patterns:
+
+- `npm install`, `npm i`, `npm ci`, `npm add`
+- `pnpm install`, `pnpm i`, `pnpm add`
+- `yarn`, `yarn install`, `yarn add`
+- `bun install`, `bun i`, `bun add`
+- `composer install`, `composer require`, `composer update`
+- `pip install`, `pip3 install`, `uv install`, `uv sync`, `uv add`
+
+Note any line that already starts with `sfw ` — those are already secured and don't
+need to be touched.
+
+### Step 2 — Plan the changes
+
+For each install command found, plan one of these rewrites:
+
+**a) GitHub Actions workflow YAML**
+
+Before:
+```yaml
+- name: Install dependencies
+  run: npm ci
+```
+
+After:
+```yaml
+- name: Install Socket Firewall
+  run: npm install -g @socketsecurity/cli
+- name: Install dependencies
+  run: sfw npm ci
+```
+
+If a job has multiple install steps, only one `Install Socket Firewall` step is needed
+per job (it persists across steps because they share the same runner).
+
+**b) Dockerfile**
+
+Before:
+```dockerfile
+RUN npm ci
+```
+
+After:
+```dockerfile
+RUN npm install -g @socketsecurity/cli && sfw npm ci
+```
+
+For Composer:
+```dockerfile
+RUN npm install -g @socketsecurity/cli && sfw composer install --no-dev --optimize-autoloader
+```
+
+(npm is the simplest install vector for sfw itself; if the base image doesn't have
+Node, install Node first or use the official Socket installer.)
+
+**c) Shell deploy scripts (`deploy.sh`, etc.)**
+
+Before:
+```bash
+npm ci --omit=dev
+```
+
+After:
+```bash
+# Ensure sfw is available
+if ! command -v sfw >/dev/null 2>&1; then
+  npm install -g @socketsecurity/cli
+fi
+sfw npm ci --omit=dev
+```
+
+**d) `package.json` scripts**
+
+Before:
+```json
+{
+  "scripts": {
+    "postinstall": "npm install --prefix ./client"
+  }
+}
+```
+
+After:
+```json
+{
+  "scripts": {
+    "postinstall": "sfw npm install --prefix ./client"
+  }
+}
+```
+
+(Don't add the `npm install -g @socketsecurity/cli` step inside `package.json` — assume
+sfw is already installed wherever this script runs. If it's running in CI, the workflow
+or Dockerfile should have installed sfw at the top.)
+
+### Step 3 — Show the diff and confirm
+
+Before writing any changes, show the user a clear summary:
+
+> Found N install commands across M files. Proposed changes:
+>
+> 1. `.github/workflows/ci.yml` — wrap `npm ci` in build job (+ add sfw install step)
+> 2. `Dockerfile` — wrap `RUN npm ci` with sfw install
+> 3. `package.json` — wrap postinstall script
+>
+> Apply these changes?
+
+Use AskUserQuestion if there's any ambiguity (e.g. multiple jobs in a workflow, unclear
+whether a step is part of the build or local-only). For Dockerfiles especially, ask
+about the base image — if it doesn't have Node, the sfw install command needs to be
+different.
+
+### Step 4 — Apply the changes
+
+Use Edit to apply each change. After applying:
+
+1. **Validate YAML/JSON syntax** — for any modified `.yml` or `.json` file, run a quick
+   parse check (e.g. `python3 -c 'import yaml,sys; yaml.safe_load(open("path"))'` for
+   YAML, or `python3 -m json.tool path` for JSON). Fix any syntax errors.
+2. **Run a build smoke test if possible** — for Dockerfiles, suggest the user run
+   `docker build .` locally. For GitHub Actions, suggest pushing to a feature branch
+   and watching the workflow run.
+3. **Document what was changed** — print a final summary listing every file modified
+   and what was added.
+
+### Step 5 — Verify CI doesn't already use a different security tool
+
+If during Step 1 you find references to other security scanners (Snyk, Dependabot,
+Trivy, npm audit, etc.), don't remove them — they complement Socket Firewall, they
+don't replace it. Mention to the user: "I found existing security scanning via X. I
+left it in place — Socket Firewall complements it by blocking malicious packages
+*before* they install, while X scans the installed tree."
+
+## Important conventions
+
+- **Never silently change install commands.** Always show the diff and get
+  confirmation before writing CI/deploy files. These are production-critical files.
+- **Don't add sfw to dev-only `node_modules` install steps in `package.json`** unless
+  the user explicitly asks. The PreToolUse hook handles dev-side enforcement
+  automatically; only retrofit `package.json` scripts that run in CI/deploy contexts.
+- **Don't try to install Socket Firewall globally on the user's machine** as part of
+  this skill. That's the developer's responsibility, and the slashdev hook will warn
+  them if it's missing. This skill only modifies project files.
+- **Don't touch `.lock` files** (`package-lock.json`, `pnpm-lock.yaml`, `yarn.lock`,
+  `composer.lock`, `bun.lockb`). They're generated.
+- **Preserve existing flags** — when wrapping `npm ci --omit=dev` with `sfw`, keep
+  the `--omit=dev` flag.
+
+## Output format
+
+Always end the skill with:
+
+```
+✓ Secured N install commands across M files:
+  - <file>: <change summary>
+  - <file>: <change summary>
+
+Next steps:
+  - Test locally (if applicable)
+  - Push to a feature branch and watch CI
+  - Confirm sfw is available in your CI environment (the install step is now in place)
+```

package/hooks/pre-install-guard.sh

@@ -0,0 +1,88 @@
+#!/usr/bin/env bash
+# pre-install-guard.sh — PreToolUse hook for Bash tool calls.
+#
+# Blocks bare dependency install commands and forces them to be re-run with
+# Socket Firewall (`sfw`) prefix to protect against supply-chain attacks.
+#
+# Reads tool-call JSON from stdin, returns:
+#   {} → allow
+#   {"permissionDecision":"deny","message":"..."} → block
+#
+# Patterns matched (anchored at the start of the actual command, after any
+# leading `cd ... &&` prefix):
+#   - npm/pnpm/yarn/bun (install|i|ci|add|update|upgrade)
+#   - composer (install|require|update)
+#   - pip/pip3/uv (install|sync)
+set -euo pipefail
+
+INPUT=$(cat)
+
+# Extract tool_input.command from the JSON. Try grep/sed first for speed,
+# fall back to python3 for properly-escaped JSON.
+COMMAND=$(printf '%s' "$INPUT" \
+  | grep -o '"command"[[:space:]]*:[[:space:]]*"[^"]*"' \
+  | head -1 \
+  | sed 's/.*:[[:space:]]*"//;s/"$//' \
+  || true)
+
+if [ -z "$COMMAND" ]; then
+  COMMAND=$(printf '%s' "$INPUT" \
+    | python3 -c 'import sys,json; print(json.loads(sys.stdin.read()).get("tool_input",{}).get("command",""))' \
+    2>/dev/null || true)
+fi
+
+# No command extracted → allow (don't block on parse failure).
+if [ -z "$COMMAND" ]; then
+  echo '{}'
+  exit 0
+fi
+
+# Strip leading whitespace.
+TRIMMED=$(printf '%s' "$COMMAND" | sed 's/^[[:space:]]*//')
+
+# Strip a leading `cd <dir> && ` prefix (or `cd <dir>; `) so we examine the
+# actual command being run, not the directory change.
+ACTUAL_CMD="$TRIMMED"
+while printf '%s' "$ACTUAL_CMD" | grep -qE '^cd[[:space:]]+[^&;]+[[:space:]]*(&&|;)[[:space:]]*'; do
+  ACTUAL_CMD=$(printf '%s' "$ACTUAL_CMD" \
+    | sed -E 's/^cd[[:space:]]+[^&;]+[[:space:]]*(&&|;)[[:space:]]*//')
+done
+
+# Strip leading env-var assignments (e.g. `NODE_ENV=production npm ci`).
+while printf '%s' "$ACTUAL_CMD" | grep -qE '^[A-Z_][A-Z0-9_]*=[^[:space:]]+[[:space:]]+'; do
+  ACTUAL_CMD=$(printf '%s' "$ACTUAL_CMD" \
+    | sed -E 's/^[A-Z_][A-Z0-9_]*=[^[:space:]]+[[:space:]]+//')
+done
+
+# Already wrapped with sfw → allow immediately.
+if printf '%s' "$ACTUAL_CMD" | grep -qE '^sfw([[:space:]]|$)'; then
+  echo '{}'
+  exit 0
+fi
+
+# Detect install commands. Patterns are conservative — must be the first token,
+# followed by an install-style subcommand.
+IS_INSTALL=0
+case "$ACTUAL_CMD" in
+  npm[[:space:]]install*|npm[[:space:]]i[[:space:]]*|"npm i"|npm[[:space:]]ci*|npm[[:space:]]add*|npm[[:space:]]update*|npm[[:space:]]upgrade*) IS_INSTALL=1 ;;
+  pnpm[[:space:]]install*|pnpm[[:space:]]i[[:space:]]*|"pnpm i"|pnpm[[:space:]]add*|pnpm[[:space:]]update*|pnpm[[:space:]]upgrade*) IS_INSTALL=1 ;;
+  yarn[[:space:]]install*|yarn[[:space:]]add*|yarn[[:space:]]upgrade*|"yarn") IS_INSTALL=1 ;;
+  bun[[:space:]]install*|bun[[:space:]]i[[:space:]]*|"bun i"|bun[[:space:]]add*|bun[[:space:]]update*) IS_INSTALL=1 ;;
+  composer[[:space:]]install*|composer[[:space:]]require*|composer[[:space:]]update*|composer[[:space:]]upgrade*) IS_INSTALL=1 ;;
+  pip[[:space:]]install*|pip3[[:space:]]install*|uv[[:space:]]install*|uv[[:space:]]sync*|uv[[:space:]]add*) IS_INSTALL=1 ;;
+esac
+
+if [ "$IS_INSTALL" -eq 0 ]; then
+  echo '{}'
+  exit 0
+fi
+
+# It's an install command without sfw — block it.
+# Escape the original command for safe inclusion in JSON.
+ESCAPED_CMD=$(printf '%s' "$ACTUAL_CMD" | python3 -c 'import sys,json; print(json.dumps(sys.stdin.read())[1:-1])' 2>/dev/null || printf '%s' "$ACTUAL_CMD" | sed 's/\\/\\\\/g; s/"/\\"/g')
+
+if command -v sfw >/dev/null 2>&1; then
+  printf '{"permissionDecision":"deny","message":"[slashdev] Bare install command blocked. Re-run with the sfw prefix:\\n\\n    sfw %s\\n\\nSocket Firewall scans every package against Socket'"'"'s vulnerability/malware database before installing it. This protects against supply-chain attacks."}\n' "$ESCAPED_CMD"
+else
+  printf '{"permissionDecision":"deny","message":"[slashdev] Socket Firewall (sfw) is required for dependency installs but is not installed on this machine. Install it once:\\n\\n    npm install -g @socketsecurity/cli\\n\\nThen retry the install with:\\n\\n    sfw %s"}\n' "$ESCAPED_CMD"
+fi

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slashdev",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Skills & workflows for AI agents in the Slashdev ecosystem",
   "type": "module",
   "main": "src/index.js",

package/src/commands/setup-internals.js

@@ -20,6 +20,38 @@ const CLAUDE_DIR = join(homedir(), '.claude');
 const CLAUDE_HOOKS_DIR = join(CLAUDE_DIR, 'hooks');
 const CLAUDE_SKILLS_DIR = join(CLAUDE_DIR, 'skills');
 const CLAUDE_SETTINGS_FILE = join(CLAUDE_DIR, 'settings.json');
+const CLAUDE_MEMORY_FILE = join(CLAUDE_DIR, 'CLAUDE.md');
+
+const SLASHDEV_SECTION_START = '<!-- SLASHDEV:RULES:START -->';
+const SLASHDEV_SECTION_END = '<!-- SLASHDEV:RULES:END -->';
+
+const SLASHDEV_RULES_BLOCK = `${SLASHDEV_SECTION_START}
+# Slashdev workspace rules
+
+## Security: always use Socket Firewall for dependency installs
+
+Claude must use Socket Firewall (\`sfw\`) for **every** dependency install command.
+This applies to:
+
+- **Local development** — never run \`npm install\`, \`pnpm install\`, \`yarn add\`,
+  \`bun install\`, \`composer install\`, \`pip install\`, or any equivalent without
+  prefixing \`sfw \`. A PreToolUse hook will block bare install commands and tell
+  you to retry with \`sfw\`.
+- **Production deployment** — when generating or editing CI/CD config (GitHub Actions,
+  GitLab CI, CircleCI, Jenkins), Dockerfiles, deploy scripts (\`deploy.sh\`, \`Procfile\`),
+  or \`package.json\` scripts that install dependencies, **always** wrap the install
+  step with \`sfw\`. Examples:
+  - \`sfw npm ci\` instead of \`npm ci\`
+  - \`sfw composer install --no-dev\` instead of \`composer install --no-dev\`
+  - \`RUN npm install -g @socketsecurity/cli && sfw npm ci\` in a Dockerfile
+- If \`sfw\` is not yet installed in a CI environment, install it first:
+  \`npm install -g @socketsecurity/cli\`. Document the install step inline in the workflow.
+- Use the \`/secure-deploy\` skill to retrofit existing CI/CD configs.
+
+Reason: Socket Firewall scans every package against Socket's vulnerability/malware
+database before letting it install. This protects against supply-chain attacks
+(compromised packages, typosquats, dependency confusion).
+${SLASHDEV_SECTION_END}`;
 
 function ensureDir(dir) {
   if (!existsSync(dir)) {
@@ -87,12 +119,64 @@ export function installHooks() {
     settings.hooks.Stop = stopHooks;
   }
 
+  // Register PreToolUse hook for the install guard (Bash tool only).
+  const guardCommand = join(CLAUDE_HOOKS_DIR, 'pre-install-guard.sh');
+  if (existsSync(guardCommand)) {
+    const preToolUseHooks = settings.hooks.PreToolUse || [];
+    const guardRegistered = preToolUseHooks.some(
+      (entry) =>
+        entry.matcher === 'Bash' &&
+        Array.isArray(entry.hooks) &&
+        entry.hooks.some((h) => h.command && h.command.includes('pre-install-guard.sh'))
+    );
+
+    if (!guardRegistered) {
+      preToolUseHooks.push({
+        matcher: 'Bash',
+        hooks: [
+          {
+            type: 'command',
+            command: guardCommand,
+            statusMessage: 'Checking install safety…',
+          },
+        ],
+      });
+      settings.hooks.PreToolUse = preToolUseHooks;
+    }
+  }
+
   writeFileSync(CLAUDE_SETTINGS_FILE, JSON.stringify(settings, null, 2), 'utf-8');
 
   const hookFiles = readdirSync(hooksSource).filter((f) => f.endsWith('.sh'));
   return { installed: hookFiles.length };
 }
 
+export function writeGlobalClaudeMd() {
+  ensureDir(CLAUDE_DIR);
+
+  let existing = '';
+  if (existsSync(CLAUDE_MEMORY_FILE)) {
+    existing = readFileSync(CLAUDE_MEMORY_FILE, 'utf-8');
+  }
+
+  let next;
+  if (existing.includes(SLASHDEV_SECTION_START) && existing.includes(SLASHDEV_SECTION_END)) {
+    // Replace the existing managed section in place, preserving everything around it.
+    const before = existing.split(SLASHDEV_SECTION_START)[0];
+    const after = existing.split(SLASHDEV_SECTION_END)[1];
+    next = `${before}${SLASHDEV_RULES_BLOCK}${after}`;
+  } else if (existing.trim().length > 0) {
+    // Append after existing user content.
+    next = `${existing.trimEnd()}\n\n${SLASHDEV_RULES_BLOCK}\n`;
+  } else {
+    // Brand new file.
+    next = `${SLASHDEV_RULES_BLOCK}\n`;
+  }
+
+  writeFileSync(CLAUDE_MEMORY_FILE, next, 'utf-8');
+  return { written: true, path: CLAUDE_MEMORY_FILE };
+}
+
 export function installSkills() {
   const skillsSource = join(PACKAGE_ROOT, 'claude-skills');
   if (!existsSync(skillsSource)) {

package/src/commands/setup.js

@@ -6,7 +6,7 @@ import { fileURLToPath } from 'url';
 import { existsSync, readFileSync, mkdirSync } from 'fs';
 import { homedir } from 'os';
 import { getConfig, setConfig, getSlashdevDir } from '../core/config.js';
-import { installHooks, installSkills, installGstack } from './setup-internals.js';
+import { installHooks, installSkills, installGstack, writeGlobalClaudeMd } from './setup-internals.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -82,6 +82,10 @@ export async function setup() {
     spinner.text = 'Installing gstack skills...';
     const gstackResult = installGstack();
 
+    // Write global Claude rules (Socket Firewall + workspace policy)
+    spinner.text = 'Writing global Claude rules...';
+    const rulesResult = writeGlobalClaudeMd();
+
     spinner.succeed('Slashdev Claude tools installed');
 
     console.log('');
@@ -92,9 +96,11 @@ export async function setup() {
     if (gstackResult.warning) {
       console.log(`  ${chalk.yellow('!')} ${gstackResult.warning}`);
     }
+    console.log(`  ${chalk.green('✓')} Rules:     ${rulesResult.path}`);
     console.log(`  ${chalk.green('✓')} Config:    ${join(getSlashdevDir(), 'config.json')}`);
     console.log('');
-    console.log(chalk.dim('  Hooks and skills have been installed to ~/.claude/'));
+    console.log(chalk.dim('  Hooks, skills, and global rules have been installed to ~/.claude/'));
+    console.log(chalk.dim('  Socket Firewall enforcement is active for all Bash install commands.'));
     console.log(chalk.dim('  Prompt logs will be sent to the Slashdev API for quality review.\n'));
   } catch (err) {
     spinner.fail('Setup failed');

package/src/commands/update.js

@@ -27,7 +27,7 @@ export async function update() {
   try {
     // Re-import setup internals by calling setup's install functions
     // We import dynamically to avoid circular deps
-    const { installHooks, installSkills, installGstack } = await import('./setup-internals.js');
+    const { installHooks, installSkills, installGstack, writeGlobalClaudeMd } = await import('./setup-internals.js');
 
     const hookResult = installHooks();
 
@@ -37,6 +37,9 @@ export async function update() {
     spinner.text = 'Updating gstack skills...';
     const gstackResult = installGstack();
 
+    spinner.text = 'Updating global Claude rules...';
+    const rulesResult = writeGlobalClaudeMd();
+
     // Update version in config
     const pkg = JSON.parse(readFileSync(join(PACKAGE_ROOT, 'package.json'), 'utf-8'));
     setConfig('packageVersion', pkg.version);
@@ -50,6 +53,7 @@ export async function update() {
     if (gstackResult.warning) {
       console.log(`  ${chalk.yellow('!')} ${gstackResult.warning}`);
     }
+    console.log(`  ${chalk.green('✓')} Rules:   ${rulesResult.path}`);
     console.log(`  ${chalk.green('✓')} Config:  version set to ${pkg.version}`);
     console.log('');
   } catch (err) {