Get relevant Sensei engineering context for the current task.

Args: operation: What you're doing (e.g., "reviewing API endpoints") file_paths: List of file paths involved description: Additional context about the task session_id: Session identifier project_root: Absolute path to the project root (for local rules/sessions)

Returns: Markdown-formatted engineering standards relevant to this task

Record an architectural or technical decision for this session.

Args: category: Type of decision ("architecture", "pattern", "constraint", "standard") description: Brief description of the decision rationale: Why this decision was made session_id: Session identifier constraint: Optional constraint to add to active constraints pattern: Optional pattern to add to agreed patterns project_root: Absolute path to the project root

Returns: Confirmation message with decision ID

Validate code or design against Sensei engineering standards.

Args: code_snippet: Code to validate (optional) design_description: Design/architecture to validate (optional) focus_areas: Specific areas to check session_id: Session identifier project_root: Absolute path to the project root

Returns: Structured validation report

Get a summary of the current session's decisions and context.

Args: session_id: Session identifier project_root: Absolute path to the project root

Returns: Summary of session state

List all available sessions in the global directory. (Note: Does not list local project sessions)

Query a specific section of the rulebook directly by name.

Check if a proposed change is consistent with session decisions and constraints.

Analyze staged git changes to identify relevant engineering contexts (v0.5.0 enhanced).

Args: project_root: Absolute path to the project root include_diff_stats: Include line change statistics (additions/deletions) suggest_personas: Suggest relevant personas based on change context

Returns: Summary of changed files, contexts, and recommended personas for review

Get engineering guidance via multi-persona orchestration (DEFAULT in v0.3.0).

⚠️ DEPRECATION NOTICE (v0.6.0): This tool will be deprecated in v0.7.0. Please use the new granular tools instead:

• suggest_personas_for_query() - Get persona suggestions

• get_persona_content() - Get persona SKILL.md content

• get_session_context() - Get session memory

• record_consultation() - Record consultation after analysis

The new architecture provides content for Claude to analyze, rather than trying to perform analysis within the MCP server.

This is the NEW primary tool for getting engineering guidance. The Skill Orchestrator coordinates 21 specialized personas to provide holistic, multi-perspective analysis of your engineering questions.

Args: query: Your question or scenario mode: Analysis mode: - "orchestrated" (DEFAULT): Multi-persona analysis with intelligent selection - "quick": Single persona (Snarky Senior Engineer) for fast answers - "crisis": Emergency team (Incident Commander, SRE, Executive) - "standards": Legacy mode (engineering standards only, no personas) session_id: Session identifier project_root: Absolute path to project root (for local rules/sessions) specific_personas: Override auto-selection (e.g., ["security-sentinel", "pragmatic-architect"]) output_format: Response format ("brief", "standard", "executive")

Returns: Orchestrated multi-perspective guidance with synthesis and recommendations

Examples: # Auto-orchestrated (DEFAULT) get_engineering_guidance( query="Should we migrate to microservices?", session_id="saas-backend" )

# Crisis mode
get_engineering_guidance(
    query="Production database is down",
    mode="crisis"
)

# Specific personas
get_engineering_guidance(
    query="Review this payment API design",
    specific_personas=["security-sentinel", "api-platform-engineer"]
)

Consult a single skill persona directly.

⚠️ DEPRECATION NOTICE (v0.6.0): This tool will be deprecated in v0.7.0. Please use get_persona_content() instead:

• get_persona_content(persona_name=skill_name) - Get full SKILL.md content Then Claude performs the analysis using that content as context.

Use this when you want guidance from a specific expert without orchestration.

Args: skill_name: Persona name (e.g., "snarky-senior-engineer", "security-sentinel") query: Your question session_id: Session identifier project_root: Absolute path to project root

Returns: The persona's perspective

Available Personas: Core: snarky-senior-engineer, pragmatic-architect, legacy-archaeologist Specialized: api-platform-engineer, data-engineer, frontend-ux-specialist, ml-pragmatist, mobile-platform-engineer Operations: site-reliability-engineer, incident-commander, observability-engineer Security: security-sentinel, compliance-guardian Platform: devex-champion, platform-builder, qa-automation-engineer Cost: finops-optimizer Leadership: empathetic-team-lead, product-engineering-lead, executive-liaison, technical-writer Meta: skill-orchestrator

List all available skill personas with flexible detail levels.

Args: category: Optional filter (core, specialized, operations, security, platform, cost, leadership, meta) format: Output format: - "standard" (default): Name, description, and expertise areas - "detailed": Adds example queries, use cases, and related personas - "quick": One-line quick tips for each persona

Returns: Formatted list of available personas

Examples: # Standard list list_available_skills()

# Detailed format with examples
list_available_skills(format="detailed")

# Quick reference
list_available_skills(format="quick")

# Specific category
list_available_skills(category="operations", format="detailed")

Get full skill content for a specific persona.

This returns the complete SKILL.md content that defines the persona's expertise, principles, personality, and guidelines. The calling LLM should use this content to analyze queries from that persona's perspective.

