crucible-mcp 1.0.1__py3-none-any.whl → 1.2.0__py3-none-any.whl

crucible/knowledge/loader.py

@@ -247,14 +247,17 @@ def get_custom_knowledge_files() -> set[str]:
 
 
 def load_all_knowledge(
-    include_bundled: bool = False,
+    include_bundled: bool = True,
     filenames: set[str] | None = None,
 ) -> tuple[list[str], str]:
     """Load multiple knowledge files.
 
+    Knowledge follows cascade priority: project > user > bundled.
+    Project/user files override bundled files with the same name.
+
     Args:
-        include_bundled: If True, include bundled knowledge files
-        filenames: Specific files to load (if None, loads based on include_bundled)
+        include_bundled: If True, include bundled knowledge files (default: True)
+        filenames: Specific files to load (if None, loads all from cascade)
 
     Returns:
         Tuple of (list of loaded filenames, combined content)

crucible/models.py

@@ -61,16 +61,3 @@ DOMAIN_HEURISTICS: dict[Domain, dict[str, list[str]]] = {
 }
 
 
-@dataclass(frozen=True)
-class FullReviewResult:
-    """Result from full_review tool."""
-
-    domains_detected: tuple[str, ...]
-    severity_summary: dict[str, int]
-    findings: tuple[ToolFinding, ...]
-    applicable_skills: tuple[str, ...]
-    skill_triggers_matched: dict[str, tuple[str, ...]]
-    principles_loaded: tuple[str, ...]
-    principles_content: str
-    sage_knowledge: str | None = None
-    sage_query_used: str | None = None

crucible/server.py

@@ -7,12 +7,12 @@ from mcp.server import Server
 from mcp.server.stdio import stdio_server
 from mcp.types import TextContent, Tool
 
+from crucible.enforcement.assertions import load_assertions
 from crucible.knowledge.loader import (
-    get_custom_knowledge_files,
     load_all_knowledge,
     load_principles,
 )
-from crucible.models import Domain, FullReviewResult, Severity, ToolFinding
+from crucible.models import Domain, Severity, ToolFinding
 from crucible.review.core import (
     compute_severity_counts,
     deduplicate_findings,
@@ -22,14 +22,12 @@ from crucible.review.core import (
     run_enforcement,
     run_static_analysis,
 )
-from crucible.skills import get_knowledge_for_skills, load_skill, match_skills_for_domain
 from crucible.tools.delegation import (
     check_all_tools,
     delegate_bandit,
     delegate_ruff,
     delegate_semgrep,
     delegate_slither,
-    get_semgrep_config,
 )
 from crucible.tools.git import (
     GitContext,
@@ -134,76 +132,6 @@ async def list_tools() -> list[Tool]:
                 },
             },
         ),
-        Tool(
-            name="quick_review",
-            description="[DEPRECATED: use review(path, include_skills=false)] Run static analysis only.",
-            inputSchema={
-                "type": "object",
-                "properties": {
-                    "path": {
-                        "type": "string",
-                        "description": "File or directory path to scan",
-                    },
-                    "tools": {
-                        "type": "array",
-                        "items": {"type": "string"},
-                        "description": "Tools to run (semgrep, ruff, slither, bandit). Default: auto-detect based on file type",
-                    },
-                },
-                "required": ["path"],
-            },
-        ),
-        Tool(
-            name="full_review",
-            description="[DEPRECATED: use review(path)] Comprehensive code review with skills and knowledge.",
-            inputSchema={
-                "type": "object",
-                "properties": {
-                    "path": {
-                        "type": "string",
-                        "description": "File or directory path to review",
-                    },
-                    "skills": {
-                        "type": "array",
-                        "items": {"type": "string"},
-                        "description": "Override skill selection (default: auto-detect based on domain)",
-                    },
-                    "include_sage": {
-                        "type": "boolean",
-                        "description": "Include Sage knowledge recall (not yet implemented)",
-                        "default": True,
-                    },
-                },
-                "required": ["path"],
-            },
-        ),
-        Tool(
-            name="review_changes",
-            description="[DEPRECATED: use review(mode='staged')] Review git changes.",
-            inputSchema={
-                "type": "object",
-                "properties": {
-                    "mode": {
-                        "type": "string",
-                        "enum": ["staged", "unstaged", "branch", "commits"],
-                        "description": "What changes to review",
-                    },
-                    "base": {
-                        "type": "string",
-                        "description": "Base branch for 'branch' mode or commit count for 'commits' mode",
-                    },
-                    "path": {
-                        "type": "string",
-                        "description": "Repository path (default: current directory)",
-                    },
-                    "include_context": {
-                        "type": "boolean",
-                        "description": "Include findings near changes (default: false)",
-                    },
-                },
-                "required": ["mode"],
-            },
-        ),
         Tool(
             name="get_principles",
             description="Load engineering principles by topic",
@@ -293,19 +221,19 @@ async def list_tools() -> list[Tool]:
         ),
         Tool(
             name="load_knowledge",
-            description="Load knowledge/principles files without running static analysis. Useful for getting guidance on patterns, best practices, or domain-specific knowledge. Automatically includes project and user knowledge files.",
+            description="Load knowledge/principles files without running static analysis. Useful for getting guidance on patterns, best practices, or domain-specific knowledge. Loads all 14 bundled knowledge files by default, with project/user files overriding bundled ones.",
             inputSchema={
                 "type": "object",
                 "properties": {
                     "files": {
                         "type": "array",
                         "items": {"type": "string"},
-                        "description": "Specific knowledge files to load (e.g., ['SECURITY.md', 'SMART_CONTRACT.md']). If not specified, loads all project/user knowledge files.",
+                        "description": "Specific knowledge files to load (e.g., ['SECURITY.md', 'SMART_CONTRACT.md']). If not specified, loads all available knowledge files.",
                     },
                     "include_bundled": {
                         "type": "boolean",
-                        "description": "Include bundled knowledge files in addition to project/user files (default: false)",
-                        "default": False,
+                        "description": "Include bundled knowledge files (default: true). Project/user files override bundled ones with same name.",
+                        "default": True,
                     },
                     "topic": {
                         "type": "string",
@@ -314,6 +242,20 @@ async def list_tools() -> list[Tool]:
                 },
             },
         ),
+        Tool(
+            name="get_assertions",
+            description="Load active enforcement assertions for this project. Call at session start to understand what code patterns are enforced. Returns all pattern and LLM assertions that will be checked during reviews.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "include_compliance": {
+                        "type": "boolean",
+                        "description": "Include LLM compliance assertion details (default: true)",
+                        "default": True,
+                    },
+                },
+            },
+        ),
     ]
 
 
@@ -683,7 +625,7 @@ def _handle_get_principles(arguments: dict[str, Any]) -> list[TextContent]:
 def _handle_load_knowledge(arguments: dict[str, Any]) -> list[TextContent]:
     """Handle load_knowledge tool."""
     files = arguments.get("files")
-    include_bundled = arguments.get("include_bundled", False)
+    include_bundled = arguments.get("include_bundled", True)
     topic = arguments.get("topic")
 
     # If topic specified, use load_principles
@@ -715,6 +657,61 @@ def _handle_load_knowledge(arguments: dict[str, Any]) -> list[TextContent]:
     return [TextContent(type="text", text="\n".join(output_parts))]
 
 
+def _handle_get_assertions(arguments: dict[str, Any]) -> list[TextContent]:
+    """Handle get_assertions tool - load active enforcement rules."""
+    include_compliance = arguments.get("include_compliance", True)
+
+    assertions, load_errors = load_assertions()
+
+    if not assertions and not load_errors:
+        return [TextContent(type="text", text="No assertions found. Add assertion files to .crucible/assertions/ or use bundled assertions.")]
+
+    parts: list[str] = ["# Active Enforcement Assertions\n"]
+    parts.append("These patterns are enforced during code review. Avoid these in your code.\n")
+
+    if load_errors:
+        parts.append("## Load Errors\n")
+        for error in load_errors:
+            parts.append(f"- {error}")
+        parts.append("")
+
+    # Group by source file / category
+    pattern_assertions = [a for a in assertions if a.type.value == "pattern"]
+    llm_assertions = [a for a in assertions if a.type.value == "llm"]
+
+    if pattern_assertions:
+        parts.append("## Pattern Assertions (fast, always run)\n")
+        parts.append("| ID | Message | Severity | Languages |")
+        parts.append("|---|---|---|---|")
+        for a in pattern_assertions:
+            langs = ", ".join(a.languages) if a.languages else "all"
+            parts.append(f"| `{a.id}` | {a.message} | {a.severity} | {langs} |")
+        parts.append("")
+
+    if llm_assertions and include_compliance:
+        parts.append("## LLM Compliance Assertions (semantic, budget-controlled)\n")
+        parts.append("| ID | Message | Severity | Model |")
+        parts.append("|---|---|---|---|")
+        for a in llm_assertions:
+            model = a.model or "sonnet"
+            parts.append(f"| `{a.id}` | {a.message} | {a.severity} | {model} |")
+        parts.append("")
+
+        # Show compliance requirements for LLM assertions
+        parts.append("### Compliance Requirements\n")
+        for a in llm_assertions:
+            parts.append(f"**{a.id}:**")
+            if a.compliance:
+                parts.append(f"```\n{a.compliance.strip()}\n```")
+            parts.append("")
+
+    # Summary
+    parts.append("---\n")
+    parts.append(f"**Total:** {len(pattern_assertions)} pattern + {len(llm_assertions)} LLM assertions")
+
+    return [TextContent(type="text", text="\n".join(parts))]
+
+
 def _handle_delegate_semgrep(arguments: dict[str, Any]) -> list[TextContent]:
     """Handle delegate_semgrep tool."""
     path = arguments.get("path", "")
@@ -786,464 +783,17 @@ def _handle_check_tools(arguments: dict[str, Any]) -> list[TextContent]:
     return [TextContent(type="text", text="\n".join(parts))]
 
 
-def _handle_quick_review(arguments: dict[str, Any]) -> list[TextContent]:
-    """Handle quick_review tool - returns findings with domain metadata."""
-    path = arguments.get("path", "")
-    tools = arguments.get("tools")
-
-    # Internal domain detection
-    domain, domain_tags = detect_domain(path)
-
-    # Select tools based on domain
-    if domain == Domain.SMART_CONTRACT:
-        default_tools = ["slither", "semgrep"]
-    elif domain == Domain.BACKEND and "python" in domain_tags:
-        default_tools = ["ruff", "bandit", "semgrep"]
-    elif domain == Domain.FRONTEND:
-        default_tools = ["semgrep"]
-    else:
-        default_tools = ["semgrep"]
-
-    if not tools:
-        tools = default_tools
-
-    # Collect all findings
-    all_findings: list[ToolFinding] = []
-    tool_results: list[str] = []
-
-    if "semgrep" in tools:
-        config = get_semgrep_config(domain)
-        result = delegate_semgrep(path, config)
-        if result.is_ok:
-            all_findings.extend(result.value)
-            tool_results.append(f"## Semgrep\n{_format_findings(result.value)}")
-        else:
-            tool_results.append(f"## Semgrep\nError: {result.error}")
-
-    if "ruff" in tools:
-        result = delegate_ruff(path)
-        if result.is_ok:
-            all_findings.extend(result.value)
-            tool_results.append(f"## Ruff\n{_format_findings(result.value)}")
-        else:
-            tool_results.append(f"## Ruff\nError: {result.error}")
-
-    if "slither" in tools:
-        result = delegate_slither(path)
-        if result.is_ok:
-            all_findings.extend(result.value)
-            tool_results.append(f"## Slither\n{_format_findings(result.value)}")
-        else:
-            tool_results.append(f"## Slither\nError: {result.error}")
-
-    if "bandit" in tools:
-        result = delegate_bandit(path)
-        if result.is_ok:
-            all_findings.extend(result.value)
-            tool_results.append(f"## Bandit\n{_format_findings(result.value)}")
-        else:
-            tool_results.append(f"## Bandit\nError: {result.error}")
-
-    # Deduplicate findings
-    all_findings = deduplicate_findings(all_findings)
-
-    # Compute severity summary
-    severity_counts: dict[str, int] = {}
-    for f in all_findings:
-        sev = f.severity.value
-        severity_counts[sev] = severity_counts.get(sev, 0) + 1
-
-    # Build structured output
-    output_parts = [
-        "# Review Results\n",
-        f"**Domains detected:** {', '.join(domain_tags)}",
-        f"**Severity summary:** {severity_counts or 'No findings'}\n",
-        "\n".join(tool_results),
-    ]
-
-    return [TextContent(type="text", text="\n".join(output_parts))]
-
-
-def _format_change_review(
-    context: GitContext,
-    findings: list[ToolFinding],
-    severity_counts: dict[str, int],
-    tool_errors: list[str] | None = None,
-    matched_skills: list[tuple[str, list[str]]] | None = None,
-    skill_content: dict[str, str] | None = None,
-    knowledge_files: set[str] | None = None,
-    knowledge_content: dict[str, str] | None = None,
-) -> str:
-    """Format change review output."""
-    parts: list[str] = ["# Change Review\n"]
-    parts.append(f"**Mode:** {context.mode}")
-    if context.base_ref:
-        parts.append(f"**Base:** {context.base_ref}")
-    parts.append("")
-
-    # Files changed
-    added = [c for c in context.changes if c.status == "A"]
-    modified = [c for c in context.changes if c.status == "M"]
-    deleted = [c for c in context.changes if c.status == "D"]
-    renamed = [c for c in context.changes if c.status == "R"]
-
-    total = len(context.changes)
-    parts.append(f"## Files Changed ({total})")
-    for c in added:
-        parts.append(f"- `+` {c.path}")
-    for c in modified:
-        parts.append(f"- `~` {c.path}")
-    for c in renamed:
-        parts.append(f"- `R` {c.old_path} -> {c.path}")
-    for c in deleted:
-        parts.append(f"- `-` {c.path}")
-    parts.append("")
-
-    # Commit messages (if available)
-    if context.commit_messages:
-        parts.append("## Commits")
-        for msg in context.commit_messages:
-            parts.append(f"- {msg}")
-        parts.append("")
-
-    # Applicable skills
-    if matched_skills:
-        parts.append("## Applicable Skills\n")
-        for skill_name, triggers in matched_skills:
-            parts.append(f"- **{skill_name}**: matched on {', '.join(triggers)}")
-        parts.append("")
-
-    # Knowledge loaded
-    if knowledge_files:
-        parts.append("## Knowledge Loaded\n")
-        parts.append(f"Files: {', '.join(sorted(knowledge_files))}")
-        parts.append("")
-
-    # Tool errors (if any)
-    if tool_errors:
-        parts.append("## Tool Errors\n")
-        for error in tool_errors:
-            parts.append(f"- {error}")
-        parts.append("")
-
-    # Findings
-    if findings:
-        parts.append("## Findings in Changed Code\n")
-        parts.append(f"**Summary:** {severity_counts}\n")
-        parts.append(_format_findings(findings))
-    else:
-        parts.append("## Findings in Changed Code\n")
-        parts.append("No issues found in changed code.")
-    parts.append("")
-
-    # Review checklists from skills
-    if skill_content:
-        parts.append("---\n")
-        parts.append("## Review Checklists\n")
-        for skill_name, content in skill_content.items():
-            parts.append(f"### {skill_name}\n")
-            parts.append(content)
-            parts.append("")
-
-    # Knowledge reference
-    if knowledge_content:
-        parts.append("---\n")
-        parts.append("## Principles Reference\n")
-        for filename, content in sorted(knowledge_content.items()):
-            parts.append(f"### {filename}\n")
-            parts.append(content)
-            parts.append("")
-
-    return "\n".join(parts)
-
-
-def _handle_review_changes(arguments: dict[str, Any]) -> list[TextContent]:
-    """Handle review_changes tool - review git changes."""
-    import os
-
-    mode = arguments.get("mode", "staged")
-    base = arguments.get("base")
-    path = arguments.get("path", os.getcwd())
-    include_context = arguments.get("include_context", False)
-
-    # Get repo root
-    root_result = get_repo_root(path)
-    if root_result.is_err:
-        return [TextContent(type="text", text=f"Error: {root_result.error}")]
-
-    repo_path = root_result.value
-
-    # Get git context based on mode
-    if mode == "staged":
-        context_result = get_staged_changes(repo_path)
-    elif mode == "unstaged":
-        context_result = get_unstaged_changes(repo_path)
-    elif mode == "branch":
-        base_branch = base if base else "main"
-        context_result = get_branch_diff(repo_path, base_branch)
-    elif mode == "commits":
-        try:
-            count = int(base) if base else 1
-        except ValueError:
-            return [TextContent(type="text", text=f"Error: Invalid commit count '{base}'")]
-        context_result = get_recent_commits(repo_path, count)
-    else:
-        return [TextContent(type="text", text=f"Error: Unknown mode '{mode}'")]
-
-    if context_result.is_err:
-        return [TextContent(type="text", text=f"Error: {context_result.error}")]
-
-    context = context_result.value
-
-    # Check if there are any changes
-    if not context.changes:
-        if mode == "staged":
-            return [TextContent(type="text", text="No changes to review. Stage files with `git add` first.")]
-        elif mode == "unstaged":
-            return [TextContent(type="text", text="No unstaged changes to review.")]
-        else:
-            return [TextContent(type="text", text="No changes found.")]
-
-    # Get changed files (excluding deleted)
-    changed_files = get_changed_files(context)
-    if not changed_files:
-        return [TextContent(type="text", text="No files to analyze (only deletions).")]
-
-    # Run analysis on changed files
-    all_findings: list[ToolFinding] = []
-    tool_errors: list[str] = []
-    domains_detected: set[Domain] = set()
-    all_domain_tags: set[str] = set()
-
-    for file_path in changed_files:
-        full_path = f"{repo_path}/{file_path}"
-
-        # Detect domain for this file
-        domain, domain_tags = detect_domain(file_path)
-        domains_detected.add(domain)
-        all_domain_tags.update(domain_tags)
-
-        # Select tools based on domain
-        if domain == Domain.SMART_CONTRACT:
-            tools = ["slither", "semgrep"]
-        elif domain == Domain.BACKEND and "python" in domain_tags:
-            tools = ["ruff", "bandit", "semgrep"]
-        elif domain == Domain.FRONTEND:
-            tools = ["semgrep"]
-        else:
-            tools = ["semgrep"]
-
-        # Run tools
-        if "semgrep" in tools:
-            config = get_semgrep_config(domain)
-            result = delegate_semgrep(full_path, config)
-            if result.is_ok:
-                all_findings.extend(result.value)
-            elif result.is_err:
-                tool_errors.append(f"semgrep ({file_path}): {result.error}")
-
-        if "ruff" in tools:
-            result = delegate_ruff(full_path)
-            if result.is_ok:
-                all_findings.extend(result.value)
-            elif result.is_err:
-                tool_errors.append(f"ruff ({file_path}): {result.error}")
-
-        if "slither" in tools:
-            result = delegate_slither(full_path)
-            if result.is_ok:
-                all_findings.extend(result.value)
-            elif result.is_err:
-                tool_errors.append(f"slither ({file_path}): {result.error}")
-
-        if "bandit" in tools:
-            result = delegate_bandit(full_path)
-            if result.is_ok:
-                all_findings.extend(result.value)
-            elif result.is_err:
-                tool_errors.append(f"bandit ({file_path}): {result.error}")
-
-    # Filter findings to changed lines
-    filtered_findings = filter_findings_to_changes(all_findings, context, include_context)
-
-    # Deduplicate findings
-    filtered_findings = deduplicate_findings(filtered_findings)
-
-    # Compute severity summary
-    severity_counts: dict[str, int] = {}
-    for f in filtered_findings:
-        sev = f.severity.value
-        severity_counts[sev] = severity_counts.get(sev, 0) + 1
-
-    # Match skills and load knowledge based on detected domains
-    from crucible.knowledge.loader import load_knowledge_file
-    from crucible.skills.loader import (
-        get_knowledge_for_skills,
-        load_skill,
-        match_skills_for_domain,
-    )
-
-    primary_domain = next(iter(domains_detected)) if domains_detected else Domain.UNKNOWN
-    matched_skills = match_skills_for_domain(
-        primary_domain, list(all_domain_tags), override=None
-    )
-
-    skill_names = [name for name, _ in matched_skills]
-    skill_content: dict[str, str] = {}
-    for skill_name, _triggers in matched_skills:
-        result = load_skill(skill_name)
-        if result.is_ok:
-            _, content = result.value
-            skill_content[skill_name] = content
-
-    knowledge_files = get_knowledge_for_skills(skill_names)
-    knowledge_content: dict[str, str] = {}
-    for filename in knowledge_files:
-        result = load_knowledge_file(filename)
-        if result.is_ok:
-            knowledge_content[filename] = result.value
-
-    # Format output
-    output = _format_change_review(
-        context,
-        filtered_findings,
-        severity_counts,
-        tool_errors,
-        matched_skills,
-        skill_content,
-        knowledge_files,
-        knowledge_content,
-    )
-    return [TextContent(type="text", text=output)]
-
-
-def _handle_full_review(arguments: dict[str, Any]) -> list[TextContent]:
-    """Handle full_review tool - comprehensive code review.
-
-    DEPRECATED: Use _handle_review with path parameter instead.
-    """
-    from crucible.review.core import run_static_analysis
-
-    path = arguments.get("path", "")
-    skills_override = arguments.get("skills")
-
-    # 1. Detect domain
-    domain, domain_tags = detect_domain(path)
-
-    # 2. Run static analysis using shared core function
-    all_findings, tool_errors = run_static_analysis(path, domain, domain_tags)
-
-    # 3. Match applicable skills
-    matched_skills = match_skills_for_domain(domain, domain_tags, skills_override)
-    skill_names = [name for name, _ in matched_skills]
-    skill_triggers: dict[str, tuple[str, ...]] = {
-        name: tuple(triggers) for name, triggers in matched_skills
-    }
-
-    # 4. Load skill content (checklists/prompts)
-    skill_contents: dict[str, str] = {}
-    for skill_name in skill_names:
-        result = load_skill(skill_name)
-        if result.is_ok:
-            _, content = result.value
-            # Extract content after frontmatter
-            if "\n---\n" in content:
-                skill_contents[skill_name] = content.split("\n---\n", 1)[1].strip()
-            else:
-                skill_contents[skill_name] = content
-
-    # 5. Collect knowledge files from matched skills + custom project/user knowledge
-    skill_knowledge = get_knowledge_for_skills(skill_names)
-    custom_knowledge = get_custom_knowledge_files()
-    # Merge: custom knowledge always included, plus skill-referenced files
-    knowledge_files = skill_knowledge | custom_knowledge
-
-    # 6. Load knowledge content
-    loaded_files, principles_content = load_all_knowledge(
-        include_bundled=False,
-        filenames=knowledge_files,
-    )
-
-    # 7. Deduplicate findings
-    all_findings = deduplicate_findings(all_findings)
-
-    # 8. Compute severity summary
-    severity_counts = compute_severity_counts(all_findings)
-
-    # 8. Build result
-    review_result = FullReviewResult(
-        domains_detected=tuple(domain_tags),
-        severity_summary=severity_counts,
-        findings=tuple(all_findings),
-        applicable_skills=tuple(skill_names),
-        skill_triggers_matched=skill_triggers,
-        principles_loaded=tuple(loaded_files),
-        principles_content=principles_content,
-        sage_knowledge=None,  # Not implemented yet
-        sage_query_used=None,  # Not implemented yet
-    )
-
-    # 8. Format output
-    output_parts = [
-        "# Full Review Results\n",
-        f"**Path:** `{path}`",
-        f"**Domains detected:** {', '.join(review_result.domains_detected)}",
-        f"**Severity summary:** {review_result.severity_summary or 'No findings'}\n",
-    ]
-
-    if tool_errors:
-        output_parts.append("## Tool Errors\n")
-        for error in tool_errors:
-            output_parts.append(f"- {error}")
-        output_parts.append("")
-
-    output_parts.append("## Applicable Skills\n")
-    if review_result.applicable_skills:
-        for skill in review_result.applicable_skills:
-            triggers = review_result.skill_triggers_matched.get(skill, ())
-            output_parts.append(f"- **{skill}**: matched on {', '.join(triggers)}")
-    else:
-        output_parts.append("- No skills matched")
-    output_parts.append("")
-
-    # Include skill checklists
-    if skill_contents:
-        output_parts.append("## Review Checklists\n")
-        for skill_name, content in skill_contents.items():
-            output_parts.append(f"### {skill_name}\n")
-            output_parts.append(content)
-            output_parts.append("")
-
-    output_parts.append("## Knowledge Loaded\n")
-    if review_result.principles_loaded:
-        output_parts.append(f"Files: {', '.join(review_result.principles_loaded)}\n")
-    else:
-        output_parts.append("No knowledge files loaded.\n")
-
-    output_parts.append("## Static Analysis Findings\n")
-    output_parts.append(_format_findings(list(review_result.findings)))
-
-    if review_result.principles_content:
-        output_parts.append("\n---\n")
-        output_parts.append("## Principles Reference\n")
-        output_parts.append(review_result.principles_content)
-
-    return [TextContent(type="text", text="\n".join(output_parts))]
-
-
 @server.call_tool()  # type: ignore[misc]
 async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
     """Handle tool calls."""
     handlers = {
         # Unified review tool
         "review": _handle_review,
-        # Deprecated tools (kept for backwards compatibility)
-        "quick_review": _handle_quick_review,
-        "full_review": _handle_full_review,
-        "review_changes": _handle_review_changes,
-        # Other tools
+        # Context injection tools (call at session start)
+        "get_assertions": _handle_get_assertions,
         "get_principles": _handle_get_principles,
         "load_knowledge": _handle_load_knowledge,
+        # Direct tool access
         "delegate_semgrep": _handle_delegate_semgrep,
         "delegate_ruff": _handle_delegate_ruff,
         "delegate_slither": _handle_delegate_slither,

{crucible_mcp-1.0.1.dist-info → crucible_mcp-1.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crucible-mcp
-Version: 1.0.1
+Version: 1.2.0
 Summary: Code review MCP server for Claude. Not affiliated with Atlassian.
 Author: be.nvy
 License-Expression: MIT
@@ -58,6 +58,20 @@ That's it. Crucible will now:
 2. Review files Claude edits (Claude Code hook)
 3. Block code that violates bundled assertions (security, error handling, smart contracts)
 
+## CLAUDE.md Setup
+
+Add to your `CLAUDE.md` to inject rules at session start:
+
+```markdown
+# Project
+
+At session start, call get_assertions() to load enforcement rules.
+
+For code review: crucible review
+```
+
+This tells Claude to load the active assertions *before* writing code, not just catch violations after.
+
 ## How Enforcement Works
 
 ```
@@ -109,13 +123,16 @@ Add to Claude Code (`.mcp.json`):
 
 | Tool | Purpose |
 |------|---------|
+| `get_assertions()` | **Session start:** Load enforced patterns into context |
+| `get_principles(topic)` | **Session start:** Load engineering knowledge by topic |
+| `load_knowledge(files)` | **Session start:** Load specific knowledge files |
 | `review(path)` | Full review: analysis + skills + knowledge + assertions |
 | `review(mode='staged')` | Review git changes with enforcement |
-| `load_knowledge(files)` | Load specific knowledge files |
-| `get_principles(topic)` | Load engineering knowledge by topic |
 | `delegate_*` | Direct tool access (semgrep, ruff, slither, bandit) |
 | `check_tools()` | Show installed analysis tools |
 
+**Tip:** Call `get_assertions()` at the start of a session so Claude knows what patterns to avoid *before* writing code.
+
 ## CLI
 
 ```bash

{crucible_mcp-1.0.1.dist-info → crucible_mcp-1.2.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
 crucible/__init__.py,sha256=M4v_CsJVOdiAAPgmd54mxkkbnes8e5ifMznDuOJhzzY,77
 crucible/cli.py,sha256=DTYt-V5W-DJSkQV3qXumsxImd2Ib3rn2ZgeL-m-dEvA,79233
 crucible/errors.py,sha256=HrX_yvJEhXJoKodXGo_iY9wqx2J3ONYy0a_LbrVC5As,819
-crucible/models.py,sha256=jaxbiPc1E7bJxKPLadZe1dbSJdq-WINsxjveeSNNqeg,2066
-crucible/server.py,sha256=oyfDl5-Ih3eoXBGDZ0ud7H3m2v0tn-Mc7mo19Bd-d00,46756
+crucible/models.py,sha256=VBRnoL5e9-zmbIMkcegxVQCXTgsdBFZ13XQVUxKuA1M,1626
+crucible/server.py,sha256=_Fh3KX1hpif0cycBdQfajDRQCMmaN60dC6BynwXsKqs,30981
 crucible/domain/__init__.py,sha256=2fsoB5wH2Pl3vtGRt4voYOSZ04-zLoW8pNq6nvzVMgU,118
 crucible/domain/detection.py,sha256=TNeLB_VQgS1AsT5BKDf_tIpGa47THrFoRXwU4u54VB0,1797
 crucible/enforcement/__init__.py,sha256=FOaGSrE1SWFPxBJ1L5VoDhQDmlJgRXXs_iiI20wHf2Q,867
@@ -18,7 +18,7 @@ crucible/hooks/__init__.py,sha256=k5oEWhTJKEQi-QWBfTbp1p6HaKg55_wVCBVD5pZzdqw,27
 crucible/hooks/claudecode.py,sha256=9wAHbxYJkmvPPAt-GqGyMASItorF7uruMpYRDL-W-M0,11396
 crucible/hooks/precommit.py,sha256=5W8ty_ji2F9NknvpHIUr8BU75KlXaplq5Itdcfazw68,25190
 crucible/knowledge/__init__.py,sha256=unb7kyO1MtB3Zt-TGx_O8LE79KyrGrNHoFFHgUWUvGU,40
-crucible/knowledge/loader.py,sha256=J4NFGQ5KqP1tK1S1Id39_DC0il6yeJScZn6EQ5pWPpI,12442
+crucible/knowledge/loader.py,sha256=GZn-pnxcCHdzu_IMkscW0b-g5SZ50PCfAmp7QwmKIvU,12582
 crucible/knowledge/principles/API_DESIGN.md,sha256=XBYfi2Q-i47p88I72ZlmXtkj7Ph4UMHT43t3HOR6lhQ,3133
 crucible/knowledge/principles/COMMITS.md,sha256=JlP-z_izywF2qObTQabE4hlgQTcHsZn9AJM32VTk-Ng,2044
 crucible/knowledge/principles/DATABASE.md,sha256=FxxK_UWrfdwl-6f9l7esOmC2WFscwrmcziTYPmEWPXc,2816
@@ -59,8 +59,8 @@ crucible/synthesis/__init__.py,sha256=CYrkZG4bdAjp8XdOh1smfKscd3YU5lZlaDLGwLE9c-
 crucible/tools/__init__.py,sha256=gFRThTk1E-fHzpe8bB5rtBG6Z6G-ysPzjVEHfKGbEYU,400
 crucible/tools/delegation.py,sha256=_x1y76No3qkmGjjROVvMx1pSKKwU59aRu5R-r07lVFU,12871
 crucible/tools/git.py,sha256=7-aJCesoQe3ZEBFcRxHBhY8RpZrBlNtHSns__RqiG04,10406
-crucible_mcp-1.0.1.dist-info/METADATA,sha256=ltZIXAfvcRtmlStP51tk4Q7Ht49of5K1b_MegcZCmp0,6231
-crucible_mcp-1.0.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-crucible_mcp-1.0.1.dist-info/entry_points.txt,sha256=18BZaH1OlFSFYtKuHq0Z8yYX8Wmx7Ikfqay-P00ZX3Q,83
-crucible_mcp-1.0.1.dist-info/top_level.txt,sha256=4hzuFgqbFPOO-WiU_DYxTm8VYIxTXh7Wlp0gRcWR0Cs,9
-crucible_mcp-1.0.1.dist-info/RECORD,,
+crucible_mcp-1.2.0.dist-info/METADATA,sha256=cyRc5H0nkAiS8J4do0eD0Mc6d1dmquHH8n9JISfyQNc,6784
+crucible_mcp-1.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+crucible_mcp-1.2.0.dist-info/entry_points.txt,sha256=18BZaH1OlFSFYtKuHq0Z8yYX8Wmx7Ikfqay-P00ZX3Q,83
+crucible_mcp-1.2.0.dist-info/top_level.txt,sha256=4hzuFgqbFPOO-WiU_DYxTm8VYIxTXh7Wlp0gRcWR0Cs,9
+crucible_mcp-1.2.0.dist-info/RECORD,,