[C4] Restore last session (reopen recent project & last document)

Author: inliver233

issues/2026-02-10_18-23-04-ui-autosave-streaming-v1.csv

@@ -2,7 +2,7 @@ ID,Title,Description,Acceptance,Test_Method,Tools,Dev_Status,Review1_Status,Regr
 C1,Unify bottom status UI (remove duplicate editor status frame),Remove EditorPanel internal bottom status frame to avoid double bottom bars and overlapping lines; ensure stats/cursor/doc status still update via main EnhancedStatusBar; adjust layout/styling if needed; update Qt layout test accordingly.,Only one bottom status area is shown; no overlapping/stacked lines; status info still updates; Qt layout test passes.,python -m pytest -q tests/test_status_bar_layout.py,none,DONE,DONE,TODO,src/gui/editor/editor_panel.py | src/gui/status/status_bar.py | tests/test_status_bar_layout.py,none,done_at:2026-02-10 | test:.tmp\\ane0305-venv-311\\Scripts\\python.exe -m pytest -q tests/test_status_bar_layout.py
 C2,Add ProjectManager.update_document_content + editor save,Implement ProjectManager.update_document_content wrapper (persist content via update_document); update IntelligentTextEditor manual save and autosave paths to persist when bound; add unit test covering update_document_content behavior and ensuring no AttributeError/crash.,Autosave/manual save persist content via ProjectManager.update_document_content when project/doc bound; unit test passes.,python -m pytest -q tests/test_project_update_document_content.py,none,DONE,DONE,TODO,src/core/project.py | src/gui/editor/text_editor.py | tests/test_project_update_document_content.py,none,done_at:2026-02-10 | test:.tmp\\ane0305-venv-311\\Scripts\\python.exe -m pytest -q tests/test_project_update_document_content.py
 C3,Bind EditorPanel documents to ProjectManager (autosave works),Add EditorPanel.set_project_manager and ensure all editors created for project documents are bound to the active ProjectManager + correct document_id; update MainWindow wiring so selecting a document loads/updates via ProjectManager and manual save works; avoid users typing into an unbound scratch doc when a project is open; add integration test.,Editing a project document triggers autosave and persists into project DB; reopening project shows saved content; manual save works; integration test passes.,python -m pytest -q tests/test_editor_project_persistence.py,none,DONE,DONE,TODO,src/gui/editor/editor_panel.py | src/gui/main_window_parts/ui.py | src/gui/main_window_parts/integrations.py | tests/test_editor_project_persistence.py,C2,test:pytest -q tests/test_editor_project_persistence.py PASS | done_at:2026-02-10
