TRIGGER: Call this when you are unsure how to tackle a task. Returns the exact sequence of Elite Prompts and Tools you should execute for a specific scenario. Args: task_type: What you are trying to do (e.g., 'debugging', 'planning', 'refactoring', 'incident', 'optimizing')

TRIGGER: Call this BEFORE writing new code or designing a system. ⚠️ Searches for known mistakes matching your approach. Args: description: What you're about to build or the approach you're considering

TRIGGER: Call this EVERY TIME you consider writing a custom utility, component, or logic that might exist as a library. 🏗️ Adopt vs Build — Rigorous build-vs-buy analysis accounting for hidden costs. Args: capability: What capability is needed build_option: Description of the build approach adopt_option: Description of the adopt/buy approach

TRIGGER: Call this when starting a sprint or setting a major objective. 🎯 Set an OKR-style goal with measurable key results. Args: objective: The qualitative, aspirational goal key_results: Comma-separated measurable key results

TRIGGER: Call this to check progress on OKRs before starting daily work. 🎯 View all active goals and their progress.

Update progress on a specific key result of a goal. Args: goal_id: The ID of the goal to update key_result: The exact key result text to update progress: New progress percentage (0-100)

Archive a completed or stale goal, removing it from the active view. Args: goal_id: The ID of the goal to archive

Permanently delete a goal (e.g., duplicates from stress tests). Args: goal_id: The ID of the goal to delete

Resolve a prospective failure prediction as TRUE (it happened) or FALSE (prevented/impossible). Args: node_id: The exact node ID of the Prospective_Failure occurred: True if the failure happened, False if prevented evidence: Why this outcome was reached

Perform a bi-directional sync of the Elite Memory database with the central team hub. Each user's contributions are tagged with their identity for attribution. Args: remote_url: The URL of the central sync server (default: http://localhost:8000)

TRIGGER: Call this EVERY TIME you resolve a bug or make a mistake. 🛡️ Record a mistake so it NEVER happens again. The immune system gets stronger with every failure. Args: mistake: What went wrong root_cause: WHY it went wrong fix: How it was fixed severity: low/medium/high/critical tags: Comma-separated tags

TRIGGER: Call this EVERY TIME you make a consequential architectural or technical choice. 📝 Record an architectural decision with full rationale. Creates searchable audit trail. Args: decision: What was decided rationale: WHY alternatives_rejected: What was considered and rejected context: Circumstances

TRIGGER: Call this when you need context on WHY a certain technology or pattern is used in this codebase. 🔍 Search past decisions for precedent or conflict. Args: query: What to search for

TRIGGER: Call this when finishing a major component to grade the output. 📊 Record quality score (0-100). Tracks improvement over time. Args: score: 0-100 dimension: One of: test_pass_rate, tool_availability, sync_latency, dedup_effectiveness, security, performance, readability, overall notes: What was scored and HOW (must include measurement method)

TRIGGER: Call this to check if the team's output quality is improving or declining over time. 📊 Quality trend dashboard with per-dimension breakdown.

TRIGGER: Call this EXACTLY ONCE right before pushing code or calling a task 'done'. 🔍 6-pass structured audit on code changes before committing. Cross-references anti-patterns. Args: diff_summary: Description of the code changes

TRIGGER: Call this when making changes to critical paths (auth, payments, data destruction). 🧀 Swiss Cheese Model — Analyze layered defenses for aligned holes. From aviation/nuclear safety. Args: change_description: What change is being made layers: Optional comma-separated custom layers (default: standard 6-layer defense)

TRIGGER: Call this BEFORE finalizing any architectural decision or adopting a new technology. 🧠 Cognitive Bias Scanner — Check 12 biases against a decision. Args: decision_description: The decision or recommendation being evaluated

TRIGGER: Call this whenever making performance improvements to track the delta. 📈 Benchmark Tracker — SPC-style baseline & delta tracking with statistical control limits. Args: metric: Name of the metric (e.g., 'build_time', 'test_pass_rate', 'bundle_size') value: The measured value (required for 'record' action) unit: Unit of measurement action: 'record' to add a data point, 'trend' to view the trend, 'list' to see all metrics context: Additional context

Record a simulated future failure mode into the graph. Args: action: The proposed action that could lead to this failure. predicted_failure: The specific catastrophic outcome predicted. trigger_condition: The exact condition that would confirm this failure occurred.

