caa47a7 fix(sessions): harden picker search lifecycle · zut

M packages/agent/cli.go +1 -2


@@ -2045,14 +2045,13 @@ func runInteractive(ctx context.Context, args Args, version string) (runErr erro
2045	2045		}
2046	2046		return fmt.Errorf("selected session cwd is not a directory: %s", selectedMeta.CWD)
2047	2047		}
2048		-	workspaceChanged := filepath.Clean(selectedMeta.CWD) != filepath.Clean(args.CWD)
2049		-
2050	2048		// Hold the transition lock from the pre-flush through the commit.
2051	2049		// Persistence callbacks take the read side, so an active session
2052	2050		// cannot be snapshotted before its lazy writes land or overwritten by
2053	2051		// a callback while the candidate is being installed.
2054	2052		sessionTransitionMu.Lock()
2055	2053		defer sessionTransitionMu.Unlock()
	2054	+	workspaceChanged := filepath.Clean(selectedMeta.CWD) != filepath.Clean(args.CWD)
2056	2055
2057	2056		currentAg := liveInteractiveAgent(iv, ag)
2058	2057		if currentAg == nil {

 			}
 			return fmt.Errorf("selected session cwd is not a directory: %s", selectedMeta.CWD)
 		}
-		workspaceChanged := filepath.Clean(selectedMeta.CWD) != filepath.Clean(args.CWD)
 		// Hold the transition lock from the pre-flush through the commit.
 		// Persistence callbacks take the read side, so an active session
 		// cannot be snapshotted before its lazy writes land or overwritten by
 		// a callback while the candidate is being installed.
 		sessionTransitionMu.Lock()
 		defer sessionTransitionMu.Unlock()
