@wipcomputer/wip-ai-devops-toolbox 1.9.20

package/tools/post-merge-rename/post-merge-rename.sh

@@ -0,0 +1,122 @@
+#!/usr/bin/env bash
+#
+# post-merge-rename.sh
+# Scans for branches merged into main and renames them with --merged-YYYY-MM-DD.
+# Branches already renamed (containing --merged-) are skipped.
+# Never deletes branches. Only renames.
+#
+# Usage:
+#   bash post-merge-rename.sh                    # scan + rename all
+#   bash post-merge-rename.sh <branch>           # rename a specific branch
+#   bash post-merge-rename.sh --dry-run          # preview only
+#   bash post-merge-rename.sh <branch> --dry-run # preview specific branch
+#
+# Run this after merging a PR, or periodically to catch missed renames.
+#
+# Author: CC-mini (Opus 4.6)
+# Date: 2026-03-08
+
+set -euo pipefail
+
+DRY_RUN=false
+SPECIFIC_BRANCH=""
+
+for arg in "$@"; do
+  case "$arg" in
+    --dry-run) DRY_RUN=true ;;
+    --help|-h)
+      echo "Usage: post-merge-rename.sh [<branch>] [--dry-run]"
+      echo ""
+      echo "Scans for branches merged into main and renames them"
+      echo "with --merged-YYYY-MM-DD suffix. Never deletes branches."
+      exit 0
+      ;;
+    *) SPECIFIC_BRANCH="$arg" ;;
+  esac
+done
+
+# Must be in a git repo
+if ! git rev-parse --is-inside-work-tree &>/dev/null; then
+  echo "Error: not inside a git repo."
+  exit 1
+fi
+
+# Fetch latest remote state
+git fetch origin --prune 2>/dev/null || true
+
+rename_branch() {
+  local branch="$1"
+  local trimmed
+  trimmed=$(echo "$branch" | sed 's/^[[:space:]]*//' | sed 's/[[:space:]]*$//')
+
+  # Skip main
+  [[ "$trimmed" == "main" || "$trimmed" == "master" ]] && return
+
+  # Skip already renamed
+  [[ "$trimmed" == *"--merged-"* ]] && return
+
+  # Skip current branch (can't rename the checked-out branch)
+  local current
+  current=$(git branch --show-current)
+  if [[ "$trimmed" == "$current" ]]; then
+    echo "  SKIP $trimmed (currently checked out)"
+    return
+  fi
+
+  # Find merge date: when this branch's tip became reachable from main
+  local merge_date
+  merge_date=$(git log main --format="%ai" --ancestry-path "$(git merge-base main "$trimmed" 2>/dev/null)..main" 2>/dev/null | tail -1 | cut -d' ' -f1)
+
+  # Fallback: use the branch tip's own date
+  if [[ -z "$merge_date" ]]; then
+    merge_date=$(git log "$trimmed" -1 --format="%ai" 2>/dev/null | cut -d' ' -f1)
+  fi
+
+  if [[ -z "$merge_date" ]]; then
+    echo "  SKIP $trimmed (could not determine merge date)"
+    return
+  fi
+
+  local new_name="${trimmed}--merged-${merge_date}"
+
+  if $DRY_RUN; then
+    echo "  [dry-run] $trimmed -> $new_name"
+  else
+    echo "  Renaming: $trimmed -> $new_name"
+
+    # Rename local
+    git branch -m "$trimmed" "$new_name" 2>/dev/null || true
+
+    # Push new name to remote
+    git push origin "$new_name" 2>/dev/null || true
+
+    # Remove old name from remote
+    git push origin --delete "$trimmed" 2>/dev/null || true
+  fi
+}
+
+if [[ -n "$SPECIFIC_BRANCH" && "$SPECIFIC_BRANCH" != "--dry-run" ]]; then
+  # Rename a specific branch
+  echo "Checking branch: $SPECIFIC_BRANCH"
+  if git merge-base --is-ancestor "$SPECIFIC_BRANCH" main 2>/dev/null; then
+    rename_branch "$SPECIFIC_BRANCH"
+  else
+    echo "  $SPECIFIC_BRANCH is NOT merged into main. Leaving as-is."
+  fi
+else
+  # Scan all local branches merged into main
+  echo "Scanning for merged branches..."
+  merged=$(git branch --merged main | grep -v "^\*" | grep -v "main$" | grep -v "master$" | grep -v "\-\-merged\-" || true)
+
+  if [[ -z "$merged" ]]; then
+    echo "  No unrenamed merged branches found. All clean."
+    exit 0
+  fi
+
+  while IFS= read -r branch; do
+    rename_branch "$branch"
+  done <<< "$merged"
+fi
+
+echo ""
+echo "Done."

