claude-code-superkit 0.0.0-stage → 1.5.3

package/packages/core/hooks/lib/profile.sh

@@ -0,0 +1,141 @@
+#!/bin/bash
+# profile.sh — shared helper for hook strictness + disable logic
+# Source at the top of every hook:
+#   source "$(dirname "$0")/lib/profile.sh"
+#   should_skip_hook "$(basename "$0" .sh)" && exit 0
+
+should_skip_hook() {
+  local hook_name="$1"
+
+  # Explicit disable list takes precedence over everything
+  local disabled="${CLAUDE_DISABLED_HOOKS:-}"
+  if [ -n "$disabled" ]; then
+    local IFS=','
+    for item in $disabled; do
+      # Trim whitespace
+      item="${item## }"
+      item="${item%% }"
+      [ "$item" = "$hook_name" ] && return 0
+    done
+  fi
+
+  # fast profile: skip everything except critical safety hooks
+  local profile="${CLAUDE_HOOK_PROFILE:-standard}"
+  if [ "$profile" = "fast" ]; then
+    case "$hook_name" in
+      block-dangerous-git|security-patterns|audit-settings-source|doc-check-on-commit)
+        return 1
+        ;;
+      *)
+        return 0
+        ;;
+    esac
+  fi
+
+  return 1
+}
+
+# Keep the function available to sourcing scripts.
+export -f should_skip_hook 2>/dev/null || true
+
+# Canonical per-session key: prefer Claude Code session_id, then hook PID, then PPID.
+# Use for any TMPDIR state file that must accumulate across hook invocations in a session.
+superkit_session_key() {
+  printf '%s' "${SESSION_ID:-${CLAUDE_HOOK_PID:-$PPID}}"
+}
+export -f superkit_session_key 2>/dev/null || true
+
+# superkit_advise <message> — emit a warn-only PreToolUse advisory as JSON
+# `hookSpecificOutput.additionalContext` on stdout so it reaches the model.
+# Claude Code can swallow non-blocking PreToolUse stderr; stdout JSON is the
+# reliable channel for advisory context (ECC-inspired). Callers that also
+# print to stderr (for human-readable transcript logs) should additionally
+# call this so the model actually sees the reminder. Prefer jq (every hook in
+# this kit already assumes jq is on PATH); fall back to a manually-escaped
+# printf only if jq is unavailable, so the hook never emits invalid JSON.
+superkit_advise() {
+  local msg="$1"
+  if command -v jq >/dev/null 2>&1; then
+    jq -cn --arg m "$msg" \
+      '{hookSpecificOutput:{hookEventName:"PreToolUse",additionalContext:$m}}'
+  else
+    # Minimal JSON string escaping: backslash, double-quote, then control chars.
+    local esc="$msg"
+    esc="${esc//\\/\\\\}"
+    esc="${esc//\"/\\\"}"
+    esc="${esc//$'\t'/\\t}"
+    esc="${esc//$'\r'/\\r}"
+    esc="${esc//$'\n'/\\n}"
+    printf '{"hookSpecificOutput":{"hookEventName":"PreToolUse","additionalContext":"%s"}}\n' "$esc"
+  fi
+}
+export -f superkit_advise 2>/dev/null || true
+
+# superkit_should_emit_advisory <message> — per-session dedup/throttle for
+# noisy ADVISORY hooks (Opus 4.8 self-flags, so repeated nudges are noise).
+#   returns 0 → emit (first time, or window elapsed)
+#   returns 1 → suppress (identical advisory already emitted within window)
+# Keyed on superkit_session_key + a hash of the message, with a sliding
+# N-minute window (CLAUDE_NUDGE_WINDOW_MIN, default 10). Setting the window
+# to 0 disables throttling entirely (always emit). On success it records the
+# emit time so the NEXT identical call within the window is suppressed.
+#
+# Scope note: this throttles advisory FREQUENCY only. It must never be used to
+# suppress or filter reviewer findings — that is a separate layer. Use it only
+# in nudge/advisory hooks (edit-streak, gateguard advisory, behavioral nudges).
+superkit_should_emit_advisory() {
+  local msg="$1"
+  local window_min="${CLAUDE_NUDGE_WINDOW_MIN:-10}"
+
+  # Non-numeric window → fall back to default; 0 → throttling disabled.
+  case "$window_min" in (*[!0-9]*|"") window_min=10 ;; esac
+  [ "$window_min" = "0" ] && return 0
+
+  local window_sec=$((window_min * 60))
+  local now
+  now=$(date +%s)
+
+  # Hash the message for a compact, collision-resistant key.
+  local hash
+  if command -v shasum >/dev/null 2>&1; then
+    hash=$(printf '%s' "$msg" | shasum -a 256 | cut -d' ' -f1)
+  elif command -v sha256sum >/dev/null 2>&1; then
+    hash=$(printf '%s' "$msg" | sha256sum | cut -d' ' -f1)
+  else
+    # Last resort: cksum (weaker, but keeps the helper functional).
+    hash=$(printf '%s' "$msg" | cksum | tr -d ' ')
+  fi
+
+  local state_file="${SUPERKIT_NUDGE_STATE:-${TMPDIR:-/tmp}/superkit-nudge-$(superkit_session_key)}"
+
+  # Look up last emit time for this hash; suppress if still inside the window.
+  if [ -f "$state_file" ]; then
+    local last_epoch
+    last_epoch=$(grep -E "^${hash} " "$state_file" 2>/dev/null | tail -1 | cut -d' ' -f2)
+    case "$last_epoch" in (*[!0-9]*|"") last_epoch="" ;; esac
+    if [ -n "$last_epoch" ] && [ "$last_epoch" -le "$now" ] \
+       && [ "$((now - last_epoch))" -lt "$window_sec" ]; then
+      return 1
+    fi
+  fi
+
+  # Record this emit. Drop the prior line for this hash, append the fresh one,
+  # then atomically replace. Also prune entries older than the window so the
+  # file can't grow unbounded over a long session.
+  local tmp="${state_file}.$$.${now}"
+  {
+    if [ -f "$state_file" ]; then
+      while IFS=' ' read -r h e _; do
+        [ -z "$h" ] && continue
+        [ "$h" = "$hash" ] && continue
+        case "$e" in (*[!0-9]*|"") continue ;; esac
+        [ "$((now - e))" -ge "$window_sec" ] && continue
+        printf '%s %s\n' "$h" "$e"
+      done < "$state_file"
+    fi
+    printf '%s %s\n' "$hash" "$now"
+  } > "$tmp" 2>/dev/null && mv -f "$tmp" "$state_file" 2>/dev/null
+  # Fail-open: if the state write failed we still emit (return 0).
+  return 0
+}
+export -f superkit_should_emit_advisory 2>/dev/null || true

