@dtt_siye/atool 1.1.0

package/hooks/doc-sync-reminder

@@ -0,0 +1,155 @@
+#!/usr/bin/env bash
+# aTool - hooks/doc-sync-reminder
+# PostToolUse hook: reminds AI to update docs after source file modifications
+# Only triggers on Write|Edit of source files (not .md/.json/.css/.lock etc.)
+
+set -euo pipefail
+
+# Escape string for JSON embedding
+escape_for_json() {
+    local s="$1"
+    s="${s//\\/\\\\}"
+    s="${s//\"/\\\"}"
+    s="${s//$'\n'/\\n}"
+    s="${s//$'\r'/\\r}"
+    s="${s//$'\t'/\\t}"
+    printf '%s' "$s"
+}
+
+main() {
+    # Read tool input from stdin (Claude Code provides JSON on stdin for PostToolUse)
+    local INPUT=""
+    if [[ ! -t 0 ]]; then
+        INPUT=$(cat)
+    fi
+
+    # ── Fast filter: extract file path from tool input (< 5ms) ───────────────
+
+    local TOOL_NAME=""
+    local FILE_PATH=""
+    if command -v jq &>/dev/null && [[ -n "$INPUT" ]]; then
+        TOOL_NAME=$(printf '%s' "$INPUT" | jq -r '.tool_name // empty' 2>/dev/null || echo "")
+        FILE_PATH=$(printf '%s' "$INPUT" | jq -r '.tool_input.file_path // empty' 2>/dev/null || echo "")
+    elif [[ -n "$INPUT" ]]; then
+        # Fallback: extract tool_name and file_path using grep/sed (jq not available)
+        TOOL_NAME=$(printf '%s' "$INPUT" | grep -oE '"tool_name"[[:space:]]*:[[:space:]]*"[^"]*"' 2>/dev/null | head -1 | sed 's/.*"tool_name"[[:space:]]*:[[:space:]]*"//;s/"$//' || echo "")
+        FILE_PATH=$(printf '%s' "$INPUT" | grep -oE '"file_path"[[:space:]]*:[[:space:]]*"[^"]*"' 2>/dev/null | head -1 | sed 's/.*"file_path"[[:space:]]*:[[:space:]]*"//;s/"$//' || echo "")
+    fi
+
+    # Only respond to Write/Edit
+    if [[ "$TOOL_NAME" != "Write" && "$TOOL_NAME" != "Edit" ]]; then
+        exit 0
+    fi
+
+    # No file path extracted — exit silently
+    if [[ -z "$FILE_PATH" ]]; then
+        exit 0
+    fi
+
+    # ── Source file detection: only trigger on actual source code ─────────────
+
+    local FILE_EXT="${FILE_PATH##*.}"
+    local FILE_BASE
+    FILE_BASE=$(basename "$FILE_PATH")
+
+    # Skip non-source files
+    case "$FILE_EXT" in
+        md|markdown|txt|rst) exit 0 ;;
+        json|yaml|yml|toml|xml) exit 0 ;;
+        css|scss|less|sass|styl) exit 0 ;;
+        lock|map|log) exit 0 ;;
+        svg|png|jpg|jpeg|gif|ico|webp|ttf|woff|woff2|eot) exit 0 ;;
+        gitignore|editorconfig|prettierrc|eslintrc) exit 0 ;;
+    esac
+
+    # Skip config files and dotfiles
+    case "$FILE_BASE" in
+        .*|*.config.*|tsconfig.*|jsconfig.*|vite.config.*|next.config.*|tailwind.config.*|postcss.config.*|webpack.config.*) exit 0 ;;
+    esac
+
+    # Only trigger on known source extensions
+    case "$FILE_EXT" in
+        ts|tsx|js|jsx|vue|svelte) ;;   # Web
+        html) ;;                        # HTML templates
+        rs) ;;                          # Rust
+        py) ;;                          # Python
+        go) ;;                          # Go
+        java|kt|kts) ;;                 # Java/Kotlin
+        swift) ;;                       # Swift
+        dart) ;;                        # Dart
+        ets) ;;                         # HarmonyOS ArkTS
+        sh|bash) ;;                     # Shell
+        *) exit 0 ;;                     # Unknown extension, skip
+    esac
+
+    # ── Stale doc check: remind if any docs are actually stale ────────────────
+
+    local PROJECT_DIR="${PWD:-}"
+
+    # Source common.sh for count_stale_docs
+    local _LIB_FOUND=false
+    for _lib_dir in "$HOME/.claude/lib" "$HOME/.cursor/lib" "${ATOOL_ROOT:-}/lib"; do
+        if [[ -f "${_lib_dir}/common.sh" ]]; then
+            # shellcheck source=/dev/null
+            source "${_lib_dir}/common.sh"
+            _LIB_FOUND=true
+            break
+        fi
+    done
+
+    local STALE=false
+    if $_LIB_FOUND && declare -f count_stale_docs &>/dev/null; then
+        # Check against all common documentation files — any stale doc triggers reminder
+        local DOC_FILES=()
+        for doc in "README.md" "COMPONENT.md" "UI_STYLE.md" "ARCHITECTURE.md" "CODE_REVIEW.md"; do
+            [[ -f "$PROJECT_DIR/$doc" ]] && DOC_FILES+=("$doc")
+        done
+        # Also check docs/ directory markdown files (up to 20)
+        if [[ -d "$PROJECT_DIR/docs" ]]; then
+            while IFS= read -r doc; do
+                [[ -n "$doc" ]] && DOC_FILES+=("$doc")
+            done < <(find "$PROJECT_DIR/docs" -maxdepth 1 -name '*.md' -type f 2>/dev/null | head -20 | sed "s|^$PROJECT_DIR/||")
+        fi
+
+        if [[ ${#DOC_FILES[@]} -gt 0 ]]; then
+            local STALE_COUNT
+            STALE_COUNT=$(count_stale_docs "$PROJECT_DIR" "${DOC_FILES[@]}")
+            if [[ "$STALE_COUNT" -gt 0 ]]; then
+                STALE=true
+            fi
+        fi
+    fi
+
+    # If no stale doc detection available, always remind (conservative)
+    if ! $_LIB_FOUND; then
+        STALE=true
+    fi
+
+    if ! $STALE; then
+        exit 0  # Docs are up to date, no reminder needed
+    fi
+
+    # ── Output reminder ──────────────────────────────────────────────────────
+
+    local _REMINDER='<ATOOL-DOC-SYNC-REMINDER>
+You just modified a source file. Documentation may now be stale.
+
+IMMEDIATE actions required (do NOT defer):
+1. Update affected docs: README.md (architecture/structure), COMPONENT.md (API/usage), UI_STYLE.md (styles), docs/ (knowledge base).
+2. Before claiming this task done, invoke /verification-before-completion to verify doc freshness.
+3. For substantial doc updates, invoke /doc-coauthoring. For doc format validation, invoke /doc-standards-enforcer.
+
+Gate rule: if any doc is stale, the task is NOT done.
+</ATOOL-DOC-SYNC-REMINDER>'
+
+    # Use structured JSON output for Claude Code PostToolUse hooks
+    # Plain text stdout is only visible in verbose mode, NOT injected into conversation.
+    # The correct format is: {"hookSpecificOutput":{"hookEventName":"PostToolUse","additionalContext":"..."}}
+    local _ESCAPED
+    _ESCAPED=$(escape_for_json "$_REMINDER")
+    printf '{"hookSpecificOutput":{"hookEventName":"PostToolUse","additionalContext":"%s"}}\n' "$_ESCAPED"
+
+    exit 0
+}
+
+main "$@"

package/hooks/hooks-cursor.json

@@ -0,0 +1,37 @@
+{
+  "hooks": {
+    "sessionStart": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash ~/.cursor/hooks/atool-session-start"
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash ~/.cursor/hooks/atool-prompt-guard"
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Write|Edit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash ~/.cursor/hooks/atool-doc-sync-reminder"
+          }
+        ]
+      }
+    ]
+  }
+}