-C4,Restore last session (reopen recent project & last document),"Persist and restore last-open project/document when enabled: wire SettingsDialog restore_session/auto_save prefs into Config; on startup, if enabled, auto-open most recent project and re-open last document (fallback to first scene).",Restart restores the previous project and last document content instead of showing a blank scratch doc (when restore_session enabled).,manual,none,TODO,TODO,TODO,src/main.py | src/core/config_schema.py | src/gui/dialogs/settings_dialog.py | src/core/config.py | src/gui/main_window_parts/ui.py | src/gui/main_window_parts/integrations.py,C3,"manual_checklist: 1) Create/open a project, edit a scene, wait for autosave, close app. 2) Reopen app; expect project auto-open and edited content present. 3) Disable restore_session in settings; restart; expect no auto-open."
+C4,Restore last session (reopen recent project & last document),"Persist and restore last-open project/document when enabled: wire SettingsDialog restore_session/auto_save prefs into Config; on startup, if enabled, auto-open most recent project and re-open last document (fallback to first scene).",Restart restores the previous project and last document content instead of showing a blank scratch doc (when restore_session enabled).,manual,none,DONE,DONE,TODO,src/main.py | src/core/config_schema.py | src/gui/dialogs/settings_dialog.py | src/core/config.py | src/gui/main_window_parts/ui.py | src/gui/main_window_parts/integrations.py | src/gui/main_window_parts/dialogs.py | src/gui/editor/text_editor.py,C3,"manual_checklist: 1) Create/open a project, edit a scene, wait for autosave, close app. 2) Reopen app; expect project auto-open and edited content present. 3) Disable restore_session in settings; restart; expect no auto-open. | validation_limited:manual app restart not executed here | evidence:python -m compileall -q src PASS | risk:medium session-restore depends on runtime restart flow | done_at:2026-02-10"
 C5,Streaming dispatch respects stream_response toggle,Plumb config ai.stream_response (default on) through AICompletionService/AIRequestDispatcher to use QtAIClient.complete_stream_async; include context/request_id in chunk signals; ensure cancellation prevents stale chunks from updating UI; add unit test for dispatch selection.,"When stream_response enabled, streaming client method is used and chunk signals are emitted; when disabled, non-stream method used; unit test passes.",python -m pytest -q tests/test_streaming_dispatcher.py,none,TODO,TODO,TODO,src/application/ai_completion_service.py | src/core/ai_qt_client.py | src/gui/ai/enhanced_ai_manager.py | src/gui/main_window_parts/integrations.py | tests/test_streaming_dispatcher.py,none,none
 C6,Provider streaming adaptation (Gemini endpoint + chunk parsing),Implement provider-specific streaming endpoint/headers/parsing: Gemini uses streamGenerateContent + SSE; add Gemini extract_stream_content; improve streaming parser robustness; ensure OpenAI/Claude continue working; add unit tests with fixture chunks.,Gemini streaming endpoint/path is correct and chunk parsing yields incremental text; unit tests pass.,python -m pytest -q tests/test_provider_streaming_gemini.py,none,TODO,TODO,TODO,src/core/ai_client.py | src/core/ai_providers/gemini.py | src/core/ai_providers/openai.py | src/core/ai_providers/claude.py | tests/test_provider_streaming_gemini.py,C5,none
 C7,UI streaming renderer (typed sequential ghost text; no乱序),"Connect streaming chunk updates to SmartCompletionManager and render as ordered, typing-like ghost text; buffer and flush to UI to avoid乱序/抖动; ignore chunks from cancelled/old requests; finalize cleanly on completion; add unit/Qt test.","During streaming completion, suggestion grows in order like typing; cancel stops updates; no stale chunks applied; test passes.",python -m pytest -q tests/test_streaming_typed_renderer.py,none,TODO,TODO,TODO,src/gui/editor/smart_completion_manager.py | src/gui/main_window_parts/integrations.py | src/gui/ai/enhanced_ai_manager.py | tests/test_streaming_typed_renderer.py,C5|C6,none

src/core/config_schema.py