package/packages/core/hooks/loop-guard.sh

@@ -0,0 +1,75 @@
+#!/bin/bash
+# loop-guard.sh — detect and block repeated identical tool calls (anti-loop protection)
+# Triggers on: PreToolUse(Bash)
+# Profile: standard, strict
+
+# Unified profile + disable check
+SUPERKIT_PROFILE_LIB="$(dirname "$0")/lib/profile.sh"
+[ -f "$SUPERKIT_PROFILE_LIB" ] || SUPERKIT_PROFILE_LIB="$(dirname "$0")/../lib/profile.sh"
+# shellcheck source=/dev/null
+[ -f "$SUPERKIT_PROFILE_LIB" ] && source "$SUPERKIT_PROFILE_LIB" && should_skip_hook "$(basename "$0" .sh)" && exit 0
+
+PROFILE="${CLAUDE_HOOK_PROFILE:-standard}"
+if [ "$PROFILE" = "fast" ]; then
+  exit 0
+fi
+
+# Read tool input and create a fingerprint.
+# Payload shape: .tool_input.{command,file_path}. See doc-check-on-commit.sh
+# for the historical-bug context — same JSON schema change applied here.
+INPUT=$(cat)
+TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // empty' 2>/dev/null)
+COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command // .tool_input.file_path // .command // .input.command // empty' 2>/dev/null)
+
+if [ -z "$TOOL_NAME" ] || [ -z "$COMMAND" ]; then
+  exit 0
+fi
+
+# Create a hash of the tool call for comparison
+FINGERPRINT=$(echo "${TOOL_NAME}:${COMMAND}" | shasum -a 256 | cut -d' ' -f1)
+
+# Log file for tracking recent calls (per-session)
+SESSION_KEY=$(command -v superkit_session_key >/dev/null 2>&1 && superkit_session_key || printf '%s' "${SESSION_ID:-${CLAUDE_HOOK_PID:-$PPID}}")
+LOG_FILE="${TMPDIR:-/tmp}/claude-loop-guard-${SESSION_KEY}.log"
+
+# Append current fingerprint
+echo "$FINGERPRINT" >> "$LOG_FILE"
+
+# Keep only last 6 entries
+tail -6 "$LOG_FILE" > "$LOG_FILE.tmp" && mv "$LOG_FILE.tmp" "$LOG_FILE"
+
+# Read recent fingerprints
+RECENT=$(tail -4 "$LOG_FILE" 2>/dev/null)
+COUNT=$(echo "$RECENT" | grep -c "^${FINGERPRINT}$" 2>/dev/null)
+
+# Block if 3+ identical consecutive calls
+if [ "$COUNT" -ge 3 ]; then
+  echo "" >&2
+  echo "BLOCKED: Loop detected — same tool call repeated 3+ times" >&2
+  echo "  Tool: $TOOL_NAME" >&2
+  echo "  Command: $(echo "$COMMAND" | head -c 100)" >&2
+  echo "" >&2
+  echo "  Try a different approach or ask the user for guidance." >&2
+  echo "" >&2
+  exit 2
+fi
+
+# Detect A→B→A→B pattern (sliding window)
+if [ "$(wc -l < "$LOG_FILE" 2>/dev/null)" -ge 4 ]; then
+  LINE1=$(sed -n '1p' "$LOG_FILE")
+  LINE2=$(sed -n '2p' "$LOG_FILE")
+  LINE3=$(sed -n '3p' "$LOG_FILE")
+  LINE4=$(sed -n '4p' "$LOG_FILE")
+
+  if [ "$LINE1" = "$LINE3" ] && [ "$LINE2" = "$LINE4" ] && [ "$LINE1" != "$LINE2" ]; then
+    echo "" >&2
+    echo "BLOCKED: Alternating loop detected (A→B→A→B pattern)" >&2
+    echo "  The last 4 tool calls alternate between two operations." >&2
+    echo "" >&2
+    echo "  Try a different approach or ask the user for guidance." >&2
+    echo "" >&2
+    exit 2
+  fi
+fi
+
+exit 0

