feat: improve resume session labels

Author: Eilen6316

src/linuxagent/app/agent.py

@@ -19,7 +19,13 @@
 from ..interfaces import CommandSource, UserInterface
 from ..services import ChatService, ClusterService, CommandService, MonitoringService
 from .direct_command import DirectCommandRunner
-from .resume import render_resumed_session, resume_list, session_title
+from .resume import (
+    ResumeSessionItem,
+    render_resumed_session,
+    resume_item,
+    resume_list,
+    session_title,
+)
 
 
 @dataclass
@@ -175,14 +181,15 @@ async def _handle_resume_command(self, arg: str, thread_id: str) -> str | None:
             return None
         sessions = self.chat_service.list_sessions()
         if not sessions:
-            await self.ui.print(resume_list(sessions))
+            await self.ui.print(resume_list([]))
             return None
+        items = await self._resume_items(sessions)
         if self.ui.supports_resume_selector():
-            selected_thread_id = await self.ui.choose_resume_session(sessions)
+            selected_thread_id = await self.ui.choose_resume_session(items)
             if selected_thread_id is not None:
                 return await self._resume_and_continue(selected_thread_id)
             return None
-        await self.ui.print(resume_list(sessions))
+        await self.ui.print(resume_list(items))
         self._pending_resume_thread_id = ""
         return None
 
@@ -220,6 +227,22 @@ async def _resume_and_continue(self, thread_id: str) -> str | None:
             await self._resume_pending_work(selected_thread_id)
         return selected_thread_id
 
+    async def _resume_items(self, sessions: list[Any]) -> list[ResumeSessionItem]:
+        items: list[ResumeSessionItem] = []
+        for session in sessions:
+            items.append(resume_item(session, status=await self._resume_status(session.thread_id)))
+        return items
+
+    async def _resume_status(self, thread_id: str) -> str:
+        config: RunnableConfig = {"configurable": {"thread_id": thread_id}}
+        interrupts = await self._interrupts({}, config)
+        if not interrupts:
+            return ""
+        payload = interrupts[0].value
+        if isinstance(payload, dict) and payload.get("type") == "confirm_file_patch":
+            return "pending patch"
+        return "pending confirm"
+
     async def _resume_pending_work(self, thread_id: str) -> None:
         config: RunnableConfig = {"configurable": {"thread_id": thread_id}}
         state: Any = {}

src/linuxagent/app/resume.py

@@ -2,17 +2,37 @@
 
 from __future__ import annotations
 
+from dataclasses import dataclass
+from datetime import datetime
 from typing import Any
 
 from ..services import ChatSession
 
 
-def resume_list(sessions: list[ChatSession]) -> str:
-    if not sessions:
+@dataclass(frozen=True)
+class ResumeSessionItem:
+    session: ChatSession
+    status: str = ""
+
+    @property
+    def thread_id(self) -> str:
+        return self.session.thread_id
+
+    @property
+    def label(self) -> str:
+        return resume_choice_label(self)
+
+
+def resume_item(session: ChatSession, *, status: str = "") -> ResumeSessionItem:
+    return ResumeSessionItem(session=session, status=status)
+
+
+def resume_list(items: list[ResumeSessionItem]) -> str:
+    if not items:
         return "没有可恢复的会话。"
     lines = ["可恢复会话："]
-    for index, session in enumerate(sessions, start=1):
-        lines.append(f"{index}. {session.title} ({len(session.messages)} messages)")
+    for index, item in enumerate(items, start=1):
+        lines.append(f"{index}. {resume_choice_label(item)}")
     lines.append("输入编号恢复会话；直接继续提问则保持当前新对话。")
     return "\n".join(lines)
 
@@ -30,6 +50,14 @@ def session_title(messages: list[Any]) -> str:
     return "Untitled session"
 
 
+def resume_choice_label(item: ResumeSessionItem) -> str:
+    prefix = f"[{item.status}] " if item.status else ""
+    title = _compact(item.session.title, 48)
+    updated = _time_label(item.session.updated_at)
+    count = len(item.session.messages)
+    return f"{prefix}{updated} {title}  · {count} messages"
+
+
 def _session_preview(messages: list[Any]) -> str:
     tail = messages[-6:]
     lines: list[str] = []
@@ -42,3 +70,16 @@ def _session_preview(messages: list[Any]) -> str:
 
 def _display_role(role: str) -> str:
     return {"human": "你", "ai": "LinuxAgent"}.get(role, role)
+
+
+def _compact(text: str, limit: int) -> str:
+    normalized = " ".join(text.split())
+    return normalized if len(normalized) <= limit else f"{normalized[: limit - 3]}..."
+
+
+def _time_label(value: datetime) -> str:
+    local_value = value.astimezone()
+    now = datetime.now().astimezone()
+    if local_value.date() == now.date():
+        return local_value.strftime("%H:%M")
+    return local_value.strftime("%m-%d %H:%M")

src/linuxagent/services/chat_service.py

@@ -5,6 +5,7 @@
 import json
 import os
 from dataclasses import dataclass, field
+from datetime import UTC, datetime, timedelta
 from pathlib import Path
 from typing import Any
 
@@ -18,6 +19,8 @@ class ChatSession:
     thread_id: str
     title: str
     messages: tuple[BaseMessage, ...]
+    created_at: datetime
+    updated_at: datetime
 
 
 @dataclass
@@ -47,17 +50,19 @@ def replace_session(
         title: str | None = None,
     ) -> None:
         trimmed = list(messages[-self.max_messages :])
-        if thread_id in self._sessions:
-            self._sessions.pop(thread_id)
+        now = _now()
+        existing = self._sessions.get(thread_id)
         self._sessions[thread_id] = ChatSession(
             thread_id=thread_id,
             title=title or _session_title(trimmed),
             messages=tuple(trimmed),
+            created_at=existing.created_at if existing is not None else now,
+            updated_at=now,
         )
         self._messages = trimmed
 
     def list_sessions(self, *, limit: int = 10) -> list[ChatSession]:
-        sessions = list(self._sessions.values())
+        sessions = sorted(self._sessions.values(), key=lambda session: session.updated_at)
         return list(reversed(sessions[-limit:]))
 
     def get_session(self, thread_id: str) -> ChatSession | None:
@@ -75,6 +80,8 @@ def save(self) -> None:
                 {
                     "thread_id": session.thread_id,
                     "title": session.title,
+                    "created_at": session.created_at.isoformat(),
+                    "updated_at": session.updated_at.isoformat(),
                     "messages": messages_to_dict(list(session.messages)),
                 }
                 for session in self._sessions.values()
@@ -107,22 +114,43 @@ def _load_sessions(self, raw_sessions: Any) -> None:
             return
         self._sessions.clear()
         self._messages = []
-        for raw_session in raw_sessions:
+        fallback_time = _now()
+        for index, raw_session in enumerate(raw_sessions):
             if isinstance(raw_session, dict):
-                self._load_session(raw_session)
+                self._load_session(raw_session, fallback_time + timedelta(microseconds=index))
 
-    def _load_session(self, raw_session: dict[str, Any]) -> None:
+    def _load_session(self, raw_session: dict[str, Any], fallback_time: datetime) -> None:
         raw_thread_id = raw_session.get("thread_id")
         raw_messages = raw_session.get("messages")
         if not isinstance(raw_thread_id, str) or not isinstance(raw_messages, list):
             return
         messages = messages_from_dict(raw_messages)
         raw_title = raw_session.get("title")
-        self.replace_session(
-            raw_thread_id,
-            messages,
-            title=raw_title if isinstance(raw_title, str) else None,
+        trimmed = list(messages[-self.max_messages :])
+        created_at = _parse_time(raw_session.get("created_at")) or fallback_time
+        updated_at = _parse_time(raw_session.get("updated_at")) or created_at
+        self._sessions[raw_thread_id] = ChatSession(
+            thread_id=raw_thread_id,
+            title=raw_title if isinstance(raw_title, str) else _session_title(trimmed),
+            messages=tuple(trimmed),
+            created_at=created_at,
+            updated_at=updated_at,
         )
+        self._messages = trimmed
+
+
+def _now() -> datetime:
+    return datetime.now(UTC)
+
+
+def _parse_time(value: Any) -> datetime | None:
+    if not isinstance(value, str):
+        return None
+    try:
+        parsed = datetime.fromisoformat(value)
+    except ValueError:
+        return None
+    return parsed if parsed.tzinfo is not None else parsed.replace(tzinfo=UTC)
 
 
 def _session_title(messages: list[BaseMessage]) -> str:

src/linuxagent/ui/console.py

@@ -20,7 +20,6 @@
 from rich.text import Text
 
 from ..interfaces import UserInterface
-from ..services import ChatSession
 from .confirmation_renderer import ConfirmationRenderer
 from .diff_renderer import diff_line_style, render_unified_diff
 from .prompt_session import PromptSessionManager, SlashCommandCompleter
@@ -153,9 +152,14 @@ def _file_patch_approval_response(files: tuple[str, ...]) -> dict[str, Any]:
     return {"decision": "yes", "selected_files": list(selected)}
 
 
-def _resume_choice_label(session: ChatSession) -> str:
-    title = session.title if len(session.title) <= 72 else f"{session.title[:69]}..."
-    return f"{title}  [{len(session.messages)} messages]"
+def _resume_choice_label(session: Any) -> str:
+    label = getattr(session, "label", None)
+    if isinstance(label, str):
+        return label
+    title = str(getattr(session, "title", "Untitled session"))
+    messages = tuple(getattr(session, "messages", ()))
+    compact_title = title if len(title) <= 72 else f"{title[:69]}..."
+    return f"{compact_title}  [{len(messages)} messages]"
 
 
 async def _wait_for_escape() -> str:

tests/unit/app/test_agent.py

@@ -60,6 +60,7 @@ def __init__(
         self.cancel_immediately = False
         self.resume_choice: str | None = None
         self.resume_selector_enabled = False
+        self.resume_sessions: list[Any] = []
 
     async def input_stream(self):
         for item in self._inputs:
@@ -84,7 +85,7 @@ def supports_resume_selector(self) -> bool:
         return self.resume_selector_enabled
 
     async def choose_resume_session(self, sessions: list[Any]) -> str | None:
-        del sessions
+        self.resume_sessions = list(sessions)
         return self.resume_choice
 
 
@@ -433,6 +434,7 @@ async def test_resume_continues_pending_interrupt(tmp_path) -> None:
 
     assert ui.interrupts == [{"type": "confirm_command", "command": "ls"}]
     assert isinstance(graph.calls[0], Command)
+    assert "pending confirm" in ui.resume_sessions[0].label
     assert "done" in "\n".join(ui.printed)
 
 

tests/unit/app/test_resume.py

@@ -0,0 +1,47 @@
+"""Resume rendering tests."""
+
+from __future__ import annotations
+
+from datetime import datetime
+
+from langchain_core.messages import AIMessage, HumanMessage
+
+from linuxagent.app.resume import resume_choice_label, resume_item, resume_list
+from linuxagent.services import ChatSession
+
+
+def test_resume_choice_label_is_compact_and_status_aware() -> None:
+    session = _session(
+        title="修改 /tmp/disk_info.sh 并添加 CPU 和 MEM 采集信息到脚本末尾",
+        message_count=2,
+    )
+    label = resume_choice_label(resume_item(session, status="pending confirm"))
+
+    assert label.startswith("[pending confirm] ")
+    assert "修改 /tmp/disk_info.sh" in label
+    assert "2 messages" in label
+    assert len(label) < 90
+
+
+def test_resume_list_uses_compact_labels() -> None:
+    item = resume_item(_session(title="查看磁盘信息", message_count=1))
+
+    rendered = resume_list([item])
+
+    assert "1." in rendered
+    assert "查看磁盘信息" in rendered
+    assert "1 messages" in rendered
+
+
+def _session(title: str, message_count: int) -> ChatSession:
+    messages = [HumanMessage(content=title)]
+    if message_count > 1:
+        messages.append(AIMessage(content="done"))
+    now = datetime.now().astimezone()
+    return ChatSession(
+        thread_id="thread",
+        title=title,
+        messages=tuple(messages),
+        created_at=now,
+        updated_at=now,
+    )

tests/unit/services/test_services.py

@@ -4,9 +4,10 @@
 
 import asyncio
 import json
+from datetime import UTC, datetime
 
 import pytest
-from langchain_core.messages import AIMessage, HumanMessage
+from langchain_core.messages import AIMessage, HumanMessage, messages_to_dict
 
 from linuxagent.config.models import ClusterConfig, ClusterHost, MonitoringConfig
 from linuxagent.intelligence import CommandLearner
@@ -93,6 +94,57 @@ def test_chat_service_saves_named_resume_sessions(tmp_path) -> None:
     ]
 
 
+def test_chat_service_persists_session_times_and_sorts_by_updated_at(tmp_path) -> None:
+    path = tmp_path / "history.json"
+    older = datetime(2026, 4, 29, 10, 0, tzinfo=UTC)
+    newer = datetime(2026, 4, 30, 10, 0, tzinfo=UTC)
+    payload = {
+        "version": 2,
+        "sessions": [
+            _history_session("older", "old task", older),
+            _history_session("newer", "new task", newer),
+        ],
+    }
+    path.write_text(json.dumps(payload), encoding="utf-8")
+
+    loaded = ChatService(path, max_messages=10)
+    loaded.load()
+    sessions = loaded.list_sessions()
+
+    assert [session.thread_id for session in sessions] == ["newer", "older"]
+    assert sessions[0].created_at == newer
+    assert sessions[0].updated_at == newer
+
+
+def test_chat_service_migrates_undated_sessions_in_file_order(tmp_path) -> None:
+    path = tmp_path / "history.json"
+    payload = {
+        "version": 2,
+        "sessions": [
+            _history_session("thread-a", "old task", None),
+            _history_session("thread-b", "new task", None),
+        ],
+    }
+    path.write_text(json.dumps(payload), encoding="utf-8")
+
+    loaded = ChatService(path, max_messages=10)
+    loaded.load()
+
+    assert [session.thread_id for session in loaded.list_sessions()] == ["thread-b", "thread-a"]
+
+
+def _history_session(thread_id: str, content: str, timestamp: datetime | None) -> dict[str, object]:
+    session: dict[str, object] = {
+        "thread_id": thread_id,
+        "title": content,
+        "messages": messages_to_dict([HumanMessage(content=content)]),
+    }
+    if timestamp is not None:
+        session["created_at"] = timestamp.isoformat()
+        session["updated_at"] = timestamp.isoformat()
+    return session
+
+
 class _FakeSSH:
     async def execute_many(self, hosts, command, **kwargs):
         del kwargs