feat(ipad): W1-W3 — adaptive split-view layout + finding fixes

T-iPad-2: AdaptiveRootView/LayoutPolicy (sole size-class decision), SplitRootView
(NavigationSplitView sidebar+detail), StackRootView (iPhone path verbatim, zero
regression); privacy shade hoisted to shared ZStack top for both branches
T-iPad-3: KeyBarVisibility predicate (hide when hardware keyboard present),
pointer context menu (copy/new-in-cwd/kill, all via existing channels)
T-iPad-4: Projects multi-column grid on iPad (idiom-gated), adaptive sheet detents
T-iPad-5 findings (4/4 fixed): kill onKillSession thread-through +
AppCoordinator.killCurrentSession; split route-gated to .sessions (iPad first-run
pairing); continue-last banner in split sidebar; iPad XCUITest deferred (covered
by SidebarSelectionTests)
Verified: iPhone 16 277 + iPad Pro 11 278 tests green; packages 261 + integration 10;
zero changes under ios/Packages, src/, public/

ios/App/WebTerm/Components/KeyBar.swift

@@ -11,6 +11,28 @@ import UIKit
 /// never pops or fights the soft keyboard — same reason the web bar bypasses
 /// xterm and calls `ws.send`).
 
+// MARK: - Visibility policy (T-iPad-3)
+
+/// Pure predicate deciding whether the soft-keyboard KeyBar
+/// (`inputAccessoryView`) should show — THE single decision point (mirrors
+/// `PrivacyShadePolicy` / `LayoutPolicy`, no scattered checks in views):
+/// - a hardware keyboard makes the on-screen key bar redundant → default hidden;
+/// - no hardware keyboard → shown (unchanged iPhone behavior — zero regression);
+/// - an explicit user toggle (`userOverride`) always wins over the auto default.
+///
+/// Hardware presence is injected (`GCKeyboard.coalesced != nil` at the call
+/// site) so this stays a fast, device-agnostic unit (`KeyBarVisibilityTests`).
+enum KeyBarVisibility {
+    /// - Parameters:
+    ///   - hardwareKeyboardPresent: injected `GCKeyboard.coalesced != nil`.
+    ///   - userOverride: nil = follow the auto default; true/false = the user
+    ///     explicitly forced show/hide (wins over the hardware-driven default).
+    static func isVisible(hardwareKeyboardPresent: Bool, userOverride: Bool?) -> Bool {
+        if let userOverride { return userOverride }
+        return !hardwareKeyboardPresent
+    }
+}
+
 // MARK: - Layout data (mirror of KEYBAR_BUTTONS)
 
 /// One key-bar button: glyph, short function caption (shown under the glyph,

ios/App/WebTerm/Components/TerminalContextMenu.swift

@@ -0,0 +1,144 @@
+import UIKit
+
+/// T-iPad-3 · 终端面板的指针（次要点击/右键）· 长按上下文菜单。
+///
+/// 纯菜单模型（可单测）+ `UIContextMenuInteraction` 桥。每个动作都**复用既有
+/// 通道**，绝不新增网络路径：
+/// - `.copySelection` → SwiftTerm 自带的 `copy(_:)`（读选区 → 剪贴板，绝不改
+///   字节流，纯 UI —— hover 高亮同理）；
+/// - `.newInCwd`      → T-iOS-29 的 `onNewInCwd`（当前会话 cwd fresh spawn）；
+/// - `.kill`          → `onKill`（wiring 侧走 `APIClient.killSession` —— 带
+///   Origin 的 G 端点，RO/G 铁律不变）。
+///
+/// 指针菜单仅在 iPad idiom 启用（`isPointerMenuEnabled`）—— iPhone 长按仍归
+/// SwiftTerm 选区手势，字节级零回归。
+
+/// One context-menu action, each mapped to an existing channel (no new path).
+enum TerminalContextAction: String, CaseIterable, Sendable, Equatable {
+    case copySelection
+    case newInCwd
+    case kill
+}
+
+/// Display spec for one menu row (Chinese copy + SF Symbol + destructive flag).
+struct TerminalContextItem: Equatable, Sendable {
+    let action: TerminalContextAction
+    let title: String
+    let systemImage: String
+    let isDestructive: Bool
+}
+
+enum TerminalContextMenu {
+    /// 用户可见文案（named constants，plan §4）。
+    enum Copy {
+        static let copySelection = "复制选区"
+        static let newInCwd = "在当前目录开新会话"
+        static let kill = "结束会话"
+    }
+
+    private enum Symbol {
+        static let copySelection = "doc.on.doc"
+        static let newInCwd = "plus.rectangle.on.folder"
+        static let kill = "xmark.circle"
+    }
+
+    /// 指针上下文菜单仅在 iPad 启用。设备 idiom 与 size class 正交（不属
+    /// `LayoutPolicy` 的 stack/split 判据），故独立成谓词；iPhone 上不安装
+    /// interaction，长按保持 SwiftTerm 原生选区手势（零回归）。
+    static func isPointerMenuEnabled(idiom: UIUserInterfaceIdiom) -> Bool {
+        idiom == .pad
+    }
+
+    /// 依可用性过滤出菜单项（固定顺序：复制选区 → 开新会话 → 结束会话）。纯函数。
+    static func items(
+        canCopySelection: Bool,
+        canNewInCwd: Bool,
+        canKill: Bool
+    ) -> [TerminalContextItem] {
+        var result: [TerminalContextItem] = []
+        if canCopySelection {
+            result.append(TerminalContextItem(
+                action: .copySelection, title: Copy.copySelection,
+                systemImage: Symbol.copySelection, isDestructive: false
+            ))
+        }
+        if canNewInCwd {
+            result.append(TerminalContextItem(
+                action: .newInCwd, title: Copy.newInCwd,
+                systemImage: Symbol.newInCwd, isDestructive: false
+            ))
+        }
+        if canKill {
+            result.append(TerminalContextItem(
+                action: .kill, title: Copy.kill,
+                systemImage: Symbol.kill, isDestructive: true
+            ))
+        }
+        return result
+    }
+}
+
+/// 上下文菜单的可测装配核：把可用性 + 既有通道闭包收拢成 `items` 与 `perform`。
+/// wiring 供给 `onNewInCwd`（T-iOS-29）/ `onKill`（APIClient.killSession）；
+/// `onCopySelection`/`hasSelection` 由终端视图注入。动作 ↔ 通道一一映射，无旁路。
+@MainActor
+struct TerminalContextMenuModel {
+    let onNewInCwd: (@MainActor () -> Void)?
+    let onKill: (@MainActor () -> Void)?
+    let onCopySelection: @MainActor () -> Void
+    let hasSelection: @MainActor () -> Bool
+
+    /// 当前可用的菜单项：复制选区随实时选区、开新会话/结束会话随 wiring 是否
+    /// 供给了对应闭包（无闭包 = 隐藏，绝不呈现死项）。
+    var items: [TerminalContextItem] {
+        TerminalContextMenu.items(
+            canCopySelection: hasSelection(),
+            canNewInCwd: onNewInCwd != nil,
+            canKill: onKill != nil
+        )
+    }
+
+    /// 把一个动作路由到它对应的既有通道（映射的唯一实现点）。
+    func perform(_ action: TerminalContextAction) {
+        switch action {
+        case .copySelection:
+            onCopySelection()
+        case .newInCwd:
+            onNewInCwd?()
+        case .kill:
+            onKill?()
+        }
+    }
+}
+
+/// `UIContextMenuInteraction` 委托：菜单展开时用 `makeModel()` 取当前快照
+/// （实时选区/闭包），构建 `UIMenu`，每个 `UIAction` 触发 `model.perform`。
+/// 仅在 iPad 由终端视图安装（见 `TerminalContextMenu.isPointerMenuEnabled`）。
+@MainActor
+final class TerminalContextMenuInteractionDelegate: NSObject, UIContextMenuInteractionDelegate {
+    private let makeModel: @MainActor () -> TerminalContextMenuModel
+
+    init(makeModel: @escaping @MainActor () -> TerminalContextMenuModel) {
+        self.makeModel = makeModel
+    }
+
+    func contextMenuInteraction(
+        _ interaction: UIContextMenuInteraction,
+        configurationForMenuAtLocation location: CGPoint
+    ) -> UIContextMenuConfiguration? {
+        let model = makeModel()
+        let items = model.items
+        guard !items.isEmpty else { return nil } // 无可用项 → 不弹菜单
+        return UIContextMenuConfiguration(identifier: nil, previewProvider: nil) { _ in
+            UIMenu(title: "", children: items.map { item in
+                UIAction(
+                    title: item.title,
+                    image: UIImage(systemName: item.systemImage),
+                    attributes: item.isDestructive ? .destructive : []
+                ) { _ in
+                    model.perform(item.action)
+                }
+            })
+        }
+    }
+}