Fetch all unresolved predictions and validate them against the current state. Args: current_state_summary: A summary of the current reality/system state to test predictions against.

TRIGGER: Call this immediately when a bug is discovered. DO NOT fix the symptom until you call this. 🔍 5 Whys Root Cause Analysis — Drill past symptoms to the systemic cause. Args: symptom: The visible problem or symptom to investigate

TRIGGER: Call this when designing a new feature before writing any code. ⚙️ FMEA — Failure Mode & Effects Analysis. Proactively enumerate what CAN fail before it does. Args: component: The system/component/feature to analyze

TRIGGER: Call this after mitigating an incident or finishing a major project milestone. 🎖️ After Action Review — Structured learning from US Army. Blameless, focused on systemic improvement. Args: intended: What was EXPECTED to happen actual: What ACTUALLY happened went_well: What went WELL and why improve: What should be done DIFFERENTLY next time

TRIGGER: Call this EXACTLY ONCE before starting a refactor (create), and ONCE after finishing it (complete). 🚦 Smoke Test Gate — Before/after validation checkpoint. Creates explicit proof that changes don't regress. Args: description: What change is being validated before_state: Measurable state BEFORE the change after_state: Measurable state AFTER the change (leave empty when creating) action: 'create' to start a gate, 'complete' to finish one

TRIGGER: Call this BEFORE a major architectural or strategic action to generate failure predictions. Runs a simulated MCTS (Monte Carlo Tree Search) prompt template for the LLM to imagine futures. Args: proposed_action: The action you are about to take.

⚙️ FMEA Risk Gate — Computes Risk Priority Number and returns a go/no-go verdict. Call BEFORE any risky action to get a quantified risk assessment.

Args: action: The action to evaluate severity: How bad if it fails (1-5, where 5=catastrophic) probability: How likely to fail (1-5, where 5=certain) detectability: How hard to detect failure (1-5, where 5=invisible)

📊 Expected Value Calculator — Objective decision-making via probability-weighted outcomes.

Args: scenarios: Comma-separated 'probability:value' pairs. Example: '0.7:100, 0.2:-50, 0.1:0'

📐 Bayesian Probability Update — Update beliefs with new evidence.

Args: prior: Prior probability (0-1), e.g. 0.01 for 1% base rate sensitivity: True positive rate (0-1), P(test+|condition+) specificity: True negative rate (0-1), P(test-|condition-)

📈 Compound Growth Calculator — Project growth over time.

Args: principal: Starting value (e.g. revenue, users, investment) rate: Growth rate per period as decimal (e.g. 0.1 for 10%) periods: Number of periods to project

Record a prospective hypothesis and expectation into the Temporal Knowledge Graph. Args: hypothesis: The core assumption or scientific hypothesis being tested. prediction: What outcome will validate or falsify this hypothesis.

Resolve a previously recorded hypothesis as VALIDATED or FALSIFIED. Args: node_id: The exact ID of the Hypothesis node. outcome: Must be exactly 'VALIDATED' or 'FALSIFIED'. evidence: Why this outcome was reached.

Ingest raw context into the temporal knowledge graph using LangGraph background orchestration. Args: context: The raw text, discussion, or logs to analyze.

Query the temporal knowledge graph to understand connections between decisions, mistakes, and context. Args: at_time: Optional ISO timestamp to query the graph state exactly as it was at that time.

Analyzes the user's request and dynamically routes it to the most relevant MCP servers and Skills installed in THIS user's IDE environment. Now includes Goal-Aligned Prompt Polishing for maximum output quality. Returns a structured Execution Plan with quality directives and goal alignment. Call at the very start of complex requests.

Verify which MCP servers and skills are actually recommendable for the active IDE. Use before relying on optional tools or cross-IDE skills.

Return a research-backed benchmark catalog for evaluating reasoning, coding, tool use, research grounding, calibration, and ROI. Args: task_class: Optional filter such as coding_agent, tool_use, calibration, research_grounding.

Return the weighted Elite scorecard used to measure whether reasoning tools improved outcomes instead of merely adding process.

Recommend a reasoning/tool-call budget based on risk and complexity. Use this to prevent tool theater and keep quality improvements ROI-positive.

Decompose a prompt into explicit requirements, implicit requirements, constraints, risks, evidence needs, success criteria, validation plan, allowed tools, and stop conditions. Works without external LLM calls.

Select a model-agnostic reasoning protocol stack for a prompt: direct, ReAct, Tree-of-Thoughts, Reflexion, Self-Consistency, Self-Debugging, or Evidence-Grounded Research.

