Merge origin/main into Markdown renderer 2

Author: DinahK-2SO

doc/release-check-list.md

@@ -134,8 +134,8 @@ Net effect: UT shrinks the manual matrix to "did the wiring and UI connect", not
 - [ ] `C054` `[E2E]` **Different positions work:** Open/hide/focus works for bottom, right, left, and top pane positions.
 - [ ] `C252` `[new]` `[E2E]` **Agent pane move is isolated per tab and preserves input focus:** `/move` changes only the current tab's runtime pane position, leaves the global setting and sibling tabs unchanged, and returns keyboard focus to the moved agent input. _(#429; E2E: `Feature.AgentPaneMove`.)_
 - [ ] `C055` `[E2E]` **Stash preserves chat:** Hiding and restoring the pane preserves helper process, connection state, and chat history.
-- [ ] `C056` `[E2E]` **Tab close cleans up:** Closing the owning tab cleans up the helper and does not leave a broken pane.
-- [ ] `C247` `[new]` `[E2E]` **Closing a tab mid-turn leaves sibling agent tabs working:** When one tab closes with a prompt in flight, its orphaned result is discarded without terminating the shared agent CLI, and another tab can continue chatting without a restart. _(#419/#425; E2E: `Feature.SharedAgentLifecycle`.)_
+- [ ] `C056` `[E2E]` **Tab close cleans up:** Closing the owning tab physically closes its ACP session, cleans up the helper, and does not leave a broken pane.
+- [ ] `C247` `[new]` `[E2E]` **Closing a tab mid-turn leaves sibling agent tabs working:** When one tab closes with a prompt in flight, only its ACP session is closed; the shared agent CLI remains alive and another tab can continue chatting without a restart. _(#419/#425; E2E: `Feature.SharedAgentLifecycle`.)_
 - [ ] `C215` `[new]` `[E2E]` **Agent panes are not persisted into saved layout:** Saving and restoring a window layout does not resurrect a previously-open agent pane; restored windows come back without an unexpected agent pane. _(#360/#275.)_
 
 ### Built-in agent chat matrix
@@ -155,7 +155,10 @@ Net effect: UT shrinks the manual matrix to "did the wiring and UI connect", not
 - [ ] `C062` `[E2E]` **Prompt focused appearance is correct:** Input box looks correct when focused.
 - [x] `C063` `[UT✓]` `[E2E]` **Prompt out-of-focus appearance is correct:** Input box looks correct when focus leaves the agent pane. _(UT: `render_input_box_intact_when_pane_unfocused` renders with `pane_focused=false` and asserts the input box stays intact — prompt marker + connection placeholder still paint, not blanked/broken; only the caret style dims, input.rs:69/90.)_
 - [ ] `C064` `[E2E]` **Typing works:** User can type, edit, and submit prompt text correctly.
-- [ ] `C065` `[E2E]` **Paste works:** Pasted multi-line text is handled correctly.
+- [ ] `C065` `[E2E]` **Paste works:** Pasted multiline text remains in one agent draft without submitting. _(UT: `agent_paste_text_*`; E2E: `Feature.Paste`.)_
+- [ ] `C266` `[new]` `[E2E]` **Ctrl+V pastes into the agent input:** Ctrl+V invokes the structured paste path and inserts clipboard text exactly once instead of typing a literal `v`; Ctrl+Shift+V remains a positive control. _(E2E: `Feature.Paste`.)_
+- [ ] `C267` `[new]` `[E2E]` **Ctrl+V paste survives input refocus:** After a physical completed-turn interaction and input-dialog click, Ctrl+V pastes into the visible draft. _(E2E: `Feature.Paste` `PasteRefocus`.)_
+- [ ] `C268` `[new]` `[E2E]` **Ctrl+V paste stays isolated to its owner tab:** Pasting into one focused agent input does not mutate a sibling tab's agent draft. _(UT: `agent_paste_text_ignores_wrong_window_and_non_owner_helpers`; E2E: `Feature.Paste` `PasteOwnerIsolation`.)_
 - [ ] `C234` `[new]` `[E2E]` **Prompt history recall works:** Up/Down recalls submitted prompts from newest to oldest and moves back toward newer entries. _(#478/#479; E2E: `Feature.PromptHistory`.)_
 - [ ] `C235` `[new]` `[E2E]` **Prompt history preserves drafts and multiline prompts:** Reviewing history keeps each multiline prompt intact and restores the current unsent draft afterward. _(#478/#479; E2E: `Feature.PromptHistory`.)_
 - [ ] `C236` `[new]` `[E2E]` **Prompt history is isolated per tab:** Each agent tab recalls only prompts submitted in that tab. _(#478/#479; E2E: `Feature.PromptHistory`.)_
@@ -164,6 +167,8 @@ Net effect: UT shrinks the manual matrix to "did the wiring and UI connect", not
 - [ ] `C264` `[new]` `[UT✓]` `[E2E]` **Completed turns toggle and select from rendered prompt targets:** A left-button Down/Up anywhere on the same visible prompt row, including its triangle, prefix, text, explicit blank row, or unused row-end space, collapses or expands only that turn and reuses the keyboard selection, highlight, navigation, Esc, and Enter behavior. Hover uses only a hand cursor: action metadata must not add hyperlink underline or tooltip text. Details, separators, drags, overlays, tab changes, scrolling, and stale/offscreen rows do not toggle; clicking the live input dialog clears the history selection and restores draft input. Multiline, wrapped, wide-cell, and double/triple-click paths preserve their expected geometry and text-selection behavior. _(UT: `clicking_multiline_completed_turn_prompt_selects_and_reuses_enter_toggle`, `completed_turn_user_input_hit_spans_full_row_with_wide_cells`, `completed_turn_prompt_rows_expose_state_aware_action_links`, `overlay_preserves_full_rows_and_cell_styles`, `CompletedTurnActionHyperlinksSuppressUnderlines`, `clicking_input_dialog_restores_input_navigation_after_mouse_turn_selection`, `completed_turn_user_input_multi_click_preserves_turn_state_and_text_selection`, `completed_turn_mouse_selection_continues_with_keyboard_navigation`, `completed_turn_triangle_click_ignores_text_drag_and_hidden_chat`, `completed_turn_triangle_hits_follow_visible_scrolled_turns`, `completed_turn_prompt_hits_survive_a_clipped_header_row`; E2E: `Feature.AgentMouse` `CompletedTurnMouse` / `CompletedTurnPromptMouse`; hand cursor and absence of action underline manually verified on the exact deployed Dev build.)_
 - [ ] `C242` `[new]` `[UT✓]` `[E2E]` **Mouse wheel scrolls chat without changing the draft:** Wheel input scrolls the chat viewport while Up/Down remain prompt-history controls and the unsent draft stays intact. _(UT: `mouse_wheel_scrolls_chat_without_changing_input_history`; #506; E2E: `Feature.AgentMouse`.)_
 - [ ] `C243` `[new]` `[UT✓]` `[E2E]` **Mouse selection copies text and clears after copy:** Double-click selection survives release, `Ctrl+C` copies the exact selected text with confirmation instead of canceling/closing the pane, and the selection is then cleared. _(UT: `mouse_release_does_not_return_text_for_automatic_copy`, `clearing_selection_resets_multi_click_sequence`; #506; E2E: `Feature.AgentMouse`.)_
+- [ ] `C265` `[new]` `[UT✓]` `[E2E]` **Right-click copies the agent text selection:** A physical right-click copies the exact WTA-owned selection through the OS clipboard, clears it, shows the existing copied confirmation, and never also pastes; the next right-click follows the no-selection Default Paste path without replaying selected text. _(UT: `right_click_copy_event_is_forwarded`, `right_click_copies_and_clears_text_selection`; E2E: `Feature.AgentMouse` `RightClickCopy`.)_
+- [ ] `C269` `[new]` `[UT✓]` `[E2E]` **Right-click without text selection pastes throughout the Chat pane:** A physical right-click on history, input, blank space, or a completed-turn navigation highlight requests Default Paste exactly once into the visible owner draft without submitting; only an actual WTA text selection takes copy precedence. _(UT: `right_click_without_text_selection_requests_owner_default_paste`, `default_paste_request_is_chat_only`; E2E: `Feature.AgentMouse` `RightClickPaste`.)_
 - [ ] `C218` `[new]` `[UT✓]` `[E2E]` **Image paste (Alt+V) works:** A copied screenshot (`CF_DIB`/`CF_DIBV5`) appears as a uniquely numbered cyan inline token such as `[image: image-1.png]`; copied image files retain their real file name. The attachment is sent as an ACP image content block on the next prompt. Left/Right cross the token atomically, Backspace/Delete remove the whole token and attachment, and Esc/Ctrl+C clear the whole draft. The action is gated on the agent advertising image support. When the agent does not support images, or the clipboard has no image, it does not paste but surfaces a clear system message rather than silently ignoring the keypress. _(UT: `clipboard_image`, `image_attachment_*`, and `mock_agent_tests` `seen_images` side-channel; #354.)_
 - [ ] `C254` `[new]` `[UT✓]` `[E2E]` **Image attachment tokens edit atomically:** Left/Right cross an inline image token as one input unit, and Backspace removes the complete attachment without damaging adjacent prompt text. _(UT: `image_attachment_left_and_right_skip_the_whole_inline_token`, `image_attachment_backspace_in_text_preserves_images`; #536; E2E: `Feature.AgentImageAttachmentEditing`.)_
 - [ ] `C066` `[E2E]` **Keyboard navigation works:** Arrow keys, Tab completion, Ctrl combinations, and Esc behave correctly.
@@ -352,6 +357,7 @@ Net effect: UT shrinks the manual matrix to "did the wiring and UI connect", not
 - [x] `C166` `[UT✓]` `[E2E]` **Multiple windows do not cross-route:** Events from one window do not mutate another window's agent pane/session UI. _(UT: `wt_event_critical_from_other_tab_does_not_surface_in_owner_tab` — a helper owning tab A DROPS a connection-failure event broadcast from tab B (no banner, no chat, no notification), the exact cross-route isolation contract; helpers filter inbound events by window_id + owner_tab_id.)_
 - [ ] `C167` `[E2E]` **Close source window is safe:** Closing a source window after moving a tab does not kill the moved tab's agent state.
 - [ ] `C168` `[E2E]` **Close target tab cleans up:** Closing moved tabs cleans up helper/session state without affecting other tabs.
+- [ ] `C275` `[E2E]` **Move tab back to source window preserves the same ACP session:** Redocking an agent tab keeps its helper, chat, and ACP session alive and does not emit session teardown.
 
 ## 8. Agent hooks and session tracking
 
@@ -439,4 +445,4 @@ Net effect: UT shrinks the manual matrix to "did the wiring and UI connect", not
 - Slash commands: `tools\wta\src\commands.rs`.
 - Session state model: `tools\wta\src\agent_sessions.rs`, `tools\wta\AGENTS.md`.
 - Multi-window agent pane architecture: `doc\specs\Multi-window-agent-pane.md`.
-- Autofix flow, logging, and runtime layout: `AGENTS.md`.
+- Autofix flow, logging, and runtime layout: `AGENTS.md`.

src/cascadia/TerminalApp/AgentPaneContent.cpp

@@ -292,6 +292,19 @@ namespace winrt::TerminalApp::implementation
         {
             impl->UpdateSettings(settings);
         }
+
+        const winrt::Microsoft::Terminal::Control::KeyChord ctrlV{ Windows::System::VirtualKeyModifiers::Control, 'V', 0 };
+        if (const auto actionMap = settings.ActionMap())
+        {
+            const auto command = actionMap.GetActionByKeyChord(ctrlV);
+            const auto isPasteAction = command && command.ActionAndArgs().Action() == ShortcutAction::PasteText;
+            GetTermControl().EnableAgentPasteShortcutFallback(
+                !actionMap.IsKeyChordExplicitlyUnbound(ctrlV) && (!command || isPasteAction));
+        }
+        else
+        {
+            GetTermControl().EnableAgentPasteShortcutFallback(false);
+        }
     }
 
     winrt::Windows::Foundation::Size AgentPaneContent::MinimumSize()

src/cascadia/TerminalApp/Pane.cpp

@@ -3426,15 +3426,11 @@ void Pane::SetAgentChipVisible(bool value)
 }
 
 // The connection's session GUID for terminal panes. Returns the empty
-// guid for non-terminal panes (e.g. branch nodes, agent panes, snippets).
+// guid for non-terminal panes (e.g. branch nodes and snippets).
 // Used by Tab to match a protocol-supplied pane id to a Pane.
 winrt::guid Pane::GetSessionId() const
 {
-    // Mirror `_getSessionIdFromPane` in TerminalPage.Protocol.cpp:
-    // walk content → control → connection and read the SessionId. Using
-    // GetContent() (instead of `_content` directly) keeps the non-leaf
-    // case to a clean nullptr without needing an explicit leaf check.
-    if (const auto termContent = GetContent().try_as<winrt::TerminalApp::TerminalPaneContent>())
+    if (const auto termContent = _getTerminalContent())
     {
         if (const auto control = termContent.GetTermControl())
         {

src/cascadia/TerminalApp/SharedWta.cpp

@@ -11,6 +11,13 @@
 #include "../inc/WtaProcess.h"
 #include "AgentPaneLog.h"
 
+namespace
+{
+    // Must remain strictly greater than WTA's 15-second
+    // SESSION_CLOSE_TIMEOUT in tools/wta/src/master/mod.rs.
+    constexpr auto WtaSessionCloseGracePeriod{ std::chrono::seconds{ 16 } };
+}
+
 namespace winrt::TerminalApp::implementation::details
 {
     std::optional<std::wstring> BuildEnvironmentBlock(
@@ -85,15 +92,19 @@ namespace winrt::TerminalApp::implementation
 {
     SharedWta& SharedWta::Instance()
     {
-        // Magic-static initialization is thread-safe in C++11+.
-        static SharedWta s_instance;
-        return s_instance;
+        // Initialization remains thread-safe, but this process singleton must
+        // outlive delayed ReleasePaneAfterSessionClose coroutines. At process
+        // exit Windows closes the Job handle, preserving KILL_ON_JOB_CLOSE
+        // cleanup for the master and its descendants.
+        static auto* const s_instance = new SharedWta;
+        return *s_instance;
     }
 
     SharedWta::~SharedWta()
     {
-        // Process is exiting; tear wta down deterministically via
-        // KILL_ON_JOB_CLOSE rather than letting handles leak.
+        // Process is exiting, so a graceful per-session close can no longer
+        // delay app shutdown. KILL_ON_JOB_CLOSE deterministically reclaims the
+        // master, every agent CLI, and their MCP descendants without orphans.
         //
         // Wait callback synchronisation: cancel the wait WITH a
         // blocking unregister BEFORE we touch the fields it might
@@ -195,6 +206,12 @@ namespace winrt::TerminalApp::implementation
         }
     }
 
+    winrt::fire_and_forget SharedWta::ReleasePaneAfterSessionClose()
+    {
+        co_await winrt::resume_after(WtaSessionCloseGracePeriod);
+        Instance().ReleasePane();
+    }
+
     bool SharedWta::Restart()
     {
         std::lock_guard lock{ _mtx };
@@ -442,7 +459,7 @@ namespace winrt::TerminalApp::implementation
 
         // Containment: a Job Object with KILL_ON_JOB_CLOSE binds
         // wta's lifetime to ours. When the last pane releases (or
-        // Terminal exits and the destructor runs), the job handle
+        // Terminal exits and Windows closes the final handle), the job handle
         // drops and the OS terminates wta + every descendant it
         // spawned. Any failure here MUST TerminateProcess to avoid
         // leaking a suspended-then-uncontained wta.

src/cascadia/TerminalApp/SharedWta.h

@@ -99,6 +99,12 @@ namespace winrt::TerminalApp::implementation
         /// teardown paths that aren't sure whether they acquired).
         void ReleasePane();
 
+        /// Release a previously acquired reference after the bounded ACP
+        /// session-close window. Agent-pane Closed events can fire before
+        /// the owning tab publishes tab_closed, so an immediate final
+        /// release could terminate wta-master before session/close runs.
+        static winrt::fire_and_forget ReleasePaneAfterSessionClose();
+
         /// Force-restart the wta-master process, bypassing the
         /// `AcquirePane`/`ReleasePane` reference count. Used by the
         /// `/restart` slash command path: the caller (TerminalPage)

src/cascadia/TerminalApp/TabManagement.cpp

@@ -754,14 +754,20 @@ namespace winrt::TerminalApp::implementation
         //  - Close-pane (last pane): in _HandleClosePaneRequested
         //  - Close-tab: in _HandleCloseTabRequested
 
+        if (!movingAway)
+        {
+            // Notify WTA while the agent helper is still alive. Shutdown tears down the
+            // helper's ConPTY process, so emitting this afterwards races session/close
+            // against process termination and leaves the ACP session orphaned.
+            _NotifyAgentTabClosed(closedTabStableId);
+        }
+
         // Removing the tab from the collection should destroy its control and disconnect its connection,
         // but it doesn't always do so. The UI tree may still be holding the control and preventing its destruction.
         tab.Shutdown();
 
         if (!movingAway)
         {
-            _NotifyAgentTabClosed(closedTabStableId);
-
             // Preexisting latent leak (made worse by pre-warm): tab close
             // goes through `Tab::Shutdown` → `Pane::Shutdown`, which only
             // calls `_setPaneContent(nullptr)` on each leaf — it does NOT
@@ -779,9 +785,13 @@ namespace winrt::TerminalApp::implementation
             // re-wrapped pane is the new owner), so decrementing here
             // would prematurely zero the refcount and tear down the
             // master that the dragged pane still depends on.
+            // `tab_closed` reaches master asynchronously, and physical ACP
+            // close has a bounded 15-second timeout. Keep the final job-object
+            // reference alive slightly longer so last-tab/window teardown
+            // cannot kill wta-master before session/close completes.
             for (size_t i = 0; i < agentPanesOnTab; ++i)
             {
-                winrt::TerminalApp::implementation::SharedWta::Instance().ReleasePane();
+                SharedWta::ReleasePaneAfterSessionClose();
             }
         }