ios/App/WebTerm/Screens/ProjectsLayout.swift

@@ -0,0 +1,73 @@
+import SwiftUI
+import UIKit
+
+/// T-iPad-4 · Projects 大屏化的**纯布局决策** —— 列数 / 是否走网格 / sheet
+/// detents 全部收在本文件的纯函数里（单一判据点，仿 `LayoutPolicy` 先例），
+/// 视图内零散落条件、100% 单测。
+///
+/// **为何按 `UIUserInterfaceIdiom` 而非 `horizontalSizeClass`**（关键、易错）：
+/// iPad 上 Projects 以**表单 sheet**（form sheet）呈现，其内部
+/// `horizontalSizeClass` 恒为 **compact**（与 iPhone 横屏完全相同）。因此
+/// size class 无法在「iPhone 横屏零回归」的前提下区分「iPhone」与「iPad 的
+/// Projects 表单 sheet」—— 只有设备 idiom 能。故 Projects 自身的多列/卡片
+/// 决策以 idiom+宽度为判据；根视图的 stack/split 决策仍由 `LayoutPolicy`
+/// （唯一 size-class 读取点）负责，两者正交、各自单点。
+enum ProjectsGridLayout {
+    /// iPhone / 极窄 iPad 的回退列数（现有单列布局）。
+    static let singleColumn = 1
+    /// iPad 下升到 2 列的最小可用宽度（表单 sheet 内宽 ~440–540pt 即两列）。
+    static let twoColumnMinWidth: CGFloat = 400
+    /// iPad 下升到 3 列的最小可用宽度（更宽的面板/横屏全宽时）。
+    static let threeColumnMinWidth: CGFloat = 760
+
+    /// iPhone（`.phone`，任何朝向/尺寸）→ 恒 `singleColumn`（现有单列 List，
+    /// 字节级不变）。iPad（`.pad`）→ 按**可用宽度** 1–3 列。恒 `>= 1`（永不
+    /// 返回 0，防空网格）。
+    static func columnCount(
+        availableWidth: CGFloat,
+        idiom: UIUserInterfaceIdiom
+    ) -> Int {
+        guard idiom == .pad else { return singleColumn }
+        if availableWidth >= threeColumnMinWidth { return 3 }
+        if availableWidth >= twoColumnMinWidth { return 2 }
+        return singleColumn
+    }
+
+    /// 容器选择：iPad → 多列网格；其它（iPhone）→ 现有单列 List（零回归）。
+    static func usesGrid(idiom: UIUserInterfaceIdiom) -> Bool {
+        idiom == .pad
+    }
+}
+
+/// T-iPad-4 · Projects sheet 的自适应 detents 决策（同一 idiom 判据）。
+enum ProjectsSheetSizing {
+    /// iPhone → `nil`：**不套 `.presentationDetents`**，保持现有默认全高 sheet
+    /// （iPhone 字节级不变）。iPad → 卡片式 `[.medium, .large]`：不铺满大屏，
+    /// 仍可上拉到大。
+    static func detents(idiom: UIUserInterfaceIdiom) -> Set<PresentationDetent>? {
+        idiom == .pad ? [.medium, .large] : nil
+    }
+}
+
+// MARK: - 应用点（把「iPhone 不套、iPad 套 detents」收进一个 modifier）
+
+/// 条件套 `.presentationDetents` 的 modifier —— nil 时 `content` 原样透传，
+/// 故 iPhone 分支不引入任何 sheet 尺寸修饰符（零回归）。
+private struct AdaptiveSheetDetents: ViewModifier {
+    let detents: Set<PresentationDetent>?
+
+    func body(content: Content) -> some View {
+        if let detents {
+            content.presentationDetents(detents)
+        } else {
+            content
+        }
+    }
+}
+
+extension View {
+    /// iPhone 透传（现有全高 sheet，字节级不变）；iPad 套卡片式 detents。
+    func adaptiveProjectsSheetDetents(idiom: UIUserInterfaceIdiom) -> some View {
+        modifier(AdaptiveSheetDetents(detents: ProjectsSheetSizing.detents(idiom: idiom)))
+    }
+}

ios/App/WebTerm/Screens/ProjectsScreen.swift