Generate a deterministic experiment tree with hypotheses, candidate approaches, validation methods, risks, fallbacks, expected observations, and stopping criteria.

Run the lightweight local Elite eval suite. No external model calls. Scores task_success, regression_prevention, tool_efficiency, evidence_quality, calibration, latency_cost_roi, and robustness.

Recommend optional open-source integrations for prompt optimization, eval/red-team/CI, pytest-native LLM evals, rigorous agent benchmarks, and local/open-source model providers without adding core dependencies.

Export optional eval harness scaffolds for Promptfoo, DeepEval, and Inspect AI. Does not add hard dependencies; generated snippets are intended for CI/provider comparison. Args: harness: promptfoo, deepeval, inspect, or all.

Create an evidence-gated workflow run for a non-trivial task.

Use this for build/debug/research/release tasks that need durable planning, validation gates, memory retrieval, confidence, and writeback.

Args: user_prompt: The user request to execute. persist: Persist a run ID and planned steps to the local flight recorder. output_format: markdown or json.

Return the stored status and step list for a workflow run.

Update a workflow step with validation evidence.

Args: run_id: Workflow run ID returned by workflow_run. step_index: 1-based step index. status: pending, running, passed, failed, skipped, or blocked. evidence: Short evidence note, command, source, or blocker.

Record a scoped memory item with poisoning/privacy quality gates.

Low-trust, low-confidence, or sensitive memories are quarantined from automatic context packs but retained for audit.

Return trusted memory context for a task.

Args: query: Task or topic to retrieve context for. scope: Optional project/user scope. Global memories are included. limit: Maximum memory items. min_trust: Minimum trust score for automatic injection.

Run a release-readiness health check for this MCP server.

Args: output_format: markdown or json.

Return a structured release-readiness health report.

TRIGGER: Call this on EVERY user prompt to classify intent and detect reasoning type. 🧠 Records the prompt with extracted intent for adaptive learning. Args: session_id: Current session/conversation ID prompt_text: The user's prompt text intent_category: Classified intent (e.g., 'feature_request', 'debugging', 'clarification') reasoning_type: Detected reasoning type (e.g., 'loop_kick', 'gap_injection', 'depth_escalation', 'substantive') implicit_expectation: What the user implicitly expects but didn't say failure_detected: Description of any failure detected in this prompt

TRIGGER: Call this periodically to detect meta-patterns in user prompts. 📊 Analyzes recent prompts for loop failures, anticipation gaps, and depth rejections. Args: session_id: Optional session ID to filter by (empty = all sessions) limit: Number of recent prompts to analyze (default: 20)

TRIGGER: Call this to understand how the user thinks and what adaptations have been learned. 🧠 Returns the current model of user thinking patterns with confidence scores.

TRIGGER: Call this when you detect a recurring user thinking pattern. 🧠 Updates or creates a user thinking pattern with system adaptation. Args: pattern_name: Name of the thinking pattern (e.g., 'prefers_depth_over_breadth') system_adaptation: How the system should adapt (e.g., 'Always provide implementation details') example_prompt: Optional example prompt that triggered this pattern

TRIGGER: Call this periodically or when the system seems to be underperforming. 🔍 Runs the autonomous gap detector across all subsystems. Checks: missed detections, stale goals, quality regression, expired predictions, prompt health, rule effectiveness.

TRIGGER: Call this to convert a missed detection into an automated prevention rule. 🛡️ Registers an automated check that fires on a trigger event. Args: rule_name: Unique name for the rule trigger_event: Event that triggers the check (e.g., 'pre_commit', 'prompt_received', 'tool_invoked') check_query: What to check when triggered action_on_match: What to do if the check matches severity: P0/P1/P2 source_detection_id: ID of the missed detection this rule was derived from (0 = manual)

TRIGGER: Call this for a full health check of the adaptive learning system. 🏥 Runs a complete diagnostic covering prevention rules, prompt intelligence, missed detections, tool usage, and autonomy rate.

TRIGGER: Call this to generate prioritized goals from learned patterns. 🎯 Analyzes missed detections, quality trends, and prompt patterns to create autonomous improvement goals.

TRIGGER: Call this for a complete view of what the adaptive learning system is doing autonomously. 📋 Returns full status: diagnosis, autonomous goals, and gap scan results.