package/tools/wip-branch-guard/INSTALL.md

@@ -0,0 +1,41 @@
+# wip-branch-guard Installation
+
+Add this hook to `~/.claude/settings.json` under `hooks.PreToolUse`:
+
+```json
+{
+  "matcher": "Write|Edit|NotebookEdit|Bash",
+  "hooks": [
+    {
+      "type": "command",
+      "command": "node /Users/lesa/.ldm/extensions/wip-branch-guard/guard.mjs",
+      "timeout": 5
+    }
+  ]
+}
+```
+
+Then copy the guard to the extensions directory:
+
+```bash
+mkdir -p ~/.ldm/extensions/wip-branch-guard
+cp guard.mjs package.json ~/.ldm/extensions/wip-branch-guard/
+```
+
+## What it does
+
+Blocks ALL file writes and git commits when Claude Code is on main branch.
+Agents must create a branch or use a worktree before editing anything.
+
+## What it allows on main
+
+- Read, Glob, Grep (read-only tools)
+- git status, git log, git diff, git branch, git checkout, git pull, git merge, git push
+- gh commands (issues, PRs, releases)
+- Opening files in browser/mdview
+
+## Test
+
+```bash
+node ~/.ldm/extensions/wip-branch-guard/guard.mjs --check
+```

package/tools/wip-branch-guard/guard.mjs