package/packages/core/hooks/migration-safety.sh

@@ -0,0 +1,56 @@
+#!/bin/bash
+# migration-safety.sh — PostToolUse hook for Edit/Write
+# Validates SQL migration files: checks for matching down.sql, non-empty content,
+# and correct naming convention (000NNN_description.{up,down}.sql).
+# Works with any */migrations/*.sql path.
+# Profile: standard, strict (skip on fast)
+
+# Unified profile + disable check
+SUPERKIT_PROFILE_LIB="$(dirname "$0")/lib/profile.sh"
+[ -f "$SUPERKIT_PROFILE_LIB" ] || SUPERKIT_PROFILE_LIB="$(dirname "$0")/../lib/profile.sh"
+# shellcheck source=/dev/null
+[ -f "$SUPERKIT_PROFILE_LIB" ] && source "$SUPERKIT_PROFILE_LIB" && should_skip_hook "$(basename "$0" .sh)" && exit 0
+
+PROFILE="${CLAUDE_HOOK_PROFILE:-standard}"
+if [ "$PROFILE" = "fast" ]; then
+  exit 0
+fi
+
+INPUT=$(cat)
+FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // empty')
+
+if [ -z "$FILE_PATH" ]; then
+  exit 0
+fi
+
+# Only process SQL files inside any migrations/ directory
+if [[ ! "$FILE_PATH" =~ /migrations/.*\.sql$ ]]; then
+  exit 0
+fi
+
+BASENAME=$(basename "$FILE_PATH")
+
+# Check naming convention: 000NNN_description.{up,down}.sql
+if [[ ! "$BASENAME" =~ ^[0-9]{6}_[a-z0-9_]+\.(up|down)\.sql$ ]]; then
+  echo "WARNING: Migration doesn't follow 000NNN_description.{up,down}.sql convention: $BASENAME" >&2
+fi
+
+# If writing up.sql, check matching down.sql exists
+if [[ "$FILE_PATH" =~ \.up\.sql$ ]]; then
+  DOWN_FILE="${FILE_PATH%.up.sql}.down.sql"
+  if [ ! -f "$DOWN_FILE" ]; then
+    echo "WARNING: No matching DOWN migration: $(basename "$DOWN_FILE")" >&2
+    echo "  Create the rollback migration before committing." >&2
+  fi
+fi
+
+# If writing down.sql, verify it has actual SQL content (not empty/comments-only)
+if [[ "$FILE_PATH" =~ \.down\.sql$ ]] && [ -f "$FILE_PATH" ]; then
+  SQL_LINES=$(grep -cvE '^\s*$|^\s*--' "$FILE_PATH" 2>/dev/null)
+  if [ "${SQL_LINES:-0}" -eq 0 ]; then
+    echo "WARNING: DOWN migration has no SQL statements: $BASENAME" >&2
+    echo "  Add rollback SQL (DROP/ALTER) to ensure reversibility." >&2
+  fi
+fi
+
+exit 0

