merge: đồng bộ origin/gamma/refactor (R01/R03/R04 — routing unification,

conversation application service, AtomicJsonFile fix) vào sau khi tách 6 widget UI Co4E (N3) Đã kiểm trước khi merge: ui/co4e_tab.py và ui/routing_toggle.py đều bị 2 bên cùng đụng, nhưng ở vùng dòng khác nhau hoàn toàn (bên kia sửa _apply_co4e_routing/RoutingToggle cho R03-T05, N3 chỉ đụng phần dựng sidebar/canvas/chat) — không có xung đột logic thật. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-08-25 18:43:56 +09:00
parent 0631abf85f 9d6a7be31b
commit c890a20f45
99 changed files with 8342 additions and 236 deletions
@@ -638,12 +638,16 @@ class ChatPanel(QWidget):
    def _apply_routing(self, text: str, turn: Dict[str, Any]) -> None:
        """Auto Model Routing hook — run once per outgoing message.

-        Off → no-op. Auto → silently switch to the best-fit model. Manual → ask
-        the user (modal, with the configured confirm timeout) before switching.
-        Sets ``self._routed_provider``/``self._routed_model`` for THIS turn;
-        :meth:`build_provider` honours them. Never raises — a routing failure
-        must never block sending a message; it just falls back to the tab's
-        own model.
+        Since R03-T04 the Off/Auto/Manual/Fallback rules live in
+        ``application/model_routing/routing_application_service.py``; the copy
+        that used to sit here (and again in Co4E and AI-Edit) is gone. What
+        remains is the widget's own job: snapshot the tab's provider/model into
+        a request, host the Manual-mode modal, and render the outcome by setting
+        ``self._routed_provider``/``self._routed_model`` for THIS turn (honoured
+        by :meth:`build_provider`) plus a status bubble.
+
+        Never raises — a routing failure must never block sending a message; it
+        just falls back to the tab's own model.
        """
        # Recompute fresh each message; clear any previous turn's override.
        self._routed_provider = None
@@ -651,33 +655,36 @@ class ChatPanel(QWidget):
        # An explicitly-pinned Admin agent takes precedence over routing.
        if getattr(self, "_admin_agent", None) is not None:
            return
-        if not (text or "").strip():
-            return
        try:
-            mode = self.ctx.project_routing_mode(self.kind)  # per-workspace mode
-            if mode == "off":
-                return
-            service = self.ctx.routing()
+            from ..application.model_routing import (
+                RoutingRequest,
+                build_routing_application_service,
+            )
+            from .routing_toggle import confirm_switch
+
+            # The model the tab WOULD use without routing — the picker's choice,
+            # or the provider's configured default when nothing is picked.
            cur_provider = self.ctx.config.active_provider
            cur_model = self._model or self.ctx.config.provider_conf(cur_provider).get("model", "")
-            result = service.route(self.kind, text, cur_provider, cur_model, mode_override=mode)
-            if not result.should_switch:
-                return
-            target = result.target()
-            if target is None:
-                return
-            to_provider, to_model = target
-            if mode == "manual":
-                from .routing_toggle import confirm_switch
-                timeout = float(self.ctx.config.routing.get("confirm_timeout_sec", 60) or 60)
-                if not confirm_switch(self, result.decision, timeout):
-                    return  # declined / timed out → keep current model
-            self._routed_provider = to_provider
-            self._routed_model = to_model
+            outcome = build_routing_application_service(self.ctx).resolve(
+                RoutingRequest(
+                    surface=self.kind,          # per-workspace mode key ("cowork"/…)
+                    prompt=text,
+                    current_provider=cur_provider,
+                    current_model=cur_model,
+                ),
+                # Manual mode only: the modal stays in the presentation layer so
+                # the application service never imports Qt.
+                confirm=lambda decision, timeout: confirm_switch(self, decision, timeout),
+            )
+            if not outcome.switched:
+                return  # off / nothing better / declined → keep the tab's model
+            self._routed_provider = outcome.provider
+            self._routed_model = outcome.model
            notice = self.chat_view.add_status(tr(
                "routing.switched_notice",
-                model=to_model, task=result.task_type.value,
-                gain=f"{result.decision.score_gain:.2f}"))
+                model=outcome.model, task=outcome.task_type,
+                gain=f"{outcome.score_gain:.2f}"))
            turn["bubbles"].append(notice)
        except Exception:  # noqa: BLE001 — routing must never block a chat turn
            self._routed_provider = None