@@ -0,0 +1,259 @@
+#!/usr/bin/env node
+// wip-branch-guard/guard.mjs
+// PreToolUse hook for Claude Code.
+// Blocks ALL file writes and git commits when on main branch.
+// Agents must work on branches or worktrees. Never on main.
+
+import { execSync } from 'node:child_process';
+import { dirname } from 'node:path';
+import { statSync } from 'node:fs';
+
+// Tools that modify files or git state
+const WRITE_TOOLS = new Set(['Write', 'Edit', 'NotebookEdit']);
+const BASH_TOOL = 'Bash';
+
+// Git commands that should be blocked on main
+const BLOCKED_GIT_PATTERNS = [
+  /\bgit\s+commit\b/,
+  /\bgit\s+add\b/,
+  /\bgit\s+stash\b/,
+  /\bgit\s+reset\b/,
+  /\bgit\s+revert\b/,
+];
+
+// Git commands that are ALLOWED on main (read-only or merge operations)
+const ALLOWED_GIT_PATTERNS = [
+  /\bgit\s+merge\b/,
+  /\bgit\s+pull\b/,
+  /\bgit\s+fetch\b/,
+  /\bgit\s+push\b/,
+  /\bgit\s+status\b/,
+  /\bgit\s+log\b/,
+  /\bgit\s+diff\b/,
+  /\bgit\s+branch\b/,
+  /\bgit\s+checkout\b/,
+  /\bgit\s+worktree\b/,
+  /\bgit\s+stash\s+drop\b/,
+  /\bgit\s+stash\s+list\b/,
+  /\bgit\s+remote\b/,
+  /\bgit\s+describe\b/,
+  /\bgit\s+tag\b/,
+  /\bgit\s+rev-parse\b/,
+  /\bgit\s+show\b/,
+];
+
+// Non-git bash commands that write files (common patterns)
+const BLOCKED_BASH_PATTERNS = [
+  /\bcp\s+/,
+  /\bmv\s+/,
+  /\brm\s+/,
+  /\bmkdir\s+/,
+  /\btouch\s+/,
+  /\bnpm\s+link\b/,
+  /\bnpm\s+install\s+-g\b/,
+  />\s/,          // redirects
+  /\btee\s+/,
+  /\bsed\s+-i/,
+];
+
+// Allowed bash patterns (read-only operations, even though they match blocked patterns)
+const ALLOWED_BASH_PATTERNS = [
+  /\bls\b/,
+  /\bcat\b/,
+  /\bhead\b/,
+  /\btail\b/,
+  /\bgrep\b/,
+  /\brg\b/,
+  /\bfind\b/,
+  /\bwc\b/,
+  /\becho\b/,
+  /\bcurl\b/,
+  /\bgh\s+(issue|pr|release|api)\b/,
+  /\bgh\s+pr\s+merge\b/,
+  /\bnode\s+-e\b/,
+  /\blsof\b/,
+  /\bopen\s+-a\b/,
+  /\bpwd\b/,
+  /--dry-run/,
+  /--help/,
+  /\bwip-release\b.*--dry-run/,
+];
+
+function deny(reason) {
+  const output = {
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      permissionDecision: 'deny',
+      permissionDecisionReason: reason,
+    },
+  };
+  process.stdout.write(JSON.stringify(output));
+}
+
+function findRepoRoot(filePath) {
+  // Walk up from a file path to find the git repo root
+  try {
+    let dir = filePath;
+    // If it's a file, start from its directory
+    try {
+      if (statSync(dir).isFile()) dir = dirname(dir);
+    } catch {
+      dir = dirname(dir); // File might not exist yet
+    }
+
+    // Use git rev-parse from the directory
+    const result = execSync('git rev-parse --show-toplevel 2>/dev/null', {
+      cwd: dir,
+      encoding: 'utf8',
+      timeout: 3000,
+    }).trim();
+    return result;
+  } catch {}
+  return null;
+}
+
+function getCurrentBranch(cwd) {
+  try {
+    return execSync('git branch --show-current 2>/dev/null', {
+      cwd: cwd || process.cwd(),
+      encoding: 'utf8',
+      timeout: 3000,
+    }).trim();
+  } catch {
+    return null; // Not in a git repo
+  }
+}
+
+function isInWorktree(cwd) {
+  try {
+    const gitDir = execSync('git rev-parse --git-dir 2>/dev/null', {
+      cwd: cwd || process.cwd(),
+      encoding: 'utf8',
+      timeout: 3000,
+    }).trim();
+    return gitDir.includes('/worktrees/');
+  } catch {
+    return false;
+  }
+}
+
+// CLI mode
+if (process.argv.includes('--check')) {
+  const branch = getCurrentBranch();
+  const worktree = isInWorktree();
+  console.log(`Branch: ${branch || '(not in git repo)'}`);
+  console.log(`Worktree: ${worktree ? 'yes' : 'no'}`);
+  console.log(`Status: ${branch === 'main' || branch === 'master' ? 'BLOCKED (on main)' : 'OK'}`);
+  process.exit(branch === 'main' || branch === 'master' ? 1 : 0);
+}
+
+async function main() {
+  let raw = '';
+  for await (const chunk of process.stdin) {
+    raw += chunk;
+  }
+
+  let input;
+  try {
+    input = JSON.parse(raw);
+  } catch {
+    process.exit(0);
+  }
+
+  const toolName = input.tool_name || '';
+  const toolInput = input.tool_input || {};
+
+  // Determine which repo to check.
+  // Claude Code always opens in .openclaw, but edits files in other repos.
+  // We need to check the branch of THE REPO THE FILE LIVES IN, not the CWD.
+  const filePath = toolInput.file_path || toolInput.filePath || '';
+  const command = toolInput.command || '';
+
+  // For Write/Edit: derive repo from the file path
+  // For Bash: try to extract repo path from the command (cd, or file paths in args)
+  let repoDir = null;
+
+  if (filePath) {
+    // Walk up from file path to find .git directory
+    repoDir = findRepoRoot(filePath);
+  }
+
+  if (!repoDir && command) {
+    // Try to extract a path from the bash command
+    // Common patterns: cd "/path/to/repo" && ..., or paths in arguments
+    const cdMatch = command.match(/cd\s+["']?([^"'&|;]+?)["']?\s*(?:&&|;|$)/);
+    if (cdMatch) {
+      repoDir = findRepoRoot(cdMatch[1].trim());
+    }
+    // Also check for git -C /path/to/repo
+    const gitCMatch = command.match(/git\s+-C\s+["']?([^"'&|;]+?)["']?\s/);
+    if (!repoDir && gitCMatch) {
+      repoDir = findRepoRoot(gitCMatch[1].trim());
+    }
+  }
+
+  // Fall back to CWD
+  if (!repoDir) {
+    repoDir = process.env.CWD || process.cwd();
+  }
+
+  // Check if the target repo is on main
+  const branch = getCurrentBranch(repoDir);
+  if (!branch || (branch !== 'main' && branch !== 'master')) {
+    // Not on main, allow everything
+    process.exit(0);
+  }
+
+  // We're on main. Check if this is a write operation.
+
+  // Block Write/Edit tools entirely on main
+  if (WRITE_TOOLS.has(toolName)) {
+    deny(`BLOCKED: Cannot ${toolName} while on main branch. Create a branch first: git checkout -b cc-mini/your-feature. Or use a worktree.`);
+    process.exit(0);
+  }
+
+  // For Bash, check the command
+  if (toolName === BASH_TOOL && command) {
+    // First check if it's explicitly allowed (read-only)
+    for (const pattern of ALLOWED_BASH_PATTERNS) {
+      if (pattern.test(command)) {
+        process.exit(0);
+      }
+    }
+
+    // Check for blocked git commands
+    for (const pattern of BLOCKED_GIT_PATTERNS) {
+      if (pattern.test(command)) {
+        // Make sure it's not an allowed git operation
+        let isAllowed = false;
+        for (const ap of ALLOWED_GIT_PATTERNS) {
+          if (ap.test(command)) { isAllowed = true; break; }
+        }
+        if (!isAllowed) {
+          deny(`BLOCKED: Cannot run "${command.substring(0, 60)}..." on main branch. Create a branch first.`);
+          process.exit(0);
+        }
+      }
+    }
+
+    // Check for file-writing bash commands
+    for (const pattern of BLOCKED_BASH_PATTERNS) {
+      if (pattern.test(command)) {
+        // Check it's not a read-only context
+        let isAllowed = false;
+        for (const ap of ALLOWED_BASH_PATTERNS) {
+          if (ap.test(command)) { isAllowed = true; break; }
+        }
+        if (!isAllowed) {
+          deny(`BLOCKED: Cannot run file-modifying command on main branch. Create a branch first.`);
+          process.exit(0);
+        }
+      }
+    }
+  }
+
+  // Allow everything else (Read, Glob, Grep, Agent, etc.)
+  process.exit(0);
+}
+
+main().catch(() => process.exit(0));