@@ -11,6 +11,10 @@
     # 应用程序设置
     "app": {
         "language": "zh_CN",
+        "restore_session": True,
+        "last_project_path": "",
+        "last_document_id": "",
+        "auto_save_enabled": True,
         "auto_save_interval": 30,  # 秒
         "backup_count": 5,
         "check_updates": True,

src/gui/editor/text_editor.py

@@ -785,8 +785,12 @@ def _on_text_changed(self):
         self.clear_ghost_text()
 
         # 重启自动保存定时器
-        auto_save_interval = self._config.get("app", "auto_save_interval", 30) * 1000
-        self._auto_save_timer.start(auto_save_interval)
+        auto_save_enabled = bool(self._config.get("app", "auto_save_enabled", True))
+        if auto_save_enabled:
+            auto_save_interval = self._config.get("app", "auto_save_interval", 30) * 1000
+            self._auto_save_timer.start(auto_save_interval)
+        else:
+            self._auto_save_timer.stop()
 
         # 发出文本变化信号
         text = self.toPlainText()
@@ -844,6 +848,8 @@ def _on_cursor_position_changed(self):
     @pyqtSlot()
     def _trigger_auto_save(self):
         """触发自动保存"""
+        if not bool(self._config.get("app", "auto_save_enabled", True)):
+            return
         if self._is_modified:
             content = self.toPlainText()
             if content != self._last_save_content:

src/gui/main_window_parts/dialogs.py

@@ -47,8 +47,107 @@
 class MainWindowDialogsMixin:
     """MainWindow mixin."""
     def _show_preferences(self):
-        dialog = SettingsDialog(self, {})
+        dialog = SettingsDialog(self, self._get_settings_dialog_payload())
+        dialog.settingsChanged.connect(self._apply_settings_dialog_payload)
         dialog.exec()
+
+    def _get_settings_dialog_payload(self) -> dict:
+        def _map_theme_to_label(theme: str) -> str:
+            mapping = {
+                "dark": "深色主题",
+                "light": "浅色主题",
+                "high_contrast": "高对比度",
+            }
+            return mapping.get(theme, "深色主题")
+
+        def _map_language_to_label(language: str) -> str:
+            mapping = {
+                "zh_CN": "简体中文",
+                "en_US": "English",
+                "zh_TW": "繁體中文",
+            }
+            return mapping.get(language, "简体中文")
+
+        try:
+            auto_save_interval_seconds = int(self._config.get("app", "auto_save_interval", 30))
+        except Exception:
+            auto_save_interval_seconds = 30
+        auto_save_minutes = max(1, min(60, max(1, auto_save_interval_seconds) // 60))
+
+        return {
+            "general": {
+                "language": _map_language_to_label(str(self._config.get("app", "language", "zh_CN"))),
+                "theme": _map_theme_to_label(str(self._config.get("ui", "theme", "dark"))),
+                "auto_save": bool(self._config.get("app", "auto_save_enabled", True)),
+                "auto_save_interval": auto_save_minutes,
+                "backup_enabled": bool(self._config.get("project", "auto_backup", True)),
+                "backup_count": int(self._config.get("app", "backup_count", 5)),
+                "restore_session": bool(self._config.get("app", "restore_session", True)),
+            },
+            "editor": dict(self._config.get_section("editor") or {}),
+            "ai": {},
+        }
+
+    @pyqtSlot(dict)
+    def _apply_settings_dialog_payload(self, settings: dict) -> None:
+        def _map_label_to_theme(theme_label: str) -> str:
+            mapping = {
+                "深色主题": "dark",
+                "浅色主题": "light",
+                "高对比度": "high_contrast",
+            }
+            return mapping.get(theme_label, "dark")
+
+        def _map_label_to_language(language_label: str) -> str:
+            mapping = {
+                "简体中文": "zh_CN",
+                "English": "en_US",
+                "繁體中文": "zh_TW",
+            }
+            return mapping.get(language_label, "zh_CN")
+
+        general = settings.get("general", {}) if isinstance(settings, dict) else {}
+        editor_settings = settings.get("editor", {}) if isinstance(settings, dict) else {}
+
+        try:
+            with self._config.batch_update():
+                self._config.set("app", "language", _map_label_to_language(str(general.get("language", "简体中文"))))
+                self._config.set("ui", "theme", _map_label_to_theme(str(general.get("theme", "深色主题"))))
+
+                self._config.set("app", "restore_session", bool(general.get("restore_session", True)))
+                self._config.set("app", "auto_save_enabled", bool(general.get("auto_save", True)))
+
+                try:
+                    minutes = int(general.get("auto_save_interval", 5))
+                except Exception:
+                    minutes = 5
+                minutes = max(1, min(60, minutes))
+                self._config.set("app", "auto_save_interval", minutes * 60)
+
+                self._config.set("project", "auto_backup", bool(general.get("backup_enabled", True)))
+                try:
+                    backup_count = int(general.get("backup_count", 5))
+                except Exception:
+                    backup_count = 5
+                self._config.set("app", "backup_count", max(1, min(20, backup_count)))
+
+                if isinstance(editor_settings, dict) and editor_settings:
+                    merged_editor = dict(self._config.get_section("editor") or {})
+                    merged_editor.update(editor_settings)
+                    self._config.set_section("editor", merged_editor)
+        except Exception:
+            logger.exception("Failed to apply settings dialog payload")
+
+        try:
+            self._shared.auto_save_enabled = bool(self._config.get("app", "auto_save_enabled", True))
+        except Exception:
+            pass
+
+        if hasattr(self, "_apply_theme"):
+            try:
+                self._apply_theme()
+            except Exception:
+                logger.debug("Theme apply failed", exc_info=True)
     def _show_about(self):
         dialog = AboutDialog(self)
         dialog.exec()

src/gui/main_window_parts/integrations.py

@@ -48,6 +48,7 @@ class MainWindowIntegrationsMixin:
     """MainWindow mixin."""
     def _init_signals(self):
         self._shared.projectChanged.connect(self._on_project_changed)
+        self._shared.documentChanged.connect(self._on_document_changed_for_session_restore)
         self._shared.themeChanged.connect(self._on_theme_changed)
         self._theme_manager.themeChanged.connect(self._on_theme_manager_changed)
 
@@ -411,14 +412,69 @@ def _on_project_opened(self, project_path: str):
                 logger.warning("项目打开后AI客户端不可用，尝试恢复")
                 self._ai_manager.force_reinit_ai()
 
-        # Open a default project document to avoid leaving users in an unbound scratch tab.
+        # Persist session metadata and open the last document when appropriate.
         try:
-            self._open_default_document_after_project_open()
+            self._open_last_or_default_document_after_project_open(project_path)
         except Exception as exc:  # noqa: BLE001
-            logger.debug("Failed to open default document after project open: %s", exc)
+            logger.debug("Failed to open session/default document after project open: %s", exc)
 
         logger.info(f"Project opened at: {project_path}")
 
+    @pyqtSlot(str)
+    def _on_document_changed_for_session_restore(self, document_id: str) -> None:
+        """Persist last active project/document for optional session restore."""
+        try:
+            if not document_id or document_id == "default_doc":
+                return
+            if not getattr(self, "_project_manager", None) or not self._project_manager.has_project():
+                return
+            if not self._project_manager.get_document(document_id):
+                return
+
+            self._config.set("app", "last_document_id", document_id)
+
+            project_path = ""
+            try:
+                current_path = self._shared.current_project_path
+                if current_path:
+                    project_path = str(current_path)
+            except Exception:
+                project_path = ""
+
+            if project_path:
+                self._config.set("app", "last_project_path", project_path)
+        except Exception:
+            logger.debug("Failed to persist session restore metadata", exc_info=True)
+
+    def _open_last_or_default_document_after_project_open(self, project_path: str) -> None:
+        """Open last active doc for the same project; fallback to default scene."""
+        prior_last_project = str(self._config.get("app", "last_project_path", "") or "").strip()
+        last_document_id = str(self._config.get("app", "last_document_id", "") or "").strip()
+        restore_enabled = bool(self._config.get("app", "restore_session", True))
+
+        try:
+            self._config.set("app", "last_project_path", project_path)
+        except Exception:
+            logger.debug("Failed to persist last_project_path", exc_info=True)
+
+        def _norm(path_str: str) -> str:
+            from pathlib import Path
+
+            if not path_str:
+                return ""
+            try:
+                return str(Path(path_str).resolve())
+            except Exception:
+                return str(Path(path_str))
+
+        if restore_enabled and prior_last_project and last_document_id:
+            if _norm(prior_last_project) == _norm(project_path):
+                if getattr(self, "_project_manager", None) and self._project_manager.get_document(last_document_id):
+                    self._on_document_selected(last_document_id)
+                    return
+
+        self._open_default_document_after_project_open()
+
     def _open_default_document_after_project_open(self) -> None:
         """Open a default project document if the editor is still on an empty scratch tab."""
         project_manager = getattr(self, "_project_manager", None)

src/main.py

@@ -249,6 +249,46 @@ def main():
         logger.info("AI Novel Editor started successfully")
 
         smoke_project_dir = os.environ.get("ANE_SMOKE_PROJECT", "").strip()
+
+        def _restore_last_session() -> None:
+            try:
+                if not bool(config_instance.get("app", "restore_session", True)):
+                    return
+
+                recent_projects = config_instance.get("project", "recent_projects", [])
+                project_path = str(config_instance.get("app", "last_project_path", "") or "").strip()
+                if (not project_path) and isinstance(recent_projects, list) and recent_projects:
+                    project_path = str(recent_projects[0] or "").strip()
+
+                if not project_path:
+                    return
+
+                db_file = Path(project_path) / "project.db"
+                if not db_file.is_file():
+                    logger.info("Session restore skipped; project.db not found: %s", db_file)
+                    return
+
+                ok = bool(project_manager_instance.open_project(project_path))
+                logger.info("Session restore open_project ok=%s path=%s", ok, project_path)
+                if not ok:
+                    return
+
+                try:
+                    main_window._project_controller.project_opened.emit(project_path)
+                    main_window._project_controller.project_structure_changed.emit()
+                except Exception:
+                    logger.debug("Session restore controller signal emit failed", exc_info=True)
+                    try:
+                        main_window._on_project_opened(project_path)
+                        main_window._on_project_structure_changed()
+                    except Exception:
+                        logger.debug("Session restore UI refresh failed", exc_info=True)
+            except Exception:
+                logger.exception("Session restore failed")
+
+        if not smoke_project_dir:
+            QTimer.singleShot(0, _restore_last_session)
+
         if smoke_project_dir:
             logger.warning("SMOKE mode enabled via ANE_SMOKE_PROJECT=%s", smoke_project_dir)