rhachet-roles-ehmpathy 1.13.6 → 1.13.7

package/dist/logic/roles/mechanic/.briefs/style.names.treestruct.md

@@ -0,0 +1,48 @@
+.tactic = name:treestruct
+
+.what = enforce `[verb][...noun]` for mechanisms and `[...noun][state]?` for resources
+.where:
+  - `verb` = exactly one leading verb (e.g., `gen`, `set`, `get`, `map`)
+  - `...noun` = hierarchy of nouns reflecting the domain treestruct
+  - `state` = optional suffix representing state or outcome (e.g., `Updated`, `Found`, `After`, `Draft`)
+  - this tactic applies to all named functions, types, files, folders, and slugs
+
+.why:
+  - maximizes autocomplete grouping by domain or action
+  - enables tree-sorted navigation in IDEs and file explorers
+  - avoids ambiguity and naming drift across boundaries (design, dev, product)
+
+.how:
+  .rules:
+    - For **mechanisms** (functions, generators, procedures):
+      - use format: `[Verb][...NounHierarchy]`
+      - the verb must come **first**, and be **exactly one** action (e.g., `gen`, `set`, `get`, `map`, `submit`)
+      - e.g., `genStepImagineViaTemplate`, `setCustomerPhone`, `mapJobQuoteToEstimate`
+    - For **resources** (stateful data, outcomes, snapshots):
+      - use format: `[...NounHierarchy][State]?`
+      - the optional `State` suffix:
+        - is used when disambiguating multiple forms (e.g., `InvoiceDraft` vs `InvoiceFinal`)
+        - is typically a past participle or state label (e.g., `Found`, `After`, `Draft`)
+        - may be omitted if the base noun already implies a single clear meaning
+      - e.g., `contentFound`, `customer`, `invoiceDraft`
+
+  .examples:
+    .positive:
+      // mechanisms
+      - `genStepImagineViaTemplate`   // generates a StitchStepImagine from a template
+      - `setCustomerPhone`            // sets the customer's phone number
+      - `mapGitRepoToWorkspace`       // maps a Git repo into a workspace domain
+      - `getInvoiceFinalizedState`    // retrieves the final state of an invoice
+
+      // resources
+      - `contentFound`                // content retrieved from a source
+      - `customer`                    // single canonical term for a user of services
+      - `invoiceDraft`                // invoice in editable state
+      - `invoice`                     // base noun with implicit meaning
+
+    .negative:
+      - `stepImagineGenFromTemplate`  // ⛔ wrong order — verb must come first
+      - `customerSet`                 // ⛔ vague mechanism — better as `setCustomer` or `setCustomerPhone`
+      - `FoundContent`                // ⛔ reversed word order and PascalCase — should be `contentFound`
+      - `submitQuoteJob`              // ⛔ noun hierarchy flipped — should be `submitJobQuote`
+      - `update()`                    // ⛔ unscoped verb — must include noun domain (e.g., `updateInvoice`)

package/dist/logic/roles/mechanic/.briefs/style.names.ubiqlang.md

@@ -0,0 +1,37 @@
+.tactic = name:ubiqlang
+
+.what = enforce a rigorous, domain-driven naming system rooted in ubiquitous language
+.where:
+  - ubiquitous language = the shared, unambiguous vocabulary used by both domain experts and developers
+  - this tactic applies to all names: types, variables, functions, slugs, and folders
+
+.why:
+  - eliminates ambiguity and cognitive friction
+  - ensures that everyone speaks the same language — in code, UI, tests, and docs
+  - prevents synonym drift (e.g., "client" vs "customer") and overload traps (e.g., "update" meaning 3 things)
+
+.how:
+  - eliminate synonyms
+    - choose one canonical word per concept (e.g., always use `customer`, never `client`, `user`, or `account`)
+  - eliminate overloads
+    - each term must refer to one concept only (e.g., avoid using `update` for both "save data" and "fetch latest")
+  - use consistent term stacking across all code (e.g., `customerPhoneUpdate`, not `editPhoneNumber`)
+  - whenever a new term is introduced:
+    - define its interface, expected shape, and role
+    - document its meaning clearly and visibly (ideally in context or hover docs)
+    - ensure its usage is verified across type definitions, business rules, and communication flows
+
+.examples:
+  .positive:
+    - `customer` instead of `client`, `user`, or `buyer`
+    - `jobQuote` as the single term for estimates/proposals
+    - `leadCapture` as the canonical action for inbound lead collection
+    - `customerPhoneUpdate` for updating a phone number
+    - `invoiceDraft` and `invoiceFinal` for two distinct invoice states
+
+  .negative:
+    - `client`, `user`, `account`, `buyer` all referring to the same actor
+    - `editCustomerPhone`, `changePhone`, `updateNumber` used interchangeably
+    - `job` used for both a requested service and a completed one
+    - `update()` overloaded to mean save, patch, sync, or refresh
+    - `quote`, `estimate`, `proposal`, and `bid` all floating without clear hierarchy

