Add context-aware specialist injection across all team pipelines

Replace keyword-based specialist injection with signal-driven triggering
based on actual codebase characteristics detected by workers. Workers emit
tech_profile signals in state_update; coordinator evaluates against trigger
matrix to inject P0/P1 specialists dynamically.

Author: catlog22

.claude/agents/team-worker.md

@@ -124,6 +124,10 @@ After claiming a task, check if output artifacts already exist (indicates resume
 
 The role_spec contains Phase 2, Phase 3, and Phase 4 sections with domain-specific logic. Follow those instructions exactly. Key integration points with built-in infrastructure:
 
+### Context-Aware Signal Emission (Optional)
+
+During Phase 2-4, if you detect codebase signals (SQL usage, auth modules, ML imports, performance-sensitive code, etc.), include `tech_profile` in your Phase 5 state_update. Full signal catalog and schema: `skills_lib/specs/context-aware-trigger.md`. This enables the coordinator to evaluate specialist injection for the pipeline.
+
 ## CRITICAL LIMITATION: No Agent Delegation
 
 **Team workers CANNOT call the Agent() tool to spawn other agents.**
@@ -293,7 +297,8 @@ After Phase 4 completes, determine Phase 5 variant (see Execution Flow for decis
        decisions: <from Phase 4>,
        files_modified: <from Phase 4>,
        artifact_path: "<artifact-path>",
-       verification: "<verification_method>"
+       verification: "<verification_method>",
+       tech_profile: <optional, from Phase 3/4 if signals detected>
      }
    )
    ```

.claude/skills/team-arch-opt/roles/analyzer/role.md

@@ -60,6 +60,14 @@ Execute analysis based on detected project type:
 - Rank top 3-7 architecture issues by severity (Critical / High / Medium)
 - Record evidence: file paths, line numbers, measured values
 
+### Tech Profile Scan
+
+After analysis, scan findings for context-aware trigger signals (based on detected codebase characteristics):
+
+1. Check dependency analysis → signals (`sql_detected`, `auth_detected`, `ml_detected`)
+2. Check structural analysis → risk signals (`perf_sensitive`, `legacy_patterns`, `scaling_concern`)
+3. Include `tech_profile` in Phase 5 state_update data
+
 ## Phase 4: Report Generation
 
 1. Write architecture baseline to `<session>/artifacts/architecture-baseline.json`:

.claude/skills/team-coordinate/SKILL.md

@@ -61,6 +61,9 @@ Only coordinator is statically registered. All other roles are dynamic, stored a
 | coordinator | [roles/coordinator/role.md](roles/coordinator/role.md) | built-in orchestrator |
 | (dynamic) | `<session>/role-specs/<role-name>.md` | runtime-generated role-spec |
 
+**Tech Profile Scan**: When generating role-specs for analysis/exploration roles (responsibility_type includes "analysis", "exploration", or "research"), append to Phase 3:
+> After exploration, include `tech_profile` in state_update with detected signals (e.g., `sql_detected`, `auth_detected`, `perf_sensitive`) and evidence file paths. This enables coordinator to evaluate specialist injection needs.
+
 ### CLI Tool Usage
 
 Workers can use CLI tools for analysis and code operations:

.claude/skills/team-coordinate/specs/role-spec-template.md

@@ -159,6 +159,9 @@ Coordinator MAY reference these patterns when composing Phase 2-4 content for a
 - Phase 3: Multi-dimension analysis — perspectives and depth determined by task
 - Phase 4: Verify report exists + severity classification (Behavioral Traits) + update shared state
 
+**Tech Profile Scan**: When generating role-specs for analysis/exploration roles (responsibility_type includes "analysis", "exploration", or "research"), append to Phase 3:
+> After exploration, include `tech_profile` in state_update with detected signals (e.g., `sql_detected`, `auth_detected`, `perf_sensitive`) and evidence file paths. This enables coordinator to evaluate specialist injection needs.
+
 ### Validation / Testing
 
 - Phase 2: Detect test framework + identify changed files from upstream

.claude/skills/team-frontend-debug/roles/reproducer/role.md

@@ -120,6 +120,14 @@ Write `<session>/evidence/evidence-summary.json`:
 }
 ```
 
+### Tech Profile Scan
+
+After reproduction, note any frontend-specific codebase characteristics:
+
+1. Check reproduction findings → signals (`frontend_framework`, `perf_sensitive`, `realtime_detected`)
+2. Check code patterns → signals (`legacy_patterns`, `test_gap`)
+3. Include `tech_profile` in Phase 5 state_update data
+
 ## Phase 4: Report
 
 1. Write evidence summary to session evidence/