package/tools/wip-branch-guard/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@wipcomputer/wip-branch-guard",
+  "version": "1.9.20",
+  "description": "PreToolUse hook that blocks all writes on main branch. Forces agents to work on branches or worktrees.",
+  "type": "module",
+  "main": "guard.mjs",
+  "bin": {
+    "wip-branch-guard": "guard.mjs"
+  },
+  "license": "MIT"
+}

package/tools/wip-file-guard/CHANGELOG.md

@@ -0,0 +1,6 @@
+# Changelog
+
+## 1.0.1 (2026-02-21)
+
+Align description, add SKILL.md, add badges, agent-driven install, REFERENCE.md
+

package/tools/wip-file-guard/LICENSE

@@ -0,0 +1,52 @@
+Dual License: MIT + AGPLv3
+
+Copyright (c) 2026 WIP Computer, Inc.
+
+
+1. MIT License (local and personal use)
+---------------------------------------
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+2. GNU Affero General Public License v3.0 (commercial and cloud use)
+--------------------------------------------------------------------
+
+If you run this software as part of a hosted service, cloud platform,
+marketplace listing, or any network-accessible offering for commercial
+purposes, the AGPLv3 terms apply. You must either:
+
+  a) Release your complete source code under AGPLv3, or
+  b) Obtain a commercial license.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published
+by the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+
+AGPLv3 for personal use is free. Commercial licenses available.

