rhachet-roles-ehmpathy 1.15.0 → 1.15.2

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

@@ -0,0 +1,135 @@
+#!/usr/bin/env bash
+######################################################################
+# .what = safe find-and-replace across git-tracked files only
+#
+# .why  = enables bulk text replacement without:
+#         - touching files outside the repo
+#         - modifying untracked files
+#         - accidental command chaining attacks
+#
+#         this is a controlled alternative to raw sed, which is
+#         denied in permissions due to security risks.
+#
+# usage:
+#   sedreplace.sh --old "pattern" --new "replacement"              # dry-run
+#   sedreplace.sh --old "pattern" --new "replacement" --execute    # apply
+#   sedreplace.sh --old "pattern" --new "replacement" --glob "*.ts"  # filter
+#
+# guarantee:
+#   - only operates on git-tracked files (git ls-files)
+#   - dry-run by default (shows diff, no changes)
+#   - requires --execute to apply changes
+#   - fail-fast on errors
+######################################################################
+set -euo pipefail
+
+# parse named arguments
+OLD_PATTERN=""
+NEW_PATTERN=""
+GLOB_FILTER=""
+EXECUTE=false
+
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --old)
+      OLD_PATTERN="$2"
+      shift 2
+      ;;
+    --new)
+      NEW_PATTERN="$2"
+      shift 2
+      ;;
+    --glob)
+      GLOB_FILTER="$2"
+      shift 2
+      ;;
+    --execute)
+      EXECUTE=true
+      shift
+      ;;
+    *)
+      echo "unknown argument: $1"
+      echo "usage: sedreplace.sh --old 'pattern' --new 'replacement' [--glob '*.ts'] [--execute]"
+      exit 1
+      ;;
+  esac
+done
+
+# validate required args
+if [[ -z "$OLD_PATTERN" ]]; then
+  echo "error: --old pattern is required"
+  exit 1
+fi
+
+if [[ -z "$NEW_PATTERN" ]]; then
+  echo "error: --new replacement is required"
+  exit 1
+fi
+
+# ensure we're in a git repo
+if ! git rev-parse --git-dir > /dev/null 2>&1; then
+  echo "error: not in a git repository"
+  exit 1
+fi
+
+# get git-tracked files, optionally filtered by glob
+if [[ -n "$GLOB_FILTER" ]]; then
+  FILES=$(git ls-files "$GLOB_FILTER")
+else
+  FILES=$(git ls-files)
+fi
+
+if [[ -z "$FILES" ]]; then
+  echo "no files match the criteria"
+  exit 0
+fi
+
+# find files containing the pattern
+MATCHING_FILES=$(echo "$FILES" | xargs grep -l "$OLD_PATTERN" 2>/dev/null || true)
+
+if [[ -z "$MATCHING_FILES" ]]; then
+  echo "no files contain pattern: $OLD_PATTERN"
+  exit 0
+fi
+
+# count matches
+MATCH_COUNT=$(echo "$MATCHING_FILES" | wc -l)
+echo "found $MATCH_COUNT file(s) containing pattern"
+echo ""
+
+if [[ "$EXECUTE" == "false" ]]; then
+  # dry-run: show what would change
+  echo "=== DRY RUN (use --execute to apply) ==="
+  echo ""
+
+  for file in $MATCHING_FILES; do
+    echo "--- $file ---"
+    # show the diff that would result
+    sed "s|$OLD_PATTERN|$NEW_PATTERN|g" "$file" | diff -u "$file" - || true
+    echo ""
+  done
+
+  echo "=== END DRY RUN ==="
+  echo ""
+  echo "to apply changes, run with --execute flag"
+else
+  # execute: apply changes
+  echo "=== APPLYING CHANGES ==="
+  echo ""
+
+  for file in $MATCHING_FILES; do
+    echo "updating: $file"
+    # use sed -i for in-place editing
+    # note: macOS sed requires -i '' but linux sed uses -i
+    if [[ "$(uname)" == "Darwin" ]]; then
+      sed -i '' "s|$OLD_PATTERN|$NEW_PATTERN|g" "$file"
+    else
+      sed -i "s|$OLD_PATTERN|$NEW_PATTERN|g" "$file"
+    fi
+  done
+
+  echo ""
+  echo "=== DONE: updated $MATCH_COUNT file(s) ==="
+  echo ""
+  echo "to undo: git checkout ."
+fi

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

@@ -5,11 +5,13 @@
 # .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
@@ -19,9 +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.sessionstart.notify-permissions.sh"
-"$SKILLS_DIR/init.claude.hooks.pretooluse.forbid-stderr-redirect.sh"
-"$SKILLS_DIR/init.claude.hooks.pretooluse.check-permissions.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

@@ -139,6 +139,9 @@
       "Bash(git mv:*)",
       "Bash(git rm:*)",
 
+      // sedreplace - safe bulk find-and-replace on git-tracked files only
+      "Bash(bash .agent/repo=ehmpathy/role=mechanic/skills/.skills/claude.tools/sedreplace.sh:*)",
+
       // npm read operations
       "Bash(npm view:*)",
       "Bash(npm list:*)",

package/package.json

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

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

@@ -1,118 +0,0 @@
-#!/usr/bin/env bash
-######################################################################
-# .what = bind pretooluse.check-permissions 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/pretooluse.check-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 "👌 pretooluse.check-permissions hook already bound"
-  echo "   $SETTINGS_FILE"
-  exit 0
-fi
-
-# Atomic replace
-mv "$SETTINGS_FILE.tmp" "$SETTINGS_FILE"
-
-echo "🔗 pretooluse.check-permissions 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.pretooluse.forbid-stderr-redirect.sh

@@ -1,116 +0,0 @@
-#!/usr/bin/env bash
-######################################################################
-# .what = bind pretooluse.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/pretooluse.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 "👌 pretooluse.forbid-stderr-redirect hook already bound"
-  echo "   $SETTINGS_FILE"
-  exit 0
-fi
-
-# Atomic replace
-mv "$SETTINGS_FILE.tmp" "$SETTINGS_FILE"
-
-echo "🔗 pretooluse.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.sessionstart.notify-permissions.sh

@@ -1,121 +0,0 @@
-#!/usr/bin/env bash
-######################################################################
-# .what = bind sessionstart.notify-permissions hook to Claude settings
-#
-# .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 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"
-SKILLS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-HOOK_SCRIPT="$SKILLS_DIR/claude.hooks/sessionstart.notify-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": {
-    "SessionStart": [
-      {
-        "matcher": "*",
-        "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.SessionStart[0].hooks[0].command;
-
-  # Check if hook already exists
-  def hookExists:
-    (.hooks.SessionStart // [])
-    | map(select(.matcher == "*") | .hooks // [])
-    | flatten
-    | map(.command)
-    | any(. == targetCmd);
-
-  # 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 "👌 sessionstart.notify-permissions hook already bound"
-  echo "   $SETTINGS_FILE"
-  exit 0
-fi
-
-# Atomic replace
-mv "$SETTINGS_FILE.tmp" "$SETTINGS_FILE"
-
-echo "🔗 sessionstart.notify-permissions hook bound successfully!"
-echo "   $SETTINGS_FILE"
-echo ""
-echo "✨ Claude will now see allowed permissions at the start of each session"

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"