.claude/skills/team-frontend/roles/analyst/role.md

@@ -80,6 +80,14 @@ Retrieve design intelligence via ui-ux-pro-max skill integration.
 - `<session>/analysis/design-intelligence.json`
 - `<session>/analysis/requirements.md`
 
+### Tech Profile Scan
+
+After analysis, scan findings for context-aware trigger signals (based on detected codebase characteristics):
+
+1. Check detected_stack and dependencies → framework signals (`frontend_framework`, `api_surface`)
+2. Check codebase patterns → risk signals (`perf_sensitive`, `test_gap`, `legacy_patterns`)
+3. Include `tech_profile` in Phase 5 state_update data
+
 ## Phase 4: Self-Review
 
 | Check | Method | Pass Criteria |

.claude/skills/team-issue/roles/explorer/role.md

@@ -85,6 +85,14 @@ CONSTRAINTS: Focus on issue context | Write output to <session>/explorations/con
 }
 ```
 
+### Tech Profile Scan
+
+After exploration, scan findings for context-aware trigger signals (based on detected codebase characteristics):
+
+1. Check relevant_files and dependencies → signals (`sql_detected`, `auth_detected`, `api_surface`)
+2. Check code patterns in explored files → risk signals (`injection_risk`, `eval_usage`, `perf_sensitive`)
+3. Include `tech_profile` in Phase 5 state_update data
+
 ## Phase 4: Context Report & Wisdom Contribution
 
 1. Write context report to `<session>/explorations/context-<issueId>.json`

.claude/skills/team-lifecycle-v4/roles/analyst/role.md

@@ -59,6 +59,22 @@ CONTEXT: @**/*
 EXPECTED: JSON with: tech_stack[], architecture_patterns[], conventions[], integration_points[]" --tool gemini --mode analysis`, run_in_background: false })
 ```
 
+### Tech Profile Scan
+
+After codebase exploration, scan results for context-aware trigger signals (based on detected codebase characteristics):
+
+1. Check imports/dependencies → framework signals (`sql_detected`, `auth_detected`, `ml_detected`, `frontend_framework`)
+2. Check file patterns → infrastructure signals (`devops_detected`, `data_migration`, `realtime_detected`)
+3. Check code patterns → risk signals (`perf_sensitive`, `crypto_usage`, `legacy_patterns`, `test_gap`)
+4. Include `tech_profile` in Phase 5 state_update data:
+   ```json
+   "tech_profile": {
+     "signals": ["<detected signals>"],
+     "evidence": { "<signal>": ["<file paths>"] },
+     "confidence": "high|medium|low"
+   }
+   ```
+
 ## Phase 4: Context Packaging
 
 1. Write spec-config.json → <session>/spec/

.claude/skills/team-lifecycle-v4/roles/coordinator/commands/monitor.md

@@ -31,6 +31,15 @@ Worker completed. Process and advance.
 4. Completion -> mark task done
    - Resident agent (supervisor) -> keep in active_workers (stays alive for future checkpoints)
    - Standard worker -> remove from active_workers
+4.5. **evaluateSpecialistInjection** (based on detected codebase characteristics):
+   - If callback from analyst, planner, or executor role:
+     a. `get_state(role=<callback_role>)` → extract `tech_profile.signals`
+     b. Merge with previously collected signals from other roles
+     c. Evaluate against trigger matrix (§4)
+     d. P0 matches → TaskCreate with blockedBy on current stage, blocks downstream
+     e. P1 matches → TaskCreate parallel with REVIEW/TEST stage
+     f. Log: `team_msg(type="specialist_injection", data={ specialist, signals, priority, evidence })`
+     g. Dedup: skip if same specialist already injected this session
 5. Check for checkpoints:
    - CHECKPOINT-* with verdict "block" -> AskUserQuestion: Override / Revise upstream / Abort
    - CHECKPOINT-* with verdict "warn" -> log risks to wisdom, proceed normally

.claude/skills/team-lifecycle-v4/roles/planner/role.md

@@ -41,6 +41,15 @@ Codebase-informed implementation planning with complexity assessment.
    ```
 4. Store results in <session>/explorations/
 
+### Secondary Signal Scan
+
+After exploration, supplement upstream tech_profile with planning-phase signals (based on detected codebase characteristics):
+
+1. Check plan complexity → `scaling_concern` if O(n^2)+ patterns found
+2. Check scope → `breaking_change` if public API modifications planned
+3. Check data → `data_migration` if schema changes identified
+4. Include `tech_profile` in Phase 5 state_update (merge with any upstream signals)
+
 ## Phase 3: Plan Generation
 
 Generate plan.json + .task/TASK-*.json: