@jetcrab/pi-desk 1.1.28-dev → 1.1.30-dev

package/src/common/l4_foundation/locale/l4-host-error-messages.ts

@@ -103,6 +103,7 @@ export const L4_HOST_ERROR_MESSAGES = {
     branchInputInvalid: 'Invalid branch operation request',
     branchEntryMissing: 'Branch entry not found or no longer available',
     branchForkUserOnly: 'Only user messages can start a new session',
+    branchResendUserOnly: 'Only user messages can be resent',
     branchCloneEmpty: 'There are no messages to clone yet',
     branchFailed: 'Could not perform branch operation',
     taskDetailInvalid: 'Invalid task detail request',
@@ -262,6 +263,7 @@ export const L4_HOST_ERROR_MESSAGES = {
     branchInputInvalid: '分支操作参数无效',
     branchEntryMissing: '分支节点不存在或已失效',
     branchForkUserOnly: '只有用户消息可以 Fork',
+    branchResendUserOnly: '只有用户消息可以重发',
     branchCloneEmpty: '当前会话还没有可克隆的消息',
     branchFailed: '执行分支操作失败',
     taskDetailInvalid: '任务详情参数无效',

package/src/server/l1_entry/api/l1-work-session-branch-route.ts

@@ -1,14 +1,7 @@
 import 'server-only'
 
 import { L2WorkSessionBranchRequestSchema } from '@common/l2_biz/work-session/l2-work-session-tree-contract'
-import {
-  getL2WorkSessionManage,
-  WorkSessionBindingChangedError,
-  WorkSessionBranchBlockedError,
-  WorkSessionBranchEntryNotFoundError,
-  WorkSessionBranchInvalidError,
-  WorkSessionNotFoundError
-} from '@server/l2_biz/work-session/l2-work-session-manage'
+import { getL2WorkSessionManage } from '@server/l2_biz/work-session/l2-work-session-manage'
 import { readL4ClientId } from '@server/l4_foundation/http/l4-client-id'
 import {
   createL4ApiErrorResponse,
@@ -33,27 +26,40 @@ export async function POST(request: Request): Promise<Response> {
 
   try {
     const data = await getL2WorkSessionManage().branchWorkSession(input.data)
-    return createL4ApiSuccessResponse(data, input.data.action === 'tree' ? 200 : 201)
+    return createL4ApiSuccessResponse(
+      data,
+      input.data.action === 'tree' || input.data.action === 'resend' ? 200 : 201
+    )
   } catch (error) {
-    if (error instanceof WorkSessionNotFoundError) {
+    // 管理器由 Node 与 Next 共享，业务异常构造器并非同一实例。
+    if (error instanceof Error && error.name === 'WorkSessionNotFoundError') {
       return createL4ApiErrorResponse(404, '工作会话不存在', { key: 'errors:sessionMissing' })
     }
-    if (error instanceof WorkSessionBranchEntryNotFoundError) {
+    if (error instanceof Error && error.name === 'WorkSessionBranchEntryNotFoundError') {
       return createL4ApiErrorResponse(404, '分支节点不存在或已失效', {
         key: 'errors:branchEntryMissing'
       })
     }
-    if (error instanceof WorkSessionBranchInvalidError) {
+    if (
+      error instanceof Error &&
+      error.name === 'WorkSessionBranchInvalidError' &&
+      'kind' in error
+    ) {
       return createL4ApiErrorResponse(400, error.message, {
-        key: error.kind === 'fork-target' ? 'errors:branchForkUserOnly' : 'errors:branchCloneEmpty'
+        key:
+          error.kind === 'fork-target'
+            ? 'errors:branchForkUserOnly'
+            : error.kind === 'resend-target'
+              ? 'errors:branchResendUserOnly'
+              : 'errors:branchCloneEmpty'
       })
     }
-    if (error instanceof WorkSessionBindingChangedError) {
+    if (error instanceof Error && error.name === 'WorkSessionBindingChangedError') {
       return createL4ApiErrorResponse(409, '工作会话已切换，请重新打开会话树', {
         key: 'errors:sessionTreeChanged'
       })
     }
-    if (error instanceof WorkSessionBranchBlockedError) {
+    if (error instanceof Error && error.name === 'WorkSessionBranchBlockedError') {
       return createL4ApiErrorResponse(409, error.message)
     }
     console.error('[Pi Desk][WorkSessionBranchApi] 执行分支操作失败', {

package/src/server/l1_entry/api/l1-work-session-search-route.ts

@@ -0,0 +1,38 @@
+import 'server-only'
+
+import { L2WorkSessionSearchRequestSchema } from '@common/l2_biz/work-session/l2-work-session-search-contract'
+import { getL2WorkSessionManage } from '@server/l2_biz/work-session/l2-work-session-manage'
+import { readL4ClientId } from '@server/l4_foundation/http/l4-client-id'
+import {
+  createL4ApiErrorResponse,
+  createL4ApiSuccessResponse
+} from '@server/l4_foundation/http/l4-api-response'
+
+export async function POST(request: Request): Promise<Response> {
+  const clientId = readL4ClientId(request)
+  if (!clientId)
+    return createL4ApiErrorResponse(400, '客户端标识无效', { key: 'errors:invalidClient' })
+
+  let payload: unknown
+  try {
+    payload = await request.json()
+  } catch {
+    return createL4ApiErrorResponse(400, '请求 JSON 格式无效', { key: 'errors:invalidJson' })
+  }
+
+  const input = L2WorkSessionSearchRequestSchema.safeParse(payload)
+  if (!input.success) return createL4ApiErrorResponse(400, '工作会话搜索参数无效')
+
+  try {
+    return createL4ApiSuccessResponse(await getL2WorkSessionManage().searchWorkSessions(input.data))
+  } catch (error) {
+    console.error('[Pi Desk][WorkSessionSearchApi] 搜索工作会话失败', {
+      clientId,
+      queryLength: input.data.query.length,
+      searchIn: input.data.searchIn,
+      errorName: error instanceof Error ? error.name : 'UnknownError',
+      errorMessage: error instanceof Error ? error.message : String(error)
+    })
+    return createL4ApiErrorResponse(500, '搜索工作会话失败')
+  }
+}

package/src/server/l2_biz/work-session/l2-work-session-chat-runtime.ts

@@ -190,11 +190,13 @@ export class L2WorkSessionChatRuntime {
       await disposeL4PiWorkSessionRuntime(previous.sessionId)
   }
 
-  async refreshWorkSession(workSession: WorkSession): Promise<void> {
+  async refreshWorkSession(workSession: WorkSession, acceptingCommands = true): Promise<void> {
     const previousSource = this.recordsByWorkId.get(workSession.workId)?.source
     await this.closeRecord(workSession.workId)
     if (previousSource) this.publish({ type: 'source_invalidated', source: previousSource })
-    this.recordsByWorkId.set(workSession.workId, this.buildRecord(workSession))
+    const record = this.buildRecord(workSession)
+    record.acceptingCommands = acceptingCommands
+    this.recordsByWorkId.set(workSession.workId, record)
   }
 
   async removeWorkSession(workSession: WorkSession): Promise<void> {

package/src/server/l2_biz/work-session/l2-work-session-manage.ts

@@ -72,6 +72,12 @@ import {
   type L2WorkSessionRecord,
   type L2WorkSessionStatus
 } from '@common/l2_biz/work-session/l2-work-session-contract'
+import {
+  L2WorkSessionSearchRequestSchema,
+  L2WorkSessionSearchResponseSchema,
+  type L2WorkSessionSearchRequest,
+  type L2WorkSessionSearchResponse
+} from '@common/l2_biz/work-session/l2-work-session-search-contract'
 import {
   L2WorkSessionChangesSchema,
   L2WorkSessionsUpdateSchema,
@@ -102,7 +108,8 @@ import { resolveL4PiSessionPath } from '@server/l4_foundation/pi/l4-pi-session-c
 import {
   getL4PiWorkSessionRuntime,
   L4PiSessionBranchBlockedError,
-  L4PiSessionCloneEmptyError
+  L4PiSessionCloneEmptyError,
+  L4PiSessionResendTargetError
 } from '@server/l4_foundation/pi/l4-pi-work-session-runtime'
 import {
   L4PiSessionEntryNotFoundError,
@@ -196,7 +203,7 @@ export class WorkSessionBranchBlockedError extends Error {
 
 export class WorkSessionBranchInvalidError extends Error {
   constructor(
-    readonly kind: 'fork-target' | 'clone-empty',
+    readonly kind: 'fork-target' | 'clone-empty' | 'resend-target',
     message: string
   ) {
     super(message)
@@ -250,6 +257,19 @@ export class WorkSessionManage {
     })
   }
 
+  searchWorkSessions(inputValue: L2WorkSessionSearchRequest): Promise<L2WorkSessionSearchResponse> {
+    const input = L2WorkSessionSearchRequestSchema.parse(inputValue)
+    return this.runExclusive(async () => {
+      await this.ensureHydrated()
+      return L2WorkSessionSearchResponseSchema.parse({
+        sessions: this.orderedWorkSessions().flatMap((workSession) => {
+          const matches = getL4PiWorkSessionRuntime(workSession.sessionId).search(input)
+          return matches.length > 0 ? [{ workId: workSession.workId, matches }] : []
+        })
+      })
+    })
+  }
+
   runPluginRestart<T>(operation: () => Promise<T>): Promise<T> {
     return this.runExclusive(async () => {
       await this.ensureHydrated()
@@ -681,23 +701,35 @@ export class WorkSessionManage {
       if (!source) throw new WorkSessionNotFoundError(input.workId)
       this.assertSessionBinding(source, input.sessionId)
 
-      if (input.action === 'tree') {
+      if (input.action === 'tree' || input.action === 'resend') {
         const previousItem = this.toListItem(source)
         await this.chat.pauseWorkSession(source.workId)
+        let refreshed = false
         let result: Awaited<ReturnType<WorkSession['branch']>>
         try {
-          result = await source.branch(input.entryId)
-          if (result.changed) await this.chat.refreshWorkSession(source)
-          else this.chat.resumeWorkSession(source.workId)
+          if (input.action === 'resend') {
+            await source.send({
+              mode: 'resend',
+              entryId: input.entryId,
+              onBranchChanged: async () => {
+                await this.chat.refreshWorkSession(source, false)
+                refreshed = true
+              }
+            })
+            result = { changed: true, editorText: null }
+          } else {
+            result = await source.branch(input.entryId)
+            if (result.changed) await this.chat.refreshWorkSession(source)
+          }
         } catch (error) {
-          if (source.branchId !== previousItem.branchId) {
-            await this.chat.refreshWorkSession(source)
+          if (source.branchId !== previousItem.branchId || refreshed) {
+            if (!refreshed) await this.chat.refreshWorkSession(source, false)
             const changes = this.toChanges(previousItem, this.toListItem(source))
             if (changes) this.publishUpdate({ type: 'update', workId: source.workId, changes })
-          } else {
-            this.chat.resumeWorkSession(source.workId)
           }
           this.throwBranchError(error, input.entryId)
+        } finally {
+          this.chat.resumeWorkSession(source.workId)
         }
 
         const item = this.toListItem(source)
@@ -710,6 +742,7 @@ export class WorkSessionManage {
           sessionId: source.sessionId,
           entryId: input.entryId,
           branchId: source.branchId,
+          action: input.action,
           changed: result.changed
         })
         return L2WorkSessionBranchResponseSchema.parse({
@@ -857,6 +890,9 @@ export class WorkSessionManage {
     if (error instanceof L4PiSessionForkTargetError) {
       throw new WorkSessionBranchInvalidError('fork-target', '只有用户消息可以 Fork')
     }
+    if (error instanceof L4PiSessionResendTargetError) {
+      throw new WorkSessionBranchInvalidError('resend-target', '只有用户消息可以重发')
+    }
     if (error instanceof L4PiSessionCloneEmptyError) {
       throw new WorkSessionBranchInvalidError('clone-empty', '当前会话还没有可克隆的消息')
     }

package/src/server/l3_modules/work-session/l3-work-session.ts

@@ -1,7 +1,10 @@
 import 'server-only'
 
 import type { ThinkingLevel } from '@earendil-works/pi-agent-core'
-import { L4PiWorkSessionRuntime } from '@server/l4_foundation/pi/l4-pi-work-session-runtime'
+import {
+  L4PiWorkSessionRuntime,
+  type L4PiResendInput
+} from '@server/l4_foundation/pi/l4-pi-work-session-runtime'
 
 export interface WorkSessionInputImage {
   mimeType: 'image/jpeg' | 'image/png' | 'image/webp' | 'image/gif'
@@ -10,11 +13,13 @@ export interface WorkSessionInputImage {
   height: number
 }
 
-export interface WorkSessionSendInput {
-  mode: 'auto' | 'follow_up'
-  text: string
-  images: WorkSessionInputImage[]
-}
+export type WorkSessionSendInput =
+  | {
+      mode: 'auto' | 'follow_up'
+      text: string
+      images: WorkSessionInputImage[]
+    }
+  | L4PiResendInput
 
 export interface WorkSessionModelInput {
   provider: string

package/src/server/l4_foundation/pi/l4-pi-chat-worker.ts

@@ -899,7 +899,7 @@ export class L4PiChatWorker {
     await session.abort()
   }
 
-  async navigateTree(entryId: string): Promise<boolean> {
+  async navigateTree(entryId: string, beforeUserMessage = false): Promise<boolean> {
     const session = await this.ensureSession()
     this.assertIdle()
     if (this.treeResumeImmediate) clearImmediate(this.treeResumeImmediate)
@@ -913,7 +913,10 @@ export class L4PiChatWorker {
         this.messageGate.pause()
         try {
           this.initialization.setStage('切换会话树')
-          const result = await session.navigateTree(entryId, { summarize: false })
+          const result =
+            beforeUserMessage && previousLeaf === entryId
+              ? await this.navigateLeafUserMessage(session, entryId)
+              : await session.navigateTree(entryId, { summarize: false })
           changed = !result.cancelled
           if (changed) await this.capabilityRuntime.apply()
         } catch (error) {
@@ -948,6 +951,36 @@ export class L4PiChatWorker {
     }
   }
 
+  private async navigateLeafUserMessage(
+    session: AgentSession,
+    entryId: string
+  ): Promise<{ cancelled: boolean }> {
+    const entry = this.sessionManager.getEntry(entryId)!
+    // SDK 对当前 leaf 直接 no-op；重发仍需执行导航钩子并回到该用户消息之前。
+    const result = await session.extensionRunner.emit({
+      type: 'session_before_tree',
+      preparation: {
+        targetId: entryId,
+        oldLeafId: entryId,
+        commonAncestorId: entryId,
+        entriesToSummarize: [],
+        userWantsSummary: false
+      },
+      signal: this.commandLifetime.signal
+    })
+    if (result?.cancel || this.commandLifetime.signal.aborted) return { cancelled: true }
+    if (entry.parentId === null) this.sessionManager.resetLeaf()
+    else this.sessionManager.branch(entry.parentId)
+    if (result?.label) this.sessionManager.appendLabelChange(entryId, result.label)
+    session.refreshContext()
+    await session.extensionRunner.emit({
+      type: 'session_tree',
+      oldLeafId: entryId,
+      newLeafId: this.sessionManager.getLeafId()
+    })
+    return { cancelled: false }
+  }
+
   private resetBranchRuntime(): void {
     if (this.treeNavigation) this.treeNavigation.committed = true
     this.commandLifetime.abort()

package/src/server/l4_foundation/pi/l4-pi-session-history-catalog.ts

@@ -26,13 +26,20 @@ import {
 } from '@earendil-works/pi-coding-agent'
 import { z } from 'zod'
 import { findL4PiSessionFile } from './l4-pi-session-discovery'
+import {
+  compactL4PiSessionPreview as compactPreview,
+  matchL4PiSessionSearch,
+  normalizeL4PiSessionSearch as normalizeSearch,
+  readL4PiSessionMessageText as messageText,
+  readL4PiSessionTimestamp as timestampMs,
+  type L4PiSessionSearchMatch,
+  type L4PiSessionSearchScope
+} from './l4-pi-session-search'
 
 const SCAN_CONCURRENCY = 10
-const MATCH_PREVIEW_MAX_LENGTH = 120
-const MATCH_PREVIEW_PREFIX_LENGTH = 16
 const FIRST_MESSAGE_PREVIEW_MAX_LENGTH = 160
 const CACHE_VALIDATION_INTERVAL_MS = 2_000
-const CACHE_IDLE_MS = 15 * 60_000
+const CACHE_IDLE_MS = 60_000
 const CACHE_CWD_LIMIT = 8
 const CACHE_TEXT_BYTES_LIMIT = 32 * 1024 * 1024
 const CACHE_FILE_LIMIT = 4_096
@@ -41,7 +48,7 @@ const LEGACY_CACHE_FILE_NAME = 'pi-session-history.json'
 const PERSISTED_CACHE_VERSION = 2
 const CACHE_DISK_BYTES_LIMIT = 64 * 1024 * 1024
 
-export type L4PiSessionHistorySearchScope = 'title' | 'user' | 'assistant' | 'sessionId'
+export type L4PiSessionHistorySearchScope = L4PiSessionSearchScope
 
 const DEFAULT_SEARCH_IN: readonly L4PiSessionHistorySearchScope[] = ['title', 'user']
 
@@ -72,13 +79,7 @@ interface L4PiSessionAssistantMessage {
   text: string
 }
 
-export interface L4PiSessionHistoryMatch {
-  scope: L4PiSessionHistorySearchScope
-  count: number
-  entryId: string | null
-  timestampMs: number | null
-  preview: string
-}
+export type L4PiSessionHistoryMatch = L4PiSessionSearchMatch
 
 export interface L4PiSessionHistoryItem {
   sessionId: string
@@ -184,6 +185,7 @@ interface L4PiSessionHistoryCatalogState {
   epochs: Map<string, number>
   activeLoads: Map<string, L4PiSessionHistoryCatalogLoad>
   catalogs: Map<string, L4PiSessionHistoryCatalog>
+  cleanupTimer: ReturnType<typeof setTimeout> | null
 }
 
 interface L4PiSessionScanState {
@@ -365,7 +367,8 @@ function historyCatalogState(): L4PiSessionHistoryCatalogState {
     globalThis.__piDeskPiSessionHistoryCatalogState = {
       epochs: new Map(),
       activeLoads: new Map(),
-      catalogs: new Map()
+      catalogs: new Map(),
+      cleanupTimer: null
     }
   }
   return globalThis.__piDeskPiSessionHistoryCatalogState
@@ -375,37 +378,6 @@ function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null && !Array.isArray(value)
 }
 
-function timestampMs(value: unknown): number | null {
-  if (typeof value === 'number' && Number.isSafeInteger(value) && value >= 0) return value
-  if (typeof value !== 'string') return null
-  const parsed = Date.parse(value)
-  return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : null
-}
-
-function normalizeSearch(value: string): string {
-  return value.trim().toLowerCase()
-}
-
-function compactPreview(text: string, maxLength: number): string {
-  const content = text.replace(/\s+/g, ' ').trim()
-  if (content.length <= maxLength) return content
-  return `${content.slice(0, maxLength - 1).trimEnd()}…`
-}
-
-function messageText(message: unknown): string {
-  if (!isRecord(message)) return ''
-  const content = message.content
-  if (typeof content === 'string') return content
-  if (!Array.isArray(content)) return ''
-
-  return content
-    .flatMap((part) => {
-      if (!isRecord(part) || part.type !== 'text' || typeof part.text !== 'string') return []
-      return [part.text]
-    })
-    .join('\n')
-}
-
 function messageTimestamp(entry: Record<string, unknown>, fallback: number): number {
   const entryTimestamp = timestampMs(entry.timestamp)
   if (entryTimestamp !== null) return entryTimestamp
@@ -696,11 +668,31 @@ async function refreshCatalog(
   }
 }
 
-function pruneCatalogs(now: number): void {
-  const state = historyCatalogState()
+function scheduleCatalogRelease(state: L4PiSessionHistoryCatalogState): void {
+  if (state.cleanupTimer) clearTimeout(state.cleanupTimer)
+  state.cleanupTimer = null
+  if (state.catalogs.size === 0) return
+  const expiresAt = Math.min(
+    ...Array.from(state.catalogs.values(), (catalog) => catalog.lastAccessedAt + CACHE_IDLE_MS)
+  )
+  state.cleanupTimer = setTimeout(
+    () => {
+      state.cleanupTimer = null
+      pruneCatalogs(Date.now(), state)
+    },
+    Math.max(0, expiresAt - Date.now())
+  )
+  state.cleanupTimer.unref()
+}
+
+function pruneCatalogs(
+  now: number,
+  state: L4PiSessionHistoryCatalogState = historyCatalogState()
+): void {
   for (const [cwd, catalog] of state.catalogs) {
-    if (now - catalog.lastAccessedAt > CACHE_IDLE_MS) state.catalogs.delete(cwd)
+    if (now - catalog.lastAccessedAt >= CACHE_IDLE_MS) state.catalogs.delete(cwd)
   }
+  scheduleCatalogRelease(state)
 }
 
 function touchCatalog(catalog: L4PiSessionHistoryCatalog, now: number): L4PiSessionHistoryCatalog {
@@ -708,6 +700,7 @@ function touchCatalog(catalog: L4PiSessionHistoryCatalog, now: number): L4PiSess
   const state = historyCatalogState()
   state.catalogs.delete(catalog.cwd)
   state.catalogs.set(catalog.cwd, catalog)
+  scheduleCatalogRelease(state)
   return catalog
 }
 
@@ -715,6 +708,7 @@ function storeCatalog(catalog: L4PiSessionHistoryCatalog, persist: boolean): voi
   const state = historyCatalogState()
   if (catalog.files.size > CACHE_FILE_LIMIT || catalog.textBytes > CACHE_TEXT_BYTES_LIMIT) {
     state.catalogs.delete(catalog.cwd)
+    scheduleCatalogRelease(state)
     if (persist) {
       const path = persistedHistoryCachePath(catalog.cwd)
       try {
@@ -747,6 +741,7 @@ function storeCatalog(catalog: L4PiSessionHistoryCatalog, persist: boolean): voi
     state.catalogs.delete(oldest[0])
     totalBytes -= oldest[1].textBytes
   }
+  scheduleCatalogRelease(state)
   if (persist) persistHistoryCatalog(catalog)
 }
 
@@ -768,8 +763,9 @@ async function getCatalog(
   const state = historyCatalogState()
   const now = Date.now()
   pruneCatalogs(now)
-  const catalog = state.catalogs.get(cwd) ?? readPersistedHistoryCatalog(cwd)
-  const epoch = forceRefresh ? incrementEpoch(cwd) : currentEpoch(cwd)
+  const cached = state.catalogs.get(cwd)
+  const catalog = cached ? touchCatalog(cached, now) : readPersistedHistoryCatalog(cwd)
+  const epoch = forceRefresh && state.activeLoads.has(cwd) ? incrementEpoch(cwd) : currentEpoch(cwd)
   if (forceRefresh && catalog) catalog.dirty = true
   const active = state.activeLoads.get(cwd)
   if (active && active.epoch === epoch) return active.promise
@@ -783,10 +779,12 @@ async function getCatalog(
     return touchCatalog(catalog, now)
   }
 
-  const load = (async (): Promise<L4PiSessionHistoryCatalog> => {
+  const load: Promise<L4PiSessionHistoryCatalog> = Promise.resolve().then(async () => {
     const refresh = await refreshCatalog(cwd, catalog)
     const refreshed = refresh.catalog
-    if (currentEpoch(cwd) === epoch) storeCatalog(refreshed, refresh.changed)
+    if (state.activeLoads.get(cwd)?.promise === load && currentEpoch(cwd) === epoch) {
+      storeCatalog(refreshed, refresh.changed)
+    }
     console.info('[Pi Desk][PiSessionHistoryCatalog] 已更新历史会话内存投影', {
       cwd,
       sessionCount: refreshed.sessions.length,
@@ -795,43 +793,15 @@ async function getCatalog(
       forceRefresh
     })
     return refreshed
-  })()
+  })
   state.activeLoads.set(cwd, { epoch, promise: load })
   try {
     return await load
   } finally {
-    if (state.activeLoads.get(cwd)?.promise === load) state.activeLoads.delete(cwd)
-  }
-}
-
-function previewForMatch(text: string, normalizedQuery: string): string {
-  const normalizedText = text.toLowerCase()
-  const matchIndex = normalizedText.indexOf(normalizedQuery)
-  if (matchIndex < 0) return ''
-
-  const start = Math.max(0, matchIndex - MATCH_PREVIEW_PREFIX_LENGTH)
-  const requiredEnd = matchIndex + normalizedQuery.length
-  const end = Math.min(text.length, Math.max(start + MATCH_PREVIEW_MAX_LENGTH, requiredEnd))
-  const content = text.slice(start, end).replace(/\s+/g, ' ').trim()
-  return `${start > 0 ? '…' : ''}${content}${end < text.length ? '…' : ''}`
-}
-
-function messageMatch(
-  scope: 'user' | 'assistant',
-  messages: readonly L4PiSessionUserMessage[] | readonly L4PiSessionAssistantMessage[],
-  normalizedQuery: string
-): L4PiSessionHistoryMatch | null {
-  const matching = messages.filter((message) =>
-    message.text.toLowerCase().includes(normalizedQuery)
-  )
-  if (matching.length === 0) return null
-  const latest = matching.at(-1)!
-  return {
-    scope,
-    count: matching.length,
-    entryId: latest.entryId,
-    timestampMs: latest.timestampMs,
-    preview: previewForMatch(latest.text, normalizedQuery)
+    if (state.activeLoads.get(cwd)?.promise === load) {
+      state.activeLoads.delete(cwd)
+      state.epochs.delete(cwd)
+    }
   }
 }
 
@@ -854,33 +824,7 @@ function projectHistoryItem(
     }
   }
 
-  const matches: L4PiSessionHistoryMatch[] = []
-  if (searchIn.has('title') && session.name?.toLowerCase().includes(normalizedQuery)) {
-    matches.push({
-      scope: 'title',
-      count: 1,
-      entryId: null,
-      timestampMs: null,
-      preview: compactPreview(session.name, FIRST_MESSAGE_PREVIEW_MAX_LENGTH)
-    })
-  }
-  if (searchIn.has('user')) {
-    const match = messageMatch('user', session.userMessages, normalizedQuery)
-    if (match) matches.push(match)
-  }
-  if (searchIn.has('assistant')) {
-    const match = messageMatch('assistant', session.assistantMessages, normalizedQuery)
-    if (match) matches.push(match)
-  }
-  if (searchIn.has('sessionId') && session.sessionId.toLowerCase().includes(normalizedQuery)) {
-    matches.push({
-      scope: 'sessionId',
-      count: 1,
-      entryId: null,
-      timestampMs: null,
-      preview: session.sessionId
-    })
-  }
+  const matches = matchL4PiSessionSearch(session, normalizedQuery, searchIn)
   if (matches.length === 0) return null
 
   return {
@@ -917,7 +861,10 @@ async function getSessionRecord(
 ): Promise<L4PiSessionHistoryRecord | null> {
   const cwd = resolve(cwdInput)
   pruneCatalogs(Date.now())
-  const catalog = historyCatalogState().catalogs.get(cwd) ?? readPersistedHistoryCatalog(cwd)
+  const memoryCatalog = historyCatalogState().catalogs.get(cwd)
+  const catalog = memoryCatalog
+    ? touchCatalog(memoryCatalog, Date.now())
+    : readPersistedHistoryCatalog(cwd)
   const previous = catalog?.sessions.find((session) => session.sessionId === sessionId)
   const path = await findL4PiSessionFile(cwd, sessionId, previous?.path)
   if (!path) return null
@@ -972,8 +919,10 @@ export function resolveCachedL4PiSessionHistoryPath(
   cwd: string,
   sessionId: string
 ): string | undefined {
+  pruneCatalogs(Date.now())
   const catalog = historyCatalogState().catalogs.get(resolve(cwd))
   if (!catalog || catalog.dirty) return undefined
+  touchCatalog(catalog, Date.now())
   return catalog.sessions.find((session) => session.sessionId === sessionId)?.path
 }
 
@@ -981,7 +930,7 @@ export function invalidateL4PiSessionHistoryCache(cwd?: string): void {
   const state = historyCatalogState()
   if (cwd) {
     const normalizedCwd = resolve(cwd)
-    incrementEpoch(normalizedCwd)
+    if (state.activeLoads.has(normalizedCwd)) incrementEpoch(normalizedCwd)
     const catalog = state.catalogs.get(normalizedCwd)
     if (catalog) catalog.dirty = true
     return
@@ -989,7 +938,7 @@ export function invalidateL4PiSessionHistoryCache(cwd?: string): void {
 
   const affectedCwds = new Set([...state.catalogs.keys(), ...state.activeLoads.keys()])
   for (const catalogCwd of affectedCwds) {
-    incrementEpoch(catalogCwd)
+    if (state.activeLoads.has(catalogCwd)) incrementEpoch(catalogCwd)
     const catalog = state.catalogs.get(catalogCwd)
     if (catalog) catalog.dirty = true
   }