fix(sessions): require contiguous search text

commit: ae3daada901de76a04de1b332b3ea366da1ab875
author: brice · 2mo ago · 2026-08-19 09:12 UTC
committer: brice · 2mo ago · 2026-08-19 09:21 UTC
parent: 8b4e3af
signature: GPG VerifiedCD88F9E564E0102646FB6077A1A07C7C7C3E349D · arch-gpg Verified for the committer email

3 files · +140 -44

M README.md +1 -1


@@ -359,7 +359,7 @@ Type `!` followed by a command to run it directly without going through the mode
359	359
360	360		### `/sessions`
361	361
362		-	Shows previous sessions for the current working directory, newest first, with timestamp, model, message count, cost, and the session title. Press `Tab` to rotate between this directory and all sessions in the active normal or Zutfile-agent namespace; other agent namespaces never appear. Press `/` to search an ephemeral in-memory corpus of persisted user and assistant text. Tool calls, tool results, images, developer context, and compaction payloads are excluded. The picker displays each matching session's count and a highlighted best excerpt; changing a query reuses the corpus rather than reopening transcripts. Session entries and search corpus load in the background. Once an entry appears, `up`/`down` and `enter` can select it immediately; `esc` clears a search or cancels and closes the picker. Selecting a session from another working directory switches the live workspace to that session's recorded directory before the transcript resumes, so tools, instructions, sandbox state, and file suggestions do not retain the old directory. Sessions remember their stored provider and model: resuming rebuilds the live agent when necessary instead of silently using a different model; if a staged switch fails, the current session is left unchanged. Branches created for tree navigation remain available to `/session tree` but are hidden from this flat picker. `/sessions` is unavailable with `--no-session`. A fresh interactive session asks the active model for a concise title after the first real prompt and restores that title when resumed.
	362	+	Shows previous sessions for the current working directory, newest first, with timestamp, model, message count, cost, and the session title. Press `Tab` to rotate between this directory and all sessions in the active normal or Zutfile-agent namespace; other agent namespaces never appear. Press `/` and type at least two characters to search contiguous text in an ephemeral in-memory corpus of persisted user and assistant messages. Tool calls, tool results, images, developer context, and compaction payloads are excluded. The picker displays each matching session's count and a highlighted best excerpt; changing a query reuses the corpus rather than reopening transcripts. Session entries and search corpus load in the background. Once an entry appears, `up`/`down` and `enter` can select it immediately; `esc` clears a search or cancels and closes the picker. Selecting a session from another working directory switches the live workspace to that session's recorded directory before the transcript resumes, so tools, instructions, sandbox state, and file suggestions do not retain the old directory. Sessions remember their stored provider and model: resuming rebuilds the live agent when necessary instead of silently using a different model; if a staged switch fails, the current session is left unchanged. Branches created for tree navigation remain available to `/session tree` but are hidden from this flat picker. `/sessions` is unavailable with `--no-session`. A fresh interactive session asks the active model for a concise title after the first real prompt and restores that title when resumed.
363	363
364	364		### `/session`
365	365


@@ -359,7 +359,7 @@ Type `!` followed by a command to run it directly without going through the mode
359			359
360		### `/sessions`	360		### `/sessions`
361			361
362	-	Shows previous sessions for the current working directory, newest first, with timestamp, model, message count, cost, and the session title. Press `Tab` to rotate between this directory and all sessions in the active normal or Zutfile-agent namespace; other agent namespaces never appear. Press `/` to search an ephemeral in-memory corpus of persisted user and assistant text. Tool calls, tool results, images, developer context, and compaction payloads are excluded. The picker displays each matching session's count and a highlighted best excerpt; changing a query reuses the corpus rather than reopening transcripts. Session entries and search corpus load in the background. Once an entry appears, `up`/`down` and `enter` can select it immediately; `esc` clears a search or cancels and closes the picker. Selecting a session from another working directory switches the live workspace to that session's recorded directory before the transcript resumes, so tools, instructions, sandbox state, and file suggestions do not retain the old directory. Sessions remember their stored provider and model: resuming rebuilds the live agent when necessary instead of silently using a different model; if a staged switch fails, the current session is left unchanged. Branches created for tree navigation remain available to `/session tree` but are hidden from this flat picker. `/sessions` is unavailable with `--no-session`. A fresh interactive session asks the active model for a concise title after the first real prompt and restores that title when resumed.	362	+	Shows previous sessions for the current working directory, newest first, with timestamp, model, message count, cost, and the session title. Press `Tab` to rotate between this directory and all sessions in the active normal or Zutfile-agent namespace; other agent namespaces never appear. Press `/` and type at least two characters to search contiguous text in an ephemeral in-memory corpus of persisted user and assistant messages. Tool calls, tool results, images, developer context, and compaction payloads are excluded. The picker displays each matching session's count and a highlighted best excerpt; changing a query reuses the corpus rather than reopening transcripts. Session entries and search corpus load in the background. Once an entry appears, `up`/`down` and `enter` can select it immediately; `esc` clears a search or cancels and closes the picker. Selecting a session from another working directory switches the live workspace to that session's recorded directory before the transcript resumes, so tools, instructions, sandbox state, and file suggestions do not retain the old directory. Sessions remember their stored provider and model: resuming rebuilds the live agent when necessary instead of silently using a different model; if a staged switch fails, the current session is left unchanged. Branches created for tree navigation remain available to `/session tree` but are hidden from this flat picker. `/sessions` is unavailable with `--no-session`. A fresh interactive session asks the active model for a concise title after the first real prompt and restores that title when resumed.
363			363
364		### `/session`	364		### `/session`
365			365