+		workspaceChanged := filepath.Clean(selectedMeta.CWD) != filepath.Clean(args.CWD)
 		currentAg := liveInteractiveAgent(iv, ag)
 		if currentAg == nil {

M packages/agent/modes/session_dialog.go +59 -7


@@ -80,9 +80,12 @@ type sessionDialog struct {
80	80		paths []string
81	81		query string
82	82		searching bool
	83	+	searchPending bool
83	84		searchReady bool
84	85		searchGeneration uint64
	86	+	searchContext context.Context
85	87		searchCancel context.CancelFunc
	88	+	matchCancel context.CancelFunc
86	89		searchEvents chan sessionSearchEvent
87	90		searchSegments []core.SessionSearchSegment
88	91		searchMatches map[string]sessionSearchMatch

@@ -145,6 +148,10 @@ func (d *sessionDialog) Open(parent context.Context, root, cwd string, allScope
145	148		d.searchCancel()
146	149		d.searchCancel = nil
147	150		}
	151	+	if d.matchCancel != nil {
	152	+	d.matchCancel()
	153	+	d.matchCancel = nil
	154	+	}
148	155		previousDone := d.loadDone
149	156		if parent == nil {
150	157		parent = context.Background()

@@ -167,6 +174,7 @@ func (d *sessionDialog) Open(parent context.Context, root, cwd string, allScope
167	174		d.paths = nil
168	175		d.query = ""
169	176		d.searching = false
	177	+	d.searchPending = false
170	178		d.searchReady = false
171	179		d.searchSegments = nil
172	180		d.searchMatches = nil

@@ -291,6 +299,10 @@ func (d *sessionDialog) ApplyLoad(event sessionLoadEvent) {
291	299		d.loadingTotal = event.total
292	300		d.loadingDone = 0
293	301		d.paths = append([]string(nil), event.paths...)
	302	+	if d.searchPending {
	303	+	d.searchPending = false
	304	+	d.startSearchReader()
	305	+	}
294	306		d.loadSlots = make([]sessionLoadSlot, event.total)
295	307		d.loadReadyThrough = 0
296	308		d.sessions = nil

@@ -411,6 +423,10 @@ func (d *sessionDialog) Close() {
411	423		d.searchCancel()
412	424		d.searchCancel = nil
413	425		}
	426	+	if d.matchCancel != nil {
	427	+	d.matchCancel()
	428	+	d.matchCancel = nil
	429	+	}
414	430		d.loading = false
415	431		d.searching = false
416	432		d.loadSlots = nil

@@ -429,13 +445,28 @@ func (d *sessionDialog) StartSearch(parent context.Context) <-chan sessionSearch
429	445		parent = context.Background()
430	446		}
431	447		ctx, cancel := context.WithCancel(parent)
	448	+	d.searchContext = ctx
432	449		d.searchCancel = cancel
433	450		d.searching = true
434	451		d.searchGeneration++
435		-	generation := d.searchGeneration
436	452		events := make(chan sessionSearchEvent, 1)
437	453		d.searchEvents = events
	454	+	if len(d.paths) == 0 && d.loading {
	455	+	d.searchPending = true
	456	+	return events
	457	+	}
	458	+	d.startSearchReader()
	459	+	return events
	460	+	}
	461	+
	462	+	func (d *sessionDialog) startSearchReader() {
	463	+	if d.searchEvents == nil \|\| d.searchCancel == nil {
	464	+	return
	465	+	}
	466	+	ctx := d.searchContext
438	467		paths := append([]string(nil), d.paths...)
	468	+	generation := d.searchGeneration
	469	+	events := d.searchEvents
439	470		go func() {
440	471		segments := make([]core.SessionSearchSegment, 0)
441	472		skipped := 0

@@ -458,7 +489,6 @@ func (d *sessionDialog) StartSearch(parent context.Context) <-chan sessionSearch
458	489		case <-ctx.Done():
459	490		}
460	491		}()
461		-	return events
462	492		}
463	493
464	494		// ApplySearch incorporates corpus and match results on the UI goroutine.

@@ -488,15 +518,23 @@ func (d *sessionDialog) scheduleSearchMatch() {
488	518		if !d.searchReady \|\| d.query == "" \|\| d.searchEvents == nil \|\| d.searchCancel == nil {
489	519		return
490	520		}
	521	+	if d.matchCancel != nil {
	522	+	d.matchCancel()
	523	+	}
491	524		query := d.query
492	525		segments := append([]core.SessionSearchSegment(nil), d.searchSegments...)
493	526		generation := d.searchGeneration
494		-	ctx := context.Background()
	527	+	events := d.searchEvents
	528	+	ctx, cancel := context.WithCancel(d.searchContext)
	529	+	d.matchCancel = cancel
495	530		go func() {
496	531		matches := matchSessionSearchSegments(ctx, query, segments)
	532	+	if ctx.Err() != nil {
	533	+	return
	534	+	}
497	535		select {
498		-	case d.searchEvents <- sessionSearchEvent{kind: sessionSearchMatchesReady, generation: generation, query: query, matches: matches}:
499		-	default:
	536	+	case events <- sessionSearchEvent{kind: sessionSearchMatchesReady, generation: generation, query: query, matches: matches}:
	537	+	case <-ctx.Done():
500	538		}
501	539		}()
502	540		}

@@ -647,7 +685,8 @@ func (d *sessionDialog) Render(th tui.Theme, width int) []string {
647	685		lines = append(lines, th.FGColor(th.Muted, fmt.Sprintf(" ↓ %d more below", hidden)))
648	686		}
649	687		if d.allScope && d.cursor >= 0 && d.cursor < len(d.sessions) && d.sessions[d.cursor].CWD != "" {
650		-	lines = append(lines, th.FGColor(th.Muted, " cwd: "+friendlyPath(d.sessions[d.cursor].CWD)))
	688	+	cwd := sanitizeSessionTreeText(friendlyPath(d.sessions[d.cursor].CWD))
	689	+	lines = append(lines, th.FGColor(th.Muted, " cwd: "+cwd))
651	690		}
652	691		if d.query != "" && d.cursor >= 0 && d.cursor < len(d.sessions) {
653	692		if match := d.searchMatches[d.sessions[d.cursor].Path]; match.excerpt != "" {

@@ -837,6 +876,12 @@ func (d *sessionDialog) HandleKey(k tui.Key) sessionDialogAction {
837	876		renameErr = err
838	877		} else {
839	878		d.sessions[d.cursor].Title = title
	879	+	for index := range d.baseSessions {
	880	+	if d.baseSessions[index].Path == path {
	881	+	d.baseSessions[index].Title = title
	882	+	break
	883	+	}
	884	+	}
840	885		renamed = true
841	886		}
842	887		}

@@ -874,6 +919,10 @@ func (d *sessionDialog) HandleKey(k tui.Key) sessionDialogAction {
874	919		if d.query != "" \|\| d.searchEvents != nil {
875	920		switch k.Kind {
876	921		case tui.KeyEsc:
	922	+	if d.query == "" {
	923	+	d.Close()
	924	+	return sessionDialogAction{Close: true}
	925	+	}
877	926		d.query = ""
878	927		d.searchMatches = nil
879	928		d.applySearchFilter()

@@ -894,8 +943,10 @@ func (d *sessionDialog) HandleKey(k tui.Key) sessionDialogAction {
894	943		d.query += string(k.Rune)
895	944		}
896	945		default:
897		-	return sessionDialogAction{}
	946	+	// Navigation and selection operate on the current filtered rows.
	947	+	goto navigate
898	948		}
	949	+	d.query = sanitizeSessionTreeText(d.query)
899	950		if len([]rune(d.query)) > 256 {
900	951		d.query = string([]rune(d.query)[:256])
901	952		}

@@ -913,6 +964,7 @@ func (d *sessionDialog) HandleKey(k tui.Key) sessionDialogAction {
913	964		return sessionDialogAction{}
914	965		}
915	966
	967	+	navigate:
916	968		page := d.MaxRows
917	969		if page <= 0 {
918	970		page = 10

 	paths            []string
 	query            string
 	searching        bool
+	searchPending    bool
 	searchReady      bool
 	searchGeneration uint64
+	searchContext    context.Context
 	searchCancel     context.CancelFunc
+	matchCancel      context.CancelFunc
 	searchEvents     chan sessionSearchEvent
 	searchSegments   []core.SessionSearchSegment
 	searchMatches    map[string]sessionSearchMatch
 		d.searchCancel()
 		d.searchCancel = nil
 	}
+	if d.matchCancel != nil {
+		d.matchCancel()
+		d.matchCancel = nil
+	}
 	previousDone := d.loadDone
 	if parent == nil {
 		parent = context.Background()
 	d.paths = nil
 	d.query = ""
 	d.searching = false
+	d.searchPending = false
 	d.searchReady = false
 	d.searchSegments = nil
 	d.searchMatches = nil
 		d.loadingTotal = event.total
 		d.loadingDone = 0
 		d.paths = append([]string(nil), event.paths...)
+		if d.searchPending {
+			d.searchPending = false
+			d.startSearchReader()
+		}
 		d.loadSlots = make([]sessionLoadSlot, event.total)
 		d.loadReadyThrough = 0
 		d.sessions = nil
 		d.searchCancel()
 		d.searchCancel = nil
 	}
+	if d.matchCancel != nil {
+		d.matchCancel()
+		d.matchCancel = nil
+	}
 	d.loading = false
 	d.searching = false
 	d.loadSlots = nil
 		parent = context.Background()
 	}
 	ctx, cancel := context.WithCancel(parent)
+	d.searchContext = ctx
 	d.searchCancel = cancel
 	d.searching = true
 	d.searchGeneration++
-	generation := d.searchGeneration
 	events := make(chan sessionSearchEvent, 1)
 	d.searchEvents = events
+	if len(d.paths) == 0 && d.loading {
+		d.searchPending = true
+		return events
+	}
+	d.startSearchReader()
+	return events
+}
+func (d *sessionDialog) startSearchReader() {
+	if d.searchEvents == nil || d.searchCancel == nil {
+		return
+	}
+	ctx := d.searchContext
 	paths := append([]string(nil), d.paths...)
+	generation := d.searchGeneration
+	events := d.searchEvents
 	go func() {
 		segments := make([]core.SessionSearchSegment, 0)
 		skipped := 0
 		case <-ctx.Done():
 		}
 	}()
-	return events
 }
 // ApplySearch incorporates corpus and match results on the UI goroutine.
 	if !d.searchReady || d.query == "" || d.searchEvents == nil || d.searchCancel == nil {
 		return
 	}
+	if d.matchCancel != nil {
+		d.matchCancel()
+	}
 	query := d.query
 	segments := append([]core.SessionSearchSegment(nil), d.searchSegments...)
 	generation := d.searchGeneration
-	ctx := context.Background()
+	events := d.searchEvents
+	ctx, cancel := context.WithCancel(d.searchContext)
+	d.matchCancel = cancel
 	go func() {
 		matches := matchSessionSearchSegments(ctx, query, segments)
+		if ctx.Err() != nil {
+			return
+		}
 		select {
-		case d.searchEvents <- sessionSearchEvent{kind: sessionSearchMatchesReady, generation: generation, query: query, matches: matches}:
+		case events <- sessionSearchEvent{kind: sessionSearchMatchesReady, generation: generation, query: query, matches: matches}:
-		default:
+		case <-ctx.Done():
 		}
 	}()
 }
 		lines = append(lines, th.FGColor(th.Muted, fmt.Sprintf("  ↓ %d more below", hidden)))
 	}
 	if d.allScope && d.cursor >= 0 && d.cursor < len(d.sessions) && d.sessions[d.cursor].CWD != "" {
-		lines = append(lines, th.FGColor(th.Muted, "  cwd: "+friendlyPath(d.sessions[d.cursor].CWD)))
+		cwd := sanitizeSessionTreeText(friendlyPath(d.sessions[d.cursor].CWD))
+		lines = append(lines, th.FGColor(th.Muted, "  cwd: "+cwd))
 	}
 	if d.query != "" && d.cursor >= 0 && d.cursor < len(d.sessions) {
 		if match := d.searchMatches[d.sessions[d.cursor].Path]; match.excerpt != "" {
 					renameErr = err
 				} else {
 					d.sessions[d.cursor].Title = title
+					for index := range d.baseSessions {
+						if d.baseSessions[index].Path == path {
+							d.baseSessions[index].Title = title
+							break
+						}
+					}
 					renamed = true
 				}
 			}
 	if d.query != "" || d.searchEvents != nil {
 		switch k.Kind {
 		case tui.KeyEsc:
+			if d.query == "" {
+				d.Close()
+				return sessionDialogAction{Close: true}
+			}
 			d.query = ""
 			d.searchMatches = nil
 			d.applySearchFilter()
 				d.query += string(k.Rune)
 			}
 		default:
-			return sessionDialogAction{}
+			// Navigation and selection operate on the current filtered rows.
+			goto navigate
 		}