TRIGGER: Call this to review tool usage analytics. 📈 Returns tool usage statistics for the specified period. Args: days: Number of days to analyze (default: 7)

TRIGGER: Call this to see all active prevention rules and their fire counts. 🛡️ Lists rules, optionally filtered by trigger event. Args: trigger_event: Optional filter (e.g., 'on_prompt', 'after_tool_call'). Empty = all.

Delete a prevention rule by name. 🗑️ Removes a rule from the active set. Use when a rule is causing false positives. Args: rule_name: Exact name of the rule to delete.

TRIGGER: Call this to see predicted failures based on pattern analysis. 🔮 Analyzes anti-patterns, quality trends, and missed detections to predict likely failures. Args: limit: Number of predictions to generate (default: 5)

TRIGGER: Call this BEFORE delivering any important answer, recommendation, or architectural decision to the user.

🎯 Confidence Scorer — Self-critique framework that forces structured evaluation of answer quality. Returns a 0-100 confidence score with specific uncertainty flags.

If confidence < 60%, the system recommends deeper analysis via sequential thinking or socratic challenge.

Args: claim: The proposed answer, recommendation, or decision evidence: Supporting evidence or reasoning (what makes you believe this?) alternatives_considered: Other options that were rejected (and why) domain: The domain of expertise (code, architecture, security, performance, general)

TRIGGER: Call this when confidence score is < 80%, when making architectural decisions, or when the user asks to "stress test" an answer.

🏛️ Socratic Challenger — Generates adversarial counter-questions that force the model to defend, revise, or strengthen its answer.

This is the single most effective technique for making ANY model (even weak/open-source) produce better answers. It turns a single-pass response into a multi-pass stress-tested response.

Args: proposed_answer: The answer/plan/recommendation to challenge context: Additional context about the problem being solved challenge_depth: Number of adversarial questions (1-5, default 3)

TRIGGER: Called AUTOMATICALLY by the orchestration interceptor before complex tasks. Can also be called manually.

🛫 Reasoning Pre-Flight — Determines what reasoning tools should be activated based on task complexity and intent. Returns a checklist of tools to invoke before execution.

Args: task_description: What the user wants to do intent: Classified intent (build, debug, audit, deploy, etc.) complexity: Pre-computed complexity score (1-5), or 0 for auto-detect

Record something the system missed detecting — feeds the autonomous improvement loop.

Args: detection_type: Category of what was missed (e.g., 'security_flaw', 'performance_bug', 'anti_pattern') what_was_missed: Description of what should have been caught how_found: How it was eventually discovered suggested_rule: Optional suggestion for a prevention rule severity: Severity level (P0/P1/P2) or 'auto' to infer from signals

Browse detailed tool usage logs — see when and how tools were used.

Args: days: Number of days to look back (1-30) tool_name: Optional filter for a specific tool name

Search and display user thinking patterns learned over time.

Args: pattern_name: Optional filter — search for a specific pattern by name

TRIGGER: Call this AFTER assess_confidence when you make a prediction or recommendation. Logs the confidence level so it can be compared against actual outcomes later for Brier score calibration.

Args: claim: The specific prediction or recommendation confidence: Your confidence as 0.0-1.0 (e.g., 0.85 = 85% confident) domain: Domain category (code, architecture, security, performance, general)

Resolve a calibration prediction with the actual outcome. This feeds the Brier score calculation.

Args: prediction_id: The prediction ID from calibration_predict outcome: What actually happened correct: Was the prediction correct? True/False

Get the calibration report — Brier score, accuracy, and confidence-vs-outcome breakdown. Lower Brier score = better calibrated.

Perfect calibration: Brier = 0.0 Random guessing: Brier = 0.25 Always wrong at 100%: Brier = 1.0

Args: domain: Filter by domain (empty = all domains) days: Look back period in days

TRIGGER: Call this for any HIGH-STAKES decision (architecture, security, data model, deployment strategy). Runs the decision through 5 adversarial perspectives that challenge it from different angles.

Args: decision: The decision or plan to review context: Additional context (codebase, constraints, requirements) complexity: Complexity level 1-5 (higher = more perspectives activated)

Generate mcp-server-memory payloads for recent decisions. Returns structured JSON that should be passed to mcp-server-memory's create_entities and create_relations tools.

Args: limit: Max number of recent decisions to sync.

Generate mcp-server-memory payloads for recent anti-patterns/mistakes. Returns structured JSON for cross-session persistence.