M packages/agent/modes/session_dialog.go +71 -43


@@ -10,7 +10,6 @@ import (
10	10
11	11		"github.com/bnema/zut/packages/core"
12	12		"github.com/bnema/zut/packages/tui"
13		-	"github.com/sahilm/fuzzy"
14	13		)
15	14
16	15		type sessionLoadEventKind uint8

@@ -41,7 +40,6 @@ type sessionSearchMatch struct {
41	40		count int
42	41		excerpt string
43	42		indexes []int
44		-	score int
45	43		}
46	44
47	45		type sessionLoadEvent struct {

@@ -63,7 +61,10 @@ type sessionLoadJob struct {
63	61		path string
64	62		}
65	63
66		-	const maxSessionLoadWorkers = 8
	64	+	const (
	65	+	maxSessionLoadWorkers = 8
	66	+	minSessionSearchQueryRunes = 2
	67	+	)
67	68
68	69		// sessionDialog is the inline picker shown when the user runs /sessions.
69	70		type sessionDialog struct {

@@ -79,6 +80,7 @@ type sessionDialog struct {
79	80		cwd string
80	81		paths []string
81	82		query string
	83	+	searchRequested bool
82	84		searching bool
83	85		searchPending bool
84	86		searchReady bool

@@ -173,6 +175,7 @@ func (d *sessionDialog) Open(parent context.Context, root, cwd string, allScope
173	175		d.allScope = len(allScope) > 0 && allScope[0]
174	176		d.paths = nil
175	177		d.query = ""
	178	+	d.searchRequested = false
176	179		d.searching = false
177	180		d.searchPending = false
178	181		d.searchReady = false

@@ -371,7 +374,7 @@ func (d *sessionDialog) appendLoadedSessions(start, end int) {
371	374		continue
372	375		}
373	376		d.baseSessions = append(d.baseSessions, slot.summary)
374		-	if d.query == "" {
	377	+	if !sessionSearchQuery(d.query) \|\| !d.searchReady {
375	378		d.sessions = append(d.sessions, slot.summary)
376	379		}
377	380		}

@@ -428,6 +431,7 @@ func (d *sessionDialog) Close() {
428	431		d.matchCancel = nil
429	432		}
430	433		d.loading = false
	434	+	d.searchRequested = false
431	435		d.searching = false
432	436		d.loadSlots = nil
433	437		d.loadReadyThrough = 0

@@ -437,9 +441,13 @@ func (d *sessionDialog) Close() {
437	441		d.active = false
438	442		}
439	443
440		-	// StartSearch starts one background corpus read for this picker opening. Query
441		-	// edits reuse the retained corpus and never reopen a session file.
	444	+	// StartSearch starts one background corpus read after the query reaches the
	445	+	// minimum length. Query edits reuse the retained corpus and never reopen a
	446	+	// session file.
442	447		func (d *sessionDialog) StartSearch(parent context.Context) <-chan sessionSearchEvent {
	448	+	if !sessionSearchQuery(d.query) {
	449	+	return nil
	450	+	}
443	451		if d.searchEvents != nil {
444	452		return d.searchEvents
445	453		}

@@ -517,7 +525,7 @@ func (d *sessionDialog) ApplySearch(event sessionSearchEvent) {
517	525		}
518	526
519	527		func (d *sessionDialog) scheduleSearchMatch() {
520		-	if !d.searchReady \|\| d.query == "" \|\| d.searchEvents == nil \|\| d.searchCancel == nil {
	528	+	if !d.searchReady \|\| !sessionSearchQuery(d.query) \|\| d.searchEvents == nil \|\| d.searchCancel == nil {
521	529		return
522	530		}
523	531		if d.matchCancel != nil {

@@ -543,46 +551,53 @@ func (d *sessionDialog) scheduleSearchMatch() {
543	551
544	552		func matchSessionSearchSegments(ctx context.Context, query string, segments []core.SessionSearchSegment) map[string]sessionSearchMatch {
545	553		query = core.NormalizeSessionSearchText(query)
546		-	if query == "" {
	554	+	if !sessionSearchQuery(query) \|\| ctx.Err() != nil {
547	555		return nil
548	556		}
549		-	if ctx.Err() != nil {
550		-	return nil
551		-	}
552		-	texts := make([]string, len(segments))
553		-	for index, segment := range segments {
	557	+	matches := make(map[string]sessionSearchMatch)
	558	+	for _, segment := range segments {
554	559		if ctx.Err() != nil {
555		-	return nil
	560	+	return matches
556	561		}
557		-	texts[index] = segment.Normalized
558		-	if texts[index] == "" {
559		-	texts[index] = core.NormalizeSessionSearchText(segment.Text)
	562	+	text := segment.Normalized
	563	+	if text == "" {
	564	+	text = core.NormalizeSessionSearchText(segment.Text)
560	565		}
561		-	}
562		-	if ctx.Err() != nil {
563		-	return nil
564		-	}
565		-	ranked := fuzzy.Find(query, texts)
566		-	matches := make(map[string]sessionSearchMatch)
567		-	for _, match := range ranked {
568		-	if ctx.Err() != nil \|\| match.Index < 0 \|\| match.Index >= len(segments) {
569		-	return matches
	566	+	indexes := sessionSearchSubstringIndexes(text, query)
	567	+	if len(indexes) == 0 {
	568	+	continue
570	569		}
571		-	segment := segments[match.Index]
572	570		current := matches[segment.Path]
573	571		current.count++
574		-	if current.excerpt == "" \|\| match.Score > current.score {
575		-	current.excerpt = texts[match.Index]
576		-	current.indexes = append([]int(nil), match.MatchedIndexes...)
577		-	current.score = match.Score
	572	+	if current.excerpt == "" {
	573	+	current.excerpt = text
	574	+	current.indexes = indexes
578	575		}
579	576		matches[segment.Path] = current
580	577		}
581	578		return matches
582	579		}
583	580
	581	+	func sessionSearchQuery(query string) bool {
	582	+	return len([]rune(core.NormalizeSessionSearchText(query))) >= minSessionSearchQueryRunes
	583	+	}
	584	+
	585	+	func sessionSearchSubstringIndexes(text, query string) []int {
	586	+	start := strings.Index(text, query)
	587	+	if start < 0 {
	588	+	return nil
	589	+	}
	590	+	indexes := make([]int, 0, utf8.RuneCountInString(query))
	591	+	for index := start; index < start+len(query); {
	592	+	indexes = append(indexes, index)
	593	+	_, size := utf8.DecodeRuneInString(text[index:])
	594	+	index += size
	595	+	}
	596	+	return indexes
	597	+	}
	598	+
584	599		func (d *sessionDialog) applySearchFilter() {
585		-	if d.query == "" {
	600	+	if !sessionSearchQuery(d.query) \|\| !d.searchReady {
586	601		d.sessions = append(d.sessions[:0], d.baseSessions...)
587	602		} else {
588	603		filtered := make([]core.SessionSummary, 0, len(d.baseSessions))

@@ -627,7 +642,7 @@ func (d *sessionDialog) Render(th tui.Theme, width int) []string {
627	642		if d.allScope {
628	643		message = "no previous sessions in this namespace"
629	644		}
630		-	if d.query != "" && d.searchReady {
	645	+	if sessionSearchQuery(d.query) && d.searchReady {
631	646		message = "no matching sessions"
632	647		}
633	648		lines = append(lines, th.FGColor(th.Muted, message))

@@ -648,9 +663,11 @@ func (d *sessionDialog) Render(th tui.Theme, width int) []string {
648	663		return lines
649	664		}
650	665		hint := "↑/↓ pick · enter resume · / search · tab scope · r rename · esc cancel"
651		-	if d.searchEvents != nil {
	666	+	if d.searchRequested {
652	667		hint = "search: " + d.query + " (esc clear · tab scope)"
653		-	if d.searching {
	668	+	if !sessionSearchQuery(d.query) {
	669	+	hint += " · type 2+ characters"
	670	+	} else if d.searching {
654	671		hint += " · indexing"
655	672		}
656	673		}

@@ -685,8 +702,11 @@ func (d *sessionDialog) Render(th tui.Theme, width int) []string {
685	702		}
686	703		for i := d.viewTop; i < viewBot; i++ {
687	704		s := d.sessions[i]
688		-	match := d.searchMatches[s.Path]
689		-	plain := " " + formatSessionSearchRowPlain(s, width-2, match.count)
	705	+	matchCount := 0
	706	+	if sessionSearchQuery(d.query) {
	707	+	matchCount = d.searchMatches[s.Path].count
	708	+	}
	709	+	plain := " " + formatSessionSearchRowPlain(s, width-2, matchCount)
690	710		if i == d.cursor {
691	711		lines = append(lines, th.PadHighlight(plain, width))
692	712		} else {

@@ -702,7 +722,7 @@ func (d *sessionDialog) Render(th tui.Theme, width int) []string {
702	722		cwd := sanitizeSessionTreeText(friendlyPath(d.sessions[d.cursor].CWD))
703	723		lines = append(lines, th.FGColor(th.Muted, " cwd: "+cwd))
704	724		}
705		-	if d.query != "" && d.cursor >= 0 && d.cursor < len(d.sessions) {
	725	+	if sessionSearchQuery(d.query) && d.cursor >= 0 && d.cursor < len(d.sessions) {
706	726		if match := d.searchMatches[d.sessions[d.cursor].Path]; match.excerpt != "" {
707	727		lines = append(lines, " "+highlightSessionSearchExcerpt(th, match.excerpt, match.indexes, width-2))
708	728		}

@@ -968,10 +988,11 @@ func (d *sessionDialog) HandleKey(k tui.Key) sessionDialogAction {
968	988		if k.Kind == tui.KeyTab {
969	989		return sessionDialogAction{ToggleScope: true}
970	990		}
971		-	if k.Kind == tui.KeyRune && k.Rune == '/' && d.query == "" {
972		-	return sessionDialogAction{StartSearch: true}
	991	+	if k.Kind == tui.KeyRune && k.Rune == '/' && d.query == "" && !d.searchRequested {
	992	+	d.searchRequested = true
	993	+	return sessionDialogAction{}
973	994		}
974		-	if d.query != "" \|\| d.searchEvents != nil {
	995	+	if d.searchRequested {
975	996		switch k.Kind {
976	997		case tui.KeyEsc:
977	998		if d.query == "" {

@@ -987,9 +1008,16 @@ func (d *sessionDialog) HandleKey(k tui.Key) sessionDialogAction {
987	1008		if len(runes) > 0 {
988	1009		d.query = string(runes[:len(runes)-1])
989	1010		}
	1011	+	if !sessionSearchQuery(d.query) {
	1012	+	if d.matchCancel != nil {
	1013	+	d.matchCancel()
	1014	+	d.matchCancel = nil
	1015	+	}
	1016	+	d.searchMatches = nil
	1017	+	}
990	1018		d.applySearchFilter()
991	1019		d.scheduleSearchMatch()
992		-	return sessionDialogAction{}
	1020	+	return sessionDialogAction{StartSearch: d.searchEvents == nil && sessionSearchQuery(d.query)}
993	1021		case tui.KeyPaste:
994	1022		d.query += k.Paste
995	1023		case tui.KeyRune:

@@ -1006,7 +1034,7 @@ func (d *sessionDialog) HandleKey(k tui.Key) sessionDialogAction {
1006	1034		}
1007	1035		d.applySearchFilter()
1008	1036		d.scheduleSearchMatch()
1009		-	return sessionDialogAction{}
	1037	+	return sessionDialogAction{StartSearch: d.searchEvents == nil && sessionSearchQuery(d.query)}
1010	1038		}
1011	1039
1012	1040		if d.loading && len(d.sessions) == 0 {

 	"github.com/bnema/zut/packages/core"
 	"github.com/bnema/zut/packages/tui"
-	"github.com/sahilm/fuzzy"
 )
 type sessionLoadEventKind uint8
 	count   int
 	excerpt string
 	indexes []int
-	score   int
 }
 type sessionLoadEvent struct {
 	path  string
 }
-const maxSessionLoadWorkers = 8
+const (
+	maxSessionLoadWorkers      = 8
+	minSessionSearchQueryRunes = 2
+)
 // sessionDialog is the inline picker shown when the user runs /sessions.
 type sessionDialog struct {
 	cwd              string
 	paths            []string
 	query            string
+	searchRequested  bool
 	searching        bool
 	searchPending    bool
 	searchReady      bool
 	d.allScope = len(allScope) > 0 && allScope[0]
 	d.paths = nil
 	d.query = ""
+	d.searchRequested = false
 	d.searching = false
 	d.searchPending = false
 	d.searchReady = false
 			continue
 		}
 		d.baseSessions = append(d.baseSessions, slot.summary)
-		if d.query == "" {
+		if !sessionSearchQuery(d.query) || !d.searchReady {
 			d.sessions = append(d.sessions, slot.summary)
 		}
 	}
 		d.matchCancel = nil
 	}
 	d.loading = false
+	d.searchRequested = false
 	d.searching = false
 	d.loadSlots = nil
 	d.loadReadyThrough = 0
 	d.active = false
 }
-// StartSearch starts one background corpus read for this picker opening. Query
+// StartSearch starts one background corpus read after the query reaches the
-// edits reuse the retained corpus and never reopen a session file.
+// minimum length. Query edits reuse the retained corpus and never reopen a
+// session file.
 func (d *sessionDialog) StartSearch(parent context.Context) <-chan sessionSearchEvent {
+	if !sessionSearchQuery(d.query) {
+		return nil
+	}
 	if d.searchEvents != nil {
 		return d.searchEvents
 	}
 }
 func (d *sessionDialog) scheduleSearchMatch() {
-	if !d.searchReady || d.query == "" || d.searchEvents == nil || d.searchCancel == nil {
+	if !d.searchReady || !sessionSearchQuery(d.query) || d.searchEvents == nil || d.searchCancel == nil {
 		return
 	}
 	if d.matchCancel != nil {
 func matchSessionSearchSegments(ctx context.Context, query string, segments []core.SessionSearchSegment) map[string]sessionSearchMatch {
 	query = core.NormalizeSessionSearchText(query)
-	if query == "" {
+	if !sessionSearchQuery(query) || ctx.Err() != nil {
 		return nil
 	}
-	if ctx.Err() != nil {
+	matches := make(map[string]sessionSearchMatch)
-		return nil
+	for _, segment := range segments {
-	}
-	texts := make([]string, len(segments))
-	for index, segment := range segments {
 		if ctx.Err() != nil {
-			return nil
+			return matches
 		}
-		texts[index] = segment.Normalized
+		text := segment.Normalized
-		if texts[index] == "" {
+		if text == "" {
-			texts[index] = core.NormalizeSessionSearchText(segment.Text)
+			text = core.NormalizeSessionSearchText(segment.Text)
 		}
-	}
+		indexes := sessionSearchSubstringIndexes(text, query)
-	if ctx.Err() != nil {
+		if len(indexes) == 0 {
-		return nil
+			continue
-	}
-	ranked := fuzzy.Find(query, texts)
-	matches := make(map[string]sessionSearchMatch)
-	for _, match := range ranked {
-		if ctx.Err() != nil || match.Index < 0 || match.Index >= len(segments) {
-			return matches
 		}
-		segment := segments[match.Index]
 		current := matches[segment.Path]
 		current.count++
-		if current.excerpt == "" || match.Score > current.score {
+		if current.excerpt == "" {
-			current.excerpt = texts[match.Index]
+			current.excerpt = text
-			current.indexes = append([]int(nil), match.MatchedIndexes...)
+			current.indexes = indexes
-			current.score = match.Score
 		}
 		matches[segment.Path] = current
 	}
 	return matches
 }
+func sessionSearchQuery(query string) bool {
+	return len([]rune(core.NormalizeSessionSearchText(query))) >= minSessionSearchQueryRunes
+}
+func sessionSearchSubstringIndexes(text, query string) []int {
+	start := strings.Index(text, query)
+	if start < 0 {
+		return nil
+	}
+	indexes := make([]int, 0, utf8.RuneCountInString(query))
+	for index := start; index < start+len(query); {
+		indexes = append(indexes, index)
+		_, size := utf8.DecodeRuneInString(text[index:])
+		index += size
+	}
+	return indexes
+}
 func (d *sessionDialog) applySearchFilter() {
-	if d.query == "" {
+	if !sessionSearchQuery(d.query) || !d.searchReady {
 		d.sessions = append(d.sessions[:0], d.baseSessions...)
 	} else {
 		filtered := make([]core.SessionSummary, 0, len(d.baseSessions))
 		if d.allScope {
 			message = "no previous sessions in this namespace"
 		}
-		if d.query != "" && d.searchReady {
+		if sessionSearchQuery(d.query) && d.searchReady {
 			message = "no matching sessions"
 		}
 		lines = append(lines, th.FGColor(th.Muted, message))
 		return lines
 	}
 	hint := "↑/↓ pick · enter resume · / search · tab scope · r rename · esc cancel"
-	if d.searchEvents != nil {
+	if d.searchRequested {
 		hint = "search: " + d.query + "  (esc clear · tab scope)"
-		if d.searching {
+		if !sessionSearchQuery(d.query) {
+			hint += " · type 2+ characters"
+		} else if d.searching {
 			hint += " · indexing"
 		}
 	}
 	}
 	for i := d.viewTop; i < viewBot; i++ {
 		s := d.sessions[i]
-		match := d.searchMatches[s.Path]
+		matchCount := 0
-		plain := "  " + formatSessionSearchRowPlain(s, width-2, match.count)
+		if sessionSearchQuery(d.query) {
+			matchCount = d.searchMatches[s.Path].count
+		}
+		plain := "  " + formatSessionSearchRowPlain(s, width-2, matchCount)
 		if i == d.cursor {
 			lines = append(lines, th.PadHighlight(plain, width))
 		} else {
 		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 sessionSearchQuery(d.query) && d.cursor >= 0 && d.cursor < len(d.sessions) {
 		if match := d.searchMatches[d.sessions[d.cursor].Path]; match.excerpt != "" {
 			lines = append(lines, "  "+highlightSessionSearchExcerpt(th, match.excerpt, match.indexes, width-2))
 		}
 	if k.Kind == tui.KeyTab {
 		return sessionDialogAction{ToggleScope: true}
 	}
-	if k.Kind == tui.KeyRune && k.Rune == '/' && d.query == "" {
+	if k.Kind == tui.KeyRune && k.Rune == '/' && d.query == "" && !d.searchRequested {
-		return sessionDialogAction{StartSearch: true}
+		d.searchRequested = true
+		return sessionDialogAction{}
 	}
-	if d.query != "" || d.searchEvents != nil {
+	if d.searchRequested {
 		switch k.Kind {
 		case tui.KeyEsc:
 			if d.query == "" {
 			if len(runes) > 0 {
 				d.query = string(runes[:len(runes)-1])
 			}
+			if !sessionSearchQuery(d.query) {
+				if d.matchCancel != nil {
+					d.matchCancel()
+					d.matchCancel = nil
+				}
+				d.searchMatches = nil
+			}
 			d.applySearchFilter()
 			d.scheduleSearchMatch()
-			return sessionDialogAction{}
+			return sessionDialogAction{StartSearch: d.searchEvents == nil && sessionSearchQuery(d.query)}
 		case tui.KeyPaste:
 			d.query += k.Paste
 		case tui.KeyRune:
 		}
 		d.applySearchFilter()
 		d.scheduleSearchMatch()
-		return sessionDialogAction{}
+		return sessionDialogAction{StartSearch: d.searchEvents == nil && sessionSearchQuery(d.query)}
 	}
 	if d.loading && len(d.sessions) == 0 {

M packages/agent/modes/session_dialog_test.go +68 -0


@@ -419,6 +419,74 @@ func TestSessionDialogSearchShowsCountsAndExcerpt(t *testing.T) {
419	419		}
420	420		}
421	421
	422	+	func TestSessionSearchUsesContiguousQueryAndRequiresTwoCharacters(t *testing.T) {
	423	+	segments := []core.SessionSearchSegment{
	424	+	{Path: "scattered", Text: "sizzle then harp, again remote"},
	425	+	{Path: "exact", Text: "resume the sharm project"},
	426	+	}
	427	+
	428	+	if matches := matchSessionSearchSegments(context.Background(), "s", segments); matches != nil {
	429	+	t.Fatalf("one-character search = %#v, want no search", matches)
	430	+	}
	431	+	matches := matchSessionSearchSegments(context.Background(), "sharm", segments)
	432	+	if len(matches) != 1 {
	433	+	t.Fatalf("matches = %#v, want only exact session", matches)
	434	+	}
	435	+	match, ok := matches["exact"]
	436	+	if !ok {
	437	+	t.Fatalf("matches = %#v, missing exact session", matches)
	438	+	}
	439	+	if match.count != 1 \|\| match.excerpt != "resume the sharm project" {
	440	+	t.Fatalf("exact match = %#v", match)
	441	+	}
	442	+	if want := []int{11, 12, 13, 14, 15}; len(match.indexes) != len(want) \|\| match.indexes[0] != want[0] \|\| match.indexes[1] != want[1] \|\| match.indexes[2] != want[2] \|\| match.indexes[3] != want[3] \|\| match.indexes[4] != want[4] {
	443	+	t.Fatalf("highlight indexes = %v, want %v", match.indexes, want)
	444	+	}
	445	+	}
	446	+
	447	+	func TestSessionDialogDefersSearchUntilSecondCharacter(t *testing.T) {
	448	+	d := newSessionDialog()
	449	+	d.active = true
	450	+	d.baseSessions = []core.SessionSummary{{Path: "one"}, {Path: "two"}}
	451	+	d.sessions = append([]core.SessionSummary(nil), d.baseSessions...)
	452	+
	453	+	if action := d.HandleKey(tui.Key{Kind: tui.KeyRune, Rune: '/'}); action.StartSearch \|\| !d.searchRequested {
	454	+	t.Fatalf("slash action = %#v, search requested = %v", action, d.searchRequested)
	455	+	}
	456	+	if action := d.HandleKey(tui.Key{Kind: tui.KeyRune, Rune: 's'}); action.StartSearch \|\| d.query != "s" {
	457	+	t.Fatalf("one-character action = %#v, query = %q", action, d.query)
	458	+	}
	459	+	if len(d.sessions) != len(d.baseSessions) {
	460	+	t.Fatalf("one-character search filtered sessions: %#v", d.sessions)
	461	+	}
	462	+	if events := d.StartSearch(context.Background()); events != nil \|\| d.searchEvents != nil {
	463	+	t.Fatal("one-character search started the corpus reader")
	464	+	}
	465	+	if action := d.HandleKey(tui.Key{Kind: tui.KeyRune, Rune: 'h'}); !action.StartSearch \|\| d.query != "sh" {
	466	+	t.Fatalf("two-character action = %#v, query = %q", action, d.query)
	467	+	}
	468	+	}
	469	+
	470	+	func TestSessionDialogClearsMatchesBelowSearchMinimum(t *testing.T) {
	471	+	d := newSessionDialog()
	472	+	d.active = true
	473	+	d.searchRequested = true
	474	+	d.searchReady = true
	475	+	d.query = "sh"
	476	+	d.baseSessions = []core.SessionSummary{{Path: "one", MessageCount: 1, FirstUserText: "session"}}
	477	+	d.sessions = append([]core.SessionSummary(nil), d.baseSessions...)
	478	+	d.searchMatches = map[string]sessionSearchMatch{"one": {count: 1}}
	479	+
	480	+	d.HandleKey(tui.Key{Kind: tui.KeyBackspace})
	481	+	if d.searchMatches != nil {
	482	+	t.Fatalf("matches after shortening query = %#v, want nil", d.searchMatches)
	483	+	}
	484	+	rendered := stripANSIBytes(strings.Join(d.Render(tui.Dark, 120), "\n"))
	485	+	if strings.Contains(rendered, "1 match") {
	486	+	t.Fatalf("one-character search rendered stale match count: %q", rendered)
	487	+	}
	488	+	}
	489	+
422	490		func TestSessionDialogIgnoresStaleLoadResults(t *testing.T) {
423	491		first := newSessionDialog()
424	492		firstEvents := first.Open(context.Background(), t.TempDir(), t.TempDir())


@@ -419,6 +419,74 @@ func TestSessionDialogSearchShowsCountsAndExcerpt(t *testing.T) {
419	}	419		}
420	}	420		}
421		421
		422	+	func TestSessionSearchUsesContiguousQueryAndRequiresTwoCharacters(t *testing.T) {
		423	+	segments := []core.SessionSearchSegment{
		424	+	{Path: "scattered", Text: "sizzle then harp, again remote"},
		425	+	{Path: "exact", Text: "resume the sharm project"},
		426	+	}
		427	+
		428	+	if matches := matchSessionSearchSegments(context.Background(), "s", segments); matches != nil {
		429	+	t.Fatalf("one-character search = %#v, want no search", matches)
		430	+	}
		431	+	matches := matchSessionSearchSegments(context.Background(), "sharm", segments)
		432	+	if len(matches) != 1 {
		433	+	t.Fatalf("matches = %#v, want only exact session", matches)
		434	+	}
		435	+	match, ok := matches["exact"]
		436	+	if !ok {
		437	+	t.Fatalf("matches = %#v, missing exact session", matches)
		438	+	}
		439	+	if match.count != 1 \|\| match.excerpt != "resume the sharm project" {
		440	+	t.Fatalf("exact match = %#v", match)
		441	+	}
		442	+	if want := []int{11, 12, 13, 14, 15}; len(match.indexes) != len(want) \|\| match.indexes[0] != want[0] \|\| match.indexes[1] != want[1] \|\| match.indexes[2] != want[2] \|\| match.indexes[3] != want[3] \|\| match.indexes[4] != want[4] {
		443	+	t.Fatalf("highlight indexes = %v, want %v", match.indexes, want)
		444	+	}
		445	+	}
		446	+
		447	+	func TestSessionDialogDefersSearchUntilSecondCharacter(t *testing.T) {
		448	+	d := newSessionDialog()
		449	+	d.active = true
		450	+	d.baseSessions = []core.SessionSummary{{Path: "one"}, {Path: "two"}}
		451	+	d.sessions = append([]core.SessionSummary(nil), d.baseSessions...)
		452	+
		453	+	if action := d.HandleKey(tui.Key{Kind: tui.KeyRune, Rune: '/'}); action.StartSearch \|\| !d.searchRequested {
		454	+	t.Fatalf("slash action = %#v, search requested = %v", action, d.searchRequested)
		455	+	}
		456	+	if action := d.HandleKey(tui.Key{Kind: tui.KeyRune, Rune: 's'}); action.StartSearch \|\| d.query != "s" {
		457	+	t.Fatalf("one-character action = %#v, query = %q", action, d.query)
		458	+	}
		459	+	if len(d.sessions) != len(d.baseSessions) {
		460	+	t.Fatalf("one-character search filtered sessions: %#v", d.sessions)
		461	+	}
		462	+	if events := d.StartSearch(context.Background()); events != nil \|\| d.searchEvents != nil {
		463	+	t.Fatal("one-character search started the corpus reader")
		464	+	}
		465	+	if action := d.HandleKey(tui.Key{Kind: tui.KeyRune, Rune: 'h'}); !action.StartSearch \|\| d.query != "sh" {
		466	+	t.Fatalf("two-character action = %#v, query = %q", action, d.query)
		467	+	}
		468	+	}
		469	+
		470	+	func TestSessionDialogClearsMatchesBelowSearchMinimum(t *testing.T) {
		471	+	d := newSessionDialog()
		472	+	d.active = true
		473	+	d.searchRequested = true
		474	+	d.searchReady = true
		475	+	d.query = "sh"
		476	+	d.baseSessions = []core.SessionSummary{{Path: "one", MessageCount: 1, FirstUserText: "session"}}
		477	+	d.sessions = append([]core.SessionSummary(nil), d.baseSessions...)
		478	+	d.searchMatches = map[string]sessionSearchMatch{"one": {count: 1}}
		479	+
		480	+	d.HandleKey(tui.Key{Kind: tui.KeyBackspace})
		481	+	if d.searchMatches != nil {
		482	+	t.Fatalf("matches after shortening query = %#v, want nil", d.searchMatches)
		483	+	}
		484	+	rendered := stripANSIBytes(strings.Join(d.Render(tui.Dark, 120), "\n"))
		485	+	if strings.Contains(rendered, "1 match") {
		486	+	t.Fatalf("one-character search rendered stale match count: %q", rendered)
		487	+	}
		488	+	}
		489	+
422	func TestSessionDialogIgnoresStaleLoadResults(t *testing.T) {	490		func TestSessionDialogIgnoresStaleLoadResults(t *testing.T) {
423	first := newSessionDialog()	491		first := newSessionDialog()
424	firstEvents := first.Open(context.Background(), t.TempDir(), t.TempDir())	492		firstEvents := first.Open(context.Background(), t.TempDir(), t.TempDir())