@dtt_siye/atool 1.3.1 → 1.4.0

package/lib/common.sh

@@ -140,11 +140,9 @@ ensure_dir() {
 # ── IDE Config Directory Helpers (cross-platform) ─────────────────────────────
 
 get_claude_config_dir() {
-    if is_windows && [[ -n "${APPDATA:-}" ]]; then
-        cygpath -u "$APPDATA/claude" 2>/dev/null || echo "$HOME/.claude"
-    else
-        echo "$HOME/.claude"
-    fi
+    # Claude Code CLI always uses ~/.claude/ on all platforms
+    # (APPDATA/claude is the Claude Desktop app, not the CLI)
+    echo "$HOME/.claude"
 }
 
 get_cursor_config_dir() {
@@ -861,15 +859,20 @@ scan_skills_catalog() {
                 ;;
             pdf|docx|pptx|xlsx)
                 office="${office}- ${skill_name}: ${desc}
+"
+                ;;
+            # Core initialization
+            atool-init)
+                planning="${planning}- ${skill_name}: ${desc}
 "
                 ;;
             # Architecture & Design
-            software-architecture|ai-project-architecture|ui-ux-pro)
+            software-architecture|ai-project-architecture|ui-ux-pro|architecture-guard)
                 arch_design="${arch_design}- ${skill_name}: ${desc}
 "
                 ;;
             # Quality & Review
-            code-review|project-analyze|project-query|verification-before-completion)
+            code-review|project-analyze|project-query|verification-before-completion|agent-audit)
                 quality_review="${quality_review}- ${skill_name}: ${desc}
 "
                 ;;
@@ -879,8 +882,13 @@ scan_skills_catalog() {
 "
                 ;;
             # Planning & Dispatch
-            writing-plans|smart-dispatch|brainstorming|clarify-before-build)
+            writing-plans|smart-dispatch|brainstorming|clarify-before-build|using-git-worktrees|find-skills)
                 planning="${planning}- ${skill_name}: ${desc}
+"
+                ;;
+            # Testing & Automation
+            webapp-testing|ci-feedback)
+                quality_review="${quality_review}- ${skill_name}: ${desc}
 "
                 ;;
             *)
