forge-orkes 0.77.0 → 0.80.0

package/template/.claude/hooks/forge-size-gate.sh

@@ -0,0 +1,175 @@
+#!/usr/bin/env sh
+# forge-size-gate — mechanical enforcement of FORGE.md's Size Gates table
+# (issue #37). Size gates were prose-only: nothing measured an artifact
+# against its declared KB gate, so FORGE.md itself drifted over its own
+# 35 KB gate and context.md drifted ~4x over its 12 KB gate before anyone
+# noticed. This hook is the mechanical check — it runs at every boot and
+# advises, once, when something is over.
+#
+#   forge-size-gate.sh [--project <path>]
+#   (SessionStart hook)  reads {cwd, hook_event_name, source} from stdin JSON.
+#
+#     --project <path>   operate on the repo containing <path>. Default: the
+#                        SessionStart payload's `cwd`, else the CWD. NEVER
+#                        $CLAUDE_PROJECT_DIR — see forge-state-rollup.sh for
+#                        why (that resolves to the main checkout even inside
+#                        a worktree).
+#
+# What it checks — every artifact FORGE.md's Size Gates table declares a KB
+# gate for (read the table directly at $root/.forge/FORGE.md, not
+# hallucinated): FORGE.md, project.yml, requirements/m*.yml (each file, not
+# summed), constitution.md, context.md, refactor-backlog.yml,
+# streams/active.yml, streams/*.yml (per file, excluding active.yml itself —
+# a different gate), streams/*/brief.md (per file), reservations.yml,
+# prototypes/*.md (per file — archive/ is a subdirectory so a flat glob never
+# reaches it). plan-{NN}.md instances are deliberately NOT checked here —
+# there are too many to enumerate at boot and no single "current" one;
+# planning's own Step 8 already lints plan size at creation time.
+#
+# Plus a tiered skill-file class this hook introduces: every
+# .claude/skills/*/SKILL.md is checked against a KB gate that depends on
+# whether the skill is an entry point. Entry-point skill names are listed one
+# per line in .claude/hooks/skill-gate-tiers.txt (40 KB tier); every other
+# skill defaults to the stricter 20 KB tier. A missing tier-list file
+# degrades to "no skills are entry-point" — every skill checked at 20 KB —
+# never a crash.
+#
+# KB is decimal (1 KB = 1000 B), matching the numbers FORGE.md's own Size
+# Gates table was measured against (research/milestone-54.md: FORGE.md is
+# "35,834 B against the declared 35 KB gate" — over only under the decimal
+# reading).
+#
+# A declared-gate artifact that does not exist in this repo (e.g. no
+# prototypes/ dir yet) is skipped silently — not an error, not a violation.
+#
+# Contract (SessionStart, mirrors forge-state-rollup.sh — ADR-032):
+#   - Exit 0 ALWAYS. SessionStart is non-blocking; this hook must never abort
+#     a session.
+#   - Read-only. No writes, no cache, nothing to render.
+#   - stdout is injected into the model's context. When every checked
+#     artifact is within gate, this hook prints NOTHING — a silent pass costs
+#     zero context. When one or more are over, it prints exactly ONE terse
+#     summary line naming every offender, never a multi-line dump (a
+#     multi-line dump would itself be the token-cost problem this hook
+#     exists to prevent).
+#
+# Portable: POSIX sh + git + wc. No network calls (NFR-030).
+
+set -u
+
+# --- argument / stdin parsing ------------------------------------------------
+
+project=""
+
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --project) shift; project="${1:-}"; [ $# -gt 0 ] && shift || true ;;
+    --project=*) project="${1#*=}"; shift ;;
+    -*) shift ;;                 # unknown flag — ignore, never fail a boot hook
+    *) shift ;;
+  esac
+done
+
+# SessionStart delivers {cwd, source, hook_event_name, ...} on stdin. When no
+# --project was given, prefer the payload's cwd (the actual worktree the
+# session started in) over the process CWD. Read stdin only if it is not a
+# tty and jq is present; never block waiting for input that will not arrive.
+stdin_cwd=""
+if [ -z "$project" ] && [ ! -t 0 ] && command -v jq >/dev/null 2>&1; then
+  payload="$(cat 2>/dev/null || true)"
+  if [ -n "$payload" ]; then
+    stdin_cwd="$(printf '%s' "$payload" | jq -r '.cwd // empty' 2>/dev/null || true)"
+  fi
+fi
+[ -z "$project" ] && project="${stdin_cwd:-$PWD}"
+
+# --- repo resolution ---------------------------------------------------------
+# Silent no-op when not in a git repo or the repo has no .forge/ — the common
+# case for a non-Forge session, and this hook must be invisible there.
+
+root="$(git -C "$project" rev-parse --show-toplevel 2>/dev/null)" || exit 0
+[ -d "$root/.forge" ] || exit 0
+
+TIER_FILE="$root/.claude/hooks/skill-gate-tiers.txt"
+
+# --- violation bookkeeping ----------------------------------------------------
+
+VIOLATIONS=""
+VIOLATION_COUNT=0
+
+record_violation() { # path actual_bytes gate_kb
+  VIOLATIONS="${VIOLATIONS}${VIOLATIONS:+, }$1 (${2}B/${3}KB)"
+  VIOLATION_COUNT=$((VIOLATION_COUNT + 1))
+}
+
+# check_gate <abs_path> <gate_kb> — decimal KB (1 KB = 1000 B). Missing file
+# is skipped silently, not a violation.
+check_gate() {
+  f="$1"; kb="$2"
+  [ -f "$f" ] || return 0
+  bytes="$(wc -c < "$f" 2>/dev/null | tr -d ' ')"
+  [ -z "$bytes" ] && return 0
+  limit=$((kb * 1000))
+  if [ "$bytes" -gt "$limit" ]; then
+    rel="${f#"$root"/}"
+    record_violation "$rel" "$bytes" "$kb"
+  fi
+}
+
+# --- declared single-file artifacts (FORGE.md Size Gates table) -------------
+
+check_gate "$root/.forge/FORGE.md" 35
+check_gate "$root/.forge/project.yml" 5
+check_gate "$root/.forge/constitution.md" 10
+check_gate "$root/.forge/context.md" 12
+check_gate "$root/.forge/refactor-backlog.yml" 150
+check_gate "$root/.forge/streams/active.yml" 20
+check_gate "$root/.forge/reservations.yml" 50
+
+# --- declared per-file glob artifacts (each file checked individually) ------
+
+for f in "$root"/.forge/requirements/m*.yml; do
+  [ -f "$f" ] || continue
+  check_gate "$f" 50
+done
+
+for f in "$root"/.forge/streams/*.yml; do
+  [ -f "$f" ] || continue
+  case "$(basename "$f")" in active.yml) continue ;; esac
+  check_gate "$f" 15
+done
+
+for f in "$root"/.forge/streams/*/brief.md; do
+  [ -f "$f" ] || continue
+  check_gate "$f" 8
+done
+
+for f in "$root"/.forge/prototypes/*.md; do
+  [ -f "$f" ] || continue
+  check_gate "$f" 8
+done
+
+# --- tiered skill-file class --------------------------------------------------
+# Entry-point skills (listed by name in skill-gate-tiers.txt) get 40 KB;
+# every other skill defaults to the stricter 20 KB tier. Missing tier-list
+# file → every skill defaults to 20 KB, never a crash.
+
+for f in "$root"/.claude/skills/*/SKILL.md; do
+  [ -f "$f" ] || continue
+  skill_name="$(basename "$(dirname "$f")")"
+  skill_kb=20
+  if [ -f "$TIER_FILE" ] && grep -qx "$skill_name" "$TIER_FILE" 2>/dev/null; then
+    skill_kb=40
+  fi
+  check_gate "$f" "$skill_kb"
+done
+
+# --- summary (stdout → injected into boot context) ---------------------------
+# Silent when clean. One terse line when not.
+
+if [ "$VIOLATION_COUNT" -gt 0 ]; then
+  printf '[forge-size-gate] %s artifact(s) over their declared gate: %s — see FORGE.md § Size Gates\n' \
+    "$VIOLATION_COUNT" "$VIOLATIONS"
+fi
+
+exit 0

package/template/.claude/hooks/forge-state-rollup.sh

@@ -7,6 +7,11 @@
 # (which a "the index is stale, work around it" project-memory habit can
 # out-compete — the exact ptnrkit failure #22 was filed against).
 #
+# A third join (ADR-033, issue #37) renders .forge/context.md itself as a
+# derived index over .forge/context/*.md — the per-milestone decision files
+# forge-context-migrate.sh produces. Same contract as the other two: derived,
+# git-ignored, rendered fresh every boot, never hand-edited.
+#
 #   forge-state-rollup.sh [--project <path>] [--quiet]
 #   (SessionStart hook)  reads {cwd, hook_event_name, source} from stdin JSON.
 #
@@ -17,9 +22,11 @@
 #                        render this worktree's caches into the wrong tree.
 #     --quiet            suppress the stdout summary line (still writes caches).
 #
-# What it writes (both are git-ignored render-on-read caches since 0.53.0):
+# What it writes (all three are git-ignored render-on-read caches since
+# 0.53.0 / this addendum for context.md):
 #     .forge/state/index.yml       — derived milestone registry
 #     .forge/streams/active.yml    — derived stream registry (if streams/ exists)
+#     .forge/context.md            — derived context index (if context/ exists)
 # It NEVER commits them and NEVER runs git add/commit. Rendering a gitignored
 # cache is a local write that never lands on main, so any checkout (main OR
 # worktree) may render its own copy (FORGE.md → State Ownership, Derived class).
@@ -398,15 +405,136 @@ render_active() {
   STREAM_ROW_COUNT="$sn"
 }
 
+# --- Context Index (ADR-033 addendum) ----------------------------------------
+# Third join: .forge/context/*.md (one file per milestone, produced by
+# forge-context-migrate.sh) ⋈ the index.yml rows this same pass already
+# rendered above — no second fold invocation, reuse what render_index wrote.
+
+# context_index_lookup <norm_id> — prints "name\tstatus\trelease_state" for
+# the index.yml row matching <norm_id> (already normalized, no leading "m-").
+# Empty output when no row matches — degrade gracefully, never error.
+context_index_lookup() {
+  awk -v want="$1" '
+    /^  - id:/ { id=$3; gsub(/["\x27]/,"",id); sub(/^m-/,"",id); inrow=(id==want); name=""; status=""; rel="" }
+    inrow && /^    name:/ { name=$0; sub(/^    name: /,"",name); gsub(/^["\x27]|["\x27]$/,"",name) }
+    inrow && /^    status:/ { status=$2 }
+    inrow && /^    release_state:/ { rel=$2; print name "\t" status "\t" rel; exit }
+  ' "$root/.forge/state/index.yml" 2>/dev/null
+}
+
+# context_summary <file> — a <!-- summary: ... --> marker wins over the
+# first "- " bullet; empty when the file has neither (row still renders,
+# just with an empty summary — never a crash).
+context_summary() {
+  f="$1"
+  s="$(awk '/<!-- summary:/ { line=$0; sub(/^.*<!-- summary: */,"",line); sub(/ *-->.*$/,"",line); print line; exit }' "$f" 2>/dev/null)"
+  if [ -z "$s" ]; then
+    s="$(awk '/^- / { line=$0; sub(/^- /,"",line); print line; exit }' "$f" 2>/dev/null)"
+  fi
+  printf '%s\n' "$s"
+}
+
+CONTEXT_ROW_COUNT=0
+
+render_context_index() {
+  context_path="$root/.forge/context.md"
+  ctx_rows=""     # "id\tname\tstatus\trelease_state\tsummary\tpath"
+  cn=0
+
+  for cfile in "$root"/.forge/context/*.md; do
+    [ -f "$cfile" ] || continue
+    case "$(basename "$cfile")" in _shared.md) continue ;; esac
+    c_id="$(basename "$cfile" .md)"
+    [ -z "$c_id" ] && continue
+    rel_path=".forge/context/$(basename "$cfile")"
+
+    fields="$(context_index_lookup "$(norm_id "$c_id")")"
+    if [ -n "$fields" ]; then
+      c_name="$(printf '%s' "$fields" | awk -F'\t' '{print $1}')"
+      c_status="$(printf '%s' "$fields" | awk -F'\t' '{print $2}')"
+      c_rel="$(printf '%s' "$fields" | awk -F'\t' '{print $3}')"
+    else
+      c_name=""
+      c_status="unknown"
+      c_rel="unknown"
+    fi
+    [ -z "$c_status" ] && c_status="unknown"
+    [ -z "$c_rel" ] && c_rel="unknown"
+    c_summary="$(context_summary "$cfile")"
+
+    # A tab-delimited empty field is unsafe: `read` with IFS set to a plain
+    # tab still treats it as IFS-whitespace, so consecutive/empty fields get
+    # collapsed and every column after them shifts left. name/summary are the
+    # only fields that can legitimately be empty — substitute a sentinel and
+    # translate it back to "" after the read loop below.
+    [ -z "$c_name" ] && c_name="@@EMPTY@@"
+    [ -z "$c_summary" ] && c_summary="@@EMPTY@@"
+
+    ctx_rows="$ctx_rows$c_id	$c_name	$c_status	$c_rel	$c_summary	$rel_path
+"
+    cn=$((cn + 1))
+  done
+
+  sorted="$(printf '%s' "$ctx_rows" | LC_ALL=C sort -t'	' -k1,1)"
+
+  {
+    printf '# Locked Context — Index (DERIVED — do not hand-edit)\n'
+    printf '# Regenerated at boot by .claude/hooks/forge-state-rollup.sh: one row per\n'
+    printf '# .forge/context/{id}.md, joined with state/index.yml (status/release_state\n'
+    printf '# already resolved by this same pass). Git-ignored render-on-read cache —\n'
+    printf '# never committed. Full decision text lives in .forge/context/{id}.md, not\n'
+    printf '# here. See .forge/context-log.md (Amendment Log + Needs Resolution + any\n'
+    printf '# content with no resolvable milestone id) and .forge/context/_shared.md\n'
+    printf '# (cross-cutting Deferred Ideas / Discretion Areas, if present).\n'
+    printf '#\n'
+    printf '# Rules (apply to every context/{id}.md this index points at):\n'
+    printf '# - Locked Decisions -> MUST be implemented exactly as stated.\n'
+    printf '# - Deferred Ideas -> MUST NOT appear in plans, tasks, or code.\n'
+    printf '# - Discretion Areas -> Agent uses judgment; research, pick, document why.\n'
+    printf '#\n'
+    printf '# A milestone that is complete AND validated renders as a thin row\n'
+    printf '# (id, name, path only) — content never moves, only the render shortens.\n'
+    printf 'context:\n'
+    if [ "$cn" -eq 0 ]; then
+      printf '  []\n'
+    else
+      printf '%s\n' "$sorted" | while IFS='	' read -r r_id r_name r_status r_rel r_summary r_path; do
+        [ -z "$r_id" ] && continue
+        [ "$r_name" = "@@EMPTY@@" ] && r_name=""
+        [ "$r_summary" = "@@EMPTY@@" ] && r_summary=""
+        printf '  - id: %s\n' "$r_id"
+        printf '    name: %s\n' "$(yaml_quote "$r_name")"
+        if [ "$r_status" = "complete" ] && [ "$r_rel" = "validated" ]; then
+          printf '    path: %s\n' "$r_path"
+        else
+          printf '    status: %s\n' "$r_status"
+          printf '    release_state: %s\n' "$r_rel"
+          [ -n "$r_summary" ] && printf '    summary: %s\n' "$(yaml_quote "$r_summary")"
+          printf '    path: %s\n' "$r_path"
+        fi
+      done
+    fi
+    printf 'see_also:\n'
+    printf '  - .forge/context-log.md\n'
+    printf '  - .forge/context/_shared.md\n'
+  } > "$context_path.tmp.$$" && mv -f "$context_path.tmp.$$" "$context_path"
+
+  CONTEXT_ROW_COUNT="$cn"
+}
+
 # --- run ---------------------------------------------------------------------
 
-render_index                 # index.yml first — stream rollup reads it
+render_index                 # index.yml first — stream rollup + context index read it
 
 if [ -d "$root/.forge/streams" ]; then
   stream_autoclose_sweep     # step 0 (main checkout only)
   render_active              # then the join
 fi
 
+if [ -d "$root/.forge/context" ]; then
+  render_context_index       # third join
+fi
+
 # --- summary (stdout → injected into boot context) ---------------------------
 
 if [ "$quiet" -eq 0 ]; then
@@ -418,6 +546,11 @@ if [ "$quiet" -eq 0 ]; then
     [ "${STREAM_ROW_COUNT:-0}" = "1" ] || summary="${summary}s"
     summary="$summary)"
   fi
+  if [ -d "$root/.forge/context" ]; then
+    summary="$summary + context.md (${CONTEXT_ROW_COUNT:-0} context row"
+    [ "${CONTEXT_ROW_COUNT:-0}" = "1" ] || summary="${summary}s"
+    summary="$summary)"
+  fi
   [ -n "$SWEEP_CLOSED" ] && summary="$summary; auto-closed:${SWEEP_CLOSED}"
   [ "${fold_unavailable:-0}" -gt 0 ] && summary="$summary; ${fold_unavailable} release_state unknown (fold unavailable)"
   if [ "$in_main_checkout" -eq 1 ]; then

package/template/.claude/hooks/protect-primary-checkout.sh

@@ -0,0 +1,149 @@
+#!/usr/bin/env bash
+# Weld the primary checkout to the default branch — deny branch create/switch there.
+#
+# PreToolUse(Bash) hook. Exit 2 (+ JSON permissionDecision:deny) = block. Exit 0 = allow.
+#
+# WHY: the primary checkout's HEAD is shared mutable state across every concurrent
+# Claude session running in that directory. One session running `git checkout -b`
+# silently redirects every OTHER session's subsequent commits onto its branch — an
+# invisible clobber that surfaces later as wrong-branch commits, contaminated PRs,
+# stranded milestone state, or dropped history (issue #21: 3 confirmed incidents —
+# m85's 12-commit drop, m62's stranded phase commits, a Quick-tier checkout -b that
+# contaminated a concurrent PR). Branch work belongs in worktrees, which each own
+# their own HEAD.
+#
+# Scope: fires ONLY in the primary checkout (git-dir == git-common-dir). Linked
+# worktrees are unaffected (their git-dir differs). Unlike the dormant
+# forge-branch-guard.sh this supersedes, the branch weld is UNCONDITIONAL — it fires
+# even when no sibling worktree exists yet, because the second session's worktree is
+# typically created AFTER the offending `checkout -b`. This hook also folds in the
+# one distinct protection the old guard provided: denying a hard-reset in the primary
+# checkout while sibling worktrees are branched off it (the history-rewrite class).
+#
+# Default branch is resolved dynamically (main/master + init.defaultBranch), never
+# hardcoded — Forge ships to repos on any default branch.
+#
+# Fails OPEN (exit 0 / allow) on any malfunction (no jq, empty command, non-git cwd,
+# git probe error) — a guard must never wedge the agent on its own failure.
+#
+# Escape hatch (deliberate, human use): ALLOW_MAIN_BRANCHING=1
+
+set -uo pipefail
+
+emit_deny() {
+  local reason="${1//\"/\\\"}"
+  printf '{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"deny","permissionDecisionReason":"%s"}}\n' "$reason"
+  exit 2
+}
+
+[ "${ALLOW_MAIN_BRANCHING:-0}" = "1" ] && exit 0
+
+command -v jq >/dev/null 2>&1 || exit 0
+
+INPUT=$(cat)
+COMMAND=$(printf '%s' "$INPUT" | jq -r '.tool_input.command // empty' 2>/dev/null || true)
+[ -z "$COMMAND" ] && exit 0
+
+# Normalize the cheapest whitespace-substitution evasion (`git checkout$IFS-b`) to a
+# real space before matching. A string matcher on an un-expanded shell command can
+# never be complete against expansion — the pre-commit backstop is the sound layer —
+# but closing the trivial $IFS trick keeps the PreToolUse layer honest.
+COMMAND=$(printf '%s' "$COMMAND" | sed -E 's/\$\{?IFS\}?/ /g')
+
+# Git allows global options BEFORE the subcommand: `git -c k=v checkout`,
+# `git --no-pager switch`, `git -C <path> -p checkout`, etc. The guard must tolerate
+# ANY run of them, not just a single `-C <path>` — otherwise `git -c x=y checkout -b`
+# sails past (issue #21 regression). GITPRE matches `git` + zero-or-more global options
+# (a `-x`/`--long`/`--long=val`/`-C <path>`/`-c <kv>` token, each optionally taking the
+# next word as its value) up to the subcommand.
+GITPRE='git[[:space:]]+((-[A-Za-z]|--[A-Za-z-]+)(=[^[:space:]]+)?[[:space:]]+([^-][^[:space:]]*[[:space:]]+)?)*'
+
+# Fast path: only inspect commands that touch checkout/switch/reset at all. Anything
+# else exits immediately WITHOUT any git probe (keeps the hook cheap on every Bash call).
+printf '%s' "$COMMAND" | grep -qE "${GITPRE}(checkout|switch|reset)([[:space:]]|\$)" || exit 0
+
+# Resolve which repo dir the command targets: honor `git -C <path>`, else the hook cwd.
+CWD=$(printf '%s' "$INPUT" | jq -r '.cwd // empty' 2>/dev/null || true)
+[ -z "$CWD" ] && CWD=$(pwd)
+# Honor a GLOBAL `git -C <path>` (before the subcommand) only. Isolate the pre-subcommand
+# segment first so `switch -C`/`checkout -C` (create-force, AFTER the subcommand) is never
+# mistaken for a target-dir option.
+PRE=$(printf '%s' "$COMMAND" | sed -E 's/[[:space:]](checkout|switch|reset)[[:space:]].*$//')
+GC_PATH=$(printf '%s' "$PRE" | grep -oE '(^|[[:space:]])-C[[:space:]]+[^[:space:]]+' | head -1 | awk '{print $2}' || true)
+# A flag-shaped -C value (e.g. `-C --foo`) is not a real target dir → ignore it.
+case "$GC_PATH" in -*) GC_PATH="" ;; esac
+TARGET_DIR="${GC_PATH:-$CWD}"
+
+GIT_DIR=$(git -C "$TARGET_DIR" rev-parse --git-dir 2>/dev/null) || exit 0
+COMMON_DIR=$(git -C "$TARGET_DIR" rev-parse --git-common-dir 2>/dev/null) || exit 0
+GIT_DIR_ABS=$(cd "$TARGET_DIR" 2>/dev/null && cd "$GIT_DIR" 2>/dev/null && pwd) || exit 0
+COMMON_DIR_ABS=$(cd "$TARGET_DIR" 2>/dev/null && cd "$COMMON_DIR" 2>/dev/null && pwd) || exit 0
+
+# In a linked worktree git-dir != git-common-dir → branch ops are fine there.
+[ "$GIT_DIR_ABS" != "$COMMON_DIR_ABS" ] && exit 0
+
+# ── Default-branch set (dynamic — mirrors block-dangerous-commands.sh) ───────────
+# Seed main+master, add the configured init.defaultBranch. A switch/checkout TO any
+# of these names is "returning home" and always allowed.
+DEFAULT_BRANCHES="main master"
+GIT_DEFAULT=$(git -C "$TARGET_DIR" config --get init.defaultBranch 2>/dev/null || true)
+[ -n "$GIT_DEFAULT" ] && DEFAULT_BRANCHES="$DEFAULT_BRANCHES $GIT_DEFAULT"
+is_default_branch() {
+  for b in $DEFAULT_BRANCHES; do [ "$1" = "$b" ] && return 0; done
+  return 1
+}
+
+DENY_MSG="Blocked: the primary checkout's HEAD stays on the default branch — branch create/switch here silently redirects every other concurrent session's commits onto your branch (recurring clobber, issue #21). Do branch work in a worktree: bash .forge/bin/new-worktree.sh <slug> (or git worktree add). To operate on an existing worktree from here, use git -C <worktree-path>. Human escape hatch: ALLOW_MAIN_BRANCHING=1."
+
+# ── 1) Branch creation / orphan / detach / track: always deny in primary checkout ──
+if printf '%s' "$COMMAND" | grep -qE "${GITPRE}checkout[[:space:]]+((-[a-zA-Z]*[bB][a-zA-Z]*|--orphan|--detach|--track)([[:space:]=]|\$))"; then
+  emit_deny "$DENY_MSG"
+fi
+if printf '%s' "$COMMAND" | grep -qE "${GITPRE}switch[[:space:]]+((-[cC]|--create|--force-create|--orphan|--detach|--track)([[:space:]=]|\$))"; then
+  emit_deny "$DENY_MSG"
+fi
+
+# ── 2) hard/keep/merge reset in the primary checkout while worktrees are branched ──
+# Folded from the superseded forge-branch-guard.sh: a reset that rewrites HEAD +
+# working tree here can drop verified work committed under sibling worktrees. Gated
+# on >1 worktree (unlike the branch weld, which is unconditional).
+if printf '%s' "$COMMAND" | grep -qE "${GITPRE}reset[[:space:]]+(--hard|--keep|--merge)([[:space:]]|\$)"; then
+  wt_count=$(git -C "$TARGET_DIR" worktree list 2>/dev/null | wc -l | tr -d ' ')
+  if [ "${wt_count:-1}" -gt 1 ]; then
+    emit_deny "Refusing to move the shared primary HEAD via reset — $wt_count worktrees are branched off it (the 'burned twice' history-rewrite failure, issue #21). Reset inside a worktree, or stop the other sessions first. Human escape hatch: ALLOW_MAIN_BRANCHING=1."
+  fi
+  exit 0   # single-worktree hard-reset is the operator's own business — allow.
+fi
+
+# ── 3) checkout/switch to a ref other than the default branch ───────────────────
+# Only checkout/switch move HEAD to a ref. A reset that reached this far (--soft /
+# --mixed, or a hard/keep/merge reset in a single-worktree repo) is not a branch move
+# off the default → allow it and stop.
+printf '%s' "$COMMAND" | grep -qE "${GITPRE}(checkout|switch)([[:space:]]|\$)" || exit 0
+
+# `git checkout <ref> -- <paths>` and `git checkout -- <paths>` never move HEAD →
+# allow anything containing a ` -- ` pathspec separator.
+printf '%s' "$COMMAND" | grep -qE '[[:space:]]--([[:space:]]|$)' && exit 0
+
+# Extract the first non-flag argument after checkout/switch. Strip everything up to and
+# including the subcommand keyword — whatever git global options preceded it (`-c`,
+# `--no-pager`, `-C <path>`, …) are consumed by the greedy prefix. The trailing separator
+# is optional so a BARE `git checkout` (no target) yields empty ARGS → allowed below.
+ARGS=$(printf '%s' "$COMMAND" | sed -E 's/.*[[:space:]](checkout|switch)([[:space:]]+|$)/ /' | head -1)
+FIRST_REF=""
+for word in $ARGS; do
+  case "$word" in
+    -*) continue ;;                     # flags (creation flags already denied above)
+    \;|\&\&|\|\||\||\&) break ;;        # end of this git command
+    *) FIRST_REF="$word"; break ;;
+  esac
+done
+
+# Bare `git checkout`/`git switch` (no target) is a no-op/error → allow.
+[ -z "$FIRST_REF" ] && exit 0
+
+# Returning home (default branch) or file-restore forms → allow. Any other ref → deny.
+case "$FIRST_REF" in
+  HEAD|.) exit 0 ;;                      # file restore forms
+  *) is_default_branch "$FIRST_REF" && exit 0 || emit_deny "$DENY_MSG" ;;
+esac

package/template/.claude/hooks/skill-gate-tiers.txt

@@ -0,0 +1,6 @@
+# Entry-point skills — checked against the 40KB size gate by
+# forge-size-gate.sh instead of the 20KB default every other skill gets.
+# One skill name per line (matches the skill's directory name under
+# .claude/skills/). Lines starting with # are comments.
+forge
+chief-of-staff