Plan Mode silently discards the comprehensive plan when exporting for a separate implementation session

## Description

Plan Mode currently appears to produce two materially different versions of an implementation plan:

1. A comprehensive, highly detailed plan stored internally in `/memories/session/plan.md`.
2. A shorter, human-readable plan displayed in chat and offered through the default "open in editor" or export action.

The problem is that the UI does not clearly explain this distinction.

The exported plan is presented as though it were the final reusable artifact, while the more comprehensive version - containing substantially more implementation detail, relevant files, symbols, dependencies, verification steps, and other context - is kept in temporary session memory and is not mentioned during the normal export flow.

This makes it very easy for users to save the abridged version and unknowingly lose the more complete result of the planning process.

## Important overlooked workflow

Many users do not start implementation immediately after planning, within the same chat session.

A common workflow is:

1. Use Plan Mode to research the codebase and create an implementation plan.
2. Review the plan carefully.
3. Save it as a Markdown file.
4. Possibly edit it manually, discuss it with teammates, commit it to the repository, or return to it later.
5. Start a fresh implementation session and provide the saved plan to the implementation agent.

For this workflow, the exported Markdown file is not merely a convenience for human reading. It becomes the primary handoff artifact for the future implementation agent.

## Actual behavior

At the end of planning, the visible plan in chat is relatively concise and easy for a human to review.

The suggested export action exports that concise version.

Separately, Plan Mode stores a much more detailed plan in `/memories/session/plan.md`. In my case, the session-memory version was approximately 13,000 characters, while the exported chat version was approximately 5,000 characters.

The comprehensive version included details that were missing or reduced in the exported version, including:

* A dedicated list of relevant files.
* Full file paths.
* More precise implementation steps.
* Lower-level architectural details.
* More detailed dependencies and relationships between changes.
* Additional verification guidance.
* Context that would potentially be useful to an implementation agent starting from a new session.

The existence and purpose of this comprehensive plan were not explained by the normal completion or export UI. I discovered it only by expanding the internal message stating that Plan Mode had reviewed and created memory, and then manually opening the memory file.

The default export mechanism therefore saves the human-oriented summary while silently leaving the more implementation-oriented artifact inside temporary session memory.

## Why this is a problem

The shorter plan looks complete and is explicitly offered for export, so a reasonable user will assume that it is the final result of Plan Mode.

As a result, users may pay for a detailed codebase analysis and comprehensive planning process, but preserve only the shortened summary. The fuller output is then effectively lost when the planning session is discarded.

It is reasonable to generate both a concise human-facing summary and a comprehensive machine-facing plan. The problem is not the existence of two versions.

The problem is that the product exposes only the concise version as the apparent final artifact while concealing the comprehensive version that may be more appropriate for implementation handoff.

## Steps to reproduce

1. Open a repository in VS Code.
2. Start a Copilot Chat session in Plan Mode.
3. Ask it to research a non-trivial feature and produce an implementation plan.
4. Complete any clarification steps.
5. Wait for the final plan to be shown in chat.
6. Use the suggested action to export or open the plan in the editor.
7. Compare the exported plan with `/memories/session/plan.md`.
8. Observe that the memory plan is significantly more detailed and may contain information absent from the exported version.
9. Observe that the normal export workflow does not disclose the existence or purpose of the comprehensive version.

## Expected behavior

VS Code should explicitly acknowledge that Plan Mode has produced two artifacts with different purposes.

For example:

* **Review summary:** concise and optimized for human review.
* **Comprehensive implementation plan:** detailed and optimized for implementation handoff or reuse in another session.

When exporting, the user should be allowed to choose which version to preserve.

A suitable completion UI might offer:

* **Start Implementation in This Session**
* **Export Comprehensive Implementation Plan**
* **Export Human-Readable Summary**

The comprehensive plan should not remain hidden exclusively in temporary session memory.

## Suggested default behavior

When the user chooses "Export Plan," the default should be the comprehensive implementation plan, because exporting usually implies that the artifact will be reused outside the current conversation.

The concise summary can remain the default version displayed in chat because it is easier to review.

In other words:

* Display the concise version by default.
* Preserve and export the comprehensive version by default.
* Clearly label both.
* Let users explicitly choose the shorter summary when that is what they want.

## Suggested resolution

1. Clearly document and label the two generated plan versions.
2. Surface the comprehensive plan in the normal Plan Mode completion UI.
3. Add an explicit option to export the comprehensive plan.
4. Make the comprehensive version the default artifact for separate-session handoff.
5. Explain that the concise version is intended primarily for human review.

The dual-output design can be valuable, but only if users understand that two versions exist and can choose the correct one for their intended workflow.

At present, the interface strongly implies that the abridged chat plan is the final reusable artifact, while the more complete implementation-oriented result is hidden and easily lost.

## Technical details

- VS Code Version: 1.128.0 (user setup)
- OS Version: Windows 11 Pro 25H2 x64 10.0.26200
- Feature: Plan mode
- Selected model: GPT 5.6 Sol ('very high' reasoning)