@@ -1638,36 +1638,43 @@ class Co4ETab(QWidget):
    def _apply_co4e_routing(self, request: str) -> str:
        """Route this Co4E turn to the best-fit model. Returns the model id to
        use ('' → provider default) and sets ``self._co4e_routed_provider`` when
-        a cross-provider switch is chosen. Off → no-op. Manual → confirm first.
-        Never raises — falls back to the default model on any error."""
+        a cross-provider switch is chosen.
+
+        R03-T05: the Off/Auto/Manual/Fallback rules are no longer re-implemented
+        here — they come from the shared ``RoutingApplicationService``, so Co4E,
+        the Cowork chat and AI-Edit can never drift apart again. This method only
+        adapts between Co4E's state and the service's DTOs. Never raises — falls
+        back to the default model on any error.
+        """
        self._co4e_routed_provider = None
-        if not (request or "").strip():
-            return ""
        try:
-            mode = self.ctx.project_routing_mode("co4e")  # per-workspace mode
-            if mode == "off":
-                return ""
-            service = self.ctx.routing()
+            from ..application.model_routing import (
+                RoutingRequest,
+                build_routing_application_service,
+            )
+            from .routing_toggle import confirm_switch
+
            cur_provider = self.ctx.config.active_provider
            cur_model = self.ctx.config.provider_conf(cur_provider).get("model", "")
-            result = service.route("co4e", request, cur_provider, cur_model, mode_override=mode)
-            if not result.should_switch:
-                return ""
-            target = result.target()
-            if target is None:
-                return ""
-            to_provider, to_model = target
-            if mode == "manual":
-                from .routing_toggle import confirm_switch
-                timeout = float(self.ctx.config.routing.get("confirm_timeout_sec", 60) or 60)
-                if not confirm_switch(self, result.decision, timeout):
-                    return ""
-            self._co4e_routed_provider = to_provider
+            outcome = build_routing_application_service(self.ctx).resolve(
+                RoutingRequest(
+                    surface="co4e",
+                    prompt=request,
+                    current_provider=cur_provider,
+                    current_model=cur_model,
+                ),
+                confirm=lambda decision, timeout: confirm_switch(self, decision, timeout),
+            )
+            if not outcome.switched:
+                return ""   # '' keeps the provider's configured default model
+            # Remembered so the worker's build_provider_for() can follow a
+            # cross-provider switch, not just a model change.
+            self._co4e_routed_provider = outcome.provider
            self._append_chat("system", tr(
                "routing.switched_notice",
-                model=to_model, task=result.task_type.value,
-                gain=f"{result.decision.score_gain:.2f}"))
-            return to_model
+                model=outcome.model, task=outcome.task_type,
+                gain=f"{outcome.score_gain:.2f}"))
+            return outcome.model
        except Exception:  # noqa: BLE001 — routing must never block a Co4E turn
            self._co4e_routed_provider = None
            return ""
@@ -346,19 +346,45 @@ class CoworkTab(ChatPanel):
        self._apply_output_folder_label()  # picks up edits made via Settings too

    def build_job(self, text: str, messages, out_dir):
-        # Each turn writes into its OWN isolated folder (out_dir) and works on its
-        # OWN message list, so several turns can run in parallel without clobbering
-        # each other's files or history. Deliverables are moved up to the session
-        # Output root when the turn finishes (see _cleanup_turn).
+        """This turn's job: a frozen request run through the conversation service.
+
+        Since R04-T04 the widget no longer drives the turn loop. Every value a
+        turn depends on is read HERE, on the UI thread at submit time, and packed
+        into an immutable ``ConversationExecutionRequest`` — so clicking a
+        different model or switching workspace mid-answer cannot reach work
+        already in flight.
+        """
        output_dir = out_dir or self._session_output_dir()
+        # The sandbox folder is named by the turn id ('.turns/t3'); with no
+        # sandbox the session id identifies the turn well enough for the audit log.
+        turn_id = out_dir.name if out_dir is not None else self.session_id
+        session_id = self.session_id
        title = self.title
        project_id = self.project_id
+        home_output_root = self.workspace_dir()
        # Captured at submit time (UI thread): the Admin-defined agent
        # preset's instructions, if one is selected in the Agent picker.
        agent_prompt = self.admin_agent_prompt()
+        # Per-workspace Auto-run override wins, else the global "confirm before
+        # running commands" setting. Frozen now, so a Settings change mid-turn
+        # cannot flip the rules this turn started under.
+        confirm_commands = self.ctx.project_confirm_commands()
+        # What the turn is recorded as running on. A routing override (R03) wins
+        # over the tab's own picker; '' means the provider's configured default.
+        # Informational only — an Admin-agent preset builds its own provider
+        # below, so treat these as the record, not the decision.
+        provider_id = self._routed_provider or self.ctx.config.active_provider
+        model = self._routed_model or self._model or ""

        def job(worker: AgentWorker):
-            from ..core.chat_agent import run_cowork
+            from ..application.conversations.core_runtime_adapter import (
+                build_cowork_conversation_service,
+                legacy_event_sink,
+            )
+            from ..application.conversations.cowork_turn_request import (
+                build_cowork_turn_request,
+            )
+            from ..application.conversations.turn_runtime import combine_instructions
            from ..core.projects import load_project, project_context_text

            provider = self.build_provider()  # this tab's selected agent/model
@@ -367,23 +393,36 @@ class CoworkTab(ChatPanel):
            # built-in MCP server auto-registered while signed in, see
            # AppContext._ms365_builtin_connection / mcp_servers/ms365_server.py).
            extra_tools, extra_exec = self.ctx.build_mcp_tools()
-            # Shared project instructions (Claude-Projects style) — refreshed
-            # each turn so edits in the Workspace screen apply immediately.
-            proj_ctx = project_context_text(load_project(project_id))
-            if agent_prompt:
-                proj_ctx = f"{proj_ctx}\n\n{agent_prompt}" if proj_ctx else agent_prompt
+            # Shared project instructions (Claude-Projects style) plus the Admin
+            # agent's persona, refreshed each turn so edits in the Workspace
+            # screen apply immediately.
+            instructions = combine_instructions(
+                project_context_text(load_project(project_id)), agent_prompt)
            # Permission Management (Sandbox Security Layer): off by default —
-            # matches the pre-existing auto-run behavior. Now resolved PER
-            # WORKSPACE: this project's Auto-run override wins, else the global
-            # "confirm before running commands" setting (project_confirm_commands).
+            # matches the pre-existing auto-run behavior. The gate lives on the
+            # worker because the UI resolves it from the main thread.
            gate = None
-            if self.ctx.project_confirm_commands():
+            if confirm_commands:
                gate = worker.new_gate("confirm", agent_role=agent_roles.COWORK)
-            run_cowork(provider, messages, output_dir, worker.emit_event,
-                       worker.is_cancelled, title=title,
-                       extra_tools=extra_tools, extra_executor=extra_exec,
-                       project_context=proj_ctx, security_config=self.ctx.config,
-                       gate=gate)
+
+            service = build_cowork_conversation_service(
+                provider, output_dir, worker.emit_event, title=title,
+                project_context=instructions, extra_tools=extra_tools,
+                extra_executor=extra_exec, security_config=self.ctx.config,
+                gate=gate, agent_role=agent_roles.COWORK,
+            )
+            request = build_cowork_turn_request(
+                turn_id=turn_id, session_id=session_id, surface=self.kind,
+                project_id=project_id, title=title, messages=messages,
+                provider_id=provider_id, model=model, instructions=instructions,
+                output_dir=output_dir, home_output_root=home_output_root,
+                confirm_commands=gate is not None, agent_role=agent_roles.COWORK,
+            )
+            # Hand the widget's own list over: _reattach_running_turn replays
+            # from it while the turn is still running, and _finalize_turn slices
+            # it afterwards, so the service must append into that very object.
+            service.execute(request, legacy_event_sink(worker.emit_event),
+                            cancel=worker.is_cancelled, messages=messages)
            return {"messages": messages, "turn_dir": str(output_dir)}

        return job
@@ -923,43 +923,42 @@ class FolderTab(QWidget):
    def _ai_apply_routing(self, instruction: str) -> None:
        """Auto Model Routing for the AI-Edit surface (always a CODING task).

