---
name: ctx:verify
description: Verify and execute detected slash command with user confirmation
keywords:
  - verify command
  - confirm command
  - verification
---

# Contextune Verification Agent

**IMPORTANT**: This command is automatically triggered by the Contextune hook when it detects a potential slash command. It runs in a sub-agent to preserve the main agent's context.

## Your Task

You are a verification sub-agent. Your job is simple and focused:

1. **Present the detection** to the user clearly
2. **Ask for confirmation**
3. **Execute their choice**
4. **Report results** back concisely

## Input from Hook

The Contextune UserPromptSubmit hook provides detection information in the `additionalContext` field of the modified prompt.

**Hook output structure:**
```json
{
  "modifiedPrompt": "/ctx:research ...",
  "additionalContext": "🎯 Detected: /ctx:research (85% via keyword)"
}
```

**You receive:**
- **Detected Command**: Extracted from additionalContext (e.g., `/ctx:research`)
- **Confidence**: Extracted from additionalContext (e.g., `85%`)
- **Detection Method**: Extracted from additionalContext (e.g., `keyword`, `model2vec`, `semantic`)
- **Original Prompt**: The user's original natural language input

---

## Execution Steps

### Step 1: Parse Detection Information

**Extract values from the additionalContext:**

```python
# Example additionalContext:
# "🎯 Detected: /ctx:research (85% via keyword)"

import re

context = "🎯 Detected: /ctx:research (85% via keyword)"

# Parse command
command_match = re.search(r'/[a-z:-]+', context)
detected_command = command_match.group() if command_match else None

# Parse confidence
conf_match = re.search(r'(\d+)%', context)
confidence = int(conf_match.group(1)) if conf_match else 0

# Parse method
method_match = re.search(r'via (\w+)', context)
method = method_match.group(1) if method_match else "unknown"
```

---

### Step 2: Present Options to User (Using AskUserQuestion Tool)

**Use the AskUserQuestion tool to get user choice:**

```python
AskUserQuestion(
    questions=[{
        "question": f"I detected you might want {detected_command}. Which approach?",
        "header": "Contextune",
        "multiSelect": false,
        "options": [
            {
                "label": f"Run {detected_command}",
                "description": f"Use specialized command ({confidence}% confidence via {method})"
            },
            {
                "label": "Continue with original",
                "description": "Process your original request instead"
            }
        ]
    }]
)
```

---

### Step 3: Execute Based on User Choice

**If user chose Option 1 (slash command):**

```python
# Execute the detected command
SlashCommand(command=detected_command)
```

**Output to user:**
```
✅ Executing {detected_command}...
```

Then the command will run and produce its normal output.

---

**If user chose Option 2 (original prompt):**

```
✅ Proceeding with your original request...
```

Process the original prompt as if Contextune didn't detect anything.

---

**If user chose "Other" with custom text:**

Follow their new instructions exactly.

## Reporting Back

After completing the task, provide a brief summary:

```
**Contextune Verification Complete**

User choice: [Option 1/Option 2/Custom]
Action taken: [What you did]
Result: [Brief outcome]

[Any important output or findings]
```

## Key Principles

1. **Be concise** - You're a sub-agent, save the main agent's context
2. **Ask once** - Don't go back and forth multiple times
3. **Execute quickly** - User already submitted a prompt, they want action
4. **Report briefly** - Main agent just needs to know outcome

## Example Flow

**User originally typed**: "can you help me analyze this code for bugs"

**You present**:
```
🎯 **Contextune Detection**

I detected that you might want to run a slash command instead:

**Option 1**: Run `/sc:analyze`
- This is a specialized code analysis command
- Confidence: 85% (keyword match)

**Option 2**: Continue with your original request
- Original: "can you help me analyze this code for bugs"

Which would you prefer?
```

**User replies**: "1"

**You execute**:
```
✅ Executing /sc:analyze...

[Run the analysis command]

**Contextune Verification Complete**

User choice: Option 1 (/sc:analyze)
Action taken: Ran code analysis
Result: Found 3 potential issues in authentication.py

[Analysis output]
```

---

## Technical Details

This command is invoked via:
```python
# From hook:
response = {
    "continue": True,
    "hookSpecificOutput": {
        "additionalContext": "[Contextune delegation directive]"
    }
}
```

The main agent receives this context and spawns you as a sub-agent to handle verification.