feat(pov): Parzival 2.1 — Skill Architecture + Dispatch System

.claude/commands/pov/parzival-team.md

@@ -1,5 +1,5 @@
 ---
-description: 'Design agent team structure for parallel work execution via Claude Code teams'
+description: 'Design agent team structure for parallel work execution'
 argument-hint: '<description of the work to parallelize>'
 allowed-tools: Read, Grep, Glob, AskUserQuestion
 ---

.claude/hooks/scripts/agent_response_store_async.py

@@ -140,6 +140,18 @@ def store_agent_response(store_data: dict[str, Any]) -> bool:
                     "reason": "too_short_or_low_value",
                 },
             )
+            try:
+                from memory.metrics_push import push_capture_metrics_async
+
+                push_capture_metrics_async(
+                    hook_type="Stop",
+                    status="quality_gate_skip",
+                    project=detect_project(os.getcwd()) or "unknown",
+                    collection="skipped",
+                    count=1,
+                )
+            except ImportError:
+                pass
             return True
 
         # SPEC-021: Read trace_id from capture hook env propagation

.claude/hooks/scripts/best_practices_retrieval.py

@@ -657,7 +657,7 @@ def main() -> int:
                         parent_span_id=None,
                         session_id=bp_session_id,
                         project_id=project_name,
-                        tags=["search", "best_practices"],
+                        tags=["retrieval", "best_practices"],
                     )
                 except Exception:
                     pass

.claude/hooks/scripts/context_injection_tier2.py

@@ -401,6 +401,7 @@ def main() -> int:
             budget=budget,
             excluded_ids=state.injected_point_ids,
             score_gap_threshold=config.injection_score_gap_threshold,
+            project_id=project_name,
         )
 
         # WP-2: Push freshness-blocked counter if any results were blocked this turn
@@ -437,7 +438,7 @@ def main() -> int:
             return 0
 
         # Format output
-        formatted = format_injection_output(selected, tier=2)
+        formatted = format_injection_output(selected, tier=2, project_id=project_name)
 
         # Update session state
         state.injected_point_ids.extend(str(r.get("id", "")) for r in selected)

.claude/hooks/scripts/error_detection.py

@@ -540,7 +540,7 @@ def main() -> int:
                             trace_id=uuid4().hex,
                             session_id=_err_session_id,
                             project_id=project_name,
-                            tags=["injection", "error_detection"],
+                            tags=["capture", "error_detection"],
                         )
                 except Exception:
                     logger.debug("trace_event_failed_error_fix_injection")

.claude/hooks/scripts/langfuse_stop_hook.py

@@ -407,7 +407,11 @@ def main():
 
         # ── V3 SDK: Create root observation + child spans ──
         # LANGFUSE-INTEGRATION-SPEC.md §7.1: Uses start_as_current_observation (V3)
-        from langfuse import get_client as _get_v3_client, propagate_attributes
+        try:
+            from langfuse import get_client as _get_v3_client, propagate_attributes
+        except ImportError:
+            logger.warning("langfuse_not_installed", extra={"message": "langfuse package not available, skipping trace emission"})
+            sys.exit(0)
 
         langfuse_v3 = _get_v3_client()
 

.claude/hooks/scripts/post_tool_capture.py

@@ -540,9 +540,22 @@ def main() -> int:
                 )
 
             # Extract content based on tool type
+            # BUG-226: For Edit, read full file instead of just new_string
             content = ""
             if tool_name == "Edit":
-                content = tool_input.get("new_string", "")
+                # BUG-226: Read full file for richer context, fallback to new_string
+                _MAX_EDIT_READ = 200_000  # 200KB cap
+                if file_path:
+                    try:
+                        _fsize = Path(file_path).stat().st_size
+                        if _fsize <= _MAX_EDIT_READ:
+                            content = Path(file_path).read_text(encoding="utf-8", errors="replace")
+                        else:
+                            content = tool_input.get("new_string", "")
+                    except OSError:
+                        content = tool_input.get("new_string", "")
+                else:
+                    content = tool_input.get("new_string", "")
             elif tool_name == "Write":
                 content = tool_input.get("content", "")
             elif tool_name == "NotebookEdit":

.claude/hooks/scripts/session_start.py

@@ -577,7 +577,7 @@ def main():
                             parent_span_id=None,
                             session_id=session_id,
                             project_id=project_name,
-                            tags=["injection", "resume"],
+                            tags=["injection", "tier1", "bootstrap"],
                         )
                     except Exception:
                         pass