@@ -11,14 +11,26 @@ struct ProjectsScreen: View {
     @Bindable var viewModel: ProjectsViewModel
     /// "在此仓库开新会话" 导航钩子（AppCoordinator.openProject 消费）。
     var onOpen: (ProjectOpenRequest) -> Void = { _ in }
+    /// T-iPad-4 · 设备 idiom 只在此读一次，交给 `ProjectsGridLayout`/
+    /// `ProjectsSheetSizing` 决策（视图里零散落条件）。iPhone → 现有单列 List
+    /// （字节级不变）；iPad → 多列网格 + 卡片式 sheet detents。idiom 是设备常量、
+    /// 运行期不变，故非 @Environment 即可。见 `ProjectsLayout` 注释解释为何用
+    /// idiom 而非 size class（iPad 表单 sheet 内部恒 compact）。
+    private var idiom: UIUserInterfaceIdiom { UIDevice.current.userInterfaceIdiom }
 
     private enum Metrics {
         static let rowSpacing: CGFloat = 2
         static let chipSpacing: CGFloat = 6
+        // T-iPad-4 · 多列网格专属度量 —— 只走 iPad（.pad）分支，iPhone 不受影响。
+        static let gridSectionSpacing: CGFloat = 12
+        static let gridPadding: CGFloat = 16
+        static let gridCardVerticalPadding: CGFloat = 8
+        static let gridCardHorizontalPadding: CGFloat = 10
+        static let gridCardCornerRadius: CGFloat = 10
     }
 
     var body: some View {
-        list
+        adaptiveContent
             .navigationTitle(ProjectsCopy.title)
             .navigationBarTitleDisplayMode(.inline)
             .searchable(text: $viewModel.searchText, prompt: ProjectsCopy.searchPrompt)
@@ -36,6 +48,22 @@ struct ProjectsScreen: View {
                     onOpenClaude: { viewModel.requestOpenClaude(cwd: $0) }
                 )
             }
+            // T-iPad-4 · iPhone 透传（现有全高 sheet 字节级不变）；iPad 套
+            // 卡片式 detents（不铺满大屏）。
+            .adaptiveProjectsSheetDetents(idiom: idiom)
+    }
+
+    // MARK: - 自适应容器（唯一 idiom 消费点，经 ProjectsGridLayout）
+
+    /// iPhone → 现有单列 `list`（原样复用，字节级零回归）；iPad → 多列
+    /// `gridList`。分组/折叠/收藏/prefs 往返全部是同一 `ProjectsViewModel`
+    /// 逻辑，两条路径只换视觉容器。
+    @ViewBuilder private var adaptiveContent: some View {
+        if ProjectsGridLayout.usesGrid(idiom: idiom) {
+            gridList
+        } else {
+            list
+        }
     }
 
     // MARK: - List
@@ -61,6 +89,75 @@ struct ProjectsScreen: View {
         }
     }
 
