rhachet-roles-ehmpathy 1.14.0 → 1.15.1

package/dist/logic/roles/mechanic/.skills/claude.hooks/sessionstart.notify-permissions.sh

@@ -0,0 +1,106 @@
+#!/usr/bin/env bash
+######################################################################
+# .what = SessionStart hook to notify Claude of allowed permissions
+#
+# .why  = proactively informing Claude of pre-approved Bash commands
+#         at session start reduces interruptions from permission
+#         prompts by guiding it to use allowed patterns upfront.
+#
+#         this complements the PreToolUse hook which blocks/nudges
+#         when Claude attempts unapproved commands, by providing
+#         the information before any attempts are made.
+#
+# .how  = reads .claude/settings.local.json, extracts Bash permissions,
+#         outputs a formatted list of allowed commands for Claude
+#         to reference throughout the session.
+#
+# usage:
+#   configure in .claude/settings.local.json under hooks.SessionStart
+#
+# guarantee:
+#   ✔ non-blocking: always exits 0
+#   ✔ informational only: no side effects
+#   ✔ graceful fallback: exits silently if no settings found
+######################################################################
+
+set -euo pipefail
+
+# Find the .claude directory (search upward from current directory)
+find_claude_dir() {
+  local dir="$PWD"
+  while [[ "$dir" != "/" ]]; do
+    if [[ -d "$dir/.claude" ]]; then
+      echo "$dir/.claude"
+      return 0
+    fi
+    dir="$(dirname "$dir")"
+  done
+  return 1
+}
+
+# Find the settings file
+find_settings_file() {
+  local claude_dir
+  claude_dir=$(find_claude_dir) || return 1
+  local settings_file="$claude_dir/settings.local.json"
+  if [[ -f "$settings_file" ]]; then
+    echo "$settings_file"
+    return 0
+  fi
+  return 1
+}
+
+SETTINGS_FILE=$(find_settings_file) || {
+  # No settings file found, exit silently
+  exit 0
+}
+
+# Extract Bash permissions from settings file
+# Patterns look like: "Bash(npm run test:*)" -> extract "npm run test:*"
+mapfile -t ALLOWED_PATTERNS < <(
+  jq -r '.permissions.allow // [] | .[] | select(startswith("Bash(")) | sub("^Bash\\("; "") | sub("\\)$"; "")' "$SETTINGS_FILE" 2>/dev/null
+)
+
+# If no Bash permissions found, exit silently
+if [[ ${#ALLOWED_PATTERNS[@]} -eq 0 ]]; then
+  exit 0
+fi
+
+# Transform raw permission pattern to compact bracket notation for display
+format_pattern() {
+  local pattern="$1"
+
+  # Check if pattern ends with :*
+  if [[ "$pattern" == *":*" ]]; then
+    # Remove :* suffix and format with [p]: label (prefix match)
+    local prefix="${pattern%:*}"
+    echo "[p]: $prefix"
+  else
+    # Exact match - format with [e]: label
+    echo "[e]: $pattern"
+  fi
+}
+
+# Output the allowed permissions notification
+echo ""
+echo "=================================================="
+echo "PRE-APPROVED BASH PERMISSIONS"
+echo "=================================================="
+echo ""
+echo "The following Bash commands are pre-approved and can be used without"
+echo "requesting permission from the user:"
+echo ""
+echo "([e] = exact match, [p] = prefix match - anything starting with this)"
+echo ""
+for pattern in "${ALLOWED_PATTERNS[@]}"; do
+  echo "  $(format_pattern "$pattern")"
+done
+echo ""
+echo "IMPORTANT: If you attempt a Bash command NOT on this list, you will be"
+echo "blocked and asked to reconsider. Please check this list first before"
+echo "using Bash commands to minimize interruptions to the user."
+echo ""
+echo "=================================================="
+echo ""
+
+exit 0

package/dist/logic/roles/mechanic/.skills/init.claude.hooks.cleanup.sh

@@ -0,0 +1,104 @@
+#!/usr/bin/env bash
+######################################################################
+# .what = cleanup stale hooks from Claude settings
+#
+# .why  = when hook scripts are removed from claude.hooks/, the
+#         corresponding entries in .claude/settings.local.json
+#         become stale and should be cleaned up.
+#
+# .how  = reads settings.local.json, finds hooks referencing files
+#         in claude.hooks/, checks if those files exist, and removes
+#         any hooks whose scripts no longer exist.
+#
+# usage:
+#   init.claude.hooks.cleanup.sh
+#
+# guarantee:
+#   ✔ only removes hooks referencing missing claude.hooks/ files
+#   ✔ preserves all other hooks and settings
+#   ✔ idempotent: safe to rerun
+#   ✔ no-op if no stale hooks found
+######################################################################
+
+set -euo pipefail
+
+SKILLS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+HOOKS_DIR="$SKILLS_DIR/claude.hooks"
+
+PROJECT_ROOT="$PWD"
+SETTINGS_FILE="$PROJECT_ROOT/.claude/settings.local.json"
+
+# Exit if no settings file
+if [[ ! -f "$SETTINGS_FILE" ]]; then
+  exit 0
+fi
+
+# Extract all hook commands that reference claude.hooks/
+# and check which ones point to missing files
+STALE_COMMANDS=$(jq -r '
+  .hooks // {} | to_entries[] |
+  .value[] | .hooks[] | .command // empty
+' "$SETTINGS_FILE" 2>/dev/null | grep -E "claude\.hooks/" | while read -r cmd; do
+  # Extract the path - it might be absolute or relative
+  # Look for the claude.hooks/ part and check if the file exists
+  if [[ "$cmd" == /* ]]; then
+    # Absolute path
+    if [[ ! -f "$cmd" ]]; then
+      echo "$cmd"
+    fi
+  else
+    # Relative path or command - check if it contains claude.hooks/
+    # and if the file exists relative to PWD
+    if [[ ! -f "$PROJECT_ROOT/$cmd" ]]; then
+      echo "$cmd"
+    fi
+  fi
+done)
+
+# Exit if no stale commands found
+if [[ -z "$STALE_COMMANDS" ]]; then
+  echo "👌 no stale hooks found"
+  exit 0
+fi
+
+# Build jq filter to remove stale hooks
+# Convert stale commands to JSON array for jq
+STALE_JSON=$(echo "$STALE_COMMANDS" | jq -R -s 'split("\n") | map(select(length > 0))')
+
+jq --argjson stale "$STALE_JSON" '
+  # Remove hooks whose command is in the stale list
+  .hooks |= (
+    if . then
+      to_entries | map(
+        .value |= map(
+          .hooks |= map(select(.command as $cmd | ($stale | index($cmd)) == null))
+        )
+        # Remove matchers with empty hooks arrays
+        | .value |= map(select(.hooks | length > 0))
+      )
+      # Remove hook types with empty arrays
+      | map(select(.value | length > 0))
+      | from_entries
+    else
+      .
+    end
+  )
+' "$SETTINGS_FILE" > "$SETTINGS_FILE.tmp"
+
+# Check if any changes were made
+if diff -q "$SETTINGS_FILE" "$SETTINGS_FILE.tmp" >/dev/null 2>&1; then
+  rm "$SETTINGS_FILE.tmp"
+  echo "👌 no stale hooks found"
+  exit 0
+fi
+
+# Report what's being removed
+echo "🧹 removing stale hooks:"
+echo "$STALE_COMMANDS" | while read -r cmd; do
+  echo "   - $cmd"
+done
+
+# Atomic replace
+mv "$SETTINGS_FILE.tmp" "$SETTINGS_FILE"
+
+echo "✨ cleanup complete"

package/dist/logic/roles/mechanic/.skills/init.claude.hooks.findsert.sh

@@ -0,0 +1,216 @@
+#!/usr/bin/env bash
+######################################################################
+# .what = generic findsert utility for Claude hooks
+#
+# .why  = centralizes the "find-or-insert" logic for binding hooks
+#         to .claude/settings.local.json, avoiding duplication across
+#         individual hook initializers.
+#
+# .how  = takes hook configuration as arguments and uses jq to merge
+#         the hook into the settings file, creating structure if absent.
+#
+# usage:
+#   init.claude.hooks.findsert.sh \
+#     --hook-type SessionStart|PreToolUse \
+#     --matcher "*"|"Bash"|... \
+#     --command "command to run" \
+#     --name "hookname" \
+#     [--timeout 5] \
+#     [--position append|prepend]
+#
+# guarantee:
+#   ✔ creates .claude/settings.local.json if missing
+#   ✔ preserves existing settings (permissions, other hooks)
+#   ✔ idempotent: no-op if hook already present (at correct position)
+#   ✔ fail-fast on errors
+######################################################################
+
+set -euo pipefail
+
+# Defaults
+HOOK_TYPE=""
+MATCHER=""
+HOOK_COMMAND=""
+HOOK_NAME=""
+TIMEOUT=5
+POSITION="append"
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --hook-type)
+      HOOK_TYPE="$2"
+      shift 2
+      ;;
+    --matcher)
+      MATCHER="$2"
+      shift 2
+      ;;
+    --command)
+      HOOK_COMMAND="$2"
+      shift 2
+      ;;
+    --name)
+      HOOK_NAME="$2"
+      shift 2
+      ;;
+    --timeout)
+      TIMEOUT="$2"
+      shift 2
+      ;;
+    --position)
+      POSITION="$2"
+      shift 2
+      ;;
+    *)
+      echo "Unknown argument: $1" >&2
+      exit 1
+      ;;
+  esac
+done
+
+# Validate required arguments
+if [[ -z "$HOOK_TYPE" || -z "$MATCHER" || -z "$HOOK_COMMAND" || -z "$HOOK_NAME" ]]; then
+  echo "Usage: $0 --hook-type TYPE --matcher MATCHER --command CMD --name NAME [--timeout SECS] [--position append|prepend]" >&2
+  exit 1
+fi
+
+PROJECT_ROOT="$PWD"
+SETTINGS_FILE="$PROJECT_ROOT/.claude/settings.local.json"
+
+# Ensure .claude directory exists
+mkdir -p "$(dirname "$SETTINGS_FILE")"
+
+# Initialize settings file if it doesn't exist
+if [[ ! -f "$SETTINGS_FILE" ]]; then
+  echo "{}" > "$SETTINGS_FILE"
+fi
+
+# Build the hook configuration JSON
+HOOK_CONFIG=$(jq -n \
+  --arg hookType "$HOOK_TYPE" \
+  --arg matcher "$MATCHER" \
+  --arg command "$HOOK_COMMAND" \
+  --argjson timeout "$TIMEOUT" \
+  '{
+    hooks: {
+      ($hookType): [
+        {
+          matcher: $matcher,
+          hooks: [
+            {
+              type: "command",
+              command: $command,
+              timeout: $timeout
+            }
+          ]
+        }
+      ]
+    }
+  }'
+)
+
+# Generate jq script based on position (append vs prepend)
+if [[ "$POSITION" == "prepend" ]]; then
+  # Prepend: ensure hook is first in the array
+  JQ_SCRIPT=$(cat <<'JQEOF'
+    def hookType: $hookType;
+    def matcher: $matcher;
+    def targetCmd: $hook.hooks[hookType][0].hooks[0].command;
+
+    # Check if hook is already first in the matcher
+    def hookIsFirst:
+      (.hooks[hookType] // [])
+      | map(select(.matcher == matcher) | .hooks // [])
+      | flatten
+      | first
+      | .command == targetCmd;
+
+    # If hook is already first, return unchanged
+    if hookIsFirst then
+      .
+    else
+      # Ensure .hooks exists
+      .hooks //= {} |
+
+      # Ensure .hooks[hookType] exists
+      .hooks[hookType] //= [] |
+
+      # Check if our matcher already exists
+      if (.hooks[hookType] | map(.matcher) | index(matcher)) then
+        # Matcher exists - remove our hook if present, then prepend it
+        .hooks[hookType] |= map(
+          if .matcher == matcher then
+            .hooks = $hook.hooks[hookType][0].hooks + (.hooks | map(select(.command != targetCmd)))
+          else
+            .
+          end
+        )
+      else
+        # Matcher does not exist, add the entire entry
+        .hooks[hookType] += $hook.hooks[hookType]
+      end
+    end
+JQEOF
+  )
+else
+  # Append: add hook to end of array (default)
+  JQ_SCRIPT=$(cat <<'JQEOF'
+    def hookType: $hookType;
+    def matcher: $matcher;
+    def targetCmd: $hook.hooks[hookType][0].hooks[0].command;
+
+    # Check if hook already exists anywhere
+    def hookExists:
+      (.hooks[hookType] // [])
+      | map(select(.matcher == matcher) | .hooks // [])
+      | flatten
+      | map(.command)
+      | any(. == targetCmd);
+
+    # If hook already exists, return unchanged
+    if hookExists then
+      .
+    else
+      # Ensure .hooks exists
+      .hooks //= {} |
+
+      # Ensure .hooks[hookType] exists
+      .hooks[hookType] //= [] |
+
+      # Check if our matcher already exists
+      if (.hooks[hookType] | map(.matcher) | index(matcher)) then
+        # Matcher exists, add our hook to its hooks array
+        .hooks[hookType] |= map(
+          if .matcher == matcher then
+            .hooks += $hook.hooks[hookType][0].hooks
+          else
+            .
+          end
+        )
+      else
+        # Matcher does not exist, add the entire entry
+        .hooks[hookType] += $hook.hooks[hookType]
+      end
+    end
+JQEOF
+  )
+fi
+
+# Run jq with the appropriate script
+jq --argjson hook "$HOOK_CONFIG" \
+   --arg hookType "$HOOK_TYPE" \
+   --arg matcher "$MATCHER" \
+   "$JQ_SCRIPT" "$SETTINGS_FILE" > "$SETTINGS_FILE.tmp"
+
+# Check if any changes were made
+if diff -q "$SETTINGS_FILE" "$SETTINGS_FILE.tmp" >/dev/null 2>&1; then
+  rm "$SETTINGS_FILE.tmp"
+  echo "👌 $HOOK_NAME hook already bound"
+  exit 0
+fi
+
+# Atomic replace
+mv "$SETTINGS_FILE.tmp" "$SETTINGS_FILE"
+
+echo "🔗 $HOOK_NAME hook bound successfully!"

package/dist/logic/roles/mechanic/.skills/init.claude.hooks.sh

@@ -4,11 +4,14 @@
 #
 # .why  = the mechanic role uses multiple hooks:
 #           • SessionStart: boot mechanic on every session
+#           • SessionStart: notify Claude of allowed permissions upfront
+#           • PreToolUse: forbid stderr redirects (2>&1)
 #           • PreToolUse: check existing permissions before new requests
 #
-#         this script dispatches to each hook initializer.
+#         this script manages hook registration via findsert utility.
 #
-# .how  = runs each init.claude.hooks.*.sh script in sequence
+# .how  = 1. runs cleanup to remove stale hooks (deleted scripts)
+#         2. calls findsert for each hook in desired order
 #
 # guarantee:
 #   ✔ idempotent: safe to rerun
@@ -18,8 +21,44 @@
 set -euo pipefail
 
 SKILLS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+FINDSERT="$SKILLS_DIR/init.claude.hooks.findsert.sh"
+CLEANUP="$SKILLS_DIR/init.claude.hooks.cleanup.sh"
 
-# Dispatch to each hook initializer
-"$SKILLS_DIR/init.claude.hooks.sessionstart.sh"
-"$SKILLS_DIR/init.claude.hooks.forbid.stderr.redirect.sh"
-"$SKILLS_DIR/init.claude.hooks.pretooluse.sh"
+# Path to hook scripts (relative to this script)
+HOOKS_DIR="$SKILLS_DIR/claude.hooks"
+
+# First, cleanup any stale hooks (referencing removed scripts)
+"$CLEANUP"
+
+# SessionStart hooks (order matters - boot first, then notify permissions)
+
+"$FINDSERT" \
+  --hook-type SessionStart \
+  --matcher "*" \
+  --command "npx rhachet roles boot --repo ehmpathy --role mechanic" \
+  --name "sessionstart.boot" \
+  --timeout 60
+
+"$FINDSERT" \
+  --hook-type SessionStart \
+  --matcher "*" \
+  --command "$HOOKS_DIR/sessionstart.notify-permissions.sh" \
+  --name "sessionstart.notify-permissions" \
+  --timeout 5
+
+# PreToolUse hooks (order matters - forbid-stderr-redirect first via prepend)
+
+"$FINDSERT" \
+  --hook-type PreToolUse \
+  --matcher "Bash" \
+  --command "$HOOKS_DIR/pretooluse.forbid-stderr-redirect.sh" \
+  --name "pretooluse.forbid-stderr-redirect" \
+  --timeout 5 \
+  --position prepend
+
+"$FINDSERT" \
+  --hook-type PreToolUse \
+  --matcher "Bash" \
+  --command "$HOOKS_DIR/pretooluse.check-permissions.sh" \
+  --name "pretooluse.check-permissions" \
+  --timeout 5

package/dist/logic/roles/mechanic/.skills/init.claude.permissions.jsonc

@@ -135,8 +135,9 @@
       "Bash(mkdir:*)",
       "Bash(pwd)",
 
-      // safe custom tools
-      "Bash(bash src/logic/roles/mechanic/.skills/claude.tools/mvsafe.sh:*)",
+      // git mv/rm are safe - constrained to repo, all changes revertable
+      "Bash(git mv:*)",
+      "Bash(git rm:*)",
 
       // npm read operations
       "Bash(npm view:*)",

package/package.json

@@ -2,7 +2,7 @@
   "name": "rhachet-roles-ehmpathy",
   "author": "ehmpathy",
   "description": "empathetic software construction roles and skills, via rhachet",
-  "version": "1.14.0",
+  "version": "1.15.1",
   "repository": "ehmpathy/rhachet-roles-ehmpathy",
   "homepage": "https://github.com/ehmpathy/rhachet-roles-ehmpathy",
   "keywords": [

package/dist/logic/roles/mechanic/.skills/claude.tools/mvsafe.sh

@@ -1,75 +0,0 @@
-#!/usr/bin/env bash
-######################################################################
-# .what = safe mv wrapper that constrains moves to within the repo
-#
-# .why  = mv can move/overwrite files anywhere on the filesystem.
-#         this wrapper ensures both source and destination resolve
-#         to paths within the current working directory (repo root).
-#
-# .how  = uses realpath to resolve absolute paths, then validates
-#         both are prefixed by $PWD before executing mv.
-#
-# usage:
-#   bash mvsafe.sh <source> <destination>
-#
-# guarantee:
-#   ✔ fails if source is outside repo
-#   ✔ fails if destination is outside repo
-#   ✔ fails if source doesn't exist
-#   ✔ passes all arguments to mv if validation passes
-######################################################################
-
-set -euo pipefail
-
-if [[ $# -lt 2 ]]; then
-  echo "error: mvsafe requires at least 2 arguments" >&2
-  echo "usage: mvsafe.sh <source> <destination>" >&2
-  exit 1
-fi
-
-REPO_ROOT="$PWD"
-
-# get the last argument (destination)
-DEST="${*: -1}"
-
-# get all arguments except the last (sources, could be multiple)
-SOURCES=("${@:1:$#-1}")
-
-# resolve destination path
-# if dest doesn't exist yet, resolve its parent directory
-if [[ -e "$DEST" ]]; then
-  DEST_RESOLVED="$(realpath "$DEST")"
-else
-  DEST_PARENT="$(dirname "$DEST")"
-  if [[ ! -d "$DEST_PARENT" ]]; then
-    echo "error: destination parent directory does not exist: $DEST_PARENT" >&2
-    exit 1
-  fi
-  DEST_RESOLVED="$(realpath "$DEST_PARENT")/$(basename "$DEST")"
-fi
-
-# validate destination is within repo
-if [[ "$DEST_RESOLVED" != "$REPO_ROOT"* ]]; then
-  echo "error: destination is outside repo: $DEST_RESOLVED" >&2
-  echo "       repo root: $REPO_ROOT" >&2
-  exit 1
-fi
-
-# validate each source is within repo
-for SRC in "${SOURCES[@]}"; do
-  if [[ ! -e "$SRC" ]]; then
-    echo "error: source does not exist: $SRC" >&2
-    exit 1
-  fi
-
-  SRC_RESOLVED="$(realpath "$SRC")"
-
-  if [[ "$SRC_RESOLVED" != "$REPO_ROOT"* ]]; then
-    echo "error: source is outside repo: $SRC_RESOLVED" >&2
-    echo "       repo root: $REPO_ROOT" >&2
-    exit 1
-  fi
-done
-
-# all validations passed, execute mv
-exec mv "$@"

package/dist/logic/roles/mechanic/.skills/init.claude.hooks.forbid.stderr.redirect.sh

@@ -1,116 +0,0 @@
-#!/usr/bin/env bash
-######################################################################
-# .what = bind forbid.stderr.redirect hook to Claude settings
-#
-# .why  = when Claude uses 2>&1, error messages are hidden and
-#         debugging becomes harder. this hook blocks such commands.
-#
-# .how  = uses jq to findsert the PreToolUse hook configuration
-#         into .claude/settings.local.json
-#
-# guarantee:
-#   ✔ creates .claude/settings.local.json if missing
-#   ✔ preserves existing settings (permissions, other hooks)
-#   ✔ idempotent: no-op if hook already present
-#   ✔ prepends to hooks array (runs before other Bash hooks)
-#   ✔ fail-fast on errors
-######################################################################
-
-set -euo pipefail
-
-PROJECT_ROOT="$PWD"
-SETTINGS_FILE="$PROJECT_ROOT/.claude/settings.local.json"
-SKILLS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-HOOK_SCRIPT="$SKILLS_DIR/claude.hooks/forbid.stderr.redirect.sh"
-
-# Verify hook script exists
-if [[ ! -f "$HOOK_SCRIPT" ]]; then
-  echo "❌ hook script not found: $HOOK_SCRIPT" >&2
-  exit 1
-fi
-
-# Define the hook configuration to findsert
-HOOK_CONFIG=$(cat <<EOF
-{
-  "hooks": {
-    "PreToolUse": [
-      {
-        "matcher": "Bash",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "$HOOK_SCRIPT",
-            "timeout": 5
-          }
-        ]
-      }
-    ]
-  }
-}
-EOF
-)
-
-# Ensure .claude directory exists
-mkdir -p "$(dirname "$SETTINGS_FILE")"
-
-# Initialize settings file if it doesn't exist
-if [[ ! -f "$SETTINGS_FILE" ]]; then
-  echo "{}" > "$SETTINGS_FILE"
-fi
-
-# Findsert: ensure hook is at the front of the hooks array
-jq --argjson hook "$HOOK_CONFIG" '
-  # Define the target command for comparison
-  def targetCmd: $hook.hooks.PreToolUse[0].hooks[0].command;
-
-  # Check if hook is already first in the Bash matcher
-  def hookIsFirst:
-    (.hooks.PreToolUse // [])
-    | map(select(.matcher == "Bash") | .hooks // [])
-    | flatten
-    | first
-    | .command == targetCmd;
-
-  # If hook is already first, return unchanged
-  if hookIsFirst then
-    .
-  else
-    # Ensure .hooks exists
-    .hooks //= {} |
-
-    # Ensure .hooks.PreToolUse exists
-    .hooks.PreToolUse //= [] |
-
-    # Check if our matcher already exists
-    if (.hooks.PreToolUse | map(.matcher) | index("Bash")) then
-      # Matcher exists - remove our hook if present, then prepend it
-      .hooks.PreToolUse |= map(
-        if .matcher == "Bash" then
-          # Remove existing instance of our hook, then prepend
-          .hooks = $hook.hooks.PreToolUse[0].hooks + (.hooks | map(select(.command != targetCmd)))
-        else
-          .
-        end
-      )
-    else
-      # Matcher does not exist, add the entire entry
-      .hooks.PreToolUse += $hook.hooks.PreToolUse
-    end
-  end
-' "$SETTINGS_FILE" > "$SETTINGS_FILE.tmp"
-
-# Check if any changes were made
-if diff -q "$SETTINGS_FILE" "$SETTINGS_FILE.tmp" >/dev/null 2>&1; then
-  rm "$SETTINGS_FILE.tmp"
-  echo "👌 forbid.stderr.redirect hook already bound"
-  echo "   $SETTINGS_FILE"
-  exit 0
-fi
-
-# Atomic replace
-mv "$SETTINGS_FILE.tmp" "$SETTINGS_FILE"
-
-echo "🔗 forbid.stderr.redirect hook bound successfully!"
-echo "   $SETTINGS_FILE"
-echo ""
-echo "✨ Claude will now be blocked from using 2>&1 in commands"

package/dist/logic/roles/mechanic/.skills/init.claude.hooks.pretooluse.sh

@@ -1,118 +0,0 @@
-#!/usr/bin/env bash
-######################################################################
-# .what = bind mechanic PreToolUse hook to Claude settings
-#
-# .why  = when Claude attempts a Bash command not covered by existing
-#         permissions, this hook provides feedback asking it to
-#         reconsider whether a pre-approved command could work instead.
-#
-#         this reduces unnecessary permission prompts and encourages
-#         consistent command patterns across the project.
-#
-# .how  = uses jq to findsert the PreToolUse hook configuration
-#         into .claude/settings.local.json
-#
-# guarantee:
-#   ✔ creates .claude/settings.local.json if missing
-#   ✔ preserves existing settings (permissions, other hooks)
-#   ✔ idempotent: no-op if hook already present
-#   ✔ fail-fast on errors
-######################################################################
-
-set -euo pipefail
-
-PROJECT_ROOT="$PWD"
-SETTINGS_FILE="$PROJECT_ROOT/.claude/settings.local.json"
-SKILLS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-HOOK_SCRIPT="$SKILLS_DIR/claude.hooks/check.pretooluse.permissions.sh"
-
-# Verify hook script exists
-if [[ ! -f "$HOOK_SCRIPT" ]]; then
-  echo "❌ hook script not found: $HOOK_SCRIPT" >&2
-  exit 1
-fi
-
-# Define the hook configuration to findsert
-HOOK_CONFIG=$(cat <<EOF
-{
-  "hooks": {
-    "PreToolUse": [
-      {
-        "matcher": "Bash",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "$HOOK_SCRIPT",
-            "timeout": 5
-          }
-        ]
-      }
-    ]
-  }
-}
-EOF
-)
-
-# Ensure .claude directory exists
-mkdir -p "$(dirname "$SETTINGS_FILE")"
-
-# Initialize settings file if it doesn't exist
-if [[ ! -f "$SETTINGS_FILE" ]]; then
-  echo "{}" > "$SETTINGS_FILE"
-fi
-
-# Findsert: merge the hook configuration if not already present
-jq --argjson hook "$HOOK_CONFIG" '
-  # Define the target command for comparison
-  def targetCmd: $hook.hooks.PreToolUse[0].hooks[0].command;
-
-  # Check if hook already exists
-  def hookExists:
-    (.hooks.PreToolUse // [])
-    | map(select(.matcher == "Bash") | .hooks // [])
-    | flatten
-    | map(.command)
-    | any(. == targetCmd);
-
-  # If hook already exists, return unchanged
-  if hookExists then
-    .
-  else
-    # Ensure .hooks exists
-    .hooks //= {} |
-
-    # Ensure .hooks.PreToolUse exists
-    .hooks.PreToolUse //= [] |
-
-    # Check if our matcher already exists
-    if (.hooks.PreToolUse | map(.matcher) | index("Bash")) then
-      # Matcher exists, add our hook to its hooks array
-      .hooks.PreToolUse |= map(
-        if .matcher == "Bash" then
-          .hooks += $hook.hooks.PreToolUse[0].hooks
-        else
-          .
-        end
-      )
-    else
-      # Matcher does not exist, add the entire entry
-      .hooks.PreToolUse += $hook.hooks.PreToolUse
-    end
-  end
-' "$SETTINGS_FILE" > "$SETTINGS_FILE.tmp"
-
-# Check if any changes were made
-if diff -q "$SETTINGS_FILE" "$SETTINGS_FILE.tmp" >/dev/null 2>&1; then
-  rm "$SETTINGS_FILE.tmp"
-  echo "👌 mechanic PreToolUse hook already bound"
-  echo "   $SETTINGS_FILE"
-  exit 0
-fi
-
-# Atomic replace
-mv "$SETTINGS_FILE.tmp" "$SETTINGS_FILE"
-
-echo "🔗 mechanic PreToolUse hook bound successfully!"
-echo "   $SETTINGS_FILE"
-echo ""
-echo "✨ Claude will now be reminded to check existing permissions before requesting new ones"

package/dist/logic/roles/mechanic/.skills/init.claude.hooks.sessionstart.sh

@@ -1,113 +0,0 @@
-#!/usr/bin/env bash
-######################################################################
-# .what = bind mechanic SessionStart hook to Claude settings
-#
-# .why  = the mechanic role needs to boot on every Claude session
-#         to ensure project context and briefs are loaded.
-#
-#         this script "findserts" (find-or-insert) the SessionStart
-#         hook into .claude/settings.local.json, ensuring:
-#           • the hook is present after running this skill
-#           • no duplication if already present
-#           • idempotent: safe to rerun
-#
-# .how  = uses jq to merge the SessionStart hook configuration
-#         into the existing hooks structure, creating it if absent.
-#
-# guarantee:
-#   ✔ creates .claude/settings.local.json if missing
-#   ✔ preserves existing settings (permissions, other hooks)
-#   ✔ idempotent: no-op if hook already present
-#   ✔ fail-fast on errors
-######################################################################
-
-set -euo pipefail
-
-PROJECT_ROOT="$PWD"
-SETTINGS_FILE="$PROJECT_ROOT/.claude/settings.local.json"
-
-# Define the hook configuration to findsert
-HOOK_CONFIG=$(cat <<'EOF'
-{
-  "hooks": {
-    "SessionStart": [
-      {
-        "matcher": "*",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "npx rhachet roles boot --repo ehmpathy --role mechanic",
-            "timeout": 60
-          }
-        ]
-      }
-    ]
-  }
-}
-EOF
-)
-
-# Ensure .claude directory exists
-mkdir -p "$(dirname "$SETTINGS_FILE")"
-
-# Initialize settings file if it doesn't exist
-if [[ ! -f "$SETTINGS_FILE" ]]; then
-  echo "{}" > "$SETTINGS_FILE"
-fi
-
-# Findsert: merge the hook configuration if not already present
-# Strategy: deep merge with existing hooks, creating structure if needed
-jq --argjson hook "$HOOK_CONFIG" '
-  # Define the target command for comparison
-  def targetCmd: "npx rhachet roles boot --repo ehmpathy --role mechanic";
-
-  # Check if hook already exists
-  def hookExists:
-    (.hooks.SessionStart // [])
-    | map(select(.matcher == "*") | .hooks // [])
-    | flatten
-    | map(.command)
-    | index(targetCmd) != null;
-
-  # If hook already exists, return unchanged
-  if hookExists then
-    .
-  else
-    # Ensure .hooks exists
-    .hooks //= {} |
-
-    # Ensure .hooks.SessionStart exists
-    .hooks.SessionStart //= [] |
-
-    # Check if our matcher already exists
-    if (.hooks.SessionStart | map(.matcher) | index("*")) then
-      # Matcher exists, add our hook to its hooks array
-      .hooks.SessionStart |= map(
-        if .matcher == "*" then
-          .hooks += $hook.hooks.SessionStart[0].hooks
-        else
-          .
-        end
-      )
-    else
-      # Matcher does not exist, add the entire entry
-      .hooks.SessionStart += $hook.hooks.SessionStart
-    end
-  end
-' "$SETTINGS_FILE" > "$SETTINGS_FILE.tmp"
-
-# Check if any changes were made
-if diff -q "$SETTINGS_FILE" "$SETTINGS_FILE.tmp" >/dev/null 2>&1; then
-  rm "$SETTINGS_FILE.tmp"
-  echo "👌 mechanic SessionStart hook already bound"
-  echo "   $SETTINGS_FILE"
-  exit 0
-fi
-
-# Atomic replace
-mv "$SETTINGS_FILE.tmp" "$SETTINGS_FILE"
-
-echo "🔗 mechanic SessionStart hook bound successfully!"
-echo "   $SETTINGS_FILE"
-echo ""
-echo "✨ next time you start a Claude session, the mechanic will boot automatically"