package/dist/logic/roles/mechanic/.briefs/style.words.lowercase.md

@@ -0,0 +1,36 @@
+.tactic = words:lowercase
+
+.what = enforce lowercase for all words unless capitalization is required by code or naming convention
+.where:
+  - applies to comments, docstrings, markdown, logs, and prompt copy
+  - only exceptions are code constructs (e.g., class names) and proper nouns (e.g., OpenAI)
+
+.why:
+  - keeps language neutral, minimal, and machine-aligned
+  - prevents inconsistent or performative emphasis via caps
+  - improves scanability and reduces visual noise across surfaces
+
+.how:
+  .rules:
+    - do not capitalize the first word of a sentence
+    - only use capitalization when:
+      - referencing a class, type, or constant (e.g., `StitchStepImagine`, `GitRepo`)
+      - writing a proper noun or brand (e.g., OpenAI, GitHub, AWS)
+    - never capitalize:
+      - generic nouns (`customer`, `invoice`, `step`)
+      - verbs (`set`, `get`, `submit`, `handle`)
+      - system comments or instructions, even at the beginning of a line
+
+  .examples:
+    .positive:
+      - `// returns a new invoice if customer exists`
+      - `// handled in gitrepo.init()`
+      - `// fallback if no customer was found`
+      - `// pass into StitchStepImagine to generate`
+      - `// openai prompt requires flattened string`
+    .negative:
+      - `// Returns a new invoice`       // ⛔ capitalized sentence start
+      - `// This is handled in GitRepo`  // ⛔ capitalized sentence + verb
+      - `// Submit the job for approval` // ⛔ capitalized imperative
+      - `// Customer must exist first`   // ⛔ capitalized domain noun
+      - `// GitHub Repository`           // ⛔ capitalized generic noun

package/dist/logic/roles/mechanic/.briefs/terms/badpractice/script.md

@@ -0,0 +1,9 @@
+pitch: "script" is overloaded
+
+specify what it is
+- command? = shell invoked only
+- procedure? = reusable sequence of steps
+- operation? = domain logic procedure
+- etc
+
+everything is scripted. be specific with what it is

package/dist/logic/roles/mechanic/.briefs/terms/plan.exec_vs_apply.md

@@ -0,0 +1,45 @@
+# Execute vs Apply
+
+## ⚙️ Execute
+**Meaning:**
+To **carry out** or **perform** something, especially a plan, command, or program.
+
+**Connotation:**
+Focuses on the **act of doing** — actually running the instructions.
+
+**Examples:**
+- The computer **executes** the program.
+- She **executed** the plan perfectly.
+- The database will **execute** this SQL query.
+
+**Key idea:** "Do it."
+
+---
+
+## 🖐️ Apply
+**Meaning:**
+To **put something into use** or **bring it into effect** on a target or situation.
+
+**Connotation:**
+Focuses on **using something that already exists** (a tool, rule, concept, method, etc.) to affect something else.
+
+**Examples:**
+- Please **apply** the paint evenly.
+- We can **apply** this algorithm to the data.
+- He **applied** the brakes.
+
+**Key idea:** "Use it (on something)."
+
+---
+
+## 🧠 How They Differ
+
+|            | **Execute**                  | **Apply**                         |
+|------------|------------------------------|----------------------------------|
+| **Focus**  | Performing an action or plan | Using something in a situation   |
+| **Implied object** | A plan, command, task | A method, tool, concept          |
+| **Example** | Execute a script            | Apply a formula                  |
+
+**Memory trick:**
+- **Execute = do**
+- **Apply = use**

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