+    // MARK: - Grid（regular 宽度：多列网格）
+
+    /// iPad 分栏/大屏下的多列网格。列数由 `ProjectsGridLayout.columnCount` 按
+    /// **可用宽度**（GeometryReader）决定；分组头/折叠/收藏/行渲染全部复用 List
+    /// 路径的同名 builder（`groupHeader`/`projectRow`/`errorRows`）—— 只换外层
+    /// 容器，分组/收藏/prefs 往返逻辑零改。
+    private var gridList: some View {
+        GeometryReader { proxy in
+            let columns = ProjectsGridLayout.columnCount(
+                availableWidth: proxy.size.width,
+                idiom: idiom
+            )
+            ScrollView {
+                LazyVStack(alignment: .leading, spacing: Metrics.gridSectionSpacing) {
+                    errorRows
+                    if let message = viewModel.emptyStateMessage {
+                        Text(message)
+                            .foregroundStyle(.secondary)
+                            .frame(maxWidth: .infinity, alignment: .center)
+                    }
+                    ForEach(viewModel.groups) { group in
+                        gridSection(group, columns: columns)
+                    }
+                }
+                .padding(Metrics.gridPadding)
+            }
+            .overlay {
+                if !viewModel.hasLoadedOnce && viewModel.fetchErrorMessage == nil {
+                    ProgressView()
+                }
+            }
+        }
+    }
+
+    @ViewBuilder private func gridSection(_ group: ProjectGroup, columns: Int) -> some View {
+        let isCollapsed = viewModel.isCollapsed(group)
+        VStack(alignment: .leading, spacing: Metrics.rowSpacing) {
+            if group.kind != .flat {
+                groupHeader(group, isCollapsed: isCollapsed)
+                    .padding(.top, Metrics.gridSectionSpacing)
+            }
+            if !isCollapsed {
+                LazyVGrid(
+                    columns: gridColumns(columns),
+                    alignment: .leading,
+                    spacing: Metrics.chipSpacing
+                ) {
+                    ForEach(group.projects, id: \.path) { project in
+                        projectRow(project, group: group)
+                            .padding(.vertical, Metrics.gridCardVerticalPadding)
+                            .padding(.horizontal, Metrics.gridCardHorizontalPadding)
+                            .background(
+                                .quaternary,
+                                in: RoundedRectangle(cornerRadius: Metrics.gridCardCornerRadius)
+                            )
+                    }
+                }
+            }
+        }
+    }
+
+    /// 等宽弹性列（`columns >= 1` 由 `ProjectsGridLayout` 保证，绝不空网格）。
+    private func gridColumns(_ count: Int) -> [GridItem] {
+        Array(
+            repeating: GridItem(.flexible(), spacing: Metrics.chipSpacing),
+            count: max(count, ProjectsGridLayout.singleColumn)
+        )
+    }
+
     /// 显式错误行（刷新失败留旧列表、prefs 失败降级本地 —— 都要可见）。
     @ViewBuilder private var errorRows: some View {
         ForEach(

ios/App/WebTerm/Screens/TerminalScreen.swift

@@ -1,3 +1,4 @@
+import GameController
 import SessionCore
 import SwiftTerm
 import SwiftUI
@@ -25,6 +26,16 @@ struct TerminalScreen: View {
     /// `AppCoordinator.openNewSessionInCurrentCwd`）。nil = 两处入口都隐藏
     /// （预览/无 coordinator 的测试环境）。
     var onNewSessionInCwd: (@MainActor () -> Void)? = nil
+    /// T-iPad-3 · 上下文菜单「结束会话」动作 —— wiring 侧路由到
+    /// `APIClient.killSession`（带 Origin 的 G 端点）。nil = 无 kill 通道时
+    /// 菜单不呈现该项（预览/未布线环境）。
+    var onKillSession: (@MainActor () -> Void)? = nil
+
+    /// T-iPad-3 · 硬件键盘在场标记（`GCKeyboard.coalesced != nil`），随
+    /// 连接/断开通知更新，驱动 `KeyBarVisibility` 的自动默认。
+    @State private var hasHardwareKeyboard = GCKeyboard.coalesced != nil
+    /// T-iPad-3 · 用户对 KeyBar 的显式覆盖：nil = 跟随自动默认。
+    @State private var keyBarUserOverride: Bool?
 
     private enum Metrics {
         static let bannerHorizontalPadding: CGFloat = 12
@@ -33,10 +44,25 @@ struct TerminalScreen: View {
 
     private enum Copy {
         static let newSessionInCwd = "在当前目录开新会话"
+        static let showKeyBar = "显示快捷键栏"
+        static let hideKeyBar = "隐藏快捷键栏"
+    }
+
+    /// KeyBar 是否可见 —— 唯一判据经 `KeyBarVisibility` 纯谓词。
+    private var isKeyBarVisible: Bool {
+        KeyBarVisibility.isVisible(
+            hardwareKeyboardPresent: hasHardwareKeyboard,
+            userOverride: keyBarUserOverride
+        )
     }
 
     var body: some View {
-        TerminalHostView(viewModel: viewModel)
+        TerminalHostView(
+            viewModel: viewModel,
+            keyBarVisible: isKeyBarVisible,
+            onNewSessionInCwd: onNewSessionInCwd,
+            onKillSession: onKillSession
+        )
             .ignoresSafeArea(.container, edges: .bottom)
             .overlay(alignment: .top) {
                 if let model = viewModel.bannerModel {
@@ -47,10 +73,39 @@ struct TerminalScreen: View {
                 }
             }
             .animation(.default, value: viewModel.bannerModel)
-            .toolbar { newSessionToolbarItem }
+            .toolbar {
+                newSessionToolbarItem
+                keyBarToggleToolbarItem
+            }
+            .onReceive(NotificationCenter.default.publisher(for: .GCKeyboardDidConnect)) { _ in
+                hasHardwareKeyboard = true
+            }
+            .onReceive(NotificationCenter.default.publisher(for: .GCKeyboardDidDisconnect)) { _ in
+                hasHardwareKeyboard = GCKeyboard.coalesced != nil
+            }
             .onAppear { viewModel.start() }
     }
 
+    /// T-iPad-3 · KeyBar 手动切换。仅在硬件键盘在场时出现 —— 无硬件键盘的
+    /// iPhone 默认工具栏因此逐屏不变（零回归）；有硬件键盘时（自动隐藏后）
+    /// 用户可一键取回/再隐。切换即写显式覆盖，压过自动默认。
+    @ToolbarContentBuilder private var keyBarToggleToolbarItem: some ToolbarContent {
+        if hasHardwareKeyboard {
+            ToolbarItem(placement: .topBarTrailing) {
+                Button {
+                    keyBarUserOverride = !isKeyBarVisible
+                } label: {
+                    Label(
+                        isKeyBarVisible ? Copy.hideKeyBar : Copy.showKeyBar,
+                        systemImage: isKeyBarVisible
+                            ? "keyboard.chevron.compact.down" : "keyboard"
+                    )
+                }
+                .accessibilityIdentifier("terminal.keyBarToggleButton")
+            }
+        }
+    }
+
     /// Mirrors web `tabs.ts newTab()` (M6): the + affordance opens a fresh
     /// session in the active session's cwd, if known.
     @ToolbarContentBuilder private var newSessionToolbarItem: some ToolbarContent {
@@ -74,6 +129,11 @@ struct TerminalScreen: View {
 /// `KeyCommandTerminalView` subclass. Both route through the ViewModel.
 private struct TerminalHostView: UIViewRepresentable {
     let viewModel: TerminalViewModel
+    /// T-iPad-3 · KeyBar (`inputAccessoryView`) 可见性，由 `KeyBarVisibility`
+    /// 谓词在 SwiftUI 侧算出；`updateUIView` 仅在变化时增量应用。
+    let keyBarVisible: Bool
+    var onNewSessionInCwd: (@MainActor () -> Void)? = nil
+    var onKillSession: (@MainActor () -> Void)? = nil
 
     func makeCoordinator() -> Coordinator {
         Coordinator(viewModel: viewModel)
@@ -88,7 +148,14 @@ private struct TerminalHostView: UIViewRepresentable {
 
         let keyBar = KeyBarView()
         keyBar.onKey = { key in viewModel.send(key: key) }
-        terminal.inputAccessoryView = keyBar
+        terminal.installKeyBar(keyBar, visible: keyBarVisible)
+
+        // T-iPad-3 · 指针右键/长按上下文菜单（仅 iPad 安装 —— iPhone 长按保持
+        // SwiftTerm 选区手势）。动作复用既有通道，无新增网络路径。
+        terminal.installPointerContextMenuIfSupported(
+            onNewInCwd: onNewSessionInCwd,
+            onKill: onKillSession
+        )
 
         // Output sink: buffered replay flushes now, live bytes follow.
         // @MainActor-typed closure — feeding off the main actor cannot compile.
@@ -100,7 +167,10 @@ private struct TerminalHostView: UIViewRepresentable {
 
     func updateUIView(_ uiView: KeyCommandTerminalView, context: Context) {
         // State-driven UI lives in SwiftUI (banner overlay); the terminal view
-        // itself is driven by the sink/delegate, nothing to push here.
+        // itself is driven by the sink/delegate. The only push is the KeyBar
+        // visibility (hardware-keyboard aware / user toggle) — a no-op unless it
+        // actually changed, so iPhone (always-visible) never reloads input views.
+        uiView.setKeyBarVisible(keyBarVisible)
     }
 
     /// SwiftTerm's delegate is a pre-concurrency protocol; the conformance is
@@ -164,6 +234,14 @@ final class KeyCommandTerminalView: TerminalView {
     /// Chord outlet; the screen routes it to `TerminalViewModel.send(key:)`.
     var onKeyCommand: (@MainActor (KeyByteMap.Key) -> Void)?
 
+    /// Retained KeyBar so visibility can toggle it in/out of `inputAccessoryView`
+    /// (T-iPad-3). The last-applied value avoids reloading input views when the
+    /// visibility did not change (iPhone stays byte-identical).
+    private var keyBar: KeyBarView?
+    private var appliedKeyBarVisible = true
+    /// Retained so the interaction's delegate outlives menu presentation.
+    private var contextMenuDelegate: TerminalContextMenuInteractionDelegate?
+
     override var keyCommands: [UIKeyCommand]? {
         (super.keyCommands ?? [])
             + HardwareKeyCommands.build(action: #selector(runHardwareKeyCommand(_:)))
@@ -173,4 +251,64 @@ final class KeyCommandTerminalView: TerminalView {
         guard let key = HardwareKeyCommands.key(matching: sender) else { return }
         onKeyCommand?(key)
     }
+
+    // MARK: - KeyBar install / visibility (T-iPad-3)
+
+    /// Install the KeyBar as `inputAccessoryView`, honoring the initial
+    /// visibility (hidden when a hardware keyboard makes it redundant).
+    func installKeyBar(_ bar: KeyBarView, visible: Bool) {
+        keyBar = bar
+        appliedKeyBarVisible = visible
+        inputAccessoryView = visible ? bar : nil
+    }
+
+    /// Apply a visibility change; a no-op when unchanged so no needless
+    /// `reloadInputViews()` (the KeyByteMap routing on `keyBar.onKey` is
+    /// untouched — the same bar is only detached/re-attached).
+    func setKeyBarVisible(_ visible: Bool) {
+        guard visible != appliedKeyBarVisible else { return }
+        appliedKeyBarVisible = visible
+        inputAccessoryView = visible ? keyBar : nil
+        reloadInputViews()
+    }
+
+    // MARK: - Pointer context menu (T-iPad-3, iPad only)
+
+    /// Install the secondary-click / long-press context menu — iPad only, so
+    /// iPhone long-press keeps SwiftTerm's native selection gesture (zero
+    /// regression). The delegate builds a fresh model per presentation so the
+    /// copy item reflects the live selection.
+    func installPointerContextMenuIfSupported(
+        onNewInCwd: (@MainActor () -> Void)?,
+        onKill: (@MainActor () -> Void)?
+    ) {
+        // `UIDevice.current.userInterfaceIdiom` (not `traitCollection`, which can
+        // be `.unspecified` before the view joins a window at makeUIView time).
+        guard TerminalContextMenu.isPointerMenuEnabled(
+            idiom: UIDevice.current.userInterfaceIdiom
+        ) else { return }
+        let delegate = TerminalContextMenuInteractionDelegate { [weak self] in
+            TerminalContextMenuModel(
+                onNewInCwd: onNewInCwd,
+                onKill: onKill,
+                onCopySelection: { [weak self] in self?.copySelectionToPasteboard() },
+                hasSelection: { [weak self] in self?.hasActiveSelection ?? false }
+            )
+        }
+        contextMenuDelegate = delegate
+        addInteraction(UIContextMenuInteraction(delegate: delegate))
+    }
+
+    /// Whether a selection exists — reuses SwiftTerm's own `copy` eligibility
+    /// (`canPerformAction` returns `selection.active`); pure read, no bytes.
+    var hasActiveSelection: Bool {
+        canPerformAction(#selector(UIResponderStandardEditActions.copy(_:)), withSender: nil)
+    }
+
+    /// Copy the current selection via SwiftTerm's own `copy(_:)` (selection →
+    /// `UIPasteboard`). Pure UI: it never writes to the PTY, so the byte stream
+    /// is untouched (invariant preserved — same as pointer hover highlight).
+    func copySelectionToPasteboard() {
+        copy(nil)
+    }
 }

ios/App/WebTerm/Wiring/AdaptiveRootView.swift

@@ -0,0 +1,110 @@
+import SwiftUI
+
+/// T-iPad-2 · size-class 驱动的单一根视图。按 `LayoutPolicy.mode` 在 compact
+/// 宽度（iPhone / iPad Slide Over）选 `StackRootView`（现有路径，字节级不变）、
+/// 在 regular 宽度（iPad 全屏 / 大分屏 / Stage Manager 大窗）选 `SplitRootView`
+/// （分栏）。
+///
+/// **横切布线只声明一次、两分支共享**（PLAN_IOS_IPAD §5 T-iPad-2）：
+/// - 隐私遮罩：ZStack 的**最顶层**，覆盖整棵导航树（含 split detail 的终端
+///   字节）——`scenePhase != .active` 即遮（安全不变式，见 `PrivacyShadePolicy`）。
+///   上提到这里，split detail 与 stack push 同样被遮，无遗漏。
+/// - `.task` bootstrap / `.onChange(scenePhase)` / `.onOpenURL` / deep-link 提示
+///   alert / add-host sheet / Projects sheet：全部设备无关，原样从旧 `RootView`
+///   搬到这一层，故 compact 分支拿到与适配前完全一致的横切行为。
+///
+/// size class 是**运行时可变量**（iPad 拉出 Slide Over 立刻 regular→compact），
+/// 所以这不是两套 UI 分叉，而是同一次运行内的自适应切换：`terminalController`
+/// 归 `AppCoordinator` 所有，与布局分支正交，切换时不重建（T-iOS-29 `.id`
+/// 稳定性的前提）。
+struct AdaptiveRootView: View {
+    @Bindable var coordinator: AppCoordinator
+    @Environment(\.scenePhase) private var scenePhase
+    @Environment(\.horizontalSizeClass) private var horizontalSizeClass
+
+    var body: some View {
+        ZStack {
+            layoutBranch
+            if PrivacyShadePolicy.isShadeVisible(for: scenePhase) {
+                PrivacyShadeView()
+            }
+        }
+        .task { await coordinator.bootstrap() }
+        .onChange(of: scenePhase) { _, phase in
+            coordinator.handleScenePhase(phase)
+        }
+        .onOpenURL { coordinator.handleDeepLink(url: $0) } // T-iOS-22
+        .alert(DeepLinkCopy.hintTitle, isPresented: deepLinkHintBinding) {
+            Button(DeepLinkCopy.hintConfirm) { coordinator.deepLink.clearHint() }
+        } message: {
+            Text(coordinator.deepLink.hintMessage ?? "")
+        }
+        .sheet(
+            isPresented: $coordinator.isAddHostPresented,
+            onDismiss: { coordinator.addHostDismissed() }
+        ) {
+            addHostSheet
+        }
+        .sheet(
+            isPresented: $coordinator.isProjectsPresented,
+            onDismiss: { coordinator.projectsDismissed() }
+        ) {
+            projectsSheet
+        }
+    }
+
+    // MARK: - Layout branch (the SOLE size-class consumer)
+
+    @ViewBuilder private var layoutBranch: some View {
+        // Split only makes sense once we're in the session list. `.loading` and
+        // `.pairing` (genuine iPad first-run, no paired host) get the full-screen
+        // stack flow regardless of size class — a split sidebar has nothing to
+        // list yet and would strand the user on the not-paired empty state
+        // (T-iPad-5 finding). Route-gate the split branch.
+        switch LayoutPolicy.mode(horizontalSizeClass: horizontalSizeClass) {
+        case .split where coordinator.route == .sessions:
+            SplitRootView(coordinator: coordinator)
+        default:
+            StackRootView(coordinator: coordinator)
+        }
+    }
+
+    // MARK: - Deep-link hint alert (T-iOS-22)
+
+    /// unknown host / store failure 提示（同旧 `RootView`）。
+    private var deepLinkHintBinding: Binding<Bool> {
+        Binding(
+            get: { coordinator.deepLink.hintMessage != nil },
+            set: { presented in
+                guard !presented else { return }
+                coordinator.deepLink.clearHint()
+            }
+        )
+    }
+
+    // MARK: - Add-host sheet (multi-host entry, list header)
+
+    @ViewBuilder private var addHostSheet: some View {
+        if let viewModel = coordinator.addHostPairingViewModel {
+            NavigationStack {
+                PairingScreen(viewModel: viewModel) { host in
+                    coordinator.completeAddHost(host)
+                }
+            }
+        }
+    }
+
+    // MARK: - Projects sheet (T-iOS-26)
+
+    /// 自带 NavigationStack：列表 → 详情 → 差异都在 sheet 内 push；
+    /// "在此仓库开新会话" 关掉 sheet 并在根导航开终端。
+    @ViewBuilder private var projectsSheet: some View {
+        if let viewModel = coordinator.projectsViewModel {
+            NavigationStack {
+                ProjectsScreen(viewModel: viewModel) { request in
+                    coordinator.openProject(request)
+                }
+            }
+        }
+    }
+}

ios/App/WebTerm/Wiring/AppCoordinator.swift

@@ -170,6 +170,62 @@ final class AppCoordinator {
         terminalController = nil
     }
 
+    /// T-iPad-3 · 终端指针上下文菜单「结束会话」→ 复用既有 kill 通道
+    /// （`SessionListViewModel.kill` → `APIClient.killSession`，带 Origin，无新
+    /// 网络路径），随后 detach detail。无 adopted 会话 → no-op。
+    func killCurrentSession() {
+        guard let sessionId = terminalController?.terminalViewModel.sessionId else { return }
+        Task { await sessionList.kill(sessionId: sessionId) }
+        closeTerminal()
+    }
+
+    // MARK: - Split-view sidebar bridge (T-iPad-2)
+
+    /// Detail 面板当前显示的会话 → sidebar 选中态（二向绑定的 getter）。只反映
+    /// **adopted** 会话；未 adopted / 无打开的 detail → nil（占位「选择或新建
+    /// 会话」）。分栏与 stack 共享同一 `terminalController`（归 coordinator
+    /// 所有，与布局分支正交）。
+    var selectedSidebarItem: SidebarItem? {
+        terminalController?.terminalViewModel.sessionId.map(SidebarItem.session)
+    }
+
+    /// `NavigationSplitView` 的选中绑定。getter 反映 detail 会话；setter 复用
+    /// 既有路由（`open` / `presentProjects`）—— 分栏只是又一个触发面，绝不新开
+    /// 一条会话生命周期。取消选中（set nil）不主动关闭 detail。
+    var sidebarSelection: Binding<SidebarItem?> {
+        Binding(
+            get: { self.selectedSidebarItem },
+            set: { item in
+                guard let item else { return }
+                self.selectSidebarItem(item)
+            }
+        )
+    }
+
+    /// sidebar 触发面：把选中项映射到**同一** open(id) / open(nil) /
+    /// presentProjects API。切会话沿用单活 WS 不变式的 close→open（与
+    /// new-in-cwd / deep-link 切换同一套原语），`.projects` 走既有 sheet 呈现。
+    func selectSidebarItem(_ item: SidebarItem) {
+        switch item {
+        case .session(let sessionId):
+            switchTerminal(sessionId: sessionId)
+        case .newSession:
+            switchTerminal(sessionId: nil)
+        case .projects:
+            presentProjects()
+        }
+    }
+
+    /// 单活 WS 不变式下的会话切换：已在显示同一会话 → no-op（免无谓 churn）；
+    /// 否则先 `closeTerminal()`（旧会话记 last-seen 水位、engine detach）再
+    /// `open()`。复用既有原语，**非**平行生命周期。无 activeHost → no-op。
+    private func switchTerminal(sessionId: UUID?) {
+        guard let host = sessionList.activeHost else { return }
+        if let sessionId, selectedSidebarItem == .session(sessionId) { return }
+        if terminalController != nil { closeTerminal() }
+        open(SessionListViewModel.OpenRequest(id: UUID(), host: host, sessionId: sessionId))
+    }
+
     // MARK: - "在当前目录开新会话" (T-iOS-29)
 
     /// 当前终端会话的 cwd。解析次序：/live-sessions 行数据（server-adopted
@@ -235,3 +291,12 @@ final class AppCoordinator {
         PairingViewModel(store: environment.hostStore, probe: environment.probe)
     }
 }
+
+/// T-iPad-2 · split 模式下 sidebar 的选中项。与现有 `AppCoordinator` 路由
+/// 一一等价映射：`.session(id)` == `open(id)`、`.newSession` == `open(nil)`、
+/// `.projects` == `presentProjects()`。
+enum SidebarItem: Hashable {
+    case session(UUID)
+    case newSession
+    case projects
+}

ios/App/WebTerm/Wiring/LayoutMode.swift

@@ -0,0 +1,22 @@
+import SwiftUI
+
+/// T-iPad-2 · 自适应根视图的布局模式。
+public enum LayoutMode: Equatable {
+    /// 现有 iPhone 路径：`NavigationStack`（列表 → push 终端）。
+    case stack
+    /// iPad 分栏：`NavigationSplitView`（sidebar 会话列表 + detail 终端）。
+    case split
+}
+
+/// T-iPad-2 · **唯一** size-class 决策点（仿 `PrivacyShadePolicy` 的纯谓词
+/// 先例）。视图内严禁散落 `if sizeClass == …`（PLAN_IOS_IPAD §4）—— 所有
+/// 分支只从这里读一次，故可 100% 单测。
+///
+/// regular 宽度（iPad 全屏 / 大分屏 / Stage Manager 大窗）→ `.split`；
+/// compact 或 nil（iPhone / iPad Slide Over / 小分屏 / size class 未定）→
+/// `.stack`。nil 走最保守回退：退到现有已测的 iPhone 路径，绝不误判成分栏。
+public enum LayoutPolicy {
+    public static func mode(horizontalSizeClass: UserInterfaceSizeClass?) -> LayoutMode {
+        horizontalSizeClass == .regular ? .split : .stack
+    }
+}

ios/App/WebTerm/Wiring/RootView.swift

@@ -1,62 +1,39 @@
 import HostRegistry
 import SwiftUI
 
-/// T-iOS-15 · Root of the app: route switch (Pairing / SessionList), terminal
-/// push, add-host sheet, scenePhase forwarding and the privacy shade.
+/// T-iOS-15 / T-iPad-2 · App 根入口。历史上这里是单一 `NavigationStack` +
+/// 隐私遮罩 + sheets/scenePhase/deepLink 的全部布线；iPad 自适应（T-iPad-2）
+/// 把它拆成两层：
+/// - `RootView`（本 struct）保持 `@main` 的唯一实例化点不变（WebTermApp 仍
+///   `RootView(coordinator:)`），内部只委托给 `AdaptiveRootView`。
+/// - `AdaptiveRootView` 按 `horizontalSizeClass` 选 `StackRootView`（compact，
+///   现有路径，字节级不变）或 `SplitRootView`（regular，iPad 分栏），并把
+///   隐私遮罩 / scenePhase / deepLink / sheets 这些**设备无关的横切布线**
+///   上提到唯一一处，两分支共享（遮罩因此仍是两分支共同的 ZStack 顶层）。
 ///
-/// The shade is the TOPMOST layer of this ZStack and appears whenever
-/// `scenePhase != .active` (exact rule — PrivacyShadePolicy + tests); it
-/// covers the whole navigation tree, terminal included. Sheets live above any
-/// overlay, but no sheet renders terminal bytes (pairing / plan gate only).
+/// `StackRootView` 是原 `RootView` 的 body **原样搬迁** —— compact 分支复用它
+/// 不改一行，故 iPhone 逐屏渲染与适配前一致（零回归硬性要求）。
 struct RootView: View {
     @Bindable var coordinator: AppCoordinator
-    @Environment(\.scenePhase) private var scenePhase
 
     var body: some View {
-        ZStack {
-            NavigationStack {
-                rootContent
-                    .navigationDestination(isPresented: terminalBinding) {
-                        terminalDestination
-                    }
-            }
-            if PrivacyShadePolicy.isShadeVisible(for: scenePhase) {
-                PrivacyShadeView()
-            }
-        }
-        .task { await coordinator.bootstrap() }
-        .onChange(of: scenePhase) { _, phase in
-            coordinator.handleScenePhase(phase)
-        }
-        .onOpenURL { coordinator.handleDeepLink(url: $0) } // T-iOS-22
-        .alert(DeepLinkCopy.hintTitle, isPresented: deepLinkHintBinding) {
-            Button(DeepLinkCopy.hintConfirm) { coordinator.deepLink.clearHint() }
-        } message: {
-            Text(coordinator.deepLink.hintMessage ?? "")
-        }
-        .sheet(
-            isPresented: $coordinator.isAddHostPresented,
-            onDismiss: { coordinator.addHostDismissed() }
-        ) {
-            addHostSheet
-        }
-        .sheet(
-            isPresented: $coordinator.isProjectsPresented,
-            onDismiss: { coordinator.projectsDismissed() }
-        ) {
-            projectsSheet
-        }
+        AdaptiveRootView(coordinator: coordinator)
     }
+}
 
-    /// Deep-link hint alert (unknown host / store failure, T-iOS-22).
-    private var deepLinkHintBinding: Binding<Bool> {
-        Binding(
-            get: { coordinator.deepLink.hintMessage != nil },
-            set: { presented in
-                guard !presented else { return }
-                coordinator.deepLink.clearHint()
-            }
-        )
+/// T-iPad-2 · compact 宽度（iPhone / iPad Slide Over）的根视图 —— 原
+/// `RootView` 的 `NavigationStack` 主体原样搬迁，行为字节级不变。横切布线
+/// （遮罩/scenePhase/deepLink/sheets）不在这里，已上提到 `AdaptiveRootView`。
+struct StackRootView: View {
+    @Bindable var coordinator: AppCoordinator
+
+    var body: some View {
+        NavigationStack {
+            rootContent
+                .navigationDestination(isPresented: terminalBinding) {
+                    terminalDestination
+                }
+        }
     }
 
     // MARK: - Route switch
@@ -140,7 +117,8 @@ struct RootView: View {
         if let controller = coordinator.terminalController {
             TerminalContainerView(
                 controller: controller,
-                onNewSessionInCwd: { coordinator.openNewSessionInCurrentCwd() }
+                onNewSessionInCwd: { coordinator.openNewSessionInCurrentCwd() },
+                onKillSession: { coordinator.killCurrentSession() } // T-iPad-3
             )
             // T-iOS-29 · identity PER CONTROLLER: an in-place session switch
             // (new-in-cwd, deep link) swaps the controller while the
@@ -151,40 +129,15 @@ struct RootView: View {
             .id(controller.id)
         }
     }
-
-    // MARK: - Add-host sheet (multi-host entry, list header)
-
-    @ViewBuilder private var addHostSheet: some View {
-        if let viewModel = coordinator.addHostPairingViewModel {
-            NavigationStack {
-                PairingScreen(viewModel: viewModel) { host in
-                    coordinator.completeAddHost(host)
-                }
-            }
-        }
-    }
-
-    // MARK: - Projects sheet (T-iOS-26)
-
-    /// 自带 NavigationStack：列表 → 详情 → 差异都在 sheet 内 push；
-    /// "在此仓库开新会话" 关掉 sheet 并在根导航推入终端。
-    @ViewBuilder private var projectsSheet: some View {
-        if let viewModel = coordinator.projectsViewModel {
-            NavigationStack {
-                ProjectsScreen(viewModel: viewModel) { request in
-                    coordinator.openProject(request)
-                }
-            }
-        }
-    }
 }
 
-private enum RootMetrics {
+enum RootMetrics {
     static let bannerHorizontalPadding: CGFloat = 16
     static let bannerVerticalPadding: CGFloat = 8
 }
 
-private enum RootCopy {
+/// 根层用户可见文案（internal —— `SplitRootView` 复用同一「项目」标签，DRY）。
+enum RootCopy {
     static let continueLast = "继续上次会话"
     static let projects = "项目"
 }

ios/App/WebTerm/Wiring/SplitRootView.swift

@@ -0,0 +1,110 @@
+import SwiftUI
+
+/// T-iPad-2 · regular 宽度（iPad 全屏 / 大分屏 / Stage Manager 大窗）的分栏根
+/// 视图。左 sidebar = 会话列表（复用 `SessionListScreen` **不改一行** + 与
+/// stack 同款的「项目」leading 工具栏入口）；右 detail = `TerminalContainerView`
+/// （终端 + gate/digest 叠层，复用不动），无打开会话时给「选择或新建会话」占位。
+///
+/// 设计要点：
+/// - **detail 复用 `TerminalContainerView`**：终端组装与它挂 push destination 还是
+///   split detail 无关，只换外层容器、内容零改（PLAN_IOS_IPAD §1）。
+/// - **选中态经 `AppCoordinator` 单一真值**：sidebar 触发面全部走
+///   `selectSidebarItem` / `open`（同 stack 的既有路由），不新开会话生命周期。
+/// - **detail 终端仍带 `.id(controller.id)`**：换会话时新 controller → 新
+///   SwiftTerm 视图（回放 ring buffer），identity 稳定复用 T-iOS-29 语义。
+/// - **隐私遮罩不在这里**：它在 `AdaptiveRootView` 的 ZStack 顶层，两分支共享，
+///   故 detail 终端字节同样在 `scenePhase != .active` 时被遮（安全不变式）。
+struct SplitRootView: View {
+    @Bindable var coordinator: AppCoordinator
+
+    var body: some View {
+        NavigationSplitView {
+            sidebar
+        } detail: {
+            detail
+        }
+    }
+
+    // MARK: - Sidebar（会话列表 + 项目入口，复用 SessionListScreen）
+
+    private var sidebar: some View {
+        SessionListScreen(
+            viewModel: coordinator.sessionList,
+            onOpen: { request in
+                // 分栏只是又一个触发面：映射到同一 selectSidebarItem 路由。
+                coordinator.selectSidebarItem(sidebarItem(for: request))
+            },
+            onAddHost: { coordinator.presentAddHost() }
+        )
+        .safeAreaInset(edge: .bottom) { continueLastBanner }
+        .toolbar { projectsToolbarItem }
+    }
+
+    /// 与 `StackRootView.continueLastBanner` 同款「继续上次会话」（冷启动第 5 步）
+    /// —— 分栏 sidebar 也提供，iPad 用户不丢该入口（T-iPad-5 finding）。
+    @ViewBuilder private var continueLastBanner: some View {
+        if coordinator.continueLastSessionId != nil {
+            Button {
+                coordinator.openContinueLast()
+            } label: {
+                Label(RootCopy.continueLast, systemImage: "arrow.uturn.forward.circle.fill")
+                    .frame(maxWidth: .infinity)
+            }
+            .buttonStyle(.borderedProminent)
+            .padding(.horizontal, RootMetrics.bannerHorizontalPadding)
+            .padding(.vertical, RootMetrics.bannerVerticalPadding)
+            .background(.thinMaterial)
+        }
+    }
+
+    /// 列表的 `OpenRequest` → sidebar 选中项（sessionId 有无 = 采纳既有 / 新建）。
+    private func sidebarItem(for request: SessionListViewModel.OpenRequest) -> SidebarItem {
+        request.sessionId.map(SidebarItem.session) ?? .newSession
+    }
+
+    /// 与 `StackRootView.projectsToolbarItem` 同款（leading 位、同 disabled 条件、
+    /// 复用 `presentProjects`）—— iPad 上 Projects 本期仍走既有 sheet（大屏化留
+    /// 给 T-iPad-4）。
+    @ToolbarContentBuilder private var projectsToolbarItem: some ToolbarContent {
+        ToolbarItem(placement: .topBarLeading) {
+            Button {
+                coordinator.presentProjects()
+            } label: {
+                Label(RootCopy.projects, systemImage: "folder")
+            }
+            .disabled(coordinator.sessionList.activeHost == nil)
+            .accessibilityIdentifier("sessions.projectsButton")
+        }
+    }
+
+    // MARK: - Detail（终端或占位）
+
+    @ViewBuilder private var detail: some View {
+        if let controller = coordinator.terminalController {
+            NavigationStack {
+                TerminalContainerView(
+                    controller: controller,
+                    onNewSessionInCwd: { coordinator.openNewSessionInCurrentCwd() },
+                    onKillSession: { coordinator.killCurrentSession() } // T-iPad-3
+                )
+                .id(controller.id) // T-iOS-29 · identity per controller
+            }
+        } else {
+            placeholder
+        }
+    }
+
+    private var placeholder: some View {
+        ContentUnavailableView {
+            Label(SplitCopy.placeholderTitle, systemImage: "sidebar.left")
+        } description: {
+            Text(SplitCopy.placeholderHint)
+        }
+    }
+}
+
+/// split 专属用户可见文案（「项目」标签复用 `RootCopy.projects`，DRY）。
+private enum SplitCopy {
+    static let placeholderTitle = "选择或新建会话"
+    static let placeholderHint = "从左侧选择一个运行中的会话，或新建一个开始工作。"
+}

ios/App/WebTerm/Wiring/TerminalContainerView.swift

@@ -22,6 +22,10 @@ struct TerminalContainerView: View {
     /// T-iOS-29 · pass-through to TerminalScreen's toolbar/exit-banner
     /// "在当前目录开新会话" action (RootView supplies the coordinator hop).
     var onNewSessionInCwd: (@MainActor () -> Void)? = nil
+    /// T-iPad-3 · pass-through to TerminalScreen's pointer context-menu
+    /// "结束会话" action (root layers supply the coordinator hop). nil on
+    /// surfaces without a kill affordance (e.g. previews).
+    var onKillSession: (@MainActor () -> Void)? = nil
     /// Epoch of a plan gate the user swiped away — suppresses re-present for
     /// THAT gate only; a new epoch re-presents automatically.
     @State private var dismissedPlanGateEpoch: Int?
@@ -48,7 +52,8 @@ struct TerminalContainerView: View {
     var body: some View {
         TerminalScreen(
             viewModel: controller.terminalViewModel,
-            onNewSessionInCwd: onNewSessionInCwd
+            onNewSessionInCwd: onNewSessionInCwd,
+            onKillSession: onKillSession
         )
         .id(controller.generation)
             .navigationBarTitleDisplayMode(.inline)