3.3 KiB
name, description, keywords, category
| name | description | keywords | category |
|---|---|---|---|
| meta | Unified meta-cognition command with semantic capability matching. Accepts natural language intent and automatically selects the best capability to execute. | meta, capability, semantic, match, intent, unified, command, discover | unified |
λ(intent) → capability_execution | ∀capability ∈ available_capabilities:
execute :: intent → output execute(I) = discover(I) ∧ match(I) ∧ report(I) ∧ run(I)
discover :: intent → CapabilityIndex discover(I) = { index: mcp_meta_cc.list_capabilities(),
Help mode: empty or help-like intent → show capabilities
if is_help_request(I): display_help(index), halt,
display_discovery_summary(index), display_intent(I),
return index }
is_help_request :: intent → bool is_help_request(I) = empty(I) ∨ is_help_keyword(I)
display_help :: CapabilityIndex → void display_help(index) = { display_welcome_message(), display_available_capabilities(index), display_usage_examples() }
match :: (intent, CapabilityIndex) → ScoredCapabilities match(I, index) = {
Score: name(+3), desc(+2), keywords(+1), category(+1), threshold > 0
scored: score_and_rank(I, index.capabilities),
display_match_summary(scored),
if empty(scored): display_available_capabilities(index), halt,
return scored }
report :: (intent, ScoredCapabilities) → ExecutionPlan report(I, scored) = { composite: detect_composite(scored),
if composite: report_composite_plan(composite), return {type: "composite", target: scored[0], composite: composite}, else: report_single_plan(scored), return {type: "single", target: scored[0]} }
detect_composite :: (ScoredCapabilities) → CompositeIntent | null detect_composite(scored) = {
Threshold: ≥2 caps with score ≥ max(3, best*0.7)
candidates: find_high_scoring(scored, threshold=max(3, best*0.7)),
if len(candidates) >= 2: {capabilities: candidates, pattern: infer_pattern(candidates)}, else: null }
infer_pattern :: (ScoredCapabilities) → PipelinePattern infer_pattern(caps) = {
Patterns: data_to_viz | analysis_to_guidance | multi_analysis | sequential
detect_pattern_from_categories(caps) }
report_composite_plan :: (CompositeIntent) → void report_composite_plan(composite) = { display_composite_detection(composite), display_pipeline_pattern(composite.pattern), display_execution_plan(composite, type="composite") }
report_single_plan :: (ScoredCapabilities) → void report_single_plan(scored) = { display_best_match(scored[0]), display_alternatives_if_close(scored), display_execution_plan(scored[0], type="single") }
run :: ExecutionPlan → output run(plan) = { capability: plan.target.capability, content: mcp_meta_cc.get_capability(name=capability.name),
display_capability_info(content.frontmatter, content.source), interpret_and_execute(content.body)
Note: User can request full pipeline execution for composite intents
}
constraints:
- semantic_scoring: name(+3) ∧ desc(+2) ∧ keywords(+1) ∧ category(+1)
- composite_threshold: ≥2 caps ∧ score ≥ max(3, best*0.7)
- pipeline_patterns: data_to_viz | analysis_to_guidance | multi_analysis | sequential
- error_handling: first_failure → abort | subsequent_failure → partial_results
- transparent ∧ discoverable ∧ flexible ∧ non_recursive