@@ -890,26 +898,31 @@ scan_skills_catalog() {
         esac
     done
 
-    # Check for Superpowers skills
+    # Check for Superpowers skills (only if Superpowers directory exists and is separate from skills_dir)
     local sp_dir="$skills_dir"
     if [[ -d "$skills_dir/_superpowers/skills" ]]; then
         sp_dir="$skills_dir/_superpowers/skills"
     fi
-    for skill_dir in "$sp_dir"/*/; do
-        [[ ! -d "$skill_dir" ]] && continue
-        local skill_name
-        skill_name=$(basename "$skill_dir")
-        [[ -L "$skill_dir" ]] && continue
-        local sp_md="$skill_dir/SKILL.md"
-        [[ ! -f "$sp_md" ]] && continue
-        local desc=""
-        desc=$(head -10 "$sp_md" | sed -n '/^---$/,/^---$/p' | grep '^description:' | head -1 | sed 's/^description:[[:space:]]*//')
-        if [[ -z "$desc" ]]; then
-            desc=$(head -10 "$sp_md" | grep -i '^#' | head -1 | sed 's/^#*\s*//' || echo "$skill_name")
-        fi
-        superpowers_list="${superpowers_list}- ${skill_name}: ${desc}
+
+    # Only scan Superpowers directory if it exists and is NOT the same as skills_dir
+    # (prevents double-scanning skills already categorized in first loop)
+    if [[ "$sp_dir" != "$skills_dir" ]] && [[ -d "$sp_dir" ]]; then
+        for skill_dir in "$sp_dir"/*/; do
+            [[ ! -d "$skill_dir" ]] && continue
+            local skill_name
+            skill_name=$(basename "$skill_dir")
+            [[ -L "$skill_dir" ]] && continue
+            local sp_md="$skill_dir/SKILL.md"
+            [[ ! -f "$sp_md" ]] && continue
+            local desc=""
+            desc=$(head -10 "$sp_md" | sed -n '/^---$/,/^---$/p' | grep '^description:' | head -1 | sed 's/^description:[[:space:]]*//')
+            if [[ -z "$desc" ]]; then
+                desc=$(head -10 "$sp_md" | grep -i '^#' | head -1 | sed 's/^#*\s*//' || echo "$skill_name")
+            fi
+            superpowers_list="${superpowers_list}- ${skill_name}: ${desc}
 "
-    done
+        done
+    fi
 
     # Output catalog
     if [[ -n "$conventions" ]]; then

package/lib/compute-importance.sh

@@ -591,6 +591,79 @@ compute_importance() {
     rm -rf "$tmpdir"
 }
 
+# === Batch Processing (for pre-scan manifest.json) ===
+
+# Update manifest.json modules array with importance scores
+# Args: MANIFEST_PATH - path to manifest.json
+#       PROJECT_ROOT - project root directory (parent of .atool-docs)
+# Updates: manifest.json modules[].importance field in-place
+compute_importance_batch() {
+    local manifest_path="${1:-.atool-docs/pre-scan/manifest.json}"
+    local project_root="${2:-.}"
+
+    if [[ ! -f "$manifest_path" ]]; then
+        log_error "Manifest not found: $manifest_path"
+        return 1
+    fi
+
+    log_info "Computing importance scores for modules in manifest..."
+
+    # Get inventory directory from project_root
+    local inventory_dir="${project_root}/.atool-docs/inventory"
+
+    # Read modules from manifest
+    local modules_json
+    modules_json=$(jq -r '.modules[] | .slug' "$manifest_path" 2>/dev/null)
+
+    if [[ -z "$modules_json" ]]; then
+        log_warn "No modules found in manifest"
+        return 0
+    fi
+
+    # Build module path map: slug -> importance_score
+    local tmpdir
+    tmpdir=$(mktemp -d)
+
+    # Discover all modules in project and compute importance
+    local all_modules
+    all_modules=$(discover_modules "$project_root")
+
+    if [[ -z "$all_modules" ]]; then
+        log_warn "No source modules found in project"
+        echo "{}" > "$tmpdir/importance_map"
+    else
+        # Compute importance for all discovered modules
+        log_info "Computing importance factors for discovered modules..."
+        local importance_output
+        importance_output=$(compute_importance "$project_root" --inventory-dir "$inventory_dir" 2>/dev/null || true)
+
+        # Build slug-to-importance map from output (module_path<tab>score<tab>tier)
+        # Convert module path to slug: extract last path component
+        {
+            while IFS=$'\t' read -r module_path score tier; do
+                [[ -z "$module_path" ]] && continue
+                local slug
+                slug=$(basename "$module_path")
+                printf '%s\t%s\n' "$slug" "$score"
+            done <<< "$importance_output"
+        } > "$tmpdir/importance_map"
+    fi
+
+    # Update manifest.json with importance scores
+    log_info "Updating manifest with importance scores..."
+    jq --slurpfile importance_data <(cat "$tmpdir/importance_map" | jq -R 'split("\t") | {key: .[0], value: (.[1] | tonumber)}' | jq -s 'from_entries') \
+        '.modules |= map(.importance = ($importance_data[0][.slug] // 0))' \
+        "$manifest_path" > "$tmpdir/manifest_updated.json"
+
+    # Atomically replace manifest
+    mv "$tmpdir/manifest_updated.json" "$manifest_path"
+
+    # Cleanup
+    rm -rf "$tmpdir"
+
+    log_success "Importance scores computed and manifest updated"
+}
+
 # === Standalone Execution ===
 # When run directly (not sourced), execute compute_importance with CLI args
 if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then

package/lib/install-cursor.sh

@@ -79,8 +79,8 @@ should_always_apply() {
         project-analyze)           return 0 ;;
         # Workflow skill with no good glob match - must be always-on
         using-git-worktrees)       return 0 ;;
-        # Conventions skills - always relevant for their file types (via globs too)
-        *-conventions)              return 0 ;;
+        # Conventions skills - globs handle triggering by file type (no need for alwaysApply)
+        *-conventions)              return 1 ;;
         # All other skills: use globs or on-demand (reduces context token consumption)
         *)                          return 1 ;;
     esac

package/lib/install-hooks.sh