+		d.query = sanitizeSessionTreeText(d.query)
 		if len([]rune(d.query)) > 256 {
 			d.query = string([]rune(d.query)[:256])
 		}
 		return sessionDialogAction{}
 	}
+navigate:
 	page := d.MaxRows
 	if page <= 0 {
 		page = 10

M packages/core/session_picker.go +10 -1


@@ -60,7 +60,12 @@ func ListSessionPathsContext(ctx context.Context, root, cwd string, all bool) []
60	60		dirs = append(dirs, filepath.Join(sessionsDir, entry.Name()))
61	61		}
62	62		} else {
63		-	dirs = []string{SessionsDir(root, cwd)}
	63	+	dir := SessionsDir(root, cwd)
	64	+	info, err := os.Lstat(dir)
	65	+	if err != nil \|\| info.Mode()&os.ModeSymlink != 0 \|\| !info.IsDir() {
	66	+	return nil
	67	+	}
	68	+	dirs = []string{dir}
64	69		}
65	70
66	71		type candidate struct {

@@ -139,6 +144,10 @@ func ManagedSessionMeta(ctx context.Context, root, path string) (SessionMeta, er
139	144		return SessionMeta{}, errors.New("managed session: invalid session metadata")
140	145		}
141	146		wantDir := filepath.Clean(SessionsDir(root, meta.CWD))
	147	+	dirInfo, err := os.Lstat(wantDir)
	148	+	if err != nil \|\| dirInfo.Mode()&os.ModeSymlink != 0 \|\| !dirInfo.IsDir() {
	149	+	return SessionMeta{}, errors.New("managed session: cwd bucket is not a directory")
	150	+	}
142	151		if filepath.Clean(filepath.Dir(path)) != wantDir {
143	152		return SessionMeta{}, errors.New("managed session: cwd bucket does not match metadata")
144	153		}

 			dirs = append(dirs, filepath.Join(sessionsDir, entry.Name()))
 		}
 	} else {
-		dirs = []string{SessionsDir(root, cwd)}
+		dir := SessionsDir(root, cwd)
+		info, err := os.Lstat(dir)
+		if err != nil || info.Mode()&os.ModeSymlink != 0 || !info.IsDir() {
+			return nil
+		}
+		dirs = []string{dir}
 	}
 	type candidate struct {
 		return SessionMeta{}, errors.New("managed session: invalid session metadata")
 	}
 	wantDir := filepath.Clean(SessionsDir(root, meta.CWD))
+	dirInfo, err := os.Lstat(wantDir)
+	if err != nil || dirInfo.Mode()&os.ModeSymlink != 0 || !dirInfo.IsDir() {
+		return SessionMeta{}, errors.New("managed session: cwd bucket is not a directory")
+	}
 	if filepath.Clean(filepath.Dir(path)) != wantDir {
 		return SessionMeta{}, errors.New("managed session: cwd bucket does not match metadata")
 	}