package/tools/wip-file-guard/README.md

@@ -0,0 +1,113 @@
+###### WIP Computer
+
+[![npm](https://img.shields.io/npm/v/@wipcomputer/wip-file-guard)](https://www.npmjs.com/package/@wipcomputer/wip-file-guard) [![CLI / TUI](https://img.shields.io/badge/interface-CLI_/_TUI-black)](https://github.com/wipcomputer/wip-ai-devops-toolbox/blob/main/tools/wip-file-guard/guard.mjs) [![OpenClaw Plugin](https://img.shields.io/badge/interface-OpenClaw_Plugin-black)](https://github.com/wipcomputer/wip-ai-devops-toolbox/blob/main/tools/wip-file-guard/openclaw.plugin.json) [![Claude Code Hook](https://img.shields.io/badge/interface-Claude_Code_Hook-black)](https://github.com/wipcomputer/wip-ai-devops-toolbox/blob/main/tools/wip-file-guard/guard.mjs) [![Claude Code Skill](https://img.shields.io/badge/interface-Claude_Code_Skill-black)](https://github.com/wipcomputer/wip-ai-devops-toolbox/blob/main/tools/wip-file-guard/SKILL.md) [![Universal Interface Spec](https://img.shields.io/badge/Universal_Interface_Spec-black?style=flat&color=black)](https://github.com/wipcomputer/wip-ai-devops-toolbox/blob/main/tools/wip-universal-installer/SPEC.md)
+
+# File Guard
+
+PreToolUse hook that blocks destructive edits to protected files. When an AI agent tries to overwrite or strip content from files like CLAUDE.md, SHARED-CONTEXT.md, or SOUL.md... it gets blocked with a clear explanation of what went wrong.
+
+## The Problem
+
+AI agents replace content instead of extending it. After context compaction, behavioral rules like "don't delete things" vanish. The agent rewrites your CLAUDE.md, strips 30 lines from SHARED-CONTEXT.md, or replaces your SOUL.md with a shorter version. Every time.
+
+File Guard is a technical guardrail. It doesn't ask the agent to be careful. It blocks the operation before it happens.
+
+## How It Works
+
+Two rules:
+
+1. **Write is blocked** on protected files. Always. Use Edit instead.
+2. **Edit is blocked** when it removes more than 2 net lines from a protected file.
+
+The agent gets a deny message explaining what happened and telling it to re-read the file and add content instead of replacing it.
+
+### Protected Files
+
+| File | What it protects |
+|------|-----------------|
+| `CLAUDE.md` | Project instructions, boot sequence, system docs |
+| `SHARED-CONTEXT.md` | Cross-agent shared state |
+| `SOUL.md` | Agent identity |
+| `IDENTITY.md` | Agent identity (alternate format) |
+| `CONTEXT.md` | Current state snapshot |
+| `TOOLS.md` | Tool and workflow rules |
+| `MEMORY.md` | Persistent memory and preferences |
+
+## Install
+
+Open your AI coding tool and say:
+
+```
+Read the README at github.com/wipcomputer/wip-file-guard.
+Then explain to me:
+1. What is this tool?
+2. What does it do?
+3. What would it change or fix in our current system?
+
+Then ask me:
+- Do you have more questions?
+- Do you want to integrate it into our system?
+- Do you want to clone it (use as-is) or fork it (so you can contribute back if you find bugs)?
+```
+
+Your agent will read the repo, explain the tool, and walk you through integration interactively.
+
+Also see **[wip-release](https://github.com/wipcomputer/wip-release)** ... one-command release pipeline for agent-native software.
+
+See [REFERENCE.md](REFERENCE.md) for manual install instructions (Claude Code, OpenClaw, CLI).
+
+## Four Interfaces
+
+One core, four interfaces into the same guard logic.
+
+| Interface | File | What it does |
+|-----------|------|-------------|
+| **Core** | `guard.mjs` | Pure guard logic. Reads stdin JSON, decides allow/deny. |
+| **Claude Code** | `guard.mjs` (PreToolUse hook) | Hooks into CC's PreToolUse event. Blocks before the edit happens. |
+| **OpenClaw** | `openclaw.plugin.json` | Lifecycle hook for OpenClaw agents. Same rules, different runtime. |
+| **CLI** | `guard.mjs --list`, `test.sh` | Testing and inspection from the command line. |
+
+See [REFERENCE.md](REFERENCE.md) for customization (adding protected files, changing thresholds).
+
+## Tests
+
+```bash
+bash test.sh
+```
+
+```
+wip-file-guard tests
+===================
+
+PASS: Block Write to CLAUDE.md
+PASS: Block Write to SHARED-CONTEXT.md
+PASS: Allow Write to random file
+PASS: Block Edit removing 5 lines from CLAUDE.md
+PASS: Allow Edit adding lines to CLAUDE.md
+PASS: Allow Edit on non-protected file (even removing lines)
+PASS: Allow Edit with small removal (2 lines)
+PASS: Block Edit with 4 line removal from SOUL.md
+PASS: Block Write to IDENTITY.md
+PASS: Block Write to TOOLS.md
+
+Results: 10 passed, 0 failed
+```
+
+## Why This Exists
+
+Context compaction erases behavioral rules. An agent that was told "never delete content from CLAUDE.md" forgets that instruction after compaction. It then proceeds to replace 50 lines with 10, confident it's improving the file.
+
+This happened five times in one session. The fix isn't better prompting. It's a hook that blocks the operation before it executes. Behavioral rules degrade. Technical guards don't.
+
+---
+
+## License
+
+```
+CLI, OpenClaw plugin, hooks                    MIT    (use anywhere, no restrictions)
+Hosted or cloud service use                    AGPL   (network service distribution)
+```
+
+AGPL for personal use is free.
+
+Built by Parker Todd Brooks, Lēsa (OpenClaw, Claude Opus 4.6), Claude Code (Claude Opus 4.6).

package/tools/wip-file-guard/REFERENCE.md

@@ -0,0 +1,86 @@
+###### WIP Computer
+# wip-file-guard ... Reference
+
+Manual install instructions, CLI usage, and customization.
+
+## Install
+
+Install to your LDM OS home:
+
+```bash
+mkdir -p ~/.ldm/extensions/wip-file-guard
+cp guard.mjs openclaw.plugin.json package.json ~/.ldm/extensions/wip-file-guard/
+```
+
+All config paths should point to the installed location (`~/.ldm/extensions/`), not the source repo.
+
+## Claude Code
+
+Add to `~/.claude/settings.json`:
+
+```json
+{
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Edit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ~/.ldm/extensions/wip-file-guard/guard.mjs",
+            "timeout": 5
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+## OpenClaw
+
+```bash
+cp -r ~/.ldm/extensions/wip-file-guard ~/.openclaw/extensions/wip-file-guard
+```
+
+The `openclaw.plugin.json` registers a `before_tool_use` lifecycle hook that applies the same rules.
+
+## CLI
+
+```bash
+# List protected files
+node guard.mjs --list
+
+# Test the guard with a simulated input
+echo '{"tool_name":"Write","tool_input":{"file_path":"/foo/CLAUDE.md"}}' | node guard.mjs
+
+# Run the test suite
+bash test.sh
+```
+
+## Customization
+
+### Adding Protected Files
+
+Edit the `PROTECTED` set in `guard.mjs`:
+
+```javascript
+const PROTECTED = new Set([
+  'CLAUDE.md',
+  'SHARED-CONTEXT.md',
+  'SOUL.md',
+  'IDENTITY.md',
+  'CONTEXT.md',
+  'TOOLS.md',
+  'MEMORY.md',
+  'YOUR-FILE-HERE.md',   // add yours
+]);
+```
+
+### Changing the Line Threshold
+
+The default blocks edits that remove more than 2 net lines. Change the threshold in the Edit handler:
+
+```javascript
+if (removed > 2) {   // change 2 to your threshold
+```