-        Off → no-op. Auto → silently pick the best coding model. Manual → ask
-        first. Sets ``self._ai_routed_provider``/``_ai_routed_model`` for this
-        run; :meth:`_ai_provider` honours them. Never raises."""
+        R03-T05: routes through the shared ``RoutingApplicationService`` instead
+        of repeating the Off/Auto/Manual/Fallback rules locally. Sets
+        ``self._ai_routed_provider``/``_ai_routed_model`` for this run;
+        :meth:`_ai_provider` honours them. Never raises."""
        self._ai_routed_provider = None
        self._ai_routed_model = None
-        if not (instruction or "").strip():
-            return
        try:
-            from ..core.routing.models import TaskType
-            mode = self.ctx.project_routing_mode("ai_edit")  # per-workspace mode
-            if mode == "off":
-                return
-            service = self.ctx.routing()
+            from ..application.model_routing import (
+                RoutingRequest,
+                build_routing_application_service,
+            )
+            from .routing_toggle import confirm_switch
+
            cur_provider = self.ctx.config.active_provider
            picked = self.ai_model_combo.currentData() if hasattr(self, "ai_model_combo") else None
            cur_model = picked or self.ctx.config.provider_conf(cur_provider).get("model", "")
-            result = service.route(
-                "ai_edit", instruction, cur_provider, cur_model,
-                mode_override=mode, task_type=TaskType.CODING,
+            outcome = build_routing_application_service(self.ctx).resolve(
+                RoutingRequest(
+                    surface="ai_edit",
+                    prompt=instruction,
+                    current_provider=cur_provider,
+                    current_model=cur_model,
+                    # AI-Edit turns are always code edits, so the task type is
+                    # pinned rather than classified from the instruction text.
+                    task_type="coding",
+                ),
+                confirm=lambda decision, timeout: confirm_switch(self, decision, timeout),
            )
-            if not result.should_switch:
+            if not outcome.switched:
                return
-            target = result.target()
-            if target is None:
-                return
-            to_provider, to_model = target
-            if mode == "manual":
-                from .routing_toggle import confirm_switch
-                timeout = float(self.ctx.config.routing.get("confirm_timeout_sec", 60) or 60)
-                if not confirm_switch(self, result.decision, timeout):
-                    return
-            self._ai_routed_provider = to_provider
-            self._ai_routed_model = to_model
+            self._ai_routed_provider = outcome.provider
+            self._ai_routed_model = outcome.model
            self.ai_chat.add_status(tr(
                "routing.switched_notice",
-                model=to_model, task=result.task_type.value,
-                gain=f"{result.decision.score_gain:.2f}"))
+                model=outcome.model, task=outcome.task_type,
+                gain=f"{outcome.score_gain:.2f}"))
        except Exception:  # noqa: BLE001 — routing must never block an edit
            self._ai_routed_provider = None
            self._ai_routed_model = None
