Feature Request: Compare two AI chat / agent sessions and show the agent flow differences

### Summary

I would like VS Code / GitHub Copilot Chat to support comparing two AI chat or agent sessions from the sessions list.

In my workflow, I often run the same AI workflow, skill, or agent task in different chat sessions. Even when the input and workspace are similar, the behavior can be very different between sessions. The agent may choose different files, run different commands, use different tools, follow a different reasoning path, or produce different code changes.

It would be very useful to select two sessions in the chat sessions list and compare what flow the AI agent took in each session.

### Problem

Currently, the chat sessions list lets users open and manage previous sessions, but it is difficult to understand why two sessions behaved differently.

For example:

1. I start session A and run a specific AI workflow / skill.
2. I start session B and run the same workflow / skill again.
3. The final result is different.
4. I want to understand what changed:

* Which prompts or context were different?
* Which files were inspected?
* Which tools or commands were run?
* Which edits were proposed or applied?
* Which checkpoints or intermediate steps were different?
* Where did the agent’s flow diverge?

At the moment, this requires manually opening both sessions and reading through them side by side, which is hard for long agentic workflows.

### Proposed feature

Add an option in the chat sessions / Agents window UI to compare two sessions.

Possible UX:

1. In the sessions list, allow multi-select of two chat or agent sessions.
2. Add a context menu action: **Compare Sessions**.
3. Open a comparison view showing the two sessions side by side.
4. Highlight differences in the agent flow.

The comparison could include:

* User prompts
* Model responses
* Tools used
* Terminal commands run
* Files read or modified
* Checkpoints created
* Agent mode / model / skill / custom instruction differences
* Workspace context differences
* Final code changes
* Errors or failed commands
* A summarized “where the flows diverged” section

### Example use case

I have a reusable AI workflow skill. I run it in two different sessions against the same repository. In one session, the agent correctly identifies the relevant files and produces the expected change. In another session, it takes a completely different path and produces a different result.

I want to compare both sessions and understand:

* Did the agent receive different context?
* Did it inspect different files?
* Did it choose a different plan?
* Did it run different commands?
* Did it skip a step from the workflow?
* Did the behavior change because of model/tool/context differences?

### Why this would be useful
This would help users debug agentic workflows and improve repeatability. It would also make AI-assisted development more transparent by showing how a result was produced, not just the final answer.

This is especially important when users are building or relying on repeatable AI workflows, custom instructions, skills, or agent behaviors across multiple sessions.

### Possible implementation ideas

The comparison view could provide:

* Side-by-side timeline of both sessions
* Diff view for prompts and responses
* Tool-call timeline comparison
* File access / file edit comparison
* Command execution comparison
* Checkpoint comparison
* Summary generated from structured session metadata
* Exportable comparison report

### Expected behavior

A user should be able to select two chat / agent sessions and ask VS Code to compare them. VS Code should show both the detailed differences and a high-level summary of how the agent flows differed.

### Actual behavior

Currently, users need to manually inspect each session separately and infer the differences themselves.

### Related area

This is related to chat session history, agent sessions, and exporting or inspecting AI session artifacts.