discover-capabilities

Intent

Execute discover-capabilities to analyze a natural language task description and automatically:

1. •Detect which ontology capabilities are needed
2. •Identify gaps where the ontology lacks coverage
3. •Synthesize a valid workflow DAG from matched capabilities

This skill bridges the gap between "I want to do X" and "here are the specific capabilities and workflow steps needed to do X safely."

Success criteria:

• •All atomic actions in the task are identified
• •Each action maps to an ontology capability with confidence score
• •Missing capabilities are flagged with proposed extensions
• •A valid workflow is synthesized with proper safety steps
• •Evidence anchors trace the discovery reasoning

Compatible schemas:

• •schemas/capability_ontology.yaml
• •schemas/workflow_catalog.yaml

Inputs

Procedure

1. •

   Load ontology context: Read the capability ontology to understand available capabilities

   • •Load schemas/capability_ontology.yaml via CapabilityRegistry
   • •Load schemas/workflow_catalog.yaml via WorkflowEngine
   • •Note: 36 atomic capabilities across 9 cognitive layers
2. •

   Analyze task: Decompose the task into atomic capability requirements

   • •Parse the task description for action verbs and targets
   • •Map each action to the closest ontology capability
   • •Assign confidence scores based on semantic match quality
   • •Identify domain parameters where applicable
3. •

   Classify matches: Validate and filter capability matches

   • •Accept matches with confidence >= 0.6
   • •Route low-confidence matches to gap detection
   • •Identify unmatched requirements
4. •

   Detect gaps: For unmatched requirements

   • •Find nearest existing capabilities by semantic similarity
   • •If available, generate proposed new capabilities with:
     • •Suggested layer, risk level, and schemas
     • •Edges to related existing capabilities
     • •Rationale for the proposal
5. •

   Synthesize workflow: Build a valid workflow from matched capabilities

   • •Resolve transitive dependency chains (requires edges)
   • •Insert safety steps (checkpoint before mutations, audit at end)
   • •Topological sort respecting precedes edge ordering
   • •Check for conflicts_with violations
   • •Generate data flow bindings between steps
6. •

   Present results: Format and display the discovery output

   • •List detected capabilities with confidence and reasoning
   • •Show any gaps with proposals
   • •Display synthesized workflow steps
   • •Offer to validate workflow against ontology
   • •Offer to scaffold gap capabilities if needed

Output Contract

Return a structured object:

capabilities:
  - id: string          # ontology capability ID
    confidence: number  # 0.0-1.0
    reasoning: string   # why this capability was matched
    domain: string      # domain parameter if applicable
gaps:
  - description: string
    proposed_capability:
      id: string
      layer: string
      risk: string
workflow:
  name: string
  steps: array          # ordered workflow steps
  confidence: number    # overall workflow confidence
confidence: number      # overall discovery confidence 0.0-1.0
evidence_anchors: array # provenance trail

Field Definitions

Examples

Example 1: Simple Analysis Task

Input:

task_description: "Find all Python files with TODO comments"

Output:

capabilities:
  - id: search
    confidence: 0.95
    reasoning: "'Find' maps to search capability for discovering items under uncertainty"
  - id: detect
    confidence: 0.85
    reasoning: "'TODO comments' requires pattern detection within found files"
    domain: pattern
gaps: []
workflow:
  name: find_python_files_with_todo
  steps:
    - capability: search
      purpose: Find Python files in the codebase
      store_as: search_out
    - capability: detect
      purpose: Detect TODO patterns in found files
      domain: pattern
      store_as: detect_out
      input_bindings:
        source: ${search_out}
  confidence: 0.9
confidence: 0.9

Example 2: Mutation Task with Safety

Input:

task_description: "Delete old log files older than 30 days"

Output:

capabilities:
  - id: search
    confidence: 0.9
    reasoning: "'log files' requires searching for matching files"
  - id: detect
    confidence: 0.8
    reasoning: "'older than 30 days' requires date-based detection"
    domain: time
  - id: checkpoint
    confidence: 1.0
    reasoning: "Auto-added: mutation requires checkpoint for safety"
  - id: mutate
    confidence: 0.95
    reasoning: "'Delete' is a persistent state mutation"
  - id: audit
    confidence: 1.0
    reasoning: "Auto-added: mutation operations require audit trail"
gaps: []
workflow:
  name: delete_old_log_files
  steps:
    - capability: search
      purpose: Find log files in the system
      store_as: search_out
    - capability: detect
      purpose: Filter files older than 30 days
      domain: time
      store_as: detect_out
    - capability: checkpoint
      purpose: Create safety checkpoint before deletion
      store_as: checkpoint_out
    - capability: mutate
      purpose: Delete the identified old log files
      store_as: mutate_out
      requires_checkpoint: true
    - capability: audit
      purpose: Record deletion actions for audit trail
      store_as: audit_out
  confidence: 0.93
confidence: 0.93

Verification

• • All action verbs in the task description are identified
• • Each capability match has confidence score and reasoning
• • Safety steps (checkpoint, audit) are automatically added for mutations
• • Workflow respects ontology edge constraints (requires, precedes, conflicts_with)
• • Binding references between steps are valid (no undefined variables)

Verification tools: Read, Grep, Bash

Safety Constraints

• •mutation: false
• •requires_checkpoint: false
• •requires_approval: false
• •risk: low

Capability-specific rules:

• •Discovery is read-only: it analyzes and proposes but never modifies the ontology
• •Gap proposals are suggestions only; they require governance review before adoption
• •Workflow synthesis validates against ontology constraints but does not execute

Composition Patterns

Commonly follows:

• •inquire - User provides task description via prompt
• •retrieve - Load ontology and workflow catalog

Commonly precedes:

• •plan - Use discovered capabilities to plan implementation
• •invoke - Execute the synthesized workflow
• •generate - Scaffold new capability files for gap proposals

Anti-patterns:

• •Do not execute synthesized workflows without human review
• •Do not add proposed capabilities to the ontology without governance
• •Do not bypass gap detection by forcing low-confidence matches

Workflow references:

• •See schemas/workflow_catalog.yaml for existing workflow patterns
• •See schemas/capability_ontology.yaml for the full ontology