@@ -0,0 +1,346 @@
+#!/usr/bin/env bash
+######################################################################
+# .what = PreToolUse hook to encourage reuse of existing permissions
+#
+# .why  = when Claude attempts a command not covered by pre-approved
+#         permissions, this hook asks it to reconsider whether an
+#         existing permission could accomplish the same task.
+#
+#         this reduces permission prompts and encourages consistent
+#         command patterns across the project.
+#
+# .how  = reads JSON from stdin (per Claude Code docs), extracts
+#         tool_input.command, checks against allowed patterns.
+#         if no match, behavior depends on mode.
+#
+# usage:
+#   configure in .claude/settings.local.json under hooks.PreToolUse
+#
+# flags:
+#   --mode HARDNUDGE  (default) blocks on first attempt, allows on retry
+#                     tracks attempts in .claude/permissions.attempted.json
+#                     forces Claude to consciously decide to request
+#                     a new permission rather than doing so automatically
+#
+#   --mode SOFTNUDGE  outputs guidance but doesn't block (exit 0)
+#                     Claude sees the message but can proceed immediately
+#
+# guarantee:
+#   ✔ HARDNUDGE (default): blocks first attempt, allows retry
+#   ✔ SOFTNUDGE: non-blocking, feedback only
+#   ✔ fast: simple pattern matching
+#   ✔ helpful: shows available alternatives
+######################################################################
+
+set -euo pipefail
+
+# Parse flags
+MODE="HARDNUDGE"  # default
+HARDNUDGE_WINDOW_SECONDS=60  # default: 60 seconds
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --mode)
+      MODE="${2:-HARDNUDGE}"
+      shift 2
+      ;;
+    --window)
+      HARDNUDGE_WINDOW_SECONDS="${2:-60}"
+      shift 2
+      ;;
+    *)
+      shift
+      ;;
+  esac
+done
+
+# Read JSON from stdin (Claude Code passes input via stdin, not env var)
+STDIN_INPUT=$(cat)
+
+# failfast: if no input received, something is wrong
+if [[ -z "$STDIN_INPUT" ]]; then
+  echo "ERROR: PreToolUse hook received no input via stdin" >&2
+  exit 2  # exit 2 = blocking error per Claude Code docs
+fi
+
+# Extract command from stdin JSON
+# Claude passes: {"tool_name": "Bash", "tool_input": {"command": "..."}}
+COMMAND=$(echo "$STDIN_INPUT" | jq -r '.tool_input.command // empty' 2>/dev/null || echo "")
+
+# Skip if not a Bash command or empty
+if [[ -z "$COMMAND" ]]; then
+  exit 0
+fi
+
+# 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 (search upward from current directory)
+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, allow command to proceed
+  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
+)
+
+# Check if a single command matches any allowed pattern
+match_pattern() {
+  local cmd="$1"
+  local pattern="$2"
+
+  # Handle Claude Code's :* suffix matcher
+  # :* means "match anything after" (any suffix, including spaces)
+  # e.g., "mkdir:*" matches "mkdir", "mkdir /path", "mkdir -p /foo/bar"
+  # e.g., "npm run test:*" matches "npm run test", "npm run test:unit"
+
+  # First, escape regex special chars except * and :
+  local escaped_pattern
+  escaped_pattern=$(printf '%s' "$pattern" | sed 's/[.^$+?{}()[\]|\\]/\\&/g')
+
+  # Convert :* to placeholder first (to avoid * -> .* conversion interfering)
+  escaped_pattern="${escaped_pattern//:\*/__ANY_SUFFIX_PLACEHOLDER__}"
+
+  # Convert remaining * to .* (glob-style wildcard)
+  escaped_pattern="${escaped_pattern//\*/.*}"
+
+  # Now replace placeholder with .* for "any suffix" matching
+  escaped_pattern="${escaped_pattern//__ANY_SUFFIX_PLACEHOLDER__/.*}"
+
+  # Build final regex
+  local regex="^${escaped_pattern}$"
+
+  if [[ "$cmd" =~ $regex ]]; then
+    return 0
+  fi
+  return 1
+}
+
+# Check if a single command matches ANY allowed pattern
+command_is_allowed() {
+  local cmd="$1"
+  # Trim leading/trailing whitespace
+  cmd=$(echo "$cmd" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
+
+  # Empty commands are allowed (e.g., trailing &&)
+  if [[ -z "$cmd" ]]; then
+    return 0
+  fi
+
+  for pattern in "${ALLOWED_PATTERNS[@]}"; do
+    if match_pattern "$cmd" "$pattern"; then
+      return 0
+    fi
+  done
+  return 1
+}
+
+# Split compound command on &&, ||, ; (respecting quotes)
+# Returns newline-separated list of commands
+split_compound_command() {
+  local input="$1"
+  local result=""
+  local current=""
+  local in_single_quote=false
+  local in_double_quote=false
+  local i=0
+  local len=${#input}
+
+  while [[ $i -lt $len ]]; do
+    local char="${input:$i:1}"
+    local next_char="${input:$((i+1)):1}"
+
+    # Handle quotes
+    if [[ "$char" == "'" && "$in_double_quote" == false ]]; then
+      in_single_quote=$([[ "$in_single_quote" == true ]] && echo false || echo true)
+      current+="$char"
+      ((i++))
+      continue
+    fi
+
+    if [[ "$char" == '"' && "$in_single_quote" == false ]]; then
+      in_double_quote=$([[ "$in_double_quote" == true ]] && echo false || echo true)
+      current+="$char"
+      ((i++))
+      continue
+    fi
+
+    # Only split if not inside quotes
+    if [[ "$in_single_quote" == false && "$in_double_quote" == false ]]; then
+      # Check for && or ||
+      if [[ "$char" == "&" && "$next_char" == "&" ]] || [[ "$char" == "|" && "$next_char" == "|" ]]; then
+        if [[ -n "$result" ]]; then
+          result+=$'\n'
+        fi
+        result+="$current"
+        current=""
+        ((i+=2))
+        continue
+      fi
+
+      # Check for ;
+      if [[ "$char" == ";" ]]; then
+        if [[ -n "$result" ]]; then
+          result+=$'\n'
+        fi
+        result+="$current"
+        current=""
+        ((i++))
+        continue
+      fi
+    fi
+
+    current+="$char"
+    ((i++))
+  done
+
+  # Add final command
+  if [[ -n "$result" ]]; then
+    result+=$'\n'
+  fi
+  result+="$current"
+
+  echo "$result"
+}
+
+# Check if ALL parts of a compound command are allowed
+all_parts_allowed() {
+  local cmd="$1"
+  local parts
+  local failed_part=""
+
+  # Split command into parts
+  parts=$(split_compound_command "$cmd")
+
+  # Check each part
+  while IFS= read -r part; do
+    # Trim whitespace
+    part=$(echo "$part" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
+
+    # Skip empty parts
+    [[ -z "$part" ]] && continue
+
+    if ! command_is_allowed "$part"; then
+      # Store the failed part for error reporting
+      echo "$part"
+      return 1
+    fi
+  done <<< "$parts"
+
+  return 0
+}
+
+# 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
+}
+
+# Check if all parts of the command (including compound commands) are allowed
+FAILED_PART=$(all_parts_allowed "$COMMAND") && exit 0
+
+# Command not matched - handle based on mode
+# FAILED_PART contains the first disallowed part of the command
+
+# SOFTNUDGE mode: provide guidance but don't block (early return)
+# Output plain text - no hookSpecificOutput so normal permission flow continues
+if [[ "$MODE" == "SOFTNUDGE" ]]; then
+  echo ""
+  echo "⚠️  This command is not covered by existing pre-approved permissions."
+  echo ""
+  echo "Before requesting user approval, check if you can accomplish this task using one of these pre-approved patterns:"
+  echo ""
+  echo "([e] = exact match, [p] = prefix match)"
+  echo ""
+  for pattern in "${ALLOWED_PATTERNS[@]}"; do
+    echo "  • $(format_pattern "$pattern")"
+  done
+  echo ""
+  echo "([e] = exact match, [p] = prefix match)"
+  echo ""
+  echo "If an existing permission pattern can solve your task, use that instead."
+  echo "If not, proceed with requesting approval."
+  echo ""
+  exit 0
+fi
+
+# HARDNUDGE mode (default): block on first attempt, allow on retry
+CLAUDE_DIR=$(find_claude_dir) || {
+  echo "ERROR: No .claude directory found. This hook requires a .claude directory." >&2
+  exit 1
+}
+ATTEMPTED_FILE="$CLAUDE_DIR/permission.nudges.local.json"
+
+# Ensure the file exists with valid JSON
+if [[ ! -f "$ATTEMPTED_FILE" ]]; then
+  echo '{}' > "$ATTEMPTED_FILE"
+fi
+
+# Check if this command was recently attempted
+now=$(date +%s)
+last_attempt=$(jq -r --arg cmd "$COMMAND" '.[$cmd] // 0' "$ATTEMPTED_FILE" 2>/dev/null || echo "0")
+elapsed=$((now - last_attempt))
+
+if [[ $elapsed -lt $HARDNUDGE_WINDOW_SECONDS ]]; then
+  # Claude already tried within the window - they've thought twice
+  # Exit silently with 0 so normal permission flow continues (user gets prompted)
+  exit 0
+fi
+
+# First attempt - record timestamp and block
+# Use a temp file for atomic update
+tmp_file=$(mktemp)
+jq --arg cmd "$COMMAND" --argjson ts "$now" '. + {($cmd): $ts}' "$ATTEMPTED_FILE" > "$tmp_file" 2>/dev/null && mv "$tmp_file" "$ATTEMPTED_FILE"
+
+# Output block message to stderr and exit 2 to deny
+{
+  echo ""
+  echo "🛑 BLOCKED: This command is not covered by existing pre-approved permissions."
+  echo ""
+  echo "Before requesting user approval, check if you can accomplish this task using one of these pre-approved patterns:"
+  echo ""
+  echo "([e] = exact match, [p] = prefix match)"
+  echo ""
+  for pattern in "${ALLOWED_PATTERNS[@]}"; do
+    echo "  • $(format_pattern "$pattern")"
+  done
+  echo ""
+  echo "([e] = exact match, [p] = prefix match)"
+  echo ""
+  echo "If an existing permission pattern can solve your task, use that instead."
+  echo "If you've considered the alternatives and still need this specific command, retry it."
+  echo ""
+} >&2
+exit 2  # Exit 2 = block with error message

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

@@ -0,0 +1,57 @@
+#!/usr/bin/env bash
+######################################################################
+# .what = PreToolUse hook to forbid 2>&1 (stderr redirection)
+#
+# .why  = redirecting stderr to stdout (2>&1) hides error messages
+#         and makes debugging harder. Claude should see stderr
+#         separately to understand when commands fail.
+#
+# .how  = reads JSON from stdin, extracts tool_input.command,
+#         checks if it contains 2>&1 and blocks if found.
+#
+# usage:
+#   configure in .claude/settings.local.json under hooks.PreToolUse
+#
+# guarantee:
+#   ✔ blocks commands containing 2>&1
+#   ✔ fast: simple string matching
+#   ✔ helpful: explains why it's blocked
+######################################################################
+
+set -euo pipefail
+
+# Read JSON from stdin (Claude Code passes input via stdin)
+STDIN_INPUT=$(cat)
+
+# failfast: if no input received, something is wrong
+if [[ -z "$STDIN_INPUT" ]]; then
+  echo "ERROR: PreToolUse hook received no input via stdin" >&2
+  exit 2
+fi
+
+# Extract command from stdin JSON
+# Claude passes: {"tool_name": "Bash", "tool_input": {"command": "..."}}
+COMMAND=$(echo "$STDIN_INPUT" | jq -r '.tool_input.command // empty' 2>/dev/null || echo "")
+
+# Skip if not a Bash command or empty
+if [[ -z "$COMMAND" ]]; then
+  exit 0
+fi
+
+# Check if command contains 2>&1
+if [[ "$COMMAND" == *"2>&1"* ]]; then
+  {
+    echo ""
+    echo "🛑 BLOCKED: Command contains '2>&1' (stderr redirect to stdout)."
+    echo ""
+    echo "Redirecting stderr to stdout hides error messages and makes debugging harder."
+    echo "Claude should see stderr separately to understand when commands fail."
+    echo ""
+    echo "Please remove '2>&1' from your command and try again."
+    echo ""
+  } >&2
+  exit 2
+fi
+
+# Command is allowed
+exit 0

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

@@ -0,0 +1,75 @@
+#!/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 "$@"