MCP Design Philosophy: This tool returns CONTENT for the LLM to use, not pre-generated analysis. The calling LLM (Claude) receives the persona content and performs the analysis itself.

Args: persona_name: Name of persona (e.g., "security-sentinel", "pragmatic-architect") include_metadata: Include metadata header (name, description, expertise)

Returns: Full persona skill content (markdown format)

Example: # Get Security Sentinel's content content = get_persona_content("security-sentinel")

# Claude then uses this content to analyze from that perspective

Suggest relevant personas for a given query using intelligent selection.

Uses keyword matching, context detection, and relevance scoring to recommend which personas would be most helpful for the query.

MCP Design Philosophy: This tool helps the LLM discover which personas to consult, but doesn't perform analysis itself. The LLM uses the suggestions to call get_persona_content() for each recommended persona.

Args: query: The user's question or scenario max_suggestions: Maximum number of personas to suggest (default: 5) context_hint: Optional context hint to improve suggestions (e.g., "crisis", "security", "architectural")

Returns: JSON list of suggested personas with relevance scores and rationale

Example: # Get suggestions for a query suggestions = suggest_personas_for_query( query="How should we handle user authentication?", max_suggestions=3 )

# Returns JSON with suggested personas and why they're relevant
# LLM then calls get_persona_content() for each suggestion

Get session context (constraints, decisions, patterns) for context-aware analysis.

Returns session memory that can be included when asking personas to analyze queries. This ensures consistency with previous decisions and agreed patterns.

MCP Design Philosophy: This tool returns session memory as data. The LLM includes this context when analyzing queries to ensure consistency with previous decisions.

Args: session_id: Session identifier project_root: Optional project root for local sessions

Returns: JSON with session constraints, patterns, and recent decisions

Example: # Get session context context = get_session_context(session_id="my-project")

# LLM includes this when asking persona to analyze:
# "Given these constraints: ..., analyze this query"

Record a consultation in session history.

After Claude analyzes a query using persona content, record the consultation for session analytics and history.

Args: query: The original query personas_used: List of persona names that were consulted session_id: Session identifier project_root: Optional project root synthesis: Optional synthesis/recommendation from Claude

Returns: Confirmation with consultation ID

Example: # After Claude analyzes using persona content: record_consultation( query="Should we migrate to microservices?", personas_used=["pragmatic-architect", "site-reliability-engineer"], synthesis="[Claude's full analysis and recommendation]" )

Get comprehensive analytics and insights for a session.

Provides data-driven insights into persona usage patterns, consultation frequency, decision-making trends, and session health metrics.

Args: session_id: Session identifier project_root: Absolute path to project root (for local sessions) time_range: Analysis window: - "all_time" (default): All consultations - "last_7_days": Last 7 days - "last_30_days": Last 30 days format: Output format ("markdown", "json", "text")

Returns: Formatted analytics report with: - Persona usage statistics (most/least used) - Context distribution (CRISIS, SECURITY, etc.) - Mode usage (orchestrated, quick, crisis, standards) - Decision metrics and velocity - Session health indicators

Examples: # Get all-time insights get_session_insights(session_id="my-project")

# Last 30 days in JSON
get_session_insights(
    session_id="my-project",
    time_range="last_30_days",
    format="json"
)

Export a single consultation as shareable report.

Perfect for sharing specific decision-making discussions with your team, documenting why you chose a particular approach, or creating ADRs.

Args: consultation_id: Consultation ID (e.g., "consult_1") session_id: Session identifier project_root: Absolute path to project root format: Output format ("markdown", "json", "text")

Returns: Formatted consultation report

Examples: # Export as markdown export_consultation( consultation_id="consult_5", session_id="my-project" )

# Export as JSON for CI/CD
export_consultation(
    consultation_id="consult_5",
    format="json"
)

Export comprehensive session summary for team sharing.

Generates Architecture Decision Records (ADRs), consultation history, and active constraints/patterns. Perfect for:

• Onboarding new team members

• Documenting architectural decisions

• Sharing team knowledge

• Creating weekly/monthly reports

Args: session_id: Session identifier project_root: Absolute path to project root format: Output format ("markdown", "json", "text") include: Components to include (default: all) - "decisions": Architecture decisions - "consultations": Consultation history - "constraints": Active constraints - "patterns": Agreed patterns max_consultations: Max recent consultations to include (default: 10)

Returns: Comprehensive session summary report

Examples: # Full summary export_session_summary(session_id="my-project")

# Just decisions and constraints
export_session_summary(
    session_id="my-project",
    include=["decisions", "constraints"]
)

# JSON export for processing
export_session_summary(
    session_id="my-project",
    format="json"
)

Merge multiple sessions into a single target session (v0.5.0).

Enables teams to combine session insights from multiple developers, resolving conflicts and tracking attribution.

