@reddb-io/red-skills 4.4.1 → 4.6.0

package/runtime/plugins/dev/skills/misc/branch-lock/scripts/lib/scope-resolver.sh

@@ -0,0 +1,43 @@
+#!/usr/bin/env bash
+# lib/scope-resolver.sh — the Scope Resolver: decides whether the branch lock is
+# enforced for a given git checkout, by toplevel location alone. Pure /
+# explicit-args, like lib/lock-store.sh.
+#
+# The lock is defined as "the primary checkout's branch". /afk does its work in
+# isolated worktrees under registered .red/tmp worktree lanes, which must never
+# be strangled by an interactive session's lock. The robust discriminator is
+# *where the checkout lives*, not its branch name or an env flag (a branch can be
+# named anything; an env flag relies on every caller setting it). So: a toplevel
+# under .red/tmp/worktrees/<lane>/<slug> or the legacy .red/tmp/work-*/ shape is
+# a worktree (exempt); anything else is the primary checkout (enforced).
+#
+# Public surface:
+#   scope_is_worktree <toplevel>
+#     Returns 0 when <toplevel> is (or is nested under) a registered .red/tmp
+#     worktree lane or legacy .red/tmp/work-* directory. Returns 1 otherwise.
+#     No output.
+#
+#   scope_should_enforce <toplevel>
+#     The verdict the hook wants: returns 0 (enforce the lock) for the primary
+#     checkout, 1 (exempt) for a worktree. The exact inverse of
+#     scope_is_worktree. No output.
+
+# scope_is_worktree <toplevel>
+scope_is_worktree() {
+  local _top="$1"
+  case "$_top" in
+    */.red/tmp/worktrees/*/*) return 0 ;;   # registered worktree lane root
+    */.red/tmp/worktrees/*/*/*) return 0 ;; # nested below registered worktree lane root
+    */.red/tmp/work-*) return 0 ;;   # the worktree root itself
+    */.red/tmp/work-*/*) return 0 ;; # nested below a worktree root
+    *) return 1 ;;
+  esac
+}
+
+# scope_should_enforce <toplevel>
+scope_should_enforce() {
+  if scope_is_worktree "$1"; then
+    return 1
+  fi
+  return 0
+}

package/runtime/plugins/dev/skills/misc/branch-lock/scripts/tests/branch-lock-cli.test.sh

@@ -0,0 +1,114 @@
+#!/usr/bin/env bash
+# Unit test for branch-lock.sh — the /branch-lock CLI (issue #63).
+#
+# Covers the atomic relock-then-switch contract of `set`:
+#   AC1: `set <new>` from a different branch updates the lock AND lands the
+#        working tree on <new> in one step.
+#   AC2: the CLI still lands the branch even though the untouchable-primary rule
+#        (ADR 0083) blocks every raw agent `git switch` — proven by showing
+#        (a) the PreToolUse hook BLOCKS a raw `git switch <new>`, yet (b)
+#        `set <new>` succeeds anyway, because the CLI performs the switch itself
+#        (a subprocess, not an agent Bash-tool call the hook can intercept).
+#   AC3: locking to the branch already checked out just rewrites the target
+#        (no switch needed, exit 0).
+#
+# End-to-end against throwaway git repos: branch-lock.sh runs main() on every
+# invocation, so it cannot be sourced for pure helpers — drive it as a subprocess.
+
+set -uo pipefail
+
+HERE="$(cd "$(dirname "$0")" && pwd)"
+SCRIPTS="$(dirname "$HERE")"
+CLI="$SCRIPTS/branch-lock.sh"
+HOOK="$SCRIPTS/branch-lock-hook.sh"
+
+pass=0
+fail=0
+
+expect_eq() {
+  local label="$1" expected="$2" actual="$3"
+  if [[ "$expected" == "$actual" ]]; then
+    echo "PASS  $label"; pass=$((pass + 1))
+  else
+    printf 'FAIL  %s\n      expected: %q\n      actual:   %q\n' "$label" "$expected" "$actual"
+    fail=$((fail + 1))
+  fi
+}
+
+expect_contains() {
+  local label="$1" needle="$2" haystack="$3"
+  if [[ "$haystack" == *"$needle"* ]]; then
+    echo "PASS  $label"; pass=$((pass + 1))
+  else
+    printf 'FAIL  %s\n      missing: %q\n      in:      %q\n' "$label" "$needle" "$haystack"
+    fail=$((fail + 1))
+  fi
+}
+
+# A throwaway repo with two branches, left checked out on `main`. The dev plugin
+# is opted in (ADR 0067 gate) so the PreToolUse hook is armed for run_hook.
+mk_repo() {
+  local dir="$1"
+  git init -q -b main "$dir"
+  git -C "$dir" config user.email t@t.t
+  git -C "$dir" config user.name t
+  git -C "$dir" commit -q --allow-empty -m init
+  git -C "$dir" branch feature
+  mkdir -p "$dir/.red"
+  printf 'plugins:\n  dev:\n    enabled: true\n' > "$dir/.red/config.yaml"
+}
+
+current_branch() { git -C "$1" rev-parse --abbrev-ref HEAD; }
+locked_branch()  { cat "$1/.red/tmp/branch-lock.yaml" 2>/dev/null | tr -d '\n'; }
+
+# Run the CLI from inside the repo (git operates on cwd) with the root pinned.
+run_cli() { local root="$1"; shift; ( cd "$root" && CLAUDE_PROJECT_DIR="$root" bash "$CLI" "$@" ); }
+# Run the PreToolUse hook against a Bash command; echoes the exit code.
+run_hook() {
+  local root="$1" cmd="$2"
+  ( cd "$root" && CLAUDE_PROJECT_DIR="$root" bash "$HOOK" \
+    <<<"{\"tool_input\":{\"command\":\"$cmd\"}}" ) >/dev/null 2>&1
+  echo $?
+}
+
+# ===========================================================================
+# AC1 — set <new> from a different branch: lock moves AND tree lands on <new>.
+# ===========================================================================
+R1="$(mktemp -d)/red-skills"; mk_repo "$R1"
+OUT1="$(run_cli "$R1" set feature)"; RC1=$?
+expect_eq "AC1 set <new>: exit 0" "0" "$RC1"
+expect_eq "AC1 set <new>: lock target rewritten" "feature" "$(locked_branch "$R1")"
+expect_eq "AC1 set <new>: working tree on new branch" "feature" "$(current_branch "$R1")"
+expect_contains "AC1 set <new>: reports the lock" "locked to 'feature'" "$OUT1"
+
+# ===========================================================================
+# AC2 — the intended switch is never blocked by the hook.
+#   Lock to main first; a raw `git switch feature` is then hook-blocked, but the
+#   CLI's `set feature` still succeeds (it relocks first, then switches).
+# ===========================================================================
+R2="$(mktemp -d)/red-skills"; mk_repo "$R2"
+run_cli "$R2" set main >/dev/null
+expect_eq "AC2 raw switch to <new> is hook-blocked while locked to old" \
+  "2" "$(run_hook "$R2" "git switch feature")"
+OUT2="$(run_cli "$R2" set feature)"; RC2=$?
+expect_eq "AC2 CLI set <new>: exit 0 despite the old lock" "0" "$RC2"
+expect_eq "AC2 CLI set <new>: lock now on new branch" "feature" "$(locked_branch "$R2")"
+expect_eq "AC2 CLI set <new>: tree landed on new branch" "feature" "$(current_branch "$R2")"
+# Untouchable primary (ADR 0083): a raw agent switch to the new target is still
+# refused — the primary is never movable by the agent, even back to the lock
+# target. The CLI succeeds because it switches itself, outside the hook's reach.
+expect_eq "AC2 post-relock: hook still blocks raw switch to the new target" \
+  "2" "$(run_hook "$R2" "git switch feature")"
+
+# ===========================================================================
+# AC3 — locking to the branch already checked out just rewrites the target.
+# ===========================================================================
+R3="$(mktemp -d)/red-skills"; mk_repo "$R3"   # on main, unlocked
+OUT3="$(run_cli "$R3" set main)"; RC3=$?
+expect_eq "AC3 set <current>: exit 0" "0" "$RC3"
+expect_eq "AC3 set <current>: lock target written" "main" "$(locked_branch "$R3")"
+expect_eq "AC3 set <current>: still on the same branch" "main" "$(current_branch "$R3")"
+
+echo
+echo "summary: $pass passed, $fail failed"
+[ "$fail" -eq 0 ]

package/runtime/plugins/dev/skills/misc/branch-lock/scripts/tests/claude-plugin-hook.test.sh

@@ -0,0 +1,117 @@
+#!/usr/bin/env bash
+# Unit test for the Claude plugin PreToolUse(Bash) branch guard wiring.
+
+set -uo pipefail
+
+HERE="$(cd "$(dirname "$0")" && pwd)"
+PLUGIN_ROOT="$(cd "$HERE/../../../../.." && pwd)"
+MANIFEST="$PLUGIN_ROOT/hooks/claude.hooks.json"
+
+pass=0
+fail=0
+
+ok()  { echo "PASS  $1"; pass=$((pass + 1)); }
+bad() { echo "FAIL  $1"; fail=$((fail + 1)); }
+
+expect_eq() {
+  local label="$1" expected="$2" actual="$3"
+  if [[ "$expected" == "$actual" ]]; then
+    ok "$label"
+  else
+    bad "$label"
+    printf '  expected: %q\n  actual:   %q\n' "$expected" "$actual"
+  fi
+}
+
+expect_contains() {
+  local label="$1" needle="$2" haystack="$3"
+  if [[ "$haystack" == *"$needle"* ]]; then
+    ok "$label"
+  else
+    bad "$label"
+    printf '  missing: %q\n  in:      %q\n' "$needle" "$haystack"
+  fi
+}
+
+tmp="$(mktemp -d -t branch-lock-claude.XXXXXX)"
+trap 'rm -rf "$tmp"' EXIT
+
+primary="$tmp/red-skills"
+mkdir -p "$primary/.red"
+# No lock file and no `dev.lock.primary-branch` toggle: the untouchable-primary
+# rule (ADR 0083) must block branch movement anyway.
+cat > "$primary/.red/config.yaml" <<'EOF'
+plugins:
+  dev:
+    enabled: true
+EOF
+
+payload() {
+  local cmd="$1"
+  jq -nc --arg cmd "$cmd" '{hook_event_name:"PreToolUse", tool_input:{command:$cmd}}'
+}
+
+manifest_matcher="$(jq -r '.hooks.PreToolUse[0].matcher' "$MANIFEST")"
+manifest_hook="$(jq -r '.hooks.PreToolUse[0].hooks[0].command' "$MANIFEST")"
+expect_eq "manifest: matcher is Bash" "Bash" "$manifest_matcher"
+expect_contains "manifest: wires branch-lock-hook.sh" "branch-lock-hook.sh" "$manifest_hook"
+expect_contains "manifest: wrapper drains stdin before hook" 'cat >"$tmp"' "$manifest_hook"
+
+out="$tmp/out"
+err="$tmp/err"
+CLAUDE_PLUGIN_ROOT="$PLUGIN_ROOT" CLAUDE_PROJECT_DIR="$primary" bash -lc "$manifest_hook" \
+  >"$out" 2>"$err" <<<"$(payload "git switch feature")"
+rc=$?
+expect_eq "primary guard: switch blocked with no lock and no config" "0" "$rc"
+expect_contains "primary guard: error names ADR 0083" "ADR 0083" "$(<"$err")"
+
+# issue #1024 — git reset (any form) and git stash (all subcommands) blocked,
+# and the refusal explains the reason + the sanctioned worktree alternative.
+CLAUDE_PLUGIN_ROOT="$PLUGIN_ROOT" CLAUDE_PROJECT_DIR="$primary" bash -lc "$manifest_hook" \
+  >"$out" 2>"$err" <<<"$(payload "git reset --hard")"
+rc=$?
+expect_eq "primary guard: reset --hard is blocked when flag is on" "0" "$rc"
+expect_contains "primary guard: reset refusal points to worktree" ".red/tmp/work-" "$(<"$err")"
+
+CLAUDE_PLUGIN_ROOT="$PLUGIN_ROOT" CLAUDE_PROJECT_DIR="$primary" bash -lc "$manifest_hook" \
+  >"$out" 2>"$err" <<<"$(payload "git stash")"
+rc=$?
+expect_eq "primary guard: stash is blocked when flag is on" "0" "$rc"
+
+CLAUDE_PLUGIN_ROOT="$PLUGIN_ROOT" CLAUDE_PROJECT_DIR="$primary" bash -lc "$manifest_hook" \
+  >"$out" 2>"$err" <<<"$(payload "git rebase --autostash main")"
+rc=$?
+expect_eq "primary guard: rebase --autostash is blocked when flag is on" "0" "$rc"
+
+CLAUDE_PLUGIN_ROOT="$PLUGIN_ROOT" CLAUDE_PROJECT_DIR="$primary" bash -lc "$manifest_hook" \
+  >"$out" 2>"$err" <<<"$(payload "git commit -m wip")"
+rc=$?
+expect_eq "primary guard: commit is allowed" "0" "$rc"
+
+# The legacy toggle stays readable but can no longer *enable* switching: with it
+# explicitly false the guard still blocks, because primary movement is
+# unconditional (ADR 0083 §2).
+cat > "$primary/.red/config.yaml" <<'EOF'
+plugins:
+  dev:
+    enabled: true
+    lock:
+      primary-branch: false
+EOF
+CLAUDE_PLUGIN_ROOT="$PLUGIN_ROOT" CLAUDE_PROJECT_DIR="$primary" bash -lc "$manifest_hook" \
+  >"$out" 2>"$err" <<<"$(payload "git switch feature")"
+rc=$?
+expect_eq "primary guard: legacy toggle off still blocks switch" "0" "$rc"
+expect_contains "primary guard: legacy-off error names ADR 0083" "ADR 0083" "$(<"$err")"
+
+missing_root="$tmp/missing-plugin-root"
+mkdir -p "$missing_root"
+CLAUDE_PLUGIN_ROOT="$missing_root" CLAUDE_PROJECT_DIR="$primary" bash -lc "$manifest_hook" \
+  >"$out" 2>"$err" <<<"$(payload "git switch feature")"
+rc=$?
+expect_eq "manifest: missing hook fails open" "0" "$rc"
+expect_eq "manifest: missing hook prints empty JSON" "{}" "$(<"$out")"
+
+echo
+echo "summary: $pass passed, $fail failed"
+[[ "$fail" -eq 0 ]]

package/runtime/plugins/dev/skills/misc/branch-lock/scripts/tests/codex-hook.test.sh

@@ -0,0 +1,230 @@
+#!/usr/bin/env bash
+# Unit test for the Codex plugin PreToolUse branch-lock hook.
+
+set -uo pipefail
+
+HERE="$(cd "$(dirname "$0")" && pwd)"
+PLUGIN_ROOT="$(cd "$HERE/../../../../.." && pwd)"
+HOOK="$PLUGIN_ROOT/hooks/branch-lock-codex.sh"
+MANIFEST="$PLUGIN_ROOT/hooks/codex.hooks.json"
+
+pass=0
+fail=0
+
+ok()  { echo "PASS  $1"; pass=$((pass + 1)); }
+bad() { echo "FAIL  $1"; fail=$((fail + 1)); }
+
+expect_eq() {
+  local label="$1" expected="$2" actual="$3"
+  if [[ "$expected" == "$actual" ]]; then
+    ok "$label"
+  else
+    bad "$label"
+    printf '  expected: %q\n  actual:   %q\n' "$expected" "$actual"
+  fi
+}
+
+expect_contains() {
+  local label="$1" needle="$2" haystack="$3"
+  if [[ "$haystack" == *"$needle"* ]]; then
+    ok "$label"
+  else
+    bad "$label"
+    printf '  missing: %q\n  in:      %q\n' "$needle" "$haystack"
+  fi
+}
+
+tmp="$(mktemp -d -t branch-lock-codex.XXXXXX)"
+trap 'rm -rf "$tmp"' EXIT
+
+primary="$tmp/red-skills"
+mkdir -p "$primary/.red/tmp"
+cat > "$primary/.red/config.yaml" <<'EOF'
+plugins:
+  dev:
+    enabled: true
+EOF
+printf 'main\n' > "$primary/.red/tmp/branch-lock.yaml"
+
+run_hook() {
+  local root="$1" payload="$2" out err rc
+  out="$tmp/out"
+  err="$tmp/err"
+  CODEX_PLUGIN_ROOT="$PLUGIN_ROOT" "$HOOK" >"$out" 2>"$err" <<<"$payload"
+  rc=$?
+  printf '%s\n---stdout---\n%s\n---stderr---\n%s\n' "$rc" "$(<"$out")" "$(<"$err")"
+}
+
+payload() {
+  local root="$1" cmd="$2"
+  jq -nc --arg cwd "$root" --arg cmd "$cmd" \
+    '{hook_event_name:"PreToolUse", cwd:$cwd, tool_input:{cmd:$cmd}}'
+}
+
+manifest_hook="$(jq -r '.hooks.PreToolUse[0].hooks[] | select(.command | contains("branch-lock-codex.sh")) | .command' "$MANIFEST")"
+expect_contains "manifest: wires branch-lock-codex.sh" "branch-lock-codex.sh" "$manifest_hook"
+expect_contains "manifest: wrapper drains stdin before hook" 'cat >"$tmp"' "$manifest_hook"
+expect_contains "manifest: invokes bash-dependent hook explicitly" 'bash "$hook"' "$manifest_hook"
+
+out="$tmp/manifest-out"
+err="$tmp/manifest-err"
+CODEX_PLUGIN_ROOT="$PLUGIN_ROOT" bash -lc "$manifest_hook" >"$out" 2>"$err" \
+  <<<"$(payload "$primary" "git status")"
+rc=$?
+expect_eq "manifest: command executes through shell" "0" "$rc"
+expect_eq "manifest: command prints empty JSON" "{}" "$(<"$out")"
+
+missing_root="$tmp/missing-plugin-root"
+mkdir -p "$missing_root"
+CODEX_PLUGIN_ROOT="$missing_root" bash -lc "$manifest_hook" >"$out" 2>"$err" \
+  <<<"$(payload "$primary" "git switch main")"
+rc=$?
+expect_eq "manifest: missing hook fails open" "0" "$rc"
+expect_eq "manifest: missing hook prints empty JSON" "{}" "$(<"$out")"
+
+early_root="$tmp/early-plugin-root"
+mkdir -p "$early_root/hooks"
+cat > "$early_root/hooks/branch-lock-codex.sh" <<'EOF'
+#!/usr/bin/env sh
+printf '{}'
+exit 0
+EOF
+chmod +x "$early_root/hooks/branch-lock-codex.sh"
+set -o pipefail
+(head -c 1048576 /dev/zero | tr '\0' x) \
+  | CODEX_PLUGIN_ROOT="$early_root" bash -lc "$manifest_hook" >"$out" 2>"$err"
+rc=$?
+set +o pipefail
+expect_eq "manifest: early hook still drains Codex stdin" "0" "$rc"
+expect_eq "manifest: early hook prints empty JSON" "{}" "$(<"$out")"
+
+CODEX_PLUGIN_ROOT="$missing_root" "$HOOK" >"$out" 2>"$err" \
+  <<<"$(payload "$primary" "git switch main")"
+rc=$?
+expect_eq "hook: incomplete plugin root fails open" "0" "$rc"
+expect_eq "hook: incomplete plugin root prints empty JSON" "{}" "$(<"$out")"
+
+# Branch movement in the primary is now blocked unconditionally by the
+# untouchable-primary rule (ADR 0083) — it fires before the branch-lock path, so
+# switching away, and even switching *back* to the locked branch, is refused.
+result="$(run_hook "$primary" "$(payload "$primary" "git switch feature")")"
+rc="$(sed -n '1p' <<<"$result")"
+stderr="$(sed -n '/---stderr---/,$p' <<<"$result")"
+expect_eq "locked: switch away is blocked" "0" "$rc"
+expect_contains "locked: error names ADR 0083" "ADR 0083" "$stderr"
+
+result="$(run_hook "$primary" "$(payload "$primary" "git switch main")")"
+rc="$(sed -n '1p' <<<"$result")"
+stderr="$(sed -n '/---stderr---/,$p' <<<"$result")"
+expect_eq "locked: switch back is also blocked (untouchable primary)" "0" "$rc"
+expect_contains "locked: switch-back error names ADR 0083" "ADR 0083" "$stderr"
+
+# Work-loss commands are caught by the unconditional untouchable-primary guard
+# (#1024 reset/stash family + #1025 unconditional structure) even while a lock
+# is active — the guard runs before the lock read, so the refusal names
+# ADR 0083, not the branch lock.
+result="$(run_hook "$primary" "$(payload "$primary" "git reset --hard HEAD~1")")"
+rc="$(sed -n '1p' <<<"$result")"
+stderr="$(sed -n '/---stderr---/,$p' <<<"$result")"
+expect_eq "locked: work-loss reset --hard is blocked" "0" "$rc"
+expect_contains "locked: work-loss error names untouchable primary" "ADR 0083" "$stderr"
+
+rm -f "$primary/.red/tmp/branch-lock.yaml"
+result="$(run_hook "$primary" "$(payload "$primary" "git switch feature")")"
+rc="$(sed -n '1p' <<<"$result")"
+stderr="$(sed -n '/---stderr---/,$p' <<<"$result")"
+expect_eq "unlocked: switch is still blocked (untouchable primary)" "0" "$rc"
+expect_contains "unlocked: error names ADR 0083" "ADR 0083" "$stderr"
+
+# With no lock file the untouchable-primary guard still blocks every branch
+# move, regardless of the legacy `dev.lock.primary-branch` toggle value.
+mkdir -p "$primary/.red"
+cat > "$primary/.red/config.yaml" <<'EOF'
+plugins:
+  dev:
+    enabled: true
+EOF
+
+result="$(run_hook "$primary" "$(payload "$primary" "git switch feature")")"
+rc="$(sed -n '1p' <<<"$result")"
+stderr="$(sed -n '/---stderr---/,$p' <<<"$result")"
+expect_eq "primary guard: switch blocked with no lock and no config" "0" "$rc"
+expect_contains "primary guard: error names ADR 0083" "ADR 0083" "$stderr"
+
+result="$(run_hook "$primary" "$(payload "$primary" "git checkout feature")")"
+rc="$(sed -n '1p' <<<"$result")"
+expect_eq "primary guard: checkout branch is blocked" "0" "$rc"
+
+# issue #1024 — git reset (any form) and git stash (all subcommands) blocked,
+# and the refusal explains the reason + the sanctioned worktree alternative.
+result="$(run_hook "$primary" "$(payload "$primary" "git reset --hard")")"
+rc="$(sed -n '1p' <<<"$result")"
+stderr="$(sed -n '/---stderr---/,$p' <<<"$result")"
+expect_eq "primary guard: reset --hard is blocked when flag is on" "0" "$rc"
+expect_contains "primary guard: reset refusal points to worktree" ".red/tmp/work-" "$stderr"
+
+result="$(run_hook "$primary" "$(payload "$primary" "git reset --soft HEAD~1")")"
+rc="$(sed -n '1p' <<<"$result")"
+expect_eq "primary guard: reset --soft is blocked when flag is on" "0" "$rc"
+
+result="$(run_hook "$primary" "$(payload "$primary" "git stash")")"
+rc="$(sed -n '1p' <<<"$result")"
+expect_eq "primary guard: stash is blocked when flag is on" "0" "$rc"
+
+result="$(run_hook "$primary" "$(payload "$primary" "git rebase --autostash main")")"
+rc="$(sed -n '1p' <<<"$result")"
+expect_eq "primary guard: rebase --autostash is blocked when flag is on" "0" "$rc"
+
+result="$(run_hook "$primary" "$(payload "$primary" "git switch -b new")")"
+rc="$(sed -n '1p' <<<"$result")"
+expect_eq "primary guard: switch -b is blocked" "0" "$rc"
+
+result="$(run_hook "$primary" "$(payload "$primary" "git commit -m wip")")"
+rc="$(sed -n '1p' <<<"$result")"
+expect_eq "primary guard: commit is allowed" "0" "$rc"
+
+result="$(run_hook "$primary" "$(payload "$primary" "git worktree add ../wt feature")")"
+rc="$(sed -n '1p' <<<"$result")"
+expect_eq "primary guard: worktree add is allowed" "0" "$rc"
+
+result="$(run_hook "$primary" "$(payload "$primary" "git status")")"
+rc="$(sed -n '1p' <<<"$result")"
+expect_eq "primary guard: read-only git is allowed" "0" "$rc"
+
+# The legacy toggle is still readable but can no longer *enable* switching:
+# explicitly false must not re-open primary branch movement (ADR 0083 §2).
+cat > "$primary/.red/config.yaml" <<'EOF'
+plugins:
+  dev:
+    enabled: true
+    lock:
+      primary-branch: false
+EOF
+result="$(run_hook "$primary" "$(payload "$primary" "git switch feature")")"
+rc="$(sed -n '1p' <<<"$result")"
+expect_eq "primary guard: legacy toggle off still blocks switch" "0" "$rc"
+
+worktree="$primary/.red/tmp/work-wAAAA-i1/worktree"
+mkdir -p "$worktree" "$primary/.red/tmp"
+printf 'main\n' > "$primary/.red/tmp/branch-lock.yaml"
+result="$(run_hook "$worktree" "$(payload "$worktree" "git switch feature")")"
+rc="$(sed -n '1p' <<<"$result")"
+expect_eq "worktree: branch lock is exempt" "0" "$rc"
+
+mkdir -p "$worktree/.red"
+cat > "$worktree/.red/config.yaml" <<'EOF'
+dev:
+  lock:
+    primary-branch: true
+EOF
+result="$(run_hook "$worktree" "$(payload "$worktree" "git switch feature")")"
+rc="$(sed -n '1p' <<<"$result")"
+expect_eq "worktree: primary guard is exempt" "0" "$rc"
+
+result="$(run_hook "$primary" "$(jq -nc --arg cwd "$primary" '{hook_event_name:"PreToolUse", cwd:$cwd, tool_input:{file:"x"}}')")"
+rc="$(sed -n '1p' <<<"$result")"
+expect_eq "non-shell payload: no-op allowed" "0" "$rc"
+
+echo
+echo "summary: $pass passed, $fail failed"
+[[ "$fail" -eq 0 ]]

package/runtime/plugins/dev/skills/misc/branch-lock/scripts/tests/dev-config.test.sh

@@ -0,0 +1,99 @@
+#!/usr/bin/env bash
+# Unit test for lib/dev-config.sh — runtime reader for dev.lock.primary-branch.
+
+set -uo pipefail
+
+HERE="$(cd "$(dirname "$0")" && pwd)"
+LIB="$(dirname "$HERE")/lib/dev-config.sh"
+
+# shellcheck source=../lib/dev-config.sh
+source "$LIB"
+
+pass=0
+fail=0
+
+expect_rc() {
+  local label="$1" expected="$2" file="$3"
+  dev_config_lock_primary_branch_enabled "$file"
+  local actual=$?
+  if [[ "$actual" == "$expected" ]]; then
+    echo "PASS  $label"; pass=$((pass + 1))
+  else
+    printf 'FAIL  %s\n      expected rc: %q\n      actual rc:   %q\n' "$label" "$expected" "$actual"
+    fail=$((fail + 1))
+  fi
+}
+
+tmp="$(mktemp -d)"
+trap 'rm -rf "$tmp"' EXIT
+
+missing="$tmp/missing.yaml"
+expect_rc "missing file: disabled" 1 "$missing"
+
+cfg="$tmp/config.yaml"
+
+cat > "$cfg" <<'EOF'
+dev:
+  lock:
+    primary-branch: true
+EOF
+expect_rc "nested dev flag true: enabled" 0 "$cfg"
+
+cat > "$cfg" <<'EOF'
+dev:
+  lock:
+    primary-branch: false
+EOF
+expect_rc "nested dev flag false: disabled" 1 "$cfg"
+
+cat > "$cfg" <<'EOF'
+dev:
+  lock:
+    primary-branch: "true"
+EOF
+expect_rc "quoted true: enabled" 0 "$cfg"
+
+cat > "$cfg" <<'EOF'
+afk:
+  default_runner: codex
+EOF
+expect_rc "absent key: disabled" 1 "$cfg"
+
+cat > "$cfg" <<'EOF'
+dev:
+   lock:
+     primary-branch: true
+EOF
+expect_rc "malformed indentation: disabled" 1 "$cfg"
+
+cat > "$cfg" <<'EOF'
+dev:
+  lock:
+    primary-branch: "true" # branch protection on
+EOF
+expect_rc "inline comment after quoted true: enabled" 0 "$cfg"
+
+cat > "$cfg" <<'EOF'
+dev:
+  lock:
+    primary-branch: true
+afk:
+  backpressure:
+    - npm run test
+    - npm run lint
+EOF
+expect_rc "block-sequence sibling does not disable guard: enabled" 0 "$cfg"
+
+cat > "$cfg" <<'EOF'
+afk:
+  backpressure:
+    - npm run test
+dev:
+  lock:
+    primary-branch: true
+EOF
+expect_rc "block-sequence before dev key: enabled" 0 "$cfg"
+
+echo
+echo "summary: $pass passed, $fail failed"
+[[ "$fail" -eq 0 ]]