Feature Request: Actionable Elements in Agent Output (clickable follow-up actions)

# Feature Request: Actionable Elements in Agent Output

## Summary

Allow the agent to render **clickable action elements** in its terminal output that, when activated by the user, inject a predefined message back into the conversation — enabling one-click execution of suggested follow-up actions like running skills, tools, or common workflows.

## Problem

Today, the agent often suggests next steps in its responses:

```
Analysis complete. You might want to:
- Run the daily incident summary
- Check the build status
- Deploy to staging
```

The user must then **manually type** the follow-up request. This creates friction, especially for:
- **Discoverable skills** — new users don't know what to type
- **Multi-step workflows** — agent suggests step 2, user has to rephrase it
- **Repetitive actions** — same follow-up typed over and over

## Proposed Solution

### Agent-side: New markdown-like syntax

The agent's response can include action elements using a special syntax:

```markdown
Analysis complete. You might want to:
- [▶ Run daily summary](@action "run PrimaryOCE daily_summary")
- [▶ Check build status](@action "check the build status for server-outlook-gateway")
- [▶ Deploy to staging](@action "deploy the current branch to staging")
```

### Client-side: Rendered as interactive elements

The CLI client renders these as **clickable/selectable items** in the terminal:

```
Analysis complete. You might want to:
▶ Run daily summary ← click or press [1]
▶ Check build status ← click or press [2]
▶ Deploy to staging ← click or press [3]
```

### Activation methods (choose one or more)

| Method | How it works | Terminal support |
|--------|-------------|-----------------|
| **Keyboard shortcut** | Press `[1]`, `[2]`, `[3]` to select | Universal |
| **OSC 8 hyperlink + custom URI** | Click triggers `copilot-action://run?msg=...` | Windows Terminal, iTerm2, modern terminals |
| **Tab-completion** | Actions appear as completable suggestions | Universal |
| **Arrow-key selection** | Navigate with ↑↓, press Enter | Universal |

### What happens on activation

1. The action's predefined message is injected as a **new user message** into the conversation
2. The agent processes it exactly as if the user typed it
3. Normal conversation flow continues

```
User clicks "▶ Run daily summary"
→ Equivalent to user typing: "run PrimaryOCE daily_summary"
→ Agent invokes the PrimaryOCE skill
→ Results displayed
```

## Use Cases

### 1. Skill Discovery & Execution
```
Agent: I found 3 relevant skills:
▶ Run daily incident summary
▶ Run gateway local dev
▶ Run API tests
```

### 2. Error Recovery Suggestions
```
Agent: Build failed with 3 errors. Suggested fixes:
▶ Auto-fix lint errors
▶ Show full error details
▶ Revert last change and retry
```

### 3. Multi-step Workflow Navigation
```
Agent: PR #4521 is ready. Next steps:
▶ View the diff
▶ Run CI checks
▶ Approve and merge
```

### 4. Confirmation Prompts
```
Agent: This will delete 47 files. Are you sure?
▶ Yes, proceed
▶ Show me the file list first
▶ Cancel
```

### 5. Onboarding & Help
```
Agent: Welcome! Here are some things I can do:
▶ Explore this codebase
▶ Run tests
▶ Show my calendar
▶ Check incidents
```

## Technical Considerations

### Syntax Design
- Must be backwards-compatible (agents that emit actions should still render readable text in older clients)
- Fallback rendering: `▶ Run daily summary` (just plain text, no interactivity)
- The action payload is a natural language message, not a function call — the agent still decides how to process it

### Client Implementation
- Actions are **ephemeral** — they're only valid for the current response
- Once any action is activated (or the user types a new message), previous actions are invalidated
- Actions should be visually distinct from regular text (color, icon, indentation)

### Security
- Action payloads are **user-visible** — no hidden commands
- The agent processes the injected message through normal guardrails
- No privilege escalation — same as if user typed the message manually

## Prior Art

- **Slack** — Bot messages with action buttons
- **GitHub Actions** — Manual workflow dispatch buttons
- **VS Code Copilot Chat** — Follow-up suggestions as clickable chips
- **ChatGPT** — Suggested follow-up prompts as clickable pills
- **Jupyter notebooks** — Interactive widgets in output cells

## Impact

This would significantly improve:
- **Discoverability** — users see what's possible without reading docs
- **Speed** — one click vs. typing a full sentence
- **Workflow continuity** — agent guides user through multi-step processes
- **Accessibility** — reduces cognitive load of remembering exact phrasings