Args: session_ids: List of session IDs to merge (e.g., ["dev1-session", "dev2-session"]) target_session_id: ID for the merged session (e.g., "team-session") conflict_strategy: How to resolve conflicts: - "latest" (default): Use most recent timestamp - "oldest": Use oldest timestamp - "all": Keep all variants (creates numbered versions) - "manual": Return conflicts for manual resolution project_root: Optional project root for local sessions

Returns: Formatted merge result with statistics and conflicts

Examples: # Merge two developer sessions merge_sessions( session_ids=["alice-frontend", "bob-backend"], target_session_id="sprint-23", conflict_strategy="latest" )

# Merge with manual conflict resolution
merge_sessions(
    session_ids=["team-a", "team-b"],
    target_session_id="combined",
    conflict_strategy="manual"
)

# Keep all decision variants
merge_sessions(
    session_ids=["experiment-1", "experiment-2"],
    target_session_id="final",
    conflict_strategy="all"
)

Compare two sessions and return differences (v0.5.0).

Useful for understanding what decisions and patterns differ between two developer sessions or team branches before merging.

Args: session_a_id: First session ID session_b_id: Second session ID project_root: Optional project root for local sessions

Returns: Formatted comparison showing unique and shared items

Examples: # Compare two developer sessions compare_sessions( session_a_id="alice-session", session_b_id="bob-session" )

# Compare feature branches
compare_sessions(
    session_a_id="feature-auth",
    session_b_id="feature-payments"
)

Suggest which MCP servers to use for a given query.

Analyzes the query and recommends which MCP servers (Context7, Tavily, Playwright, etc.) would be most helpful, along with pre-built workflow templates if available.

Args: query: The user's query context: Detected query context (default: "GENERAL") Options: SECURITY, COST, CRISIS, ARCHITECTURAL, TECHNICAL, etc. user_mcps: Optional list of MCPs to filter suggestions (e.g., ["context7", "tavily"])

Returns: JSON with suggested MCPs, rationale, matching workflows, and cost/time estimates

Example: # Get MCP suggestions suggest_mcps_for_query( query="Review authentication for security issues", context="SECURITY" )

# Returns: sensei + context7 (OWASP docs) + tavily (CVEs) + playwright (live inspection)

Get a pre-built multi-MCP workflow template.

Returns step-by-step workflow definitions for common scenarios, with optional parameter substitution for customization.

Args: template_name: Workflow template name Available templates: - "auth-security-review": Comprehensive auth security review - "performance-debug": Performance debugging workflow - "cost-optimization": Cloud cost analysis - "tech-due-diligence": Technology evaluation - "incident-postmortem": Incident analysis - "accessibility-audit": WCAG compliance check - "api-design-review": API design review

parameters: Optional dict of parameters to substitute
    Example: {
        "user_query": "Review FastAPI auth",
        "app_url": "https://app.example.com",
        "framework": "FastAPI"
    }

Returns: JSON with workflow steps, required MCPs, personas, and estimates

Example: # Get auth security review workflow get_mcp_workflow_template( template_name="auth-security-review", parameters={ "user_query": "Review authentication implementation", "app_url": "https://app.example.com/login", "framework": "FastAPI" } )

List all available multi-MCP workflow templates.

Returns a summary of pre-built workflows with their descriptions, required MCPs, cost estimates, and time estimates.

Returns: JSON array of available workflow templates

Example: # List all templates list_mcp_workflow_templates()

# Returns: 7 templates (auth-security-review, performance-debug, etc.)

Execute a demonstration workflow that showcases multi-MCP orchestration.

Runs a self-contained demo that combines Sensei + external MCPs (Context7, Tavily, Playwright) in realistic workflows. Perfect for:

• Testing multi-MCP coordination

• Generating example documentation

• Demonstrating Sensei capabilities

• Training and onboarding

Args: demo_type: Type of demo to run Available demos: - "auth-review": Authentication security review (Sensei + Context7 + Tavily + Playwright) - "performance-debug": Performance debugging (Sensei + Playwright + Context7) - "cost-analysis": Cloud cost optimization (Sensei + Tavily) - "api-review": API design review (Sensei + Context7 + Tavily)

custom_params: Optional custom parameters to override defaults
    Example for auth-review: {
        "user_query": "Review FastAPI authentication",
        "app_url": "https://myapp.com/login",
        "framework": "FastAPI"
    }

output_format: Output format ("markdown", "json", "text")

Returns: Comprehensive demo execution report showing: - Workflow steps and MCP coordination - Example findings from multi-MCP synthesis - Expected output structure - How to run the demo yourself

Examples: # Run auth security review demo with defaults run_demo(demo_type="auth-review")

# Run with custom parameters
run_demo(
    demo_type="auth-review",
    custom_params={
        "user_query": "Review OAuth implementation",
        "framework": "Django"
    }
)

# Get JSON output
run_demo(demo_type="performance-debug", output_format="json")

List all available demonstration workflows.

Returns a summary of executable demos that showcase multi-MCP orchestration capabilities.

Returns: JSON array of available demos with descriptions and example parameters

Example: # List all demos list_demos()

# Returns: 4 demos (auth-review, performance-debug, cost-analysis, api-review)