feat: delete sessions from the session picker

Ctrl+X on a row asks for confirmation and deletes the session. The
picker stays mounted and locks input while the deletion runs, so nothing
races the swap; deleting the current session closes it and starts a
fresh one, and a failed delete reattaches to the session that survived.

Author: elkaix

apps/pythinker-code/src/tui/components/dialogs/session-picker.ts

@@ -12,6 +12,7 @@ import {
 } from '@pymodel/pi-tui';
 import { CURRENT_MARK, SELECT_POINTER } from '#/tui/constant/symbols';
 import { currentTheme } from '#/tui/theme';
+import { printableChar } from '#/tui/utils/printable-key';
 import { SearchableList } from '#/tui/utils/searchable-list';
 
 export interface SessionRow {
@@ -80,7 +81,7 @@ function sessionSearchText(session: SessionRow): string {
 export class SessionPickerComponent extends Container implements Focusable {
   private sessions: SessionRow[];
   private currentSessionId: string;
-  private onSelect: (session: SessionRow) => void;
+  private onSelect: (session: SessionRow) => void | Promise<void>;
   private onCancel: () => void;
   private onToggleScope?: (selectedSessionId: string) => void;
   private maxVisibleSessions: number;
@@ -91,6 +92,8 @@ export class SessionPickerComponent extends Container implements Focusable {
   private hasMore: boolean;
   private loadingMore: boolean;
   private list: SearchableList<SessionRow>;
+  private deleteState?: { session: SessionRow; phase: 'confirm' | 'deleting' };
+  private selectInFlight = false;
 
   focused = false;
 
@@ -101,7 +104,7 @@ export class SessionPickerComponent extends Container implements Focusable {
     scope?: 'cwd' | 'all';
     initialSelectedSessionId?: string;
     pageSize?: number;
-    onSelect: (session: SessionRow) => void;
+    onSelect: (session: SessionRow) => void | Promise<void>;
     onCancel: () => void;
     onCtrlC?: () => void;
     onCtrlD?: () => void;
@@ -115,6 +118,8 @@ export class SessionPickerComponent extends Container implements Focusable {
     onLoadMore?: () => void;
     /** Fired when a search query becomes active while pages remain unfetched. */
     onSearchDrain?: () => void;
+    /** Fired after the user confirms deletion with `y`; the picker clears its delete state once the request settles. */
+    onDeleteRequest?: (session: SessionRow) => Promise<void>;
   }) {
     super();
     this.sessions = opts.sessions;
@@ -142,12 +147,14 @@ export class SessionPickerComponent extends Container implements Focusable {
     this.visibleCount = Math.min(this.sessions.length, initialLoadedPages * this.pageSize);
     this.onCtrlC = opts.onCtrlC;
     this.onCtrlD = opts.onCtrlD;
+    this.onDeleteRequest = opts.onDeleteRequest;
   }
 
   private readonly onCtrlC?: () => void;
   private readonly onCtrlD?: () => void;
   private readonly onLoadMore?: () => void;
   private readonly onSearchDrain?: () => void;
+  private readonly onDeleteRequest?: (session: SessionRow) => Promise<void>;
 
   /** Appends a freshly fetched page, keeping the cursor and active query. */
   appendSessions(rows: SessionRow[]): void {
@@ -209,6 +216,13 @@ export class SessionPickerComponent extends Container implements Focusable {
   }
 
   handleInput(data: string): void {
+    if (this.deleteState !== undefined) {
+      this.handleDeleteInput(data);
+      return;
+    }
+    // A selection runs resume/switch asynchronously; input during that window
+    // (e.g. Ctrl+X delete) would race the session swap.
+    if (this.selectInFlight) return;
     if (matchesKey(data, Key.ctrl('c'))) {
       this.onCtrlC?.();
       return;
@@ -221,6 +235,14 @@ export class SessionPickerComponent extends Container implements Focusable {
       this.onToggleScope?.(this.list.selected()?.id ?? this.currentSessionId);
       return;
     }
+    if (matchesKey(data, Key.ctrl('x'))) {
+      const selected = this.list.selected();
+      if (selected !== undefined && this.onDeleteRequest !== undefined) {
+        this.deleteState = { session: selected, phase: 'confirm' };
+        this.invalidate();
+      }
+      return;
+    }
     if (matchesKey(data, Key.escape)) {
       if (this.list.clearQuery()) {
         this.visibleCount = Math.min(this.filteredSessions().length, this.pageSize);
@@ -231,7 +253,16 @@ export class SessionPickerComponent extends Container implements Focusable {
     }
     if (matchesKey(data, Key.enter)) {
       const session = this.list.selected();
-      if (session) this.onSelect(session);
+      if (session) {
+        const selection = this.onSelect(session);
+        if (selection !== undefined) {
+          this.selectInFlight = true;
+          const clear = (): void => {
+            this.selectInFlight = false;
+          };
+          void selection.then(clear, clear);
+        }
+      }
       return;
     }
 
@@ -241,6 +272,52 @@ export class SessionPickerComponent extends Container implements Focusable {
     }
   }
 
+  private handleDeleteInput(data: string): void {
+    const state = this.deleteState;
+    if (state === undefined || state.phase === 'deleting') return;
+    const k = printableChar(data);
+    if (matchesKey(data, Key.escape) || k === 'n' || k === 'N') {
+      this.deleteState = undefined;
+      this.invalidate();
+      return;
+    }
+    if (k === 'y' || k === 'Y') {
+      this.deleteState = { session: state.session, phase: 'deleting' };
+      this.invalidate();
+      const sessionId = state.session.id;
+      const clear = (): void => {
+        if (this.deleteState?.session.id !== sessionId) return;
+        this.deleteState = undefined;
+        this.invalidate();
+      };
+      // then(clear, clear): rejections settle too — the host has already surfaced the failure.
+      void this.onDeleteRequest?.(state.session).then(clear, clear);
+    }
+  }
+
+  private renderDeleteStateLine(width: number): string {
+    const state = this.deleteState;
+    if (state === undefined) return '';
+    const rawTitle = (state.session.title ?? state.session.id).trim() || state.session.id;
+    const label = singleLine(rawTitle);
+    const prefix = state.phase === 'confirm' ? 'Delete session "' : 'Deleting session "';
+    const suffix = state.phase === 'confirm' ? '"? [y/N]' : '"…';
+    const labelBudget = Math.max(0, width - visibleWidth(prefix) - visibleWidth(suffix));
+    const shown = truncateToWidth(label, labelBudget, ELLIPSIS);
+    // The suffix carries the confirm/cancel keys: it survives by truncating
+    // the head (prefix + label) instead of the composed line.
+    const head = truncateToWidth(
+      prefix + shown,
+      Math.max(0, width - visibleWidth(suffix)),
+      ELLIPSIS,
+    );
+    const styled =
+      state.phase === 'confirm'
+        ? currentTheme.boldFg('warning', head + suffix)
+        : currentTheme.fg('textMuted', head + suffix);
+    return truncateToWidth(styled, width, ELLIPSIS);
+  }
+
   override render(width: number): string[] {
     return this.renderLines(width).map((line) => truncateToWidth(line, width, ELLIPSIS));
   }
@@ -293,6 +370,7 @@ export class SessionPickerComponent extends Container implements Focusable {
       ...(view.query.length > 0 ? ['Backspace clear'] : []),
       '↑↓ navigate',
       scopeHint,
+      ...(this.onDeleteRequest !== undefined ? ['Ctrl+X delete'] : []),
       'Enter select',
       'Esc cancel',
     ].filter((item): item is string => item !== undefined);
@@ -360,6 +438,11 @@ export class SessionPickerComponent extends Container implements Focusable {
       lines.push(currentTheme.fg('textMuted', truncateToWidth(footer, width, ELLIPSIS)));
     }
 
+    if (this.deleteState !== undefined) {
+      lines.push('');
+      lines.push(this.renderDeleteStateLine(width));
+    }
+
     lines.push(currentTheme.fg('primary', '─'.repeat(width)));
     return lines;
   }

apps/pythinker-code/src/tui/pythinker-tui.ts

@@ -3683,23 +3683,7 @@ export class PythinkerTUI {
   }): Promise<void> {
     this.sessionPickerOptions = options;
     await this.fetchSessions('cwd');
-    this.mountSessionPicker({
-      applyStartupModes: options.applyStartupModes,
-      onCancel: () => {
-        this.hideSessionPicker();
-        if (options.closeOnCancel) void this.stop();
-      },
-      onCtrlC: options.forwardEditorExit
-        ? () => {
-            this.state.editor.onCtrlC?.();
-          }
-        : undefined,
-      onCtrlD: options.forwardEditorExit
-        ? () => {
-            this.state.editor.onCtrlD?.();
-          }
-        : undefined,
-    });
+    this.remountSessionPicker();
   }
 
   private async toggleSessionPickerScope(selectedSessionId: string): Promise<void> {
@@ -3708,8 +3692,12 @@ export class PythinkerTUI {
     await this.fetchSessions(nextScope);
     if (requestToken !== this.sessionPickerScopeRequestToken) return;
     if (this.state.activeDialog !== 'session-picker') return;
+    this.remountSessionPicker(selectedSessionId);
+  }
+
+  private remountSessionPicker(initialSelectedSessionId?: string): void {
     this.mountSessionPicker({
-      initialSelectedSessionId: selectedSessionId,
+      initialSelectedSessionId,
       applyStartupModes: this.sessionPickerOptions.applyStartupModes,
       onCancel: () => {
         this.hideSessionPicker();
@@ -3736,6 +3724,68 @@ export class PythinkerTUI {
     this.restoreEditor();
   }
 
+  private async deleteSessionFromPicker(session: SessionRow): Promise<void> {
+    // Invalidate any pending scope-toggle remount: it would replace the picker
+    // that is about to lock itself for the delete.
+    this.sessionPickerScopeRequestToken += 1;
+    try {
+      await this.waitForLazyCreation();
+      if (session.id === this.state.appState.sessionId && this.session !== undefined) {
+        await this.deleteCurrentSessionFromPicker(session);
+        return;
+      }
+      await this.harness.deleteSession(session.id);
+      // fetchSessions swallows refetch errors, so drop the row locally first —
+      // a failed refetch must not resurrect it in the remounted list.
+      this.state.sessions = this.state.sessions.filter((row) => row.id !== session.id);
+      const requestToken = ++this.sessionPickerScopeRequestToken;
+      await this.fetchSessions(this.state.sessionsScope);
+      if (requestToken !== this.sessionPickerScopeRequestToken) return;
+      if (this.state.activeDialog !== 'session-picker') return;
+      this.remountSessionPicker();
+      this.showStatus('Session deleted.');
+    } catch (error) {
+      this.showError(`Failed to delete session ${session.id}: ${formatErrorMessage(error)}`);
+    }
+  }
+
+  private async deleteCurrentSessionFromPicker(session: SessionRow): Promise<void> {
+    // The picker stays mounted (locking input) until the replacement session
+    // is ready — restoring the editor mid-flight would let a prompt race the swap.
+    try {
+      // Tear down before deleting so no events from the dying session reach the UI.
+      await this.closeSession('deleting session');
+      await this.harness.deleteSession(session.id);
+    } catch (error) {
+      // The engine aborts a failed delete and keeps the session: reattach,
+      // falling back to a fresh session if it is gone. showError runs after
+      // the switch because switchToSession clears the transcript.
+      const message = `Failed to delete session ${session.id}: ${formatErrorMessage(error)}`;
+      try {
+        const resumed = await this.harness.resumeSession({
+          id: session.id,
+          replayTurnLimit: REPLAY_FETCH_TURN_LIMIT,
+        });
+        await this.switchToSession(resumed, `Resumed session (${resumed.id}).`);
+      } catch {
+        // Reattach failed and the session is already unloaded: detach before
+        // the fallback create so a failed create leaves no ghost UI behind.
+        this.setAppState({ sessionId: '' });
+        this.clearTranscriptAndRedraw();
+        await this.createNewSession();
+      }
+      this.showError(message);
+      this.hideSessionPicker();
+      return;
+    }
+    // The session is gone whether or not replacement creation succeeds: detach
+    // first so a failed create leaves no ghost (stale id + transcript) behind.
+    this.setAppState({ sessionId: '' });
+    this.clearTranscriptAndRedraw();
+    await this.createNewSession();
+    this.hideSessionPicker();
+  }
+
   openUndoSelector(): void {
     void slashCommands.handleUndoCommand(this, '');
   }
@@ -3766,19 +3816,19 @@ export class PythinkerTUI {
       onSearchDrain: () => {
         void this.drainSessionsForSearch();
       },
-      onSelect: (session: SessionRow) => {
-        void this.handleSessionPickerSelect(session, options.applyStartupModes === true).catch(
+      onSelect: (session: SessionRow) =>
+        this.handleSessionPickerSelect(session, options.applyStartupModes === true).catch(
           (error) => {
             this.showError(`Failed to apply startup flags: ${formatErrorMessage(error)}`);
           },
-        );
-      },
+        ),
       onCancel: options.onCancel,
       onCtrlC: options.onCtrlC,
       onCtrlD: options.onCtrlD,
       onToggleScope: (selectedSessionId: string) => {
         void this.toggleSessionPickerScope(selectedSessionId);
       },
+      onDeleteRequest: (session: SessionRow) => this.deleteSessionFromPicker(session),
     });
     this.sessionPickerComponent = picker;
     this.mountEditorReplacement(picker);
@@ -3788,6 +3838,9 @@ export class PythinkerTUI {
     session: SessionRow,
     applyStartupModes: boolean,
   ): Promise<void> {
+    // Invalidate any pending scope-toggle remount: it would replace the picker
+    // and drop the selection lock.
+    this.sessionPickerScopeRequestToken += 1;
     if (resolve(session.work_dir) !== resolve(this.state.appState.workDir)) {
       await this.showResumeOtherWorkDirHint(session);
       if (applyStartupModes) await this.stop(0);