@@ -924,38 +924,6 @@ def main():
                             }
                         )
 
-                    # TD-228: Per-search trace for session summaries (compact path)
-                    if emit_trace_event:
-                        try:
-                            emit_trace_event(
-                                event_type="memory_retrieval_sessions",
-                                data={
-                                    "input": f"get_recent(discussions, type=session, agent_id={_compact_agent_id!r}, limit={_summary_limit}) for {project_name}",
-                                    "output": f"Retrieved {len(session_summaries)} session summaries",
-                                    "metadata": {
-                                        "trigger": trigger,
-                                        "collection": COLLECTION_DISCUSSIONS,
-                                        "query_type": "session",
-                                        "method": "get_recent",
-                                        "agent_id": _compact_agent_id,
-                                        "limit": _summary_limit,
-                                        "result_count": len(session_summaries),
-                                        "top_results": [
-                                            {
-                                                "type": s.get("type", "session"),
-                                                "content_preview": s.get("content", "")[:200],
-                                            }
-                                            for s in session_summaries[:5]
-                                        ],
-                                    },
-                                },
-                                session_id=session_id,
-                                project_id=project_name,
-                                tags=["injection", "compact"],
-                            )
-                        except Exception:
-                            pass
-
                     # Retrieve decisions (PLAN-015 §4.1 — non-Parzival gets max 3)
                     _decision_kwargs: dict = {
                         "collection": COLLECTION_DISCUSSIONS,
@@ -987,39 +955,6 @@ def main():
                         )
                         decisions = []
 
-                    # TD-228: Per-search trace for decisions (compact path)
-                    if emit_trace_event:
-                        try:
-                            emit_trace_event(
-                                event_type="memory_retrieval_decisions",
-                                data={
-                                    "input": f"get_recent(discussions, type=decision, agent_id={_compact_agent_id!r}, limit=3) for {project_name}",
-                                    "output": f"Retrieved {len(decisions)} decisions",
-                                    "metadata": {
-                                        "trigger": trigger,
-                                        "collection": COLLECTION_DISCUSSIONS,
-                                        "query_type": "decision",
-                                        "method": "get_recent",
-                                        "agent_id": _compact_agent_id,
-                                        "limit": 3,
-                                        "result_count": len(decisions),
-                                        "top_results": [
-                                            {
-                                                "type": d.get("type", "decision"),
-                                                "score": round(d.get("score", 0.0), 4),
-                                                "content_preview": d.get("content", "")[:200],
-                                            }
-                                            for d in decisions[:5]
-                                        ],
-                                    },
-                                },
-                                session_id=session_id,
-                                project_id=project_name,
-                                tags=["injection", "compact"],
-                            )
-                        except Exception:
-                            pass
-
                     _retrieval_ms = (time.perf_counter() - _retrieval_start) * 1000
 
                     # TD-228 compatible trace event
@@ -1114,41 +1049,6 @@ def main():
                 ) + conversation_context.count("**Agent")
                 summary_count = conversation_context.count("**Summary")
                 total_count = message_count + summary_count
-
-                # TD-228: Greedy-fill trace event for compact injection
-                if emit_trace_event:
-                    try:
-                        _gf_input_count = len(session_summaries) + len(other_memories)
-                        _gf_tokens_est = (len(conversation_context) + 2) // 3
-                        _gf_dropped = max(0, _gf_input_count - total_count)
-                        emit_trace_event(
-                            event_type="greedy_fill",
-                            data={
-                                "input": f"inject_with_priority: {_gf_input_count} candidates, budget={config.token_budget} tokens",
-                                "output": f"Selected {total_count} items ({summary_count} summaries, {message_count} messages), dropped {_gf_dropped}",
-                                "metadata": {
-                                    "trigger": trigger,
-                                    "input_count": _gf_input_count,
-                                    "selected_count": total_count,
-                                    "dropped_count": _gf_dropped,
-                                    "summary_count": summary_count,
-                                    "message_count": message_count,
-                                    "tokens_used_est": _gf_tokens_est,
-                                    "budget": config.token_budget,
-                                    "budget_used_pct": (
-                                        round(_gf_tokens_est / config.token_budget * 100, 1)
-                                        if config.token_budget > 0
-                                        else 0
-                                    ),
-                                },
-                            },
-                            session_id=session_id,
-                            project_id=project_name,
-                            tags=["injection", "compact"],
-                        )
-                    except Exception:
-                        pass
-
                 logger.info(
                     "conversation_context_injected",
                     extra={

.claude/hooks/scripts/store_async.py

@@ -205,7 +205,7 @@ async def store_memory_async(hook_input: dict[str, Any]) -> None:
                     trace_id=trace_id,
                     session_id=session_id,
                     project_id=group_id,
-                    tags=["capture", "store"],
+                    tags=["capture", "trigger"],
                 )
             except Exception:
                 pass
@@ -257,7 +257,7 @@ async def store_memory_async(hook_input: dict[str, Any]) -> None:
                             trace_id=trace_id,
                             session_id=session_id,
                             project_id=group_id,
-                            tags=["capture", "store"],
+                            tags=["capture", "trigger"],
                         )
                     except Exception:
                         pass