package/packages/core/hooks/plan-completion-gate.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+# plan-completion-gate.sh — mark a superpowers plan as "awaiting doc update"
+# Triggers on: PostToolUse(Skill)
+# Profile: standard, strict
+#
+# Superpowers plan skills (executing-plans, writing-plans) finish by
+# printing "plan complete" / "✅ done" / "Final report" in the Skill
+# output. If the session touched code without updating
+# `docs/architecture/*`, we drop a marker the next `git commit` must
+# clear — either by staging architecture docs OR by adding
+# `[plan-docs-deferred: <plan-id>: <reason>]` to the commit message.
+#
+# Marker: ${TMPDIR:-/tmp}/claude-plan-docs-pending-<session>
+# Opt-out: CLAUDE_DISABLE_PLAN_GATE=1
+
+# Unified profile + disable check
+SUPERKIT_PROFILE_LIB="$(dirname "$0")/lib/profile.sh"
+[ -f "$SUPERKIT_PROFILE_LIB" ] || SUPERKIT_PROFILE_LIB="$(dirname "$0")/../lib/profile.sh"
+# shellcheck source=/dev/null
+[ -f "$SUPERKIT_PROFILE_LIB" ] && source "$SUPERKIT_PROFILE_LIB" && should_skip_hook "$(basename "$0" .sh)" && exit 0
+
+PROFILE="${CLAUDE_HOOK_PROFILE:-standard}"
+if [ "$PROFILE" = "fast" ] || [ "${CLAUDE_DISABLE_PLAN_GATE:-}" = "1" ]; then
+  exit 0
+fi
+
+INPUT=$(cat 2>/dev/null || echo '{}')
+TOOL=$(echo "$INPUT" | jq -r '.tool_name // empty' 2>/dev/null)
+[ "$TOOL" = "Skill" ] || exit 0
+
+SKILL=$(echo "$INPUT" | jq -r '.tool_input.skill // empty' 2>/dev/null)
+# Match executing-plans / writing-plans with optional namespace prefix
+if ! printf '%s' "$SKILL" | grep -qE '(^|:)(executing|writing)-plans?$'; then
+  exit 0
+fi
+
+# Pull the skill output / last assistant message for completion markers
+OUTPUT=$(echo "$INPUT" | jq -r '.tool_response.output // .tool_response // .last_assistant_message // empty' 2>/dev/null)
+if ! printf '%s' "$OUTPUT" | grep -qiE 'plan complete|✅ done|final report|plan finished|marking.*complete'; then
+  exit 0
+fi
+
+SESSION_ID=$(echo "$INPUT" | jq -r '.session_id // empty' 2>/dev/null)
+SESSION_KEY="${SESSION_ID:-${CLAUDE_HOOK_PID:-$PPID}}"
+MARKER="${TMPDIR:-/tmp}/claude-plan-docs-pending-${SESSION_KEY}"
+
+touch "$MARKER"
+
+# Echo an advisory so Claude sees it inline (hook stdout under PostToolUse
+# is surfaced; the commit gate further down handles enforcement).
+cat <<EOF
+
+Plan completion detected (skill: $SKILL).
+A doc-sync marker was placed at:
+  $MARKER
+
+Next commit touching code files must either stage docs/architecture/*
+OR include [plan-docs-deferred: <plan-id>: <reason ≥15 chars>] in the
+commit message.
+EOF
+exit 0

package/packages/core/hooks/pre-compact-save.sh

@@ -0,0 +1,89 @@
+#!/bin/bash
+# pre-compact-save.sh — PreCompact hook
+# Saves current context summary before compaction
+# Captures: git state, modified files, task state, architectural decisions, review findings
+# Profile: always on
+
+# Unified profile + disable check
+SUPERKIT_PROFILE_LIB="$(dirname "$0")/lib/profile.sh"
+[ -f "$SUPERKIT_PROFILE_LIB" ] || SUPERKIT_PROFILE_LIB="$(dirname "$0")/../lib/profile.sh"
+# shellcheck source=/dev/null
+[ -f "$SUPERKIT_PROFILE_LIB" ] && source "$SUPERKIT_PROFILE_LIB" && should_skip_hook "$(basename "$0" .sh)" && exit 0
+
+CONTEXT_DIR="$HOME/.config/claude-superkit"
+mkdir -p "$CONTEXT_DIR"
+
+CONTEXT_FILE="$CONTEXT_DIR/last-context.md"
+
+# Collect recent architectural decisions from git log
+RECENT_DECISIONS=""
+if git log --oneline -20 --format="%s" 2>/dev/null | grep -iE "(feat|refactor|arch|design|migrate)" | head -5 | grep -q .; then
+  RECENT_DECISIONS=$(git log --oneline -20 --format="- %s" 2>/dev/null | grep -iE "(feat|refactor|arch|design|migrate)" | head -5)
+fi
+
+# Collect active plan if exists
+ACTIVE_PLAN=""
+if [ -f ".claude/.active-plan.md" ]; then
+  ACTIVE_PLAN=$(head -50 ".claude/.active-plan.md" 2>/dev/null)
+fi
+
+# Collect review findings from last session
+REVIEW_FINDINGS=""
+if [ -f ".claude/.last-review.md" ]; then
+  REVIEW_FINDINGS=$(cat ".claude/.last-review.md" 2>/dev/null)
+fi
+
+# Collect discovered issues
+DISCOVERED_ISSUES=""
+if [ -f ".claude/.discovered-issues.md" ]; then
+  DISCOVERED_ISSUES=$(cat ".claude/.discovered-issues.md" 2>/dev/null)
+fi
+
+# Detect project stacks
+STACKS=""
+[ -f "go.mod" ] && STACKS="${STACKS}Go "
+[ -f "Cargo.toml" ] && STACKS="${STACKS}Rust "
+[ -f "pyproject.toml" ] && STACKS="${STACKS}Python "
+[ -f "package.json" ] && [ -f "tsconfig.json" ] && STACKS="${STACKS}TypeScript "
+
+cat > "$CONTEXT_FILE" << CTXEOF
+# Claude Code — Last Context (auto-saved before compaction)
+**Saved at:** $(date -u +"%Y-%m-%d %H:%M:%S UTC")
+**Working directory:** $(pwd)
+**Stacks:** ${STACKS:-unknown}
+**Profile:** ${CLAUDE_HOOK_PROFILE:-standard}
+
+## Git State
+**Branch:** $(git branch --show-current 2>/dev/null || echo "not a git repo")
+**Recent commits:**
+$(git log --oneline -5 2>/dev/null || echo "no commits")
+
+## Modified Files (unstaged)
+$(git diff --name-only 2>/dev/null || echo "none")
+
+## Staged Files
+$(git diff --cached --name-only 2>/dev/null || echo "none")
+
+## Task State
+$(if [ -f ".claude/.task-state.json" ]; then cat .claude/.task-state.json; else echo "no active task"; fi)
+
+## Recent Architectural Decisions
+$(if [ -n "$RECENT_DECISIONS" ]; then echo "$RECENT_DECISIONS"; else echo "none detected"; fi)
+
+## Active Plan
+$(if [ -n "$ACTIVE_PLAN" ]; then echo "$ACTIVE_PLAN"; else echo "no active plan"; fi)
+
+## Review Findings (last session)
+$(if [ -n "$REVIEW_FINDINGS" ]; then echo "$REVIEW_FINDINGS"; else echo "none"; fi)
+
+## Discovered Issues
+$(if [ -n "$DISCOVERED_ISSUES" ]; then echo "$DISCOVERED_ISSUES"; else echo "none"; fi)
+CTXEOF
+
+# Validate saved context is not empty
+if [ ! -s "$CONTEXT_FILE" ]; then
+  echo "WARNING: Context file is empty after save" >&2
+fi
+
+echo "Context saved to $CONTEXT_FILE" >&2
+exit 0

package/packages/core/hooks/security-patterns.sh

@@ -0,0 +1,119 @@
+#!/bin/bash
+# security-patterns.sh — PostToolUse hook (Edit/Write)
+# Detects dangerous code patterns in real-time during editing
+# Profile: standard, strict
+#
+# Based on Anthropic official security-guidance plugin patterns.
+# Warns (does not block) — security-scanner agent does deep analysis.
+#
+# EXIT CODES:
+#   0 = allow (always — this hook only warns)
+
+# Unified profile + disable check
+SUPERKIT_PROFILE_LIB="$(dirname "$0")/lib/profile.sh"
+[ -f "$SUPERKIT_PROFILE_LIB" ] || SUPERKIT_PROFILE_LIB="$(dirname "$0")/../lib/profile.sh"
+# shellcheck source=/dev/null
+[ -f "$SUPERKIT_PROFILE_LIB" ] && source "$SUPERKIT_PROFILE_LIB" && should_skip_hook "$(basename "$0" .sh)" && exit 0
+
+PROFILE="${CLAUDE_HOOK_PROFILE:-standard}"
+if [ "$PROFILE" = "fast" ]; then
+  exit 0
+fi
+
+# Read tool input — PostToolUse payload: .tool_input.file_path.
+# See doc-check-on-commit.sh for the historical-bug context — same JSON shape.
+INPUT=$(cat)
+FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // .tool_input.filePath // .file_path // .filePath // empty' 2>/dev/null)
+
+# Only check code files
+case "$FILE_PATH" in
+  *.go|*.ts|*.tsx|*.js|*.jsx|*.py|*.rs|*.rb|*.java|*.kt) ;;
+  *) exit 0 ;;
+esac
+
+# Skip if file doesn't exist
+if [ ! -f "$FILE_PATH" ]; then
+  exit 0
+fi
+
+WARNINGS=""
+
+# JavaScript/TypeScript patterns
+case "$FILE_PATH" in *.ts|*.tsx|*.js|*.jsx)
+  if grep -qn 'eval(' "$FILE_PATH" 2>/dev/null; then
+    WARNINGS="${WARNINGS}\n  [SECURITY] $FILE_PATH: eval() detected — potential code injection"
+  fi
+  if grep -qn 'new Function(' "$FILE_PATH" 2>/dev/null; then
+    WARNINGS="${WARNINGS}\n  [SECURITY] $FILE_PATH: new Function() — dynamic code execution"
+  fi
+  if grep -qn 'dangerouslySetInnerHTML' "$FILE_PATH" 2>/dev/null; then
+    WARNINGS="${WARNINGS}\n  [SECURITY] $FILE_PATH: dangerouslySetInnerHTML — XSS risk, use DOMPurify"
+  fi
+  if grep -qn 'document\.write' "$FILE_PATH" 2>/dev/null; then
+    WARNINGS="${WARNINGS}\n  [SECURITY] $FILE_PATH: document.write — DOM XSS vector"
+  fi
+  if grep -qn '\.innerHTML\s*=' "$FILE_PATH" 2>/dev/null; then
+    WARNINGS="${WARNINGS}\n  [SECURITY] $FILE_PATH: innerHTML assignment — XSS vector"
+  fi
+  ;;
+esac
+
+# Python patterns
+case "$FILE_PATH" in *.py)
+  if grep -qn 'pickle\.loads\|pickle\.load(' "$FILE_PATH" 2>/dev/null; then
+    WARNINGS="${WARNINGS}\n  [SECURITY] $FILE_PATH: pickle deserialization — arbitrary code execution"
+  fi
+  if grep -qn 'os\.system(' "$FILE_PATH" 2>/dev/null; then
+    WARNINGS="${WARNINGS}\n  [SECURITY] $FILE_PATH: os.system() — command injection risk, use subprocess"
+  fi
+  if grep -qn '__import__(' "$FILE_PATH" 2>/dev/null; then
+    WARNINGS="${WARNINGS}\n  [SECURITY] $FILE_PATH: __import__() — dynamic import risk"
+  fi
+  if grep -qn '\bexec(' "$FILE_PATH" 2>/dev/null; then
+    WARNINGS="${WARNINGS}\n  [SECURITY] $FILE_PATH: exec() — arbitrary code execution"
+  fi
+  ;;
+esac
+
+# Go patterns
+case "$FILE_PATH" in *.go)
+  if grep -qn 'fmt\.Sprintf.*SELECT\|fmt\.Sprintf.*INSERT\|fmt\.Sprintf.*UPDATE\|fmt\.Sprintf.*DELETE' "$FILE_PATH" 2>/dev/null; then
+    WARNINGS="${WARNINGS}\n  [SECURITY] $FILE_PATH: fmt.Sprintf in SQL — use parameterized queries"
+  fi
+  # Weak hash for passwords
+  if grep -qn 'crypto/md5\|crypto/sha1' "$FILE_PATH" 2>/dev/null; then
+    WARNINGS="${WARNINGS}\n  [SECURITY] $FILE_PATH: weak hash (md5/sha1) — use bcrypt or argon2 for passwords"
+  fi
+  # Command injection
+  if grep -qn 'exec\.Command.*+\|exec\.CommandContext.*+' "$FILE_PATH" 2>/dev/null; then
+    WARNINGS="${WARNINGS}\n  [SECURITY] $FILE_PATH: exec.Command with concatenation — potential command injection"
+  fi
+  # text/template in HTTP context (XSS)
+  if grep -qn '"text/template"' "$FILE_PATH" 2>/dev/null; then
+    if grep -q 'http\.\|Handler\|handler\|router\|chi\.\|gin\.\|echo\.' "$FILE_PATH" 2>/dev/null; then
+      WARNINGS="${WARNINGS}\n  [SECURITY] $FILE_PATH: text/template in HTTP context — use html/template for XSS safety"
+    fi
+  fi
+  # HTTP server without timeouts
+  if grep -qn 'http\.ListenAndServe\b' "$FILE_PATH" 2>/dev/null; then
+    WARNINGS="${WARNINGS}\n  [SECURITY] $FILE_PATH: http.ListenAndServe without explicit timeouts — slowloris risk. Use http.Server{ReadTimeout, WriteTimeout}"
+  fi
+  ;;
+esac
+
+# GitHub Actions injection
+case "$FILE_PATH" in .github/workflows/*.yml|.github/workflows/*.yaml)
+  if grep -qn '\${{.*github\.event' "$FILE_PATH" 2>/dev/null; then
+    WARNINGS="${WARNINGS}\n  [SECURITY] $FILE_PATH: GitHub Actions expression injection risk"
+  fi
+  ;;
+esac
+
+# Output warnings
+if [ -n "$WARNINGS" ]; then
+  echo -e "\nSecurity patterns detected:${WARNINGS}"
+  echo "  Run /security-scan for deep analysis."
+  echo ""
+fi
+
+exit 0

package/packages/core/hooks/session-context-restore.sh

@@ -0,0 +1,76 @@
+#!/bin/bash
+# session-context-restore.sh — SessionStart hook
+# Restores last saved context at session start
+# Includes: git state, task state, architectural decisions, review findings, discovered issues
+# Output to stdout is injected into Claude's context
+
+# Unified profile + disable check
+SUPERKIT_PROFILE_LIB="$(dirname "$0")/lib/profile.sh"
+[ -f "$SUPERKIT_PROFILE_LIB" ] || SUPERKIT_PROFILE_LIB="$(dirname "$0")/../lib/profile.sh"
+# shellcheck source=/dev/null
+[ -f "$SUPERKIT_PROFILE_LIB" ] && source "$SUPERKIT_PROFILE_LIB" && should_skip_hook "$(basename "$0" .sh)" && exit 0
+
+CONTEXT_FILE="$HOME/.config/claude-superkit/last-context.md"
+
+if [ -f "$CONTEXT_FILE" ]; then
+  if [ "$(uname)" = "Darwin" ]; then
+    FILE_AGE=$(( $(date +%s) - $(stat -f %m "$CONTEXT_FILE") ))
+  else
+    FILE_AGE=$(( $(date +%s) - $(stat -c %Y "$CONTEXT_FILE") ))
+  fi
+
+  if [ "$FILE_AGE" -lt 86400 ]; then
+    # Validate context file is readable
+    if [ ! -s "$CONTEXT_FILE" ]; then
+      echo "<previous-session-context>"
+      echo "WARNING: Previous context file is empty or corrupted. Starting fresh."
+      echo "</previous-session-context>"
+    else
+      echo "<previous-session-context>"
+      cat "$CONTEXT_FILE"
+      echo "</previous-session-context>"
+    fi
+
+    # Inject task state if present in project
+    if [ -f ".claude/.task-state.json" ]; then
+      # Validate JSON
+      if node -e "JSON.parse(require('fs').readFileSync('.claude/.task-state.json','utf8'))" 2>/dev/null; then
+        echo ""
+        echo "<task-state>"
+        cat .claude/.task-state.json
+        echo "</task-state>"
+      else
+        echo ""
+        echo "<task-state>"
+        echo "WARNING: .task-state.json is invalid JSON. Ignoring."
+        echo "</task-state>"
+      fi
+    fi
+
+    # Inject active plan if present
+    if [ -f ".claude/.active-plan.md" ]; then
+      echo ""
+      echo "<active-plan>"
+      head -50 ".claude/.active-plan.md" 2>/dev/null
+      echo "</active-plan>"
+    fi
+
+    # Inject discovered issues if present
+    if [ -f ".claude/.discovered-issues.md" ]; then
+      echo ""
+      echo "<discovered-issues>"
+      cat ".claude/.discovered-issues.md" 2>/dev/null
+      echo "</discovered-issues>"
+    fi
+
+    # Inject last review findings if present
+    if [ -f ".claude/.last-review.md" ]; then
+      echo ""
+      echo "<last-review-findings>"
+      cat ".claude/.last-review.md" 2>/dev/null
+      echo "</last-review-findings>"
+    fi
+  fi
+fi
+
+exit 0