package/hooks/hooks.json

@@ -0,0 +1,37 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash ~/.claude/hooks/atool-session-start"
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash ~/.claude/hooks/atool-prompt-guard"
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Write|Edit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash ~/.claude/hooks/atool-doc-sync-reminder"
+          }
+        ]
+      }
+    ]
+  }
+}

package/hooks/prompt-guard

@@ -0,0 +1,135 @@
+#!/usr/bin/env bash
+# aTool - hooks/prompt-guard
+# Lightweight UserPromptSubmit hook: reminds AI to clarify before implementing
+# Skips short/trivial prompts, triggers on substantial implementation requests
+
+set -euo pipefail
+
+# Detect which IDE is running this hook
+HOOK_IDE="claude"
+if [[ -n "${CURSOR_PLUGIN_ROOT:-}" ]]; then
+    HOOK_IDE="cursor"
+fi
+
+# Escape string for JSON embedding
+escape_for_json() {
+    local s="$1"
+    s="${s//\\/\\\\}"
+    s="${s//\"/\\\"}"
+    s="${s//$'\n'/\\n}"
+    s="${s//$'\r'/\\r}"
+    s="${s//$'\t'/\\t}"
+    printf '%s' "$s"
+}
+
+# Read JSON from stdin (Claude Code provides {"prompt": "..."} on stdin)
+INPUT=""
+if [[ ! -t 0 ]]; then
+    INPUT=$(cat)
+fi
+
+# Extract the prompt text using jq
+PROMPT=""
+if command -v jq &>/dev/null && [[ -n "$INPUT" ]]; then
+    PROMPT=$(printf '%s' "$INPUT" | jq -r '.prompt // empty' 2>/dev/null || echo "")
+fi
+
+# Fallback: if jq not available or parsing failed, try grep
+if [[ -z "$PROMPT" && -n "$INPUT" ]]; then
+    PROMPT=$(printf '%s' "$INPUT" | grep -o '"prompt"[[:space:]]*:[[:space:]]*"[^"]*"' 2>/dev/null | head -1 | sed 's/.*"prompt"[[:space:]]*:[[:space:]]*"//;s/"$//' || echo "")
+fi
+
+# No prompt extracted — exit silently
+if [[ -z "$PROMPT" ]]; then
+    exit 0
+fi
+
+# Normalize: lowercase for pattern matching
+PROMPT_LOWER=$(printf '%s' "$PROMPT" | tr '[:upper:]' '[:lower:]')
+PROMPT_LEN=${#PROMPT}
+
+# ── Skip conditions (< 5ms exit) ──────────────────────────────────────────
+
+# Detect CJK text (more information-dense, use lower threshold)
+# Use LC_ALL=C to ensure byte-level matching works regardless of locale
+HAS_CJK=false
+if printf '%s' "$PROMPT" | LC_ALL=C grep -q '[一-龥]' 2>/dev/null; then
+    HAS_CJK=true
+fi
+
+# 1. Short messages
+if $HAS_CJK && [[ "$PROMPT_LEN" -lt 8 ]]; then
+    exit 0
+elif ! $HAS_CJK && [[ "$PROMPT_LEN" -lt 20 ]]; then
+    exit 0
+fi
+
+# 2. Follow-up replies (affirmative, no new intent)
+FOLLOW_UP_PATTERNS="^(yes|ok|okay|好的|继续|继续做|go ahead|sure|yep|yeah|pls|please|go on|继续吧|对|嗯|是的|行|可以)$"
+if printf '%s' "$PROMPT_LOWER" | grep -qE "$FOLLOW_UP_PATTERNS" 2>/dev/null; then
+    exit 0
+fi
+
+# 3. User asking a question (ends with ? or ？)
+if printf '%s' "$PROMPT" | grep -qE '[?？]$' 2>/dev/null; then
+    exit 0
+fi
+
+# 4. Meta-commands (non-implementation requests)
+# Note: Ambiguous words like "build", "test", "deploy" are NOT listed here
+# because they could be feature requests (e.g., "build a dashboard")
+META_COMMANDS="^(commit|git |run |npm |yarn |pnpm |bun |cargo |go run|python |pytest|jest|vitest|explain|diff |show |list |check |lint |format |log |tail |grep |find |cat |head )"
+if printf '%s' "$PROMPT_LOWER" | grep -qE "$META_COMMANDS" 2>/dev/null; then
+    exit 0
+fi
+
+# 5. Exit signals (user wants to skip clarification)
+EXIT_SIGNALS="(别问了|不要问|别再问|直接做|直接实现|直接开始|不用确认|跳过提问|不要确认|just do it|stop asking|no questions|don.t ask|skip asking|go ahead and implement)"
+if printf '%s' "$PROMPT_LOWER" | grep -qE "$EXIT_SIGNALS" 2>/dev/null; then
+    exit 0
+fi
+
+# ── Trigger conditions ───────────────────────────────────────────────────
+
+# Count words: for CJK text (no spaces), count CJK chars as words;
+# for Latin text, count whitespace-separated tokens
+WORD_COUNT=0
+if $HAS_CJK; then
+    # CJK: count CJK characters (use LC_ALL=C for locale safety)
+    CJK_COUNT=$(printf '%s' "$PROMPT" | LC_ALL=C grep -o '[一-龥]' 2>/dev/null | wc -l | tr -d '[:space:]')
+    WORD_COUNT=$((CJK_COUNT))
+else
+    for word in $PROMPT; do
+        WORD_COUNT=$((WORD_COUNT + 1))
+    done
+fi
+
+# Trigger: sufficient length + enough words/CJK chars + implementation keyword
+IMPLEMENT_KEYWORDS="(开发|创建|新增|实现|添加|加个|做一个|写一个|build|create|add|implement|make|develop|design|feature|refactor|extract|integrate|support|handle)"
+LENGTH_OK=false
+if $HAS_CJK && [[ "$PROMPT_LEN" -ge 8 ]]; then
+    LENGTH_OK=true
+elif ! $HAS_CJK && [[ "$PROMPT_LEN" -ge 20 ]]; then
+    LENGTH_OK=true
+fi
+
+if $LENGTH_OK && [[ "$WORD_COUNT" -gt 5 ]] && \
+   printf '%s' "$PROMPT_LOWER" | grep -qE "$IMPLEMENT_KEYWORDS" 2>/dev/null; then
+    _REMINDER='<system-reminder>
+Before implementing, classify task complexity and clarify requirements if needed:
+- Tier 0 (direct): single-value change → just do it
+- Tier 1 (1-2 questions): small change with ambiguity → ask key questions
+- Tier 2 (3-5 questions): new feature → read project files first, then ask context-aware questions
+- Tier 3: architecture-level → delegate to /brainstorming
+See /clarify-before-build for full methodology.
+</system-reminder>'
+
+    if [[ "$HOOK_IDE" == "cursor" ]]; then
+        _ESCAPED=$(escape_for_json "$_REMINDER")
+        printf '{\n  "additional_context": "%s"\n}\n' "$_ESCAPED"
+    else
+        printf '%s' "$_REMINDER"
+    fi
+fi
+
+exit 0

package/hooks/session-start

@@ -0,0 +1,286 @@
+#!/usr/bin/env bash
+# aTool - hooks/session-start
+# Dynamic context generator: injects skill catalog, project context, and doc-sync reminders
+# Works with Claude Code, Cursor, and other IDEs
+
+set -euo pipefail
+
+# Locate aTool installation
+if [[ -n "${CLAUDE_PLUGIN_ROOT:-}" ]]; then
+    SCRIPT_DIR="$CLAUDE_PLUGIN_ROOT"
+elif [[ -n "${CURSOR_PLUGIN_ROOT:-}" ]]; then
+    SCRIPT_DIR="$CURSOR_PLUGIN_ROOT"
+else
+    SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+fi
+
+# Detect which IDE is running this hook
+HOOK_IDE="claude"
+if [[ -n "${CURSOR_PLUGIN_ROOT:-}" ]]; then
+    HOOK_IDE="cursor"
+fi
+
+# Read version, stripping potential CRLF from Windows
+ATOOL_VERSION="${ATOOL_VERSION:-$(cat "$SCRIPT_DIR/../VERSION" 2>/dev/null || cat "$SCRIPT_DIR/VERSION" 2>/dev/null || echo "0.1.0")}"
+ATOOL_VERSION="${ATOOL_VERSION%$'\r'}"
+
+# Source common functions (scan_skills_catalog, stack_to_conventions_skill, count_stale_docs)
+# Try: PLUGIN_ROOT/lib/ → sibling lib/ → project .claude/lib/ → installed IDE lib/
+# shellcheck source=../lib/common.sh
+_LIB_FOUND=false
+_PROJECT_LIB="${PWD}/.claude/lib"
+for _lib_dir in "${SCRIPT_DIR}/lib" "${SCRIPT_DIR}/../lib" "$_PROJECT_LIB" "$HOME/.claude/lib" "$HOME/.cursor/lib"; do
+    if [[ -f "${_lib_dir}/common.sh" ]]; then
+        source "${_lib_dir}/common.sh"
+        _LIB_FOUND=true
+        break
+    fi
+done
+
+# Source detect-stack.sh for stack detection
+# shellcheck source=../lib/detect-stack.sh
+if [[ -f "${_lib_dir:-}/detect-stack.sh" ]]; then
+    source "${_lib_dir}/detect-stack.sh"
+fi
+unset _lib_dir _LIB_FOUND _PROJECT_LIB
+
+# Escape string for JSON embedding (same approach as Superpowers)
+escape_for_json() {
+    local s="$1"
+    s="${s//\\/\\\\}"
+    s="${s//\"/\\\"}"
+    s="${s//$'\n'/\\n}"
+    s="${s//$'\r'/\\r}"
+    s="${s//$'\t'/\\t}"
+    printf '%s' "$s"
+}
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 1. Inject using-superpowers skill content
+# ═══════════════════════════════════════════════════════════════════════════
+
+INJECTION=""
+SUPERPOWERS_SKILLS=""
+if [[ -n "${CLAUDE_PLUGIN_ROOT:-}" ]]; then
+    SUPERPOWERS_SKILLS="$CLAUDE_PLUGIN_ROOT/skills/using-superpowers"
+elif [[ -n "${CURSOR_PLUGIN_ROOT:-}" ]]; then
+    SUPERPOWERS_SKILLS="$CURSOR_PLUGIN_ROOT/skills/using-superpowers"
+fi
+
+# Fallback: scan IDE-specific config dirs
+if [[ -z "$SUPERPOWERS_SKILLS" || ! -d "$SUPERPOWERS_SKILLS" ]]; then
+    if [[ "$HOOK_IDE" == "cursor" ]] && declare -f get_cursor_config_dir &>/dev/null; then
+        _sp_config_dir=$(get_cursor_config_dir 2>/dev/null || echo "")
+        if [[ -d "$_sp_config_dir/skills/using-superpowers" ]]; then
+            SUPERPOWERS_SKILLS="$_sp_config_dir/skills/using-superpowers"
+        fi
+    fi
+fi
+if [[ -z "$SUPERPOWERS_SKILLS" || ! -d "$SUPERPOWERS_SKILLS" ]]; then
+    if [[ -d "$HOME/.claude/skills/using-superpowers" ]]; then
+        SUPERPOWERS_SKILLS="$HOME/.claude/skills/using-superpowers"
+    elif [[ -d "$HOME/.atool/cache/superpowers/skills/using-superpowers" ]]; then
+        SUPERPOWERS_SKILLS="$HOME/.atool/cache/superpowers/skills/using-superpowers"
+    fi
+fi
+
+if [[ -n "$SUPERPOWERS_SKILLS" && -d "$SUPERPOWERS_SKILLS" ]]; then
+    SKILL_FILE=""
+    if [[ -f "$SUPERPOWERS_SKILLS/SKILL.md" ]]; then
+        SKILL_FILE="$SUPERPOWERS_SKILLS/SKILL.md"
+    elif [[ -f "$SUPERPOWERS_SKILLS/skill.md" ]]; then
+        SKILL_FILE="$SUPERPOWERS_SKILLS/skill.md"
+    fi
+
+    if [[ -n "$SKILL_FILE" ]]; then
+        INJECTION+=$(cat "$SKILL_FILE")
+        INJECTION+=$'\n\n'
+    fi
+fi
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 2. Scan installed skills and generate catalog
+# ═══════════════════════════════════════════════════════════════════════════
+
+# Use IDE-appropriate skills directory
+SKILLS_DIR="$HOME/.claude/skills"
+if [[ "$HOOK_IDE" == "cursor" ]] && declare -f get_cursor_config_dir &>/dev/null; then
+    _cursor_skills=$(get_cursor_config_dir 2>/dev/null || echo "$HOME/.cursor")
+    _cursor_skills="$_cursor_skills/skills"
+    if [[ -d "$_cursor_skills" ]]; then
+        SKILLS_DIR="$_cursor_skills"
+    fi
+fi
+unset _cursor_skills _sp_config_dir 2>/dev/null || true
+
+CATALOG=""
+if declare -f scan_skills_catalog &>/dev/null; then
+    CATALOG=$(scan_skills_catalog "$SKILLS_DIR")
+fi
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 3. Detect project context (only when in a project directory)
+# ═══════════════════════════════════════════════════════════════════════════
+
+PROJECT_CONTEXT=""
+DOC_SYNC=""
+PROJECT_DIR="${PWD:-}"
+
+# Only inject project context if we're in a real project (has .git or signal files)
+IS_PROJECT=false
+if [[ -d "$PROJECT_DIR/.git" ]] || [[ -f "$PROJECT_DIR/pom.xml" ]] || \
+   [[ -f "$PROJECT_DIR/package.json" ]] || [[ -f "$PROJECT_DIR/Cargo.toml" ]] || \
+   [[ -f "$PROJECT_DIR/go.mod" ]] || [[ -f "$PROJECT_DIR/pyproject.toml" ]] || \
+   [[ -f "$PROJECT_DIR/requirements.txt" ]] || [[ -f "$PROJECT_DIR/pubspec.yaml" ]] || \
+   [[ -f "$PROJECT_DIR/build.gradle" ]] || [[ -f "$PROJECT_DIR/build.gradle.kts" ]]; then
+    IS_PROJECT=true
+fi
+
+if $IS_PROJECT && declare -f detect_stack &>/dev/null; then
+    STACK=$(detect_stack "$PROJECT_DIR")
+    STACK_DESC=""
+    if declare -f get_stack_description &>/dev/null; then
+        STACK_DESC=$(get_stack_description "$STACK")
+    fi
+
+    CONVENTIONS_SKILL=""
+    if declare -f stack_to_conventions_skill &>/dev/null; then
+        CONVENTIONS_SKILL=$(stack_to_conventions_skill "$STACK")
+    fi
+
+    PROJECT_CONTEXT="<ATOOL-PROJECT-CONTEXT>"
+    PROJECT_CONTEXT+=$'\n'
+    PROJECT_CONTEXT+="Current project: ${STACK_DESC} (${STACK})"
+    PROJECT_CONTEXT+=$'\n'
+    if [[ -n "$CONVENTIONS_SKILL" ]]; then
+        PROJECT_CONTEXT+="Primary conventions: /${CONVENTIONS_SKILL}"
+        PROJECT_CONTEXT+=$'\n'
+    fi
+
+    # Check doc freshness against ALL documentation files
+    STALE_COUNT=0
+    _DOC_FILES=()
+    for _doc in "README.md" "COMPONENT.md" "UI_STYLE.md" "ARCHITECTURE.md" "CODE_REVIEW.md"; do
+        [[ -f "$PROJECT_DIR/$_doc" ]] && _DOC_FILES+=("$_doc")
+    done
+    if [[ -d "$PROJECT_DIR/docs" ]]; then
+        while IFS= read -r _doc; do
+            [[ -n "$_doc" ]] && _DOC_FILES+=("$_doc")
+        done < <(find "$PROJECT_DIR/docs" -maxdepth 1 -name '*.md' -type f 2>/dev/null | head -20 | sed "s|^$PROJECT_DIR/||")
+    fi
+    if declare -f count_stale_docs &>/dev/null && [[ ${#_DOC_FILES[@]} -gt 0 ]]; then
+        STALE_COUNT=$(count_stale_docs "$PROJECT_DIR" "${_DOC_FILES[@]}")
+    fi
+    if [[ "$STALE_COUNT" -gt 0 ]]; then
+        PROJECT_CONTEXT+="Doc status: STALE — ${STALE_COUNT} source files newer than docs (${#_DOC_FILES[@]} docs checked)"
+        PROJECT_CONTEXT+=$'\n'
+    else
+        PROJECT_CONTEXT+="Doc status: All docs up to date (${#_DOC_FILES[@]} docs checked)"
+        PROJECT_CONTEXT+=$'\n'
+    fi
+
+    # Check analysis status
+    if [[ -d "$PROJECT_DIR/.atool-docs" ]]; then
+        PROJECT_CONTEXT+="Analysis status: Project analyzed (see .atool-docs/)"
+        PROJECT_CONTEXT+=$'\n'
+    else
+        PROJECT_CONTEXT+="Analysis status: Not yet analyzed - consider running /project-analyze"
+        PROJECT_CONTEXT+=$'\n'
+    fi
+
+    PROJECT_CONTEXT+="</ATOOL-PROJECT-CONTEXT>"
+
+    # Doc sync reminder — hard rule with skill enforcement
+    DOC_SYNC="<ATOOL-DOC-SYNC>"
+    DOC_SYNC+=$'\n'
+    DOC_SYNC+="HARD RULE: Every time you modify a source file, you MUST update affected documentation BEFORE claiming the task is done."
+    DOC_SYNC+=$'\n\n'
+    DOC_SYNC+="Mandatory actions when source files change:"
+    DOC_SYNC+=$'\n'
+    DOC_SYNC+="1. Update affected docs: README.md (architecture/structure), COMPONENT.md (API/usage), UI_STYLE.md (styles), docs/ (knowledge base)."
+    DOC_SYNC+=$'\n'
+    DOC_SYNC+="2. BEFORE claiming task done, invoke /verification-before-completion — this skill checks doc freshness and blocks completion if docs are stale."
+    DOC_SYNC+=$'\n'
+    DOC_SYNC+="3. For doc writing, invoke /doc-coauthoring. For doc format validation, invoke /doc-standards-enforcer."
+    DOC_SYNC+=$'\n\n'
+    DOC_SYNC+="When writing plans: always include a Documentation Sync step as the final task."
+    DOC_SYNC+=$'\n'
+    DOC_SYNC+="Gate rule: if docs are stale, task is NOT done. No exceptions."
+    DOC_SYNC+=$'\n'
+    DOC_SYNC+="</ATOOL-DOC-SYNC>"
+fi
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 4. Assemble and output
+# ═══════════════════════════════════════════════════════════════════════════
+
+INJECTION+="<system-reminder>"
+INJECTION+=$'\n'
+INJECTION+="SessionStart: aTool v${ATOOL_VERSION} active. Skills, hooks, and MCP servers configured."
+INJECTION+=$'\n'
+INJECTION+="</system-reminder>"
+INJECTION+=$'\n\n'
+INJECTION+="<EXTREMELY_IMPORTANT>"
+INJECTION+=$'\n'
+INJECTION+="<ATOOL-SESSION>"
+INJECTION+=$'\n'
+INJECTION+="aTool v${ATOOL_VERSION} active."
+INJECTION+=$'\n\n'
+
+if [[ -n "$CATALOG" ]]; then
+    INJECTION+="<ATOOL-SKILL-CATALOG>"
+    INJECTION+=$'\n'
+    INJECTION+="$CATALOG"
+    INJECTION+=$'\n'
+    INJECTION+="Invoke skills with: /{skill-name}"
+    INJECTION+=$'\n'
+    INJECTION+="</ATOOL-SKILL-CATALOG>"
+    INJECTION+=$'\n\n'
+fi
+
+if [[ -n "$PROJECT_CONTEXT" ]]; then
+    INJECTION+="$PROJECT_CONTEXT"
+    INJECTION+=$'\n\n'
+fi
+
+if [[ -n "$DOC_SYNC" ]]; then
+    INJECTION+="$DOC_SYNC"
+    INJECTION+=$'\n\n'
+fi
+
+INJECTION+="<ATOOL-CLARIFY-RULE>"
+INJECTION+=$'\n'
+INJECTION+="Before implementing ANY feature, first classify task complexity:"
+INJECTION+=$'\n'
+INJECTION+="Tier 0 (direct): single-value change, typo, format fix -> just do it"
+INJECTION+=$'\n'
+INJECTION+="Tier 1 (1-2 questions): small change with ambiguity -> ask key questions"
+INJECTION+=$'\n'
+INJECTION+="Tier 2 (3-5 questions): new feature, medium complexity -> structured clarification"
+INJECTION+=$'\n'
+INJECTION+="Tier 3: architecture-level, vague requirements -> delegate to /brainstorming"
+INJECTION+=$'\n'
+INJECTION+="Rules: Read project files BEFORE asking (CLAUDE.md, package.json, source code). Never assume installed libs or existing patterns. Ask context-aware questions, not obvious ones."
+INJECTION+=$'\n'
+INJECTION+="Exit: If user says '别问了'/'直接做'/'just do it'/'stop asking' -> skip all questions, Tier 0."
+INJECTION+=$'\n'
+INJECTION+="See /clarify-before-build for full methodology."
+INJECTION+=$'\n'
+INJECTION+="</ATOOL-CLARIFY-RULE>"
+INJECTION+=$'\n'
+INJECTION+="</ATOOL-SESSION>"
+INJECTION+=$'\n'
+INJECTION+="</EXTREMELY_IMPORTANT>"
+
+# Output in the format expected by the running IDE.
+# Claude Code reads BOTH additional_context and hookSpecificOutput without deduplication,
+# so we must emit only the appropriate field to avoid double injection.
+if [[ "$HOOK_IDE" == "cursor" ]]; then
+    INJECTION_ESCAPED=$(escape_for_json "$INJECTION")
+    printf '{\n  "additional_context": "%s"\n}\n' "$INJECTION_ESCAPED"
+else
+    # Claude Code: plain text output (hook framework wraps it automatically)
+    printf '%s' "$INJECTION"
+fi
+
+exit 0