@@ -321,7 +321,7 @@ async def store_memory_async(hook_input: dict[str, Any]) -> None:
                     trace_id=trace_id,
                     session_id=session_id,
                     project_id=group_id,
-                    tags=["capture", "store"],
+                    tags=["capture", "trigger"],
                 )
             except Exception:
                 pass
@@ -356,7 +356,7 @@ async def store_memory_async(hook_input: dict[str, Any]) -> None:
                         trace_id=trace_id,
                         session_id=session_id,
                         project_id=group_id,
-                        tags=["capture", "store"],
+                        tags=["capture", "trigger"],
                     )
                 except Exception:
                     pass
@@ -378,7 +378,7 @@ async def store_memory_async(hook_input: dict[str, Any]) -> None:
                     from memory.security_scanner import ScanAction, SecurityScanner
 
                     scanner = SecurityScanner(enable_ner=False)
-                    scan_result = scanner.scan(patterns["content"])
+                    scan_result = scanner.scan(patterns["content"], source_type="user_session")
                     scan_actually_ran = True
                     # SPEC-021: Capture scan outcome for 4_scan span
                     scan_action = (
@@ -422,7 +422,7 @@ async def store_memory_async(hook_input: dict[str, Any]) -> None:
                                     trace_id=trace_id,
                                     session_id=session_id,
                                     project_id=group_id,
-                                    tags=["capture", "store"],
+                                    tags=["capture", "trigger"],
                                 )
                             except Exception:
                                 pass
@@ -446,7 +446,7 @@ async def store_memory_async(hook_input: dict[str, Any]) -> None:
                                     trace_id=trace_id,
                                     session_id=session_id,
                                     project_id=group_id,
-                                    tags=["capture", "store"],
+                                    tags=["capture", "trigger"],
                                 )
                             except Exception:
                                 pass
@@ -494,7 +494,7 @@ async def store_memory_async(hook_input: dict[str, Any]) -> None:
                     trace_id=trace_id,
                     session_id=session_id,
                     project_id=group_id,
-                    tags=["capture", "store"],
+                    tags=["capture", "trigger"],
                 )
             except Exception:
                 pass
@@ -544,7 +544,7 @@ async def store_memory_async(hook_input: dict[str, Any]) -> None:
                     trace_id=trace_id,
                     session_id=session_id,
                     project_id=group_id,
-                    tags=["capture", "store"],
+                    tags=["capture", "trigger"],
                 )
             except Exception:
                 pass
@@ -676,7 +676,7 @@ def _generate_embedding(content):
                     trace_id=trace_id,
                     session_id=session_id,
                     project_id=group_id,
-                    tags=["capture", "store"],
+                    tags=["capture", "trigger"],
                 )
             except Exception:
                 pass
@@ -706,7 +706,7 @@ def _generate_embedding(content):
                     trace_id=trace_id,
                     session_id=session_id,
                     project_id=group_id,
-                    tags=["capture", "store"],
+                    tags=["capture", "trigger"],
                 )
             except Exception:
                 pass
@@ -776,7 +776,7 @@ def _generate_embedding(content):
                     trace_id=trace_id,
                     session_id=session_id,
                     project_id=group_id,
-                    tags=["capture", "store"],
+                    tags=["capture", "trigger"],
                 )
             except Exception:
                 pass

.claude/hooks/scripts/user_prompt_store_async.py

@@ -144,6 +144,18 @@ def store_user_message(hook_input: dict[str, Any]) -> bool:
                     "reason": "too_short_or_low_value",
                 },
             )
+            try:
+                from memory.metrics_push import push_capture_metrics_async
+
+                push_capture_metrics_async(
+                    hook_type="UserPromptSubmit",
+                    status="quality_gate_skip",
+                    project=detect_project(os.getcwd()) or "unknown",
+                    collection="skipped",
+                    count=1,
+                )
+            except ImportError:
+                pass
             return True
 
         # Detect project name