@@ -1,12 +1,13 @@
-"""Off/Auto/Manual routing toggle + Auto-run toggle + Manual-mode confirm dialog.
+"""Off/Auto/Manual/Fallback routing toggle + Auto-run toggle + confirm dialog.

 Dropped into every chat surface's composer (Cowork / Co4E / AI-Edit). By
 default a :class:`RoutingToggle` reads/writes the **per-workspace** mode via
 ``AppContext.project_routing_mode`` / ``set_project_routing_mode`` (so each
 workspace keeps its own mode), but the storage is fully injectable through
 ``get_mode``/``set_mode`` callables — all the real decision logic lives in
-``core/routing``. Call :meth:`refresh` when the active workspace changes so the
-control shows that workspace's mode.
+``application/model_routing`` (which the surfaces call through
+``RoutingApplicationService``). Call :meth:`refresh` when the active workspace
+changes so the control shows that workspace's mode.
 """
 from __future__ import annotations

@@ -39,7 +40,7 @@ class RoutingToggle(QWidget):
    Emits :attr:`mode_changed`; call :meth:`refresh` after the workspace switches.
    """

-    mode_changed = Signal(str)  # "off" | "auto" | "manual"
+    mode_changed = Signal(str)  # "off" | "auto" | "manual" | "fallback"

    def __init__(
        self,
@@ -65,11 +66,14 @@ class RoutingToggle(QWidget):
        self._label.setObjectName("hint")
        self._combo = QComboBox()
        self._combo.setToolTip(tr("routing.toggle_tooltip"))
-        # (data value, i18n key) — data is the persisted mode string.
+        # (data value, i18n key) — data is the persisted mode string. Order is
+        # least-to-most autonomous, with Fallback (R03-T03) last because it is
+        # the "only when something breaks" mode rather than a stronger Auto.
        self._modes = [
            ("off", "routing.mode_off"),
            ("auto", "routing.mode_auto"),
            ("manual", "routing.mode_manual"),
+            ("fallback", "routing.mode_fallback"),
        ]
        for value, key in self._modes:
            self._combo.addItem(tr(key), value)