@jetcrab/pi-desk 1.1.25 → 1.1.29-dev

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
   }

package/src/server/l4_foundation/pi/l4-pi-session-search.ts

@@ -0,0 +1,166 @@
+import 'server-only'
+
+import type { SessionManager } from '@earendil-works/pi-coding-agent'
+
+export type L4PiSessionSearchScope = 'title' | 'user' | 'assistant' | 'sessionId'
+
+export interface L4PiSessionSearchMatch {
+  scope: L4PiSessionSearchScope
+  count: number
+  entryId: string | null
+  timestampMs: number | null
+  preview: string
+}
+
+export interface L4PiSessionSearchQuery {
+  query: string
+  searchIn: readonly L4PiSessionSearchScope[]
+}
+
+const MATCH_PREVIEW_MAX_LENGTH = 120
+const MATCH_PREVIEW_PREFIX_LENGTH = 16
+
+export interface L4PiSessionSearchMessage {
+  entryId: string
+  timestampMs: number
+  text: string
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+export function readL4PiSessionTimestamp(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
+}
+
+export function normalizeL4PiSessionSearch(value: string): string {
+  return value.trim().toLowerCase()
+}
+
+export function compactL4PiSessionPreview(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()}…`
+}
+
+export function readL4PiSessionMessageText(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 previewForMatch(text: string, normalizedQuery: string): string {
+  const matchIndex = text.toLowerCase().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: Iterable<L4PiSessionSearchMessage>,
+  normalizedQuery: string
+): L4PiSessionSearchMatch | null {
+  let count = 0
+  let latest: L4PiSessionSearchMessage | undefined
+  for (const message of messages) {
+    if (!message.text.toLowerCase().includes(normalizedQuery)) continue
+    count += 1
+    latest = message
+  }
+  if (!latest) return null
+  return {
+    scope,
+    count,
+    entryId: latest.entryId,
+    timestampMs: latest.timestampMs,
+    preview: previewForMatch(latest.text, normalizedQuery)
+  }
+}
+
+export function matchL4PiSessionSearch(
+  session: {
+    sessionId: string
+    name: string | null
+    userMessages: Iterable<L4PiSessionSearchMessage>
+    assistantMessages: Iterable<L4PiSessionSearchMessage>
+  },
+  normalizedQuery: string,
+  searchIn: ReadonlySet<L4PiSessionSearchScope>
+): L4PiSessionSearchMatch[] {
+  if (!normalizedQuery) return []
+  const matches: L4PiSessionSearchMatch[] = []
+  if (searchIn.has('title') && session.name?.toLowerCase().includes(normalizedQuery)) {
+    matches.push({
+      scope: 'title',
+      count: 1,
+      entryId: null,
+      timestampMs: null,
+      preview: compactL4PiSessionPreview(session.name, 160)
+    })
+  }
+  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
+    })
+  }
+  return matches
+}
+
+export function searchL4PiSessionBranch(
+  sessionManager: SessionManager,
+  input: L4PiSessionSearchQuery
+): L4PiSessionSearchMatch[] {
+  const branch = sessionManager.getBranch()
+  function* messages(role: 'user' | 'assistant'): Generator<L4PiSessionSearchMessage> {
+    for (const entry of branch) {
+      if (entry.type !== 'message' || entry.message.role !== role) continue
+      const text = readL4PiSessionMessageText(entry.message)
+      if (!text.trim()) continue
+      yield {
+        entryId: entry.id,
+        timestampMs:
+          readL4PiSessionTimestamp(entry.timestamp) ??
+          readL4PiSessionTimestamp(entry.message.timestamp) ??
+          0,
+        text
+      }
+    }
+  }
+  return matchL4PiSessionSearch(
+    {
+      sessionId: sessionManager.getSessionId(),
+      name: sessionManager.getSessionName()?.trim() || null,
+      userMessages: messages('user'),
+      assistantMessages: messages('assistant')
+    },
+    normalizeL4PiSessionSearch(input.query),
+    new Set(input.searchIn)
+  )
+}

package/src/server/l4_foundation/pi/l4-pi-work-session-runtime.ts

@@ -4,6 +4,11 @@ import { existsSync } from 'node:fs'
 import { resolve } from 'node:path'
 import { ModelRuntime, SessionManager, type SessionEntry } from '@earendil-works/pi-coding-agent'
 import type { PluginJsonObject, SessionPluginSource } from '@jetcrab/pi-desk-sdk'
+import {
+  searchL4PiSessionBranch,
+  type L4PiSessionSearchMatch,
+  type L4PiSessionSearchQuery
+} from './l4-pi-session-search'
 import { getL4CapabilityModesStore } from '@server/l4_foundation/capability-modes/l4-capability-modes-store'
 import {
   L4PiChatWorker,
@@ -17,7 +22,7 @@ import {
   type L4PiNativeCommandInfo,
   type L4PiNativeToolInfo
 } from './l4-pi-chat-worker'
-import type { L4PiInputImage } from './l4-pi-image'
+import { decodeL4PiImage, type L4PiInputImage } from './l4-pi-image'
 import type { L4PiModelCatalog } from './l4-pi-model-catalog'
 import { L4PiSessionBranchIndex, type L4PendingBranchAppend } from './l4-pi-session-branch'
 import {
@@ -48,6 +53,19 @@ export class L4PiSessionBranchBlockedError extends Error {
   }
 }
 
+export class L4PiSessionResendTargetError extends Error {
+  constructor(entryId: string) {
+    super(`Pi session resend target is not a user message: ${entryId}`)
+    this.name = 'L4PiSessionResendTargetError'
+  }
+}
+
+export interface L4PiResendInput {
+  mode: 'resend'
+  entryId: string
+  onBranchChanged: () => Promise<void>
+}
+
 export class L4PiSessionCloneEmptyError extends Error {
   constructor() {
     super('Pi session has no durable entry to clone')
@@ -166,6 +184,11 @@ export class L4PiWorkSessionRuntime {
     return projectL4PiChatSnapshot(this.sessionManager)
   }
 
+  search(input: L4PiSessionSearchQuery): L4PiSessionSearchMatch[] {
+    this.assertActive()
+    return searchL4PiSessionBranch(this.sessionManager, input)
+  }
+
   async readSessionTree(): Promise<L4PiSessionTree> {
     this.assertActive()
     const models = this.sessionManager.getEntries().some((entry) => entry.type === 'model_change')
@@ -290,9 +313,35 @@ export class L4PiWorkSessionRuntime {
     await this.chatWorker.abortDirectBash()
   }
 
-  async send(input: L4PiChatSendInput): Promise<{ tempId: string }> {
+  async send(input: L4PiChatSendInput | L4PiResendInput): Promise<{ tempId: string }> {
     this.assertActive()
-    return this.chatWorker.send(input)
+    if (input.mode !== 'resend') return this.chatWorker.send(input)
+
+    const entry = this.sessionManager.getEntry(input.entryId)
+    if (!entry) throw new L4PiSessionEntryNotFoundError(input.entryId)
+    if (entry.type !== 'message' || entry.message.role !== 'user') {
+      throw new L4PiSessionResendTargetError(input.entryId)
+    }
+    const content = entry.message.content
+    const text =
+      typeof content === 'string'
+        ? content
+        : content.flatMap((part) => (part.type === 'text' ? [part.text] : [])).join('')
+    const images =
+      typeof content === 'string'
+        ? []
+        : content.flatMap((part) =>
+            part.type === 'image'
+              ? [{ ...decodeL4PiImage(part.data).metadata, data: part.data }]
+              : []
+          )
+    const blockReason = this.chatWorker.readPluginReloadBlockReason()
+    if (blockReason) throw new L4PiSessionBranchBlockedError(blockReason)
+    const selection = await this.navigateBranch(input.entryId, true, input.onBranchChanged)
+    if (!selection.changed) {
+      throw new L4PiSessionBranchBlockedError('分支切换已取消，未重发消息')
+    }
+    return this.chatWorker.send({ mode: 'auto', text, images })
   }
 
   async interrupt(): Promise<void> {
@@ -375,10 +424,20 @@ export class L4PiWorkSessionRuntime {
   }
 
   async branch(entryId: string): Promise<L4PiBranchSelection> {
+    return this.navigateBranch(entryId)
+  }
+
+  private async navigateBranch(
+    entryId: string,
+    beforeUserMessage = false,
+    onBranchChanged?: () => Promise<void>
+  ): Promise<L4PiBranchSelection> {
     this.assertActive()
     this.assertBranchable()
     this.syncBranchIndex()
-    const selection = resolveL4PiBranchSelection(this.sessionManager, entryId)
+    const selection: L4PiBranchSelection = beforeUserMessage
+      ? { ...resolveL4PiForkSelection(this.sessionManager, entryId), changed: true }
+      : resolveL4PiBranchSelection(this.sessionManager, entryId)
     if (!selection.changed) return selection
 
     const previousLeaf = this.sessionManager.getLeafId()
@@ -387,7 +446,7 @@ export class L4PiWorkSessionRuntime {
     this.pendingBranchAppend = null
     let changed = false
     try {
-      changed = await this.chatWorker.navigateTree(selection.selectedEntryId)
+      changed = await this.chatWorker.navigateTree(selection.selectedEntryId, beforeUserMessage)
       return changed
         ? selection
         : {
@@ -402,6 +461,8 @@ export class L4PiWorkSessionRuntime {
       if (changed || leaf !== previousLeaf) {
         this.pendingBranchAppend = this.branchIndex.predictAppend(leaf)
         this.branchIdValue = this.pendingBranchAppend.branchId
+        // 包括后置钩子抛错的已提交导航；刷新后再恢复消息，不能丢失临时消息。
+        await onBranchChanged?.()
       } else {
         this.pendingBranchAppend = previousPending
       }