Args: limit: Max number of recent mistakes to sync.

Generate mcp-server-memory payloads for active prevention rules. Returns structured JSON for cross-session persistence.

Args: limit: Max number of rules to sync.

Search mcp-server-memory for relevant context before a task. Returns instructions for calling mcp-server-memory search_nodes.

Args: query: What to search for in cross-session memory.

🎯 Polish any prompt for maximum output quality.

Analyzes the prompt, aligns it with active goals, adds missing quality directives, and returns an enhanced version that produces significantly better results.

The polisher:

• Fetches active goals and injects relevant context

• Scores prompt quality (0-100) before and after

• Adds missing verification, edge-case, security checks

• Scales quality requirements to task complexity (1-5)

Args: user_prompt: The raw user prompt to polish

📊 View prompt quality scores over time.

Shows the trend of prompt polish scores to identify whether prompt quality is improving or declining. Used by the optimization loop to trigger automatic goal-setting when quality drops.

Args: limit: Number of recent prompts to analyze (default: 20)

Forward-looking work setup: goals, workflows, hypotheses, reasoning preflight.

Actions: set_goal, check_goals, update_goal, archive_goal, delete_goal, get_elite_workflow, adopt_vs_build, reasoning_preflight, generate_autonomous_goals, record_hypothesis

Args: action: Which planning operation to run subject: What is being planned (goal text, hypothesis, etc.) context: Action-specific parameters as a dict depth: Depth of analysis (1-5)

Verify or stress-test work BEFORE committing. Use before decisions, code, or plans.

Actions: check_anti_patterns, pre_commit_audit, swiss_cheese, bias_scan, fmea, fmea_risk_gate, smoke_test_gate, assess_confidence, socratic_challenge, decision_council

Args: action: Which audit to run subject: What is being audited (decision, code, plan text) context: Action-specific parameters depth: For socratic_challenge/fmea: recursion depth (1-5)

Reasoning frameworks, math tools, and thought branching.

Analysis Actions: five_whys, after_action_review, simulate_future_regrets, calculate_expected_value, bayesian_update, compound_growth, analyze_prompt_sequence, ingest_context

Thought Branching Actions: think, revise, branch, compare, conclude, trace

Args: action: Which analysis to run subject: What to analyze / thought content context: Action-specific parameters (session_id, thought_id, branch_id, etc.) depth: Analysis depth (1-5)

Memory operations: record, search, and retrieve past decisions, mistakes, and patterns.

Actions: record_mistake, record_decision, search_decisions, record_quality_score, get_quality_trend, benchmark_track, resolve_hypothesis, query_temporal_graph, record_prompt_intent, search_thinking_patterns, update_thinking_pattern, get_user_thinking_model

Args: action: Which memory operation subject: Primary content (mistake text, decision text, search query) context: Action-specific parameters (root_cause, fix, rationale, etc.)

Calibration tracking and forecasting: make predictions, resolve outcomes, score accuracy.

Actions: calibration_predict, calibration_resolve, calibration_score, record_prospective_failure, resolve_prospective_failure, validate_predictions, predictive_prevention

Args: action: Which prediction operation subject: The prediction or claim text context: Action-specific parameters (confidence, outcome, domain, etc.)

Adaptive learning: prevention rules, missed detections, team sync.

Actions: record_missed_detection, register_prevention_rule, list_prevention_rules, delete_prevention_rule, sync_team_memory, share_skill

Args: action: Which learning operation subject: What was missed or what rule to create context: Action-specific parameters

System self-inspection: diagnostics, usage stats, autonomous status.

Actions: autonomous_scan, self_diagnose, get_autonomous_status, get_tool_usage_stats, browse_tool_usage, get_injection_stats, get_prevention_stats

Args: action: Which inspection to run subject: Optional filter or query context: Action-specific parameters

Returns the current user's profile, including their identity, IDE type, installed MCP/Skill counts, sync status, and preferences. Use this to understand WHO you are serving and what tools they have.

Update a user's personalization setting. Args: key: Dot-notation path (e.g., 'sync.enabled', 'orchestration.mode', 'display_name') value: New value (strings are auto-converted to bool/int when appropriate)

List all users registered with the team sync hub. Shows each user's IDE type, MCP count, and skill count. Args: hub_url: Override sync hub URL (default: from user config)

Publish one of your locally installed skills to the team hub so other users can discover and install it. Args: skill_name: Name of the skill to share description: Optional description override