@@ -132,6 +132,58 @@ install_hooks() {
         fi
     fi
 
+    # Install pre-commit hook (PreToolUse - checks before git commit)
+    local pre_commit_src="$atool_root/hooks/pre-commit"
+    if [[ -f "$pre_commit_src" ]]; then
+        local pre_commit_name="atool-pre-commit"
+        local dest_pre_commit="$hooks_dir/$pre_commit_name"
+
+        if [[ -f "$dest_pre_commit" ]] && [[ "${ATOOL_FORCE:-0}" != "1" ]]; then
+            local pc_existing pc_source
+            pc_existing=$(file_checksum "$dest_pre_commit")
+            pc_source=$(file_checksum "$pre_commit_src")
+            if [[ "$pc_existing" == "$pc_source" ]]; then
+                log_info "Hook '$pre_commit_name' already up to date, skipping"
+            else
+                log_info "Hook '$pre_commit_name' exists but differs - backing up"
+                backup_file "$dest_pre_commit"
+                run_cmd cp "$pre_commit_src" "$dest_pre_commit"
+                run_cmd chmod +x "$dest_pre_commit"
+                log_success "Hook installed: $dest_pre_commit"
+            fi
+        else
+            run_cmd cp "$pre_commit_src" "$dest_pre_commit"
+            run_cmd chmod +x "$dest_pre_commit"
+            log_success "Hook installed: $dest_pre_commit"
+        fi
+    fi
+
+    # Install task-state-tracker hook (PostToolUse - tracks session state)
+    local task_state_src="$atool_root/hooks/task-state-tracker"
+    if [[ -f "$task_state_src" ]]; then
+        local task_state_name="atool-task-state-tracker"
+        local dest_task_state="$hooks_dir/$task_state_name"
+
+        if [[ -f "$dest_task_state" ]] && [[ "${ATOOL_FORCE:-0}" != "1" ]]; then
+            local ts_existing ts_source
+            ts_existing=$(file_checksum "$dest_task_state")
+            ts_source=$(file_checksum "$task_state_src")
+            if [[ "$ts_existing" == "$ts_source" ]]; then
+                log_info "Hook '$task_state_name' already up to date, skipping"
+            else
+                log_info "Hook '$task_state_name' exists but differs - backing up"
+                backup_file "$dest_task_state"
+                run_cmd cp "$task_state_src" "$dest_task_state"
+                run_cmd chmod +x "$dest_task_state"
+                log_success "Hook installed: $dest_task_state"
+            fi
+        else
+            run_cmd cp "$task_state_src" "$dest_task_state"
+            run_cmd chmod +x "$dest_task_state"
+            log_success "Hook installed: $dest_task_state"
+        fi
+    fi
+
     # Install hooks config JSON
     local config_file
     case "$ide_type" in
@@ -224,6 +276,18 @@ install_hooks_global() {
                 run_cmd chmod +x "$claude_hooks_dir/atool-doc-sync-reminder"
             fi
 
+            # Copy pre-commit hook (PreToolUse)
+            if [[ -f "$atool_root/hooks/pre-commit" ]]; then
+                run_cmd cp "$atool_root/hooks/pre-commit" "$claude_hooks_dir/atool-pre-commit"
+                run_cmd chmod +x "$claude_hooks_dir/atool-pre-commit"
+            fi
+
+            # Copy task-state-tracker hook (PostToolUse)
+            if [[ -f "$atool_root/hooks/task-state-tracker" ]]; then
+                run_cmd cp "$atool_root/hooks/task-state-tracker" "$claude_hooks_dir/atool-task-state-tracker"
+                run_cmd chmod +x "$claude_hooks_dir/atool-task-state-tracker"
+            fi
+
             # 2. Register hooks config in settings.json
             #    Claude Code reads hooks from settings.json, NOT from files on disk
             local settings_file="$claude_config_dir/settings.json"

package/lib/install-skills.sh

@@ -122,8 +122,11 @@ install_skills() {
         # Skills reference scripts via "source lib/X.sh" relative to the skill dir
         local skill_lib_dir="$target_skill/lib"
         local referenced_libs
-        referenced_libs=$(find "$target_skill/phases" "$target_skill" -maxdepth 2 -name '*.md' -exec grep -roh 'source lib/[^ ]*\.sh' {} + 2>/dev/null \
-            | sed 's/source lib\///' | sort -u)
+        local _find_paths=()
+        [[ -d "$target_skill/phases" ]] && _find_paths+=("$target_skill/phases")
+        _find_paths+=("$target_skill")
+        referenced_libs=$(find "${_find_paths[@]}" -maxdepth 2 -name '*.md' -exec grep -roh 'source lib/[^ ]*\.sh' {} + 2>/dev/null \
+            | sed 's/source lib\///' | sort -u || true)
         if [[ -n "$referenced_libs" ]]; then
             run_cmd mkdir -p "$skill_lib_dir"
             for lib_name in $referenced_libs; do

package/lib/pre-scan.sh

@@ -1098,7 +1098,17 @@ pre_scan_project() {
         generated_at: (now | todate),
         total_modules: length,
         scan_duration_seconds: null,
-        modules: [.[].module_summary // {} | {total_files, total_classes, total_functions, total_api_endpoints, total_data_models}]
+        modules: [.[] | {
+            slug: .module,
+            name: .module,
+            importance: 0
+        } + (.module_summary // {} | {
+            total_files,
+            total_classes,
+            total_functions,
+            total_api_endpoints,
+            total_data_models
+        })]
     }' "$output_dir"/*.json 2>/dev/null || echo '{}')
 
     # Add duration to manifest

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dtt_siye/atool",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "description": "AI Developer Toolkit - 一键配置 AI IDE 的工具集",
   "bin": {
     "atool": "bin/atool.js"

package/skills/agent-audit/SKILL.md

@@ -0,0 +1,180 @@
+---
+name: agent-audit
+description: "Use when multiple agents or parallel tasks are running — tracks each agent's modifications, detects file conflicts, and provides audit trail. 在多Agent并行工作时使用 — 追踪每个Agent的修改、检测文件冲突、提供审计记录."
+version: 0.1.0
+category: quality
+---
+
+# Agent Audit — Multi-Agent Modification Tracking
+
+Tracks file modifications across multiple AI agents or parallel tasks, detects conflicts, and provides a complete audit trail for coordination.
+
+## When to Use
+
+- When using `/smart-dispatch` for parallel agent execution
+- When using `/dispatching-parallel-agents` for independent tasks
+- When using `/subagent-driven-development` for implementation plans
+- After parallel agents complete, before merging results
+- When reviewing what changes each agent made
+
+## How It Works
+
+### Audit Log Format
+
+Each agent's modifications are recorded in `.claude/agent-audit.json`:
+
+```json
+{
+  "audit_entries": [
+    {
+      "agent_id": "agent-1",
+      "task": "Implement user authentication",
+      "started_at": 1712649600,
+      "completed_at": 1712649900,
+      "files_modified": [
+        {
+          "path": "src/auth/UserService.java",
+          "action": "modified",
+          "lines_added": 45,
+          "lines_removed": 12,
+          "intent": "Add JWT token generation"
+        }
+      ],
+      "files_planned": ["src/auth/UserService.java", "src/auth/AuthController.java"],
+      "files_unexpected": [],
+      "impact_scope": ["auth", "api"],
+      "status": "completed"
+    }
+  ],
+  "conflicts": [],
+  "summary": {
+    "total_agents": 3,
+    "total_files_modified": 8,
+    "conflicts_detected": 0
+  }
+}
+```
+
+### Step 1: Agent Registration
+
+Before dispatching an agent, register it:
+
+```
+Read: agent-audit.json (or create if not exists)
+Add entry:
+{
+  "agent_id": "{agent-N}",
+  "task": "{task description}",
+  "files_planned": [{list of expected files}],
+  "started_at": {timestamp}
+}
+```
+
+### Step 2: Modification Tracking
+
+Each agent should record its modifications. Use git diff or task-state data:
+
+```
+After agent completes:
+  git diff --stat HEAD → extract file list and line changes
+  Compare with files_planned → flag unexpected files
+  Cross-reference with knowledge-graph → compute impact_scope
+```
+
+### Step 3: Conflict Detection
+
+After all agents complete, detect file-level conflicts:
+
+```
+For each pair of agents (A, B):
+  overlap = A.files_modified ∩ B.files_modified
+  if overlap is not empty:
+    CONFLICT: agents A and B both modified: {overlap}
+    severity = check if changes are in same lines (git merge-base)
+```
+
+Conflict severity levels:
+- **Critical**: Same file, same lines → merge conflict likely
+- **Warning**: Same file, different sections → manual review needed
+- **Info**: Different files, same module → review for logical consistency
+
+### Step 4: Impact Analysis
+
+Using knowledge-graph.json (from project-analyze):
+
+```
+For each agent's modified files:
+  1. Find the module each file belongs to
+  2. Find upstream dependents (who depends on this module)
+  3. Find downstream dependencies (what this module depends on)
+  4. Compute impact scope = module + direct dependents
+```
+
+### Step 5: Consolidated Audit Report
+
+```
+## Agent Audit Report
+
+### Execution Summary
+| Agent | Task | Files | Status | Duration |
+|-------|------|-------|--------|----------|
+| agent-1 | User auth | 3 | completed | 5m |
+| agent-2 | Payment API | 4 | completed | 7m |
+| agent-3 | Tests | 5 | completed | 4m |
+
+### File Overlap
+| File | Agent-1 | Agent-2 | Agent-3 |
+|------|---------|---------|---------|
+| src/common/Utils.java | modified | - | modified |
+
+### Conflicts
+| Severity | File | Details |
+|----------|------|---------|
+| Warning | src/common/Utils.java | Both agent-1 and agent-3 modified this file |
+
+### Impact Scope
+| Agent | Modules Affected | Downstream Impact |
+|-------|-----------------|-------------------|
+| agent-1 | auth, api | gateway, frontend |
+| agent-2 | payment, billing | notification, reporting |
+
+### Recommendations
+1. Review src/common/Utils.java for merge conflicts before integrating
+2. Run integration tests after merging all agent changes
+3. Update documentation for auth and payment modules
+```
+
+## Integration with task-state
+
+The agent-audit reads from and writes to `.claude/task-state.json`:
+
+```json
+{
+  "active_agents": 3,
+  "completed_agents": 2,
+  "agent_conflicts": ["src/common/Utils.java"],
+  "pending_actions": ["resolve_conflict:Utils.java", "run_integration_tests", "update_docs"]
+}
+```
+
+## Smart-Dispatch Integration
+
+When using `/smart-dispatch`:
+
+1. **Before dispatch**: Register each chunk as an agent entry
+2. **During execution**: Each agent records its modifications
+3. **After all complete**: Run conflict detection
+4. **Review phase**: Present consolidated audit report
+5. **Integration**: User resolves conflicts, then merge
+
+## Skill 协作
+
+| 协作 Skill | 触发条件 | 交互方式 |
+|-----------|---------|---------|
+| smart-dispatch | Parallel execution | 每个chunk注册为agent，完成后审计 |
+| dispatching-parallel-agents | Independent tasks | 跟踪每个后台agent的修改 |
+| subagent-driven-development | Implementation plans | 追踪sub-agent修改范围 |
+| project-analyze | Knowledge-graph available | 使用图谱计算impact scope |
+| architecture-guard | Conflicts detected | 检查冲突是否违反架构约束 |
+| verification-before-completion | After agent merge | 合并后验证整体完整性 |
+| ci-feedback | After merge | 运行集成测试验证 |

package/skills/architecture-guard/SKILL.md

@@ -0,0 +1,164 @@
+---
+name: architecture-guard
+description: "Use when reviewing or modifying code in analyzed projects — detects architectural violations in real-time using knowledge-graph data. 在修改代码时使用 — 实时检测架构违规（分层违反/依赖方向/循环依赖/边界泄漏）."
+version: 0.1.0
+category: quality
+---
+
+# Architecture Guard
+
+Real-time architectural violation detection using knowledge-graph data. Prevents AI and developers from degrading system structure.
+
+## When to Use
+
+- After modifying source files in a previously analyzed project (has `atool-analysis/` or `.atool-docs/`)
+- Before committing changes to verify architectural compliance
+- When reviewing code changes for structural correctness
+- Auto-triggered by verification-before-completion for analyzed projects
+
+## How It Works
+
+Architecture-guard reads the knowledge-graph.json produced by `/project-analyze` and checks:
+
+1. **Dependency Direction** — Enforces layer ordering (e.g., Controller → Service → DAO). Reverse dependencies are violations.
+2. **Package Structure** — New files must belong to recognized package paths.
+3. **API Boundary Leaks** — Response/DTO types should not appear in Service/DAO layers.
+4. **Circular Dependencies** — New imports must not introduce cycles.
+
+## Guard Process
+
+### Step 1: Load Architecture Data
+
+```
+Read: atool-analysis/knowledge-graph.json (or .atool-docs/knowledge-graph.json)
+Extract:
+- architectural_layers: {layer_name: [module_names]}
+- edges: [{source, target, edge_type}]
+- nodes: [{id, type, layer}]
+```
+
+If no knowledge-graph.json exists, warn the user and suggest running `/project-analyze` first.
+
+### Step 2: Detect Violations in Changed Files
+
+For each modified source file, check:
+
+#### 2a. Dependency Direction Check
+
+```
+For each import/dependency in the modified file:
+  source_layer = lookup layer of the modified file's module
+  target_layer = lookup layer of the imported module
+  if source_layer is lower than target_layer in the layer ordering:
+    VIOLATION: "Reverse dependency: {source} ({source_layer}) imports {target} ({target_layer})"
+```
+
+Common layer ordering (adjustable per project):
+- **Java/Spring**: Controller → Service → Repository → Entity
+- **Web/React**: Page → Component → Hook → Service → API
+- **Go**: Handler → Service → Repository → Model
+- **Python**: Route → Service → Repository → Model
+
+#### 2b. API Boundary Leak Check
+
+```
+For each import in the modified file:
+  if the file is in Service/Repository layer:
+    check if imported type is a Response/DTO/ViewModel (belongs to API/Presentation layer)
+    if yes: VIOLATION: "API type {type} leaked into {layer} layer"
+```
+
+#### 2c. Circular Dependency Check
+
+```
+Build dependency graph from knowledge-graph edges + new imports
+Run cycle detection (DFS)
+if cycle found: VIOLATION: "Circular dependency: {cycle_path}"
+```
+
+#### 2d. Module Boundary Check
+
+```
+For each new file or moved file:
+  Check if it belongs to a recognized module boundary
+  if it crosses module boundaries (imports from unrelated modules):
+    WARNING: "Cross-module import: {source_module} → {target_module}"
+```
+
+### Step 3: Report Results
+
+Output a structured violation report:
+
+```
+## Architecture Guard Report
+
+### Summary
+- Files checked: {n}
+- Violations: {n} (Critical: {n}, Warning: {n})
+- Status: PASS / FAIL
+
+### Violations
+
+| Severity | Type | File | Details |
+|----------|------|------|---------|
+| Critical | Reverse Dependency | UserService.java | Imports UserController (Controller→Service violation) |
+| Critical | Circular Dependency | OrderService.java | Cycle: OrderService → UserService → OrderService |
+| Warning  | API Boundary Leak   | PaymentService.java | Uses OrderResponse (DTO in Service layer) |
+| Warning  | Cross-Module        | notification.go    | Imports billing/invoice.go (unrelated domain) |
+```
+
+### Step 4: Suggest Fixes
+
+For each violation, provide:
+1. The specific line/import causing the issue
+2. Why it violates the architecture
+3. Suggested fix (e.g., "Move logic to OrderService", "Use OrderEntity instead of OrderResponse")
+
+## Integration Points
+
+### With verification-before-completion
+When the project has been analyzed, verification-before-completion should invoke architecture-guard as an additional check before claiming complete.
+
+### With code-review
+Architecture violations detected here feed into the `architecture` dimension of `/code-review` with specific line-level details.
+
+### With project-analyze
+Reads the knowledge-graph.json output from `/project-analyze`. If the graph is stale (older than source files), suggest re-running analysis.
+
+## Layer Definition Patterns
+
+The guard auto-detects layer patterns from the knowledge-graph:
+
+| Pattern | Layers |
+|---------|--------|
+| **Spring Boot** | controller → service → repository → entity |
+| **Clean Architecture** | presentation → application → domain → infrastructure |
+| **Hexagonal** | adapter/in → port/in → application → port/out → adapter/out |
+| **Generic Web** | page → component → service → data |
+| **DDD** | ui → application → domain → infrastructure |
+
+If no layers are detected, fall back to directory-based heuristics:
+- `controller/` / `handler/` / `api/` → Presentation
+- `service/` / `usecase/` / `application/` → Application
+- `repository/` / `dao/` / `store/` / `data/` → Data
+- `model/` / `entity/` / `domain/` → Domain
+
+## Severity Classification
+
+| Type | Severity | Auto-fixable |
+|------|----------|-------------|
+| Reverse dependency | Critical | Sometimes (move import) |
+| Circular dependency | Critical | Often (extract interface) |
+| API boundary leak | Warning | Yes (use internal type) |
+| Cross-module import | Warning | Context-dependent |
+| New unknown module | Info | No (may need new layer) |
+
+## Skill 协作
+
+| 协作 Skill | 触发条件 | 交互方式 |
+|-----------|---------|---------|
+| project-analyze | No knowledge-graph.json found | 建议运行 `/project-analyze` 生成图谱 |
+| code-review | Architecture dimension scoring | 提供层违反数据给 code-review |
+| verification-before-completion | Analyzed project, before claiming done | 作为额外检查步骤 |
+| {stack}-conventions | Stack-specific layer patterns | 加载栈级分层规范 |
+| software-architecture | Architecture score < 60 | 建议运行架构重构 |