Feature/delta team/epic r04 (#7)

## Summary

epic r04 - begin refactor

## Change Type

- [x] Cowork feature
- [ ] Bug fix
- [ ] Core AI contribution
- [ ] Test / hardening
- [ ] Performance
- [ ] Documentation

## Related Work

Cowork Task:

Core Repo: http://34.143.229.138/gitea-admin/fsg-ai-core-assets

Core AI Issue:

Core Task:

Related PR:

## Scope

What is intentionally included?

What is intentionally NOT included?

## Validation

- [ ] Unit tests
- [ ] Integration tests
- [ ] Manual verification
- [ ] Regression check

Commands / evidence:

## Security Impact

Permission / credential / network / customer data impact:

## Compatibility

- [ ] No breaking change
- [ ] Breaking change documented

## Reviewer Notes

Anything Cowork reviewers should pay attention to.

---------

Co-authored-by: Anh Tran Nguyen Minh <anhtnm1@fpt.com>
Co-authored-by: Huong Le Thi Thien <huongltt35@fpt.com>
Co-authored-by: Nam Pham Dinh Thanh <nampdt@fpt.com>
Co-authored-by: Vu Dam Tuan <vudt15@fpt.com>
Co-authored-by: Hiep Ha Van <hiephv3@fpt.com>
Co-authored-by: Lam Hoang Van <lamhv7@fpt.com>
Reviewed-on: #7
Co-authored-by: Duy Le Huu <duylh19@fpt.com>

tests/integration/__init__.py

@@ -0,0 +1,7 @@
+"""Integration tests: several real layers wired together, still fully offline.
+
+Where unit tests pin one class against fakes and contract tests pin an interface
+across implementations, these exercise a real path end to end — e.g. the
+application routing service on top of the real ``core/routing`` engine — so a
+seam that only works against a mock is caught here.
+"""

tests/integration/test_agent_event_bridge.py

@@ -0,0 +1,113 @@
+"""R04-T02 — the typed event vocabulary vs. what the real runtime emits.
+
+The unit tests pin each event against the shape I *read* out of
+``core/chat_agent.py``. This one removes the reading: it runs the actual
+``run_cowork`` loop offline (FakeProvider, real tool execution, real cleanup)
+and asserts every dict it emits is recognised by :func:`from_legacy_dict` and
+survives a round trip byte-for-byte.
+
+That makes it a guard against the two failure modes a hand-written vocabulary
+has: an event type nobody modelled, and a key that silently changes meaning.
+Either one would surface here as a failure instead of as a blank chat bubble
+after R04-T03 starts routing events through the typed layer.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, List
+
+import pytest
+from cowork_local.core import chat_agent
+from cowork_local.domain.agents.agent_event_codec import from_legacy_dict
+from cowork_local.tests.fakes.fake_provider import FakeProvider
+
+
+def _run_turn_and_collect(tmp_path: Path, provider: FakeProvider) -> List[Dict[str, Any]]:
+    """Run one real ``run_cowork`` turn offline and return every emitted dict."""
+    output_dir = tmp_path / "output"
+    output_dir.mkdir(parents=True, exist_ok=True)
+    emitted: List[Dict[str, Any]] = []
+
+    chat_agent.run_cowork(
+        provider=provider,
+        messages=[{"role": "user", "content": "make me a report"}],
+        output_dir=output_dir,
+        emit=emitted.append,
+        # security_config=None disables the AI guardrail layers, which is the
+        # documented behaviour for headless callers and keeps this test offline.
+        security_config=None,
+        title="Report",
+    )
+    return emitted
+
+
+def _reporting_turn(tmp_path: Path) -> List[Dict[str, Any]]:
+    """A turn that streams text, calls save_file, then answers — the common path."""
+    provider = FakeProvider()
+    provider.queue_response(
+        content="Writing it now.",
+        chunks=["Writing ", "it now."],
+        tool_calls=[{"id": "call_1", "name": "save_file",
+                     "arguments": {"filename": "report.md", "content": "# Report\n"}}],
+    )
+    provider.queue_response(content="Saved to report.md.", chunks=["Saved to report.md."])
+    return _run_turn_and_collect(tmp_path, provider)
+
+
+def test_the_runtime_emits_only_event_types_the_domain_layer_models(tmp_path: Path) -> None:
+    emitted = _reporting_turn(tmp_path)
+
+    unmodelled = sorted({e["type"] for e in emitted if from_legacy_dict(e) is None})
+
+    assert unmodelled == [], f"run_cowork emits event types R04-T02 does not model: {unmodelled}"
+
+
+def test_every_emitted_event_round_trips_without_losing_a_key(tmp_path: Path) -> None:
+    emitted = _reporting_turn(tmp_path)
+    assert emitted, "the turn produced no events at all — the fixture is wrong"
+
+    for raw in emitted:
+        event = from_legacy_dict(raw)
+        assert event is not None, raw
+        assert event.to_legacy_dict() == raw, f"round trip changed the {raw['type']} event"
+
+
+def test_a_tool_using_turn_really_exercises_the_tool_events(tmp_path: Path) -> None:
+    # Guards the test above from passing trivially: if the fixture ever stopped
+    # calling a tool, the round-trip check would only cover text events.
+    types = {e["type"] for e in _reporting_turn(tmp_path)}
+
+    assert {"text", "assistant_done", "tool_proposed", "tool_result"} <= types
+
+
+def test_reasoning_events_from_a_thinking_model_round_trip(tmp_path: Path) -> None:
+    # A separate fixture because only reasoning models emit these, and the
+    # common-path turn above would otherwise never cover the event.
+    provider = FakeProvider()
+    provider.queue_response(content="42", chunks=["42"], reasoning="Let me think...")
+
+    emitted = _run_turn_and_collect(tmp_path, provider)
+
+    reasoning_events = [e for e in emitted if e["type"] == "reasoning"]
+    assert reasoning_events, "a reasoning model produced no reasoning event"
+    for raw in reasoning_events:
+        assert from_legacy_dict(raw).to_legacy_dict() == raw
+
+
+def test_plan_events_from_the_real_update_plan_tool_round_trip(tmp_path: Path) -> None:
+    provider = FakeProvider()
+    provider.queue_response(
+        content="Planning.",
+        tool_calls=[{"id": "call_1", "name": "update_plan",
+                     "arguments": {"steps": [{"title": "Draft", "status": "running"},
+                                             {"title": "Review", "status": "pending"}]}}],
+    )
+    provider.queue_response(content="Done.")
+
+    emitted = _run_turn_and_collect(tmp_path, provider)
+
+    plan_events = [e for e in emitted if e["type"] == "plan_set"]
+    assert plan_events, "update_plan did not produce a plan_set event"
+    for raw in plan_events:
+        assert from_legacy_dict(raw).to_legacy_dict() == raw

tests/integration/test_chat_flow.py

@@ -0,0 +1,139 @@
+"""EPIC R08 - Chat UI Hub integration tests.
+
+Tests the lifecycle, UI component assembly, and event wiring of the refactored
+presentation/chat/ sub-package (ChatPanel, ComposerWidget, AudioRecorderWidget,
+ChatHistoryWidget, OutputPanelMixin).
+"""
+from __future__ import annotations
+
+import os
+from unittest.mock import MagicMock
+
+import pytest
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+
+from cowork_local.config import AppConfig
+from cowork_local.presentation.chat import (
+    AudioRecorderWidget,
+    ChatHistoryWidget,
+    ChatPanel,
+    ChatView,
+    Composer,
+    ComposerWidget,
+    MessageBubble,
+)
+from cowork_local.state import AppContext
+
+pytest.importorskip("PySide6", reason="Qt required for chat UI integration tests")
+
+
+@pytest.fixture(scope="module")
+def qt_app():
+    from PySide6.QtWidgets import QApplication
+
+    return QApplication.instance() or QApplication([])
+
+
+@pytest.fixture
+def ctx(qt_app, tmp_path):
+    config_file = tmp_path / "config.json"
+    config = AppConfig.load(config_file)
+    return AppContext(config)
+
+
+def test_chat_history_widget_adds_and_clears_bubbles(qt_app):
+    """Verify ChatHistoryWidget / ChatView can append different bubble types and clear them."""
+    view = ChatHistoryWidget()
+    assert isinstance(view, ChatView)
+
+    b_user = view.add_user("Hello agent")
+    assert isinstance(b_user, MessageBubble)
+    assert b_user.role == "user"
+
+    b_assistant = view.add_assistant()
+    assert isinstance(b_assistant, MessageBubble)
+    assert b_assistant.role == "assistant"
+    b_assistant.set_markdown("**Bold response**")
+
+    b_status = view.add_status("Processing task...")
+    assert isinstance(b_status, MessageBubble)
+
+    b_error = view.add_error("Network timeout")
+    assert isinstance(b_error, MessageBubble)
+
+    # Clear transcript
+    view.clear()
+    assert view._lay.count() == 1  # only trailing stretch item remains
+
+
+def test_composer_widget_queue_and_submission(qt_app):
+    """Verify ComposerWidget / Composer handles text submission and parallel queueing."""
+    composer = ComposerWidget()
+    assert isinstance(composer, Composer)
+
+    submitted_events = []
+    composer.submitted.connect(lambda text, atts: submitted_events.append((text, atts)))
+
+    # Direct submission via _on_submit
+    composer.set_text("Run command ls")
+    composer._on_submit()
+    assert len(submitted_events) == 1
+    assert submitted_events[0][0] == "Run command ls"
+    assert submitted_events[0][1] == []
+
+    # Submit when busy puts message in queue
+    composer.set_busy(True)
+    composer.enqueue("Queued task 1")
+    composer.enqueue("Queued task 2", attachments=["/tmp/file.txt"])
+
+    assert len(composer._queue) == 2
+    assert composer.has_queue() is True
+
+    # Free up slot via pop_next
+    next_msg = composer.pop_next()
+    assert next_msg is not None
+    assert next_msg["text"] == "Queued task 1"
+    assert len(composer._queue) == 1
+
+
+def test_audio_recorder_widget_state_transitions(qt_app):
+    """Verify AudioRecorderWidget transitions from idle -> recording -> stopped."""
+    recorder = AudioRecorderWidget()
+    assert recorder.is_recording() is False
+
+    started_signal = MagicMock()
+    stopped_signal = MagicMock()
+    audio_ready_signal = MagicMock()
+
+    recorder.recording_started.connect(started_signal)
+    recorder.recording_stopped.connect(stopped_signal)
+    recorder.audio_ready.connect(audio_ready_signal)
+
+    # Start recording
+    recorder.start_recording()
+    assert recorder.is_recording() is True
+    started_signal.assert_called_once()
+
+    # Simulate timer tick
+    recorder._on_tick()
+    assert recorder.timer_label.text() == "00:01"
+
+    # Stop recording
+    recorder.stop_recording()
+    assert recorder.is_recording() is False
+    stopped_signal.assert_called_once_with(1)
+    audio_ready_signal.assert_called_once_with(b"", "wav")
+
+
+def test_chat_panel_initialization(ctx, qt_app):
+    """Verify ChatPanel builds correctly with its mixed-in panels and sub-widgets."""
+    panel = ChatPanel(ctx, kind="cowork", session_name="test_session")
+    assert panel.ctx is ctx
+    assert panel.kind == "cowork"
+    assert panel.session_name == "test_session"
+    assert hasattr(panel, "chat_view")
+    assert hasattr(panel, "composer")
+    assert hasattr(panel, "input_section")
+    assert hasattr(panel, "output_section")
+    assert isinstance(panel.composer, Composer)

tests/integration/test_conversation_service_parity.py

@@ -0,0 +1,207 @@
+"""R04-T03 (c) — the service must behave exactly like ``run_cowork``.
+
+The unit tests prove the loop follows the rules I wrote down. They cannot prove
+those rules are the ones the shipped runtime actually follows. This file does:
+each test scripts one provider, runs the SAME turn twice — once through
+``core/chat_agent.py::run_cowork``, once through
+``ConversationApplicationService`` wired by ``core_runtime_adapter`` — and
+compares the emitted event stream, the resulting conversation and the tool list
+the model was shown.
+
+Anything the port got wrong (a missing event, a reordered guard, a different
+tool set, a changed message) fails here rather than in front of a user. The only
+allowed difference is the extra ``turn_completed`` event R04 introduces, which
+has no legacy consumer.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+from cowork_local.application.conversations.core_runtime_adapter import (
+    build_cowork_conversation_service,
+    legacy_event_sink,
+)
+from cowork_local.core import chat_agent
+from cowork_local.domain.agents.conversation_execution_request import (
+    ConversationExecutionRequest,
+)
+from cowork_local.tests.fakes.fake_provider import FakeProvider
+
+_USER_TURN = [{"role": "user", "content": "make me a report"}]
+
+
+class _FakeGate:
+    """Stands in for ``core/permissions.py::PermissionGate``."""
+
+    def __init__(self, approve: bool) -> None:
+        self.approve = approve
+        self.requests: List[Dict[str, Any]] = []
+
+    def request(self, action: Dict[str, Any]) -> bool:
+        self.requests.append(action)
+        return self.approve
+
+
+def _normalise(events: List[Dict[str, Any]], out_dir: Path) -> List[Dict[str, Any]]:
+    """Replace the run's own output path with a placeholder.
+
+    The two runs write into different temp folders, so absolute paths in
+    ``tool_result``/``outputs_*`` events differ by construction. Everything else
+    must match verbatim.
+    """
+    marker, raw = "<OUT>", str(out_dir)
+
+    def scrub(value: Any) -> Any:
+        if isinstance(value, str):
+            return value.replace(raw, marker).replace(raw.replace("\\", "/"), marker)
+        if isinstance(value, list):
+            return [scrub(v) for v in value]
+        if isinstance(value, dict):
+            return {k: scrub(v) for k, v in value.items()}
+        return value
+
+    return [scrub(e) for e in events]
+
+
+def _run_legacy(tmp_path: Path, provider: FakeProvider, *, allowed_tools=None,
+                gate: Optional[_FakeGate] = None, max_steps: int = 30
+                ) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]], List[str]]:
+    """Run the turn through the existing ``run_cowork``."""
+    out_dir = tmp_path / "legacy"
+    out_dir.mkdir(parents=True, exist_ok=True)
+    events: List[Dict[str, Any]] = []
+    messages = [dict(m) for m in _USER_TURN]
+
+    chat_agent.run_cowork(
+        provider, messages, out_dir, events.append, title="Report",
+        security_config=None, allowed_tools=allowed_tools, gate=gate, max_steps=max_steps,
+    )
+    tool_names = [t.name for t in (provider.last_tools or [])]
+    return _normalise(events, out_dir), messages, tool_names
+
+
+def _run_service(tmp_path: Path, provider: FakeProvider, *, allowed_tools=None,
+                 gate: Optional[_FakeGate] = None, max_steps: int = 30
+                 ) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]], List[str]]:
+    """Run the same turn through the application service."""
+    out_dir = tmp_path / "service"
+    out_dir.mkdir(parents=True, exist_ok=True)
+    events: List[Dict[str, Any]] = []
+
+    service = build_cowork_conversation_service(
+        provider, out_dir, events.append, title="Report", security_config=None, gate=gate)
+    request = ConversationExecutionRequest(
+        turn_id="t1", session_id="s1",
+        # run_cowork receives the user message already appended; the request
+        # carries the history and this turn's prompt separately.
+        messages=_USER_TURN[:-1], prompt=_USER_TURN[-1]["content"],
+        output_dir=out_dir, allowed_tools=allowed_tools, max_steps=max_steps,
+        gate_mode="confirm" if gate is not None else "auto",
+    )
+    result = service.execute(request, legacy_event_sink(events.append))
+
+    # The end-of-turn event is new in R04 and has no legacy counterpart.
+    kept = [e for e in events if e.get("type") != "turn_completed"]
+    tool_names = [t.name for t in (provider.last_tools or [])]
+    return _normalise(kept, out_dir), list(result.messages), tool_names
+
+
+def _assert_parity(tmp_path: Path, script, *, approve: Optional[bool] = None, **kwargs) -> None:
+    """Script two identical providers, run both paths, compare everything."""
+    legacy_provider, service_provider = FakeProvider(), FakeProvider()
+    script(legacy_provider)
+    script(service_provider)
+
+    legacy_gate = _FakeGate(approve) if approve is not None else None
+    service_gate = _FakeGate(approve) if approve is not None else None
+
+    legacy_events, legacy_messages, legacy_tools = _run_legacy(
+        tmp_path, legacy_provider, gate=legacy_gate, **kwargs)
+    service_events, service_messages, service_tools = _run_service(
+        tmp_path, service_provider, gate=service_gate, **kwargs)
+
+    assert service_events == legacy_events
+    assert service_messages == legacy_messages
+    assert service_tools == legacy_tools
+    if legacy_gate is not None and service_gate is not None:
+        assert [r["name"] for r in service_gate.requests] == \
+               [r["name"] for r in legacy_gate.requests]
+
+
+# --------------------------------------------------------------------------- #
+# Scenarios.
+# --------------------------------------------------------------------------- #
+def test_a_plain_answer_turn_behaves_identically(tmp_path: Path) -> None:
+    def script(provider: FakeProvider) -> None:
+        provider.queue_response(content="Here you go.", chunks=["Here ", "you go."])
+
+    _assert_parity(tmp_path, script)
+
+
+def test_a_save_file_turn_behaves_identically(tmp_path: Path) -> None:
+    def script(provider: FakeProvider) -> None:
+        provider.queue_response(
+            content="Writing it.",
+            tool_calls=[{"id": "c1", "name": "save_file",
+                         "arguments": {"filename": "report.md", "content": "# Report\n"}}],
+        )
+        provider.queue_response(content="Saved.")
+
+    _assert_parity(tmp_path, script)
+
+
+def test_an_update_plan_turn_behaves_identically(tmp_path: Path) -> None:
+    def script(provider: FakeProvider) -> None:
+        provider.queue_response(
+            content="Planning.",
+            tool_calls=[{"id": "c1", "name": "update_plan",
+                         "arguments": {"steps": [{"title": "Draft", "status": "running"},
+                                                 {"title": "Ship", "status": "pending"}]}}],
+        )
+        provider.queue_response(content="Done.")
+
+    _assert_parity(tmp_path, script)
+
+
+def test_a_reasoning_only_reply_behaves_identically(tmp_path: Path) -> None:
+    def script(provider: FakeProvider) -> None:
+        provider.queue_response(content="", reasoning="thinking hard")
+
+    _assert_parity(tmp_path, script)
+
+
+def test_restricting_the_tool_scope_advertises_the_same_tools(tmp_path: Path) -> None:
+    def script(provider: FakeProvider) -> None:
+        provider.queue_response(content="ok")
+
+    _assert_parity(tmp_path, script, allowed_tools=["save_file"])
+
+
+def test_a_rejected_command_behaves_identically(tmp_path: Path) -> None:
+    # The security-critical path: the gate says no, so the command must never
+    # run and the model must read back the same refusal in both designs.
+    def script(provider: FakeProvider) -> None:
+        provider.queue_response(
+            content="Running it.",
+            tool_calls=[{"id": "c1", "name": "run_command",
+                         "arguments": {"command": "echo hi"}}],
+        )
+        provider.queue_response(content="Understood.")
+
+    _assert_parity(tmp_path, script, approve=False)
+
+
+def test_hitting_the_step_ceiling_behaves_identically(tmp_path: Path) -> None:
+    # The model never stops calling tools, so both paths must stop at the same
+    # place and say so the same way.
+    def script(provider: FakeProvider) -> None:
+        for i in range(4):
+            provider.queue_response(
+                content=f"step {i}",
+                tool_calls=[{"id": f"c{i}", "name": "save_file",
+                             "arguments": {"filename": f"f{i}.md", "content": "x"}}],
+            )
+
+    _assert_parity(tmp_path, script, max_steps=2)

tests/integration/test_cowork_tab_turn.py

@@ -0,0 +1,220 @@
+"""R04-T04 — the migrated Cowork call site, exercised end to end without Qt.
+
+``CoworkTab.build_job`` only ever *reads attributes* off its widget, so the real
+production method can be invoked against a stand-in that supplies those
+attributes. That is what happens here: the actual ``build_job`` body runs, builds
+a request, wires the service through ``core_runtime_adapter``, and drives a real
+turn (real tool execution, real output-folder cleanup) against ``FakeProvider``.
+
+Why it matters: this is the only automated check that the widget's contract with
+the service still holds — that the worker's list is appended to in place (the
+transcript re-render and history merge both read it), that events still arrive as
+legacy dicts, and that a produced file really lands in the turn's folder. None of
+it needs a display server, so it runs in CI like every other test.
+"""
+
+from __future__ import annotations
+
+import copy
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import pytest
+from cowork_local.config import DEFAULT_CONFIG, AppConfig
+from cowork_local.tests.fakes.fake_provider import FakeProvider
+
+
+class _FakeWorker:
+    """The parts of ``core/worker.py::AgentWorker`` a job actually touches."""
+
+    def __init__(self, approve_commands: bool = True) -> None:
+        self.events: List[Dict[str, Any]] = []
+        self.gate: Optional[Any] = None
+        self._approve = approve_commands
+        self.cancelled = False
+
+    def emit_event(self, event: Dict[str, Any]) -> None:
+        self.events.append(event)
+
+    def is_cancelled(self) -> bool:
+        return self.cancelled
+
+    def new_gate(self, mode: str, agent_role: str = "") -> Any:
+        # Mirrors AgentWorker.new_gate: the gate is stored on the worker so the
+        # UI thread can resolve it, and answers request() from the worker thread.
+        worker = self
+
+        class _Gate:
+            requests: List[Dict[str, Any]] = []
+
+            def request(self, action: Dict[str, Any]) -> bool:
+                self.requests.append(action)
+                return worker._approve
+
+        self.gate = _Gate()
+        return self.gate
+
+
+class _FakeCtx:
+    """The ``AppContext`` surface ``build_job`` uses."""
+
+    def __init__(self, config: AppConfig, confirm_commands: bool = False) -> None:
+        self.config = config
+        self._confirm = confirm_commands
+
+    def project_confirm_commands(self) -> bool:
+        return self._confirm
+
+    def build_mcp_tools(self):
+        return [], None
+
+
+class _WidgetStub:
+    """Stands in for the CoworkTab instance ``build_job`` reads its state from."""
+
+    kind = "cowork"
+
+    def __init__(self, out_root: Path, ctx: _FakeCtx, provider: FakeProvider) -> None:
+        self._out_root = out_root
+        self.ctx = ctx
+        self._provider = provider
+        self.title = "Report"
+        self.session_id = "s1"
+        self.project_id = ""          # the auto-seeded default workspace
+        self._model = ""
+        self._routed_provider = None
+        self._routed_model = None
+
+    def _session_output_dir(self) -> Path:
+        return self._out_root
+
+    def workspace_dir(self) -> Path:
+        return self._out_root
+
+    def admin_agent_prompt(self) -> str:
+        return ""
+
+    def build_provider(self) -> FakeProvider:
+        return self._provider
+
+
+def _config() -> AppConfig:
+    """A real AppConfig that never touches ``~/.cowork_local``.
+
+    The AI security guardrails are switched off: they would call the model to
+    review the prompt, which is a separate feature with its own tests and would
+    make this one depend on what the fake answers.
+    """
+    data = copy.deepcopy(DEFAULT_CONFIG)
+    data["agent_security"]["enabled"] = False
+    return AppConfig(data)
+
+
+def _run_turn(tmp_path: Path, provider: FakeProvider, messages: List[Dict[str, Any]],
+              *, confirm_commands: bool = False, approve: bool = True):
+    """Invoke the real ``CoworkTab.build_job`` against the stub and run its job."""
+    from cowork_local.ui.cowork_tab import CoworkTab
+
+    out_dir = tmp_path / ".turns" / "t1"
+    out_dir.mkdir(parents=True, exist_ok=True)
+    widget = _WidgetStub(tmp_path, _FakeCtx(_config(), confirm_commands), provider)
+    worker = _FakeWorker(approve_commands=approve)
+
+    job = CoworkTab.build_job(widget, "make me a report", messages, out_dir)
+    result = job(worker)
+    return result, worker
+
+
+def test_the_turn_runs_and_reports_its_folder(tmp_path: Path) -> None:
+    provider = FakeProvider()
+    provider.queue_response(content="Here you go.", chunks=["Here ", "you go."])
+    messages = [{"role": "user", "content": "make me a report"}]
+
+    result, worker = _run_turn(tmp_path, provider, messages)
+
+    assert result["turn_dir"] == str(tmp_path / ".turns" / "t1")
+    assert [e["type"] for e in worker.events] == [
+        "text", "text", "assistant_done", "turn_completed"]
+
+
+def test_the_worker_list_is_appended_to_in_place(tmp_path: Path) -> None:
+    # _reattach_running_turn replays from this very list while the turn runs, and
+    # _finalize_turn slices it by the pre-turn length afterwards.
+    provider = FakeProvider()
+    provider.queue_response(content="Done.")
+    user = {"role": "user", "content": "make me a report"}
+    messages = [user]
+
+    result, _ = _run_turn(tmp_path, provider, messages)
+
+    assert result["messages"] is messages
+    # Identity, not just equality: _reattach_running_turn locates the turn's user
+    # message with ``m is ctx["user_msg"]`` to replay the steps after it.
+    assert any(m is user for m in messages)
+    # Several system blocks are expected — the tool prompt plus the tagged
+    # skills/security-rules blocks the runtime refreshes on every turn.
+    assert [m["role"] for m in messages if m["role"] != "system"] == ["user", "assistant"]
+    assert messages[-1]["content"] == "Done."
+
+
+def test_a_saved_file_lands_in_the_turn_folder(tmp_path: Path) -> None:
+    provider = FakeProvider()
+    provider.queue_response(
+        content="Writing it.",
+        tool_calls=[{"id": "c1", "name": "save_file",
+                     "arguments": {"filename": "report.md", "content": "# Report\n"}}],
+    )
+    provider.queue_response(content="Saved.")
+    messages = [{"role": "user", "content": "make me a report"}]
+
+    _, worker = _run_turn(tmp_path, provider, messages)
+
+    produced = list((tmp_path / ".turns" / "t1").glob("*.md"))
+    assert len(produced) == 1
+    assert produced[0].read_text(encoding="utf-8") == "# Report\n"
+    results = [e for e in worker.events if e["type"] == "tool_result"]
+    assert results and results[0]["ok"] is True
+
+
+def test_auto_run_mode_never_creates_a_permission_gate(tmp_path: Path) -> None:
+    provider = FakeProvider()
+    provider.queue_response(content="ok")
+
+    _, worker = _run_turn(tmp_path, provider, [{"role": "user", "content": "hi"}],
+                          confirm_commands=False)
+
+    assert worker.gate is None
+
+
+def test_confirm_mode_creates_the_gate_and_a_refusal_stops_the_command(tmp_path: Path) -> None:
+    provider = FakeProvider()
+    provider.queue_response(
+        content="Running it.",
+        tool_calls=[{"id": "c1", "name": "run_command",
+                     "arguments": {"command": "echo hi"}}],
+    )
+    provider.queue_response(content="Understood.")
+
+    _, worker = _run_turn(tmp_path, provider, [{"role": "user", "content": "run it"}],
+                          confirm_commands=True, approve=False)
+
+    assert worker.gate is not None
+    refusals = [e for e in worker.events
+                if e["type"] == "tool_result" and e["output"] == "Rejected by user."]
+    assert len(refusals) == 1
+
+
+def test_cancelling_before_the_turn_starts_calls_no_model(tmp_path: Path) -> None:
+    from cowork_local.ui.cowork_tab import CoworkTab
+
+    provider = FakeProvider()
+    provider.queue_response(content="never")
+    out_dir = tmp_path / ".turns" / "t1"
+    out_dir.mkdir(parents=True)
+    widget = _WidgetStub(tmp_path, _FakeCtx(_config()), provider)
+    worker = _FakeWorker()
+    worker.cancelled = True
+
+    CoworkTab.build_job(widget, "x", [{"role": "user", "content": "x"}], out_dir)(worker)
+
+    assert provider.call_count == 0

tests/integration/test_dashboard_tab.py

@@ -0,0 +1,142 @@
+"""EPIC R08-T13: TokenUsageCardWidget / UsageChartWidget / HabitsWidget /
+DashboardTab shell, real Qt offscreen.
+
+``DashboardQueryService``'s own logic is unit tested (R08-T13, no Qt) in
+``tests/unit/test_dashboard_query_service.py``; this file proves the three
+widgets and the shell are actually wired to it and to each other (the period
+selector living on ``UsageChartWidget`` driving all three).
+"""
+from __future__ import annotations
+
+import json
+import os
+from datetime import date
+
+import pytest
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+
+from cowork_local.config import AppConfig  # noqa: E402
+from cowork_local.core import usage_tracker as ut  # noqa: E402
+from cowork_local.state import AppContext  # noqa: E402
+
+pytest.importorskip("PySide6", reason="Qt is required for the integration suite")
+
+
+@pytest.fixture(scope="module")
+def qt_app():
+    from PySide6.QtWidgets import QApplication
+
+    return QApplication.instance() or QApplication([])
+
+
+@pytest.fixture
+def usage_dir(tmp_path, monkeypatch):
+    d = tmp_path / "usage"
+    monkeypatch.setattr(ut, "USAGE_DIR", d)
+    return d
+
+
+@pytest.fixture
+def ctx(qt_app, tmp_path):
+    return AppContext(AppConfig.load(tmp_path / "config.json"))
+
+
+def _write_event(usage_dir, day: date, **overrides):
+    usage_dir.mkdir(parents=True, exist_ok=True)
+    event = {
+        "ts": f"{day.isoformat()}T10:00:00", "source": "cowork", "label": "Test chat",
+        "provider": "anthropic", "model": "claude-sonnet-4-6",
+        "in": 100, "out": 50, "cache": 0, "estimated": False,
+        "account": "", "machine": "",
+    }
+    event.update(overrides)
+    path = usage_dir / f"{day.isoformat()}.jsonl"
+    with path.open("a", encoding="utf-8") as f:
+        f.write(json.dumps(event) + "\n")
+
+
+def test_dashboard_tab_builds_and_populates_cards(usage_dir, ctx):
+    from cowork_local.presentation.dashboard.dashboard_tab import DashboardTab
+
+    _write_event(usage_dir, date.today())
+    tab = DashboardTab(ctx)   # refresh() runs once at construction
+
+    assert "100" in tab.token_cards.card_in.value_lbl.text() \
+        or tab.token_cards.card_in.value_lbl.text()   # non-crashing, has SOME text
+    assert tab.token_cards.card_total.value_lbl.text() != ""
+
+
+def test_period_navigation_on_chart_refreshes_the_whole_shell(usage_dir, ctx):
+    from cowork_local.presentation.dashboard.dashboard_tab import DashboardTab
+
+    _write_event(usage_dir, date.today())
+    tab = DashboardTab(ctx)
+    calls = []
+    tab.refresh = lambda *a, orig=tab.refresh: (calls.append(1), orig(*a))[-1]
+
+    tab.chart._chart_prev()
+
+    assert calls == [1]
+
+
+def test_granularity_change_resets_offset_to_current(usage_dir, ctx):
+    from cowork_local.presentation.dashboard.dashboard_tab import DashboardTab
+    from cowork_local.presentation.dashboard.usage_chart_widget import UsageChartWidget
+
+    tab = DashboardTab(ctx)
+    tab.chart._chart_offset = -3
+
+    idx = tab.chart.gran_combo.findData("month")
+    tab.chart.gran_combo.setCurrentIndex(idx)
+
+    assert tab.chart.chart_offset == 0
+
+
+def test_currency_change_persists_and_triggers_refresh(usage_dir, ctx):
+    from cowork_local.presentation.dashboard.dashboard_tab import DashboardTab
+
+    tab = DashboardTab(ctx)
+    idx = tab.chart.currency_combo.findData("EUR") \
+        if tab.chart.currency_combo.findData("EUR") >= 0 else 0
+    seen = []
+    tab.chart.currency_changed.connect(lambda: seen.append(1))
+
+    tab.chart.currency_combo.setCurrentIndex(idx)
+
+    if tab.chart.currency_combo.currentData() != "USD":
+        assert seen == [1]
+        assert ctx.config.data["usage"]["currency"] == tab.chart.currency_combo.currentData()
+
+
+def test_habits_widget_ai_analyze_noop_without_data(usage_dir, ctx):
+    """No events in range -> emits a status message instead of starting a
+    background worker (matches the original _ai_analyze guard)."""
+    from cowork_local.presentation.dashboard.habits_widget import HabitsWidget
+    from cowork_local.application.monitoring import DashboardQueryService
+
+    query = DashboardQueryService(ctx)
+    widget = HabitsWidget(ctx, query)
+    widget.refresh(date(2020, 1, 1), date(2020, 1, 1))
+    messages = []
+    widget.status_message.connect(messages.append)
+
+    widget._ai_analyze()
+
+    assert messages   # "no data" status, no worker started
+    assert widget._ai_worker is None
+
+
+def test_budget_apply_updates_budget_card(usage_dir, ctx):
+    from cowork_local.application.monitoring import DashboardQueryService
+    from cowork_local.presentation.dashboard.token_usage_card_widget import TokenUsageCardWidget
+
+    query = DashboardQueryService(ctx)
+    widget = TokenUsageCardWidget(ctx, query)
+    widget.budget_card.budget_spin.setValue(50.0)
+
+    widget._apply_budget()
+
+    status = query.budget_status()
+    assert status is not None
+    assert status["amount_usd"] == pytest.approx(50.0)

tests/integration/test_folder_tab.py

@@ -0,0 +1,213 @@
+"""EPIC R08-T12: WorkspaceFileTree / DocumentPreviewManager / FolderTab,
+real Qt offscreen.
+
+Scope note: the AI-Edit panel's send -> plan -> edit -> apply pipeline
+(``ai_edit_pipeline.py``) runs on a real ``core.worker.AgentWorker`` QThread
+and had ZERO existing tests before this task (confirmed by grep — nothing
+under tests/ exercised ``ui/folder_tab.py``'s AI methods except the routing
+surface test, fixed alongside this task in
+``tests/integration/test_routing_surfaces.py``). Driving that full async
+pipeline end to end is out of scope here; what's covered is everything that
+doesn't need a live QThread: navigation, preview rendering, and — the
+concrete R08-T12 deliverable — that saves/creates actually go through
+``FileWorkspaceService`` (containment enforced, not just "writes a file").
+"""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import pytest
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+
+from cowork_local.config import AppConfig  # noqa: E402
+from cowork_local.state import AppContext  # noqa: E402
+
+pytest.importorskip("PySide6", reason="Qt is required for the integration suite")
+
+
+@pytest.fixture(scope="module")
+def qt_app():
+    from PySide6.QtWidgets import QApplication
+
+    return QApplication.instance() or QApplication([])
+
+
+@pytest.fixture(autouse=True)
+def khong_goi_mang(monkeypatch):
+    """Chặn mọi lượt gọi mạng thật từ bộ chọn model của panel AI-Edit.
+
+    Mở panel AI-Edit sẽ gọi ``AiEditModelResolver.refresh()``, và hàm đó
+    dựng ``AgentWorker`` (QThread) đi hỏi ``list_models`` của provider qua
+    HTTP. Trong test, luồng nền đó sống lâu hơn chính test đã tạo ra nó:
+    nó vẫn đang chờ mạng khi test kết thúc, rồi vỡ giữa lúc thu gom rác ở
+    một test khác chạy sau — cả tiến trình pytest chết với
+    ``Windows fatal exception``, và chỗ báo lỗi không liên quan gì tới
+    nguyên nhân. Việc của module này là điều hướng và hiển thị, không phải
+    nạp danh sách model, nên vô hiệu hoá cả hai đường ra mạng.
+    """
+    from cowork_local.presentation.folder.ai_edit_model_resolver import AiEditModelResolver
+
+    monkeypatch.setattr(AiEditModelResolver, "refresh", lambda self: None)
+    monkeypatch.setattr(AiEditModelResolver, "_scan_all_image_models",
+                        lambda self, then_suggest=False: None)
+
+
+@pytest.fixture
+def ctx(qt_app, tmp_path: Path):
+    return AppContext(AppConfig.load(tmp_path / "config.json"))
+
+
+@pytest.fixture
+def root(tmp_path: Path) -> Path:
+    d = tmp_path / "workspace"
+    d.mkdir()
+    return d
+
+
+# ---- WorkspaceFileTree ----------------------------------------------------- #
+def test_workspace_file_tree_set_root_updates_label_and_model(qt_app, root):
+    from cowork_local.presentation.folder.workspace_file_tree import WorkspaceFileTree
+
+    tree = WorkspaceFileTree(str(root))
+    other = root.parent / "other-root"
+    other.mkdir()
+
+    tree.set_root(str(other))
+
+    assert tree.root == str(other)
+    assert tree.path_lbl.text() == str(other)
+
+
+def test_workspace_file_tree_ignores_an_invalid_root(qt_app, root):
+    from cowork_local.presentation.folder.workspace_file_tree import WorkspaceFileTree
+
+    tree = WorkspaceFileTree(str(root))
+    tree.set_root(str(root / "does-not-exist"))
+
+    assert tree.root == str(root)   # unchanged
+
+
+def test_workspace_file_tree_click_emits_file_selected(qt_app, root):
+    from cowork_local.presentation.folder.workspace_file_tree import WorkspaceFileTree
+
+    f = root / "a.txt"
+    f.write_text("hello", encoding="utf-8")
+    tree = WorkspaceFileTree(str(root))
+    seen = []
+    tree.file_selected.connect(seen.append)
+
+    index = tree.model.index(str(f))
+    tree._on_tree_clicked(index)
+
+    assert seen and os.path.normpath(seen[0]) == os.path.normpath(str(f))
+
+
+# ---- DocumentPreviewManager ------------------------------------------------- #
+def test_open_file_renders_code_into_the_editor(qt_app, root):
+    from cowork_local.presentation.folder.document_preview_manager import DocumentPreviewManager
+
+    f = root / "script.py"
+    f.write_text("print('hi')\n", encoding="utf-8")
+    preview = DocumentPreviewManager(str(root))
+
+    preview.open_file(str(f))
+
+    assert preview.stack.currentWidget() is preview.editor
+    assert preview.editor.toPlainText() == "print('hi')\n"
+    assert preview.current_file == str(f)
+
+
+def test_open_file_on_a_binary_file_shows_the_placeholder(qt_app, root):
+    from cowork_local.presentation.folder.document_preview_manager import DocumentPreviewManager
+
+    f = root / "data.bin"
+    f.write_bytes(b"\x00\x01\x02binary")
+    preview = DocumentPreviewManager(str(root))
+
+    preview.open_file(str(f))
+
+    assert preview.stack.currentWidget() is preview._placeholder
+
+
+def test_save_writes_through_file_workspace_service(qt_app, root):
+    """The concrete R08-T12/R06-T05 deliverable: FileWorkspaceService (built
+    at R06, unused until this task) is now the actual write path."""
+    from cowork_local.presentation.folder.document_preview_manager import DocumentPreviewManager
+
+    f = root / "note.txt"
+    f.write_text("old", encoding="utf-8")
+    preview = DocumentPreviewManager(str(root))
+    preview.open_file(str(f))
+
+    preview.editor.setPlainText("new content")
+    preview.save()
+
+    assert f.read_text(encoding="utf-8") == "new content"
+
+
+def test_create_new_file_writes_inside_root_via_file_workspace_service(qt_app, root):
+    from cowork_local.presentation.folder.document_preview_manager import DocumentPreviewManager
+
+    preview = DocumentPreviewManager(str(root))
+
+    dest = preview.create_new_file("sub/new.md", "# hello")
+
+    assert dest == str(root / "sub" / "new.md")
+    assert (root / "sub" / "new.md").read_text(encoding="utf-8") == "# hello"
+    assert preview.current_file == dest   # opened it, kept the AI chat (reset_ai=False)
+
+
+def test_create_new_file_rejects_a_path_escaping_the_root(qt_app, root):
+    from cowork_local.presentation.folder.document_preview_manager import DocumentPreviewManager
+
+    preview = DocumentPreviewManager(str(root))
+    messages = []
+    preview.status_message.connect(messages.append)
+
+    dest = preview.create_new_file("../escaped.txt", "nope")
+
+    assert dest is None
+    assert not (root.parent / "escaped.txt").exists()
+    assert messages   # a save_error status was emitted
+
+
+def test_write_content_persists_and_refreshes_html_preview(qt_app, root):
+    from cowork_local.presentation.folder.document_preview_manager import DocumentPreviewManager
+
+    f = root / "page.html"
+    f.write_text("<p>old</p>", encoding="utf-8")
+    preview = DocumentPreviewManager(str(root))
+    preview.open_file(str(f))   # HTML opens in preview mode by default
+
+    preview.write_content("<p>new</p>")
+
+    assert f.read_text(encoding="utf-8") == "<p>new</p>"
+
+
+# ---- FolderTab shell -------------------------------------------------------- #
+def test_folder_tab_builds_and_wires_tree_to_preview(ctx, root):
+    from cowork_local.presentation.folder.folder_tab import FolderTab
+
+    tab = FolderTab(ctx)
+    tab.set_root(str(root))
+    f = root / "hello.py"
+    f.write_text("x = 1\n", encoding="utf-8")
+
+    tab.tree.file_selected.emit(str(f))   # simulate a tree click
+
+    assert tab.preview.current_file == str(f)
+    assert tab.preview.editor.toPlainText() == "x = 1\n"
+
+
+def test_folder_tab_ai_panel_toggle_updates_button_badge(ctx, root):
+    from cowork_local.presentation.folder.folder_tab import FolderTab
+
+    tab = FolderTab(ctx)
+    assert tab.ai_panel.isHidden()
+
+    tab.ai_btn.setChecked(True)
+    tab._toggle_ai_panel()
+
+    assert not tab.ai_panel.isHidden()

tests/integration/test_history_dir_race.py

@@ -0,0 +1,85 @@
+"""EPIC R06-T04: the race in ``ui/workspace_tab.py::_load_current``.
+
+``_load_current`` sets ``ctx.config._project_history_dir`` on the SHARED
+``AppConfig`` every time the user switches projects in the Workspace screen.
+A background turn (one that isn't the conversation currently displayed) used
+to resolve its save directory by calling ``ctx.config.history_dir()`` at
+``_persist_session`` time - i.e. whenever the turn actually finished, not
+when it started. If the user switched projects while it was still running,
+the turn's conversation got written into the NEW project's history folder
+instead of the one it actually belongs to.
+
+The fix threads a ``home_history_dir`` captured at submit time (same "home_*"
+snapshot convention ``ui/chat_panel.py`` already uses for session id/title/
+messages) through to the save call. This test drives the real
+``ChatPanel._persist_session`` - the actual save path - offscreen.
+"""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import pytest
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+
+from cowork_local.config import AppConfig             # noqa: E402
+from cowork_local.core.history import list_conversations  # noqa: E402
+from cowork_local.state import AppContext              # noqa: E402
+
+pytest.importorskip("PySide6", reason="Qt is required for the integration suite")
+
+
+@pytest.fixture(scope="module")
+def qt_app():
+    from PySide6.QtWidgets import QApplication
+
+    return QApplication.instance() or QApplication([])
+
+
+@pytest.fixture
+def chat_panel(qt_app, tmp_path: Path):
+    from cowork_local.ui.chat_panel import ChatPanel
+
+    ctx = AppContext(AppConfig.load(tmp_path / "config.json"))
+    return ChatPanel(ctx, "cowork", "Test")
+
+
+def test_background_turn_saves_into_the_project_it_started_in(chat_panel, tmp_path):
+    project_a_dir = tmp_path / "project-a-history"
+    project_b_dir = tmp_path / "project-b-history"
+    chat_panel.ctx.config._project_history_dir = project_a_dir
+
+    # What ChatPanel._start_turn captures into the per-turn ctx dict at
+    # submit time (see the "home_history_dir" entry added there for R06-T04).
+    turn_ctx = {
+        "home_id": chat_panel.session_id,
+        "home_messages": [{"role": "user", "content": "hi"}],
+        "home_title": "Background turn",
+        "home_history_dir": chat_panel.ctx.config.history_dir(),
+        "record": {},
+    }
+    assert turn_ctx["home_history_dir"] == project_a_dir
+
+    # The user switches projects in the Workspace screen WHILE this turn is
+    # still running - exactly what ui/workspace_tab.py::_load_current does.
+    chat_panel.ctx.config._project_history_dir = project_b_dir
+
+    chat_panel._persist_session(turn_ctx)
+
+    assert len(list_conversations(project_a_dir)) == 1
+    assert list_conversations(project_b_dir) == []
+
+
+def test_the_currently_viewed_conversation_still_follows_live_selection(chat_panel, tmp_path):
+    """_save_snapshot's OTHER caller (the initial "register it in History right
+    away" call, and _autosave) has no captured history_dir and must keep
+    resolving it live - that path is for the conversation ACTUALLY on screen,
+    which should follow whatever project the user has selected right now."""
+    project_dir = tmp_path / "currently-viewed"
+    chat_panel.ctx.config._project_history_dir = project_dir
+
+    chat_panel._save_snapshot(chat_panel.session_id,
+                              [{"role": "user", "content": "hi"}], "Live view")
+
+    assert len(list_conversations(project_dir)) == 1

tests/integration/test_qt_scheduler_clock.py

@@ -0,0 +1,53 @@
+"""EPIC R07-T03: QtSchedulerClock against a REAL QTimer/event loop.
+
+``tests/unit/test_task_scheduler_dispatch.py`` covers ``TaskScheduler``'s
+dispatch logic entirely through ``tests/fakes/fake_clock.py::FakeClock`` (no
+Qt at all — that's the whole point of the extraction). This file is the
+complement: it proves the adapter itself actually drives a real ``QTimer``
+and pumps a real event loop, offscreen, the way ``test_history_dir_race.py``
+proves ``ui/chat_panel.py``'s fix against real Qt rather than a double.
+"""
+from __future__ import annotations
+
+import os
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+
+import pytest  # noqa: E402
+
+from PySide6.QtTest import QTest  # noqa: E402
+from PySide6.QtWidgets import QApplication  # noqa: E402
+
+from cowork_local.infrastructure.qt.qt_scheduler_clock import QtSchedulerClock  # noqa: E402
+
+
+@pytest.fixture(scope="module")
+def qapp():
+    return QApplication.instance() or QApplication([])
+
+
+def test_start_fires_callback_on_the_real_qt_event_loop(qapp):
+    clock = QtSchedulerClock()
+    ticks = []
+    clock.start(interval_ms=10, callback=lambda: ticks.append(1))
+    try:
+        QTest.qWait(200)   # let the real QTimer fire a few times
+    finally:
+        clock.stop()
+    assert len(ticks) >= 1
+
+
+def test_stop_prevents_further_callbacks(qapp):
+    clock = QtSchedulerClock()
+    ticks = []
+    clock.start(interval_ms=10, callback=lambda: ticks.append(1))
+    QTest.qWait(50)
+    clock.stop()
+    count_after_stop = len(ticks)
+    QTest.qWait(100)
+    assert len(ticks) == count_after_stop   # no more callbacks after stop()
+
+
+def test_pump_processes_pending_events_without_raising(qapp):
+    clock = QtSchedulerClock()
+    clock.pump()   # must not raise even with nothing pending

tests/integration/test_routing_surfaces.py

@@ -0,0 +1,254 @@
+"""The three chat surfaces really route through the shared service (R03-T04/T05).
+
+The unit suite proves ``RoutingApplicationService`` decides correctly against a
+fake router. This file proves the three widgets that used to own a private copy
+of that algorithm now call it, on real (offscreen) widgets:
+
+* ``ui/chat_panel.py::_apply_routing``      (Cowork)
+* ``ui/co4e_tab.py::_apply_co4e_routing``   (Co4E)
+* ``presentation/folder/ai_edit_model_resolver.py::AiEditModelResolver.apply_routing``   (AI-Edit)
+
+On this branch the Manual-mode confirm dialog (``ui/routing_toggle.py::
+confirm_switch``) still reads its decision straight off the engine's own
+``core/routing/models.py::SwitchDecision`` - ``RoutingOutcome.decision`` passes
+it through unwrapped rather than translating it into an application-layer
+type, so there is no separate field contract to pin here.
+"""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any, List, Optional, Tuple
+
+import pytest
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+
+from cowork_local.application.model_routing import (   # noqa: E402
+    RoutingApplicationService,
+    RoutingMode,
+)
+from cowork_local.config import AppConfig               # noqa: E402
+from cowork_local.state import AppContext               # noqa: E402
+
+pytest.importorskip("PySide6", reason="Qt is required for the integration suite")
+
+
+@pytest.fixture(scope="module")
+def qt_app():
+    from PySide6.QtWidgets import QApplication
+
+    return QApplication.instance() or QApplication([])
+
+
+@pytest.fixture
+def ctx(qt_app, tmp_path: Path) -> AppContext:
+    return AppContext(AppConfig.load(tmp_path / "config.json"))
+
+
+class _FakeDecisionPort:
+    """A :class:`RoutingDecisionPort` that always proposes the same switch and
+    records the surface (and task type) it was asked to evaluate."""
+
+    def __init__(self, provider="anthropic", model="claude-sonnet-4-6",
+                 gain: float = 0.4) -> None:
+        self.provider = provider
+        self.model = model
+        self.gain = gain
+        self.surfaces: List[str] = []
+
+    def evaluate(self, request, mode):
+        from cowork_local.application.model_routing import RouteEvaluation
+
+        self.surfaces.append(request.surface)
+        return RouteEvaluation(
+            task_type=request.task_type or "coding",
+            should_switch=True,
+            target_provider=self.provider,
+            target_model=self.model,
+            score_gain=self.gain,
+            reason="better fit",
+        )
+
+
+class _FixedModeResolver:
+    """A :class:`ModeResolver` that reports the same mode for every surface."""
+
+    def __init__(self, mode: str) -> None:
+        self._mode = mode
+
+    def mode_for(self, surface: str) -> str:
+        return self._mode
+
+
+def _install(ctx: AppContext, mode: str) -> _FakeDecisionPort:
+    """Wire a fake decision port into the context and force ``mode`` on every
+    surface.
+
+    Every surface reaches the service through
+    ``build_routing_application_service(ctx)``, which memoises its instance on
+    ``ctx._routing_app_service`` (see ``core_routing_adapter.py``) — pre-seeding
+    that exact attribute is what makes the surfaces under test see this fake
+    instead of building a real one against ``ctx.routing()``.
+    """
+    router = _FakeDecisionPort()
+    service = RoutingApplicationService(router, mode_resolver=_FixedModeResolver(mode))
+    ctx._routing_app_service = service   # already-built instance; accessor returns it
+    return router
+
+
+# --------------------------------------------------------------------------- #
+# Cowork chat
+# --------------------------------------------------------------------------- #
+def test_cowork_applies_an_auto_switch_to_the_next_turn(ctx):
+    from cowork_local.ui.cowork_tab import CoworkTab
+
+    router = _install(ctx, "auto")
+    tab = CoworkTab(ctx)
+    turn: dict = {"bubbles": []}
+
+    tab._apply_routing("write a function", turn)
+
+    assert router.surfaces == [tab.kind]
+    # build_provider() honours these for THIS turn only.
+    assert (tab._routed_provider, tab._routed_model) == ("anthropic", "claude-sonnet-4-6")
+    assert turn["bubbles"], "the user must be told the model was switched"
+
+
+def test_cowork_leaves_the_model_alone_when_routing_is_off(ctx):
+    from cowork_local.ui.cowork_tab import CoworkTab
+
+    router = _install(ctx, "off")
+    tab = CoworkTab(ctx)
+    turn: dict = {"bubbles": []}
+
+    tab._apply_routing("write a function", turn)
+
+    assert router.surfaces == []
+    assert (tab._routed_provider, tab._routed_model) == (None, None)
+    assert turn["bubbles"] == []
+
+
+def test_cowork_manual_mode_switches_only_after_the_dialog_approves(ctx, monkeypatch):
+    """Manual mode's confirm dialog is ``ui/routing_toggle.py::confirm_switch``,
+    imported locally inside ``_apply_routing`` at call time — patching the
+    source module's attribute is what a local import actually re-reads."""
+    from cowork_local.ui.cowork_tab import CoworkTab
+
+    _install(ctx, "manual")
+    tab = CoworkTab(ctx)
+    asked: List[Any] = []
+
+    def fake_confirm(parent, decision, timeout):
+        asked.append(decision)
+        return True
+
+    monkeypatch.setattr("cowork_local.ui.routing_toggle.confirm_switch", fake_confirm)
+    turn: dict = {"bubbles": []}
+
+    tab._apply_routing("write a function", turn)
+
+    assert len(asked) == 1
+    assert (tab._routed_provider, tab._routed_model) == ("anthropic", "claude-sonnet-4-6")
+
+
+def test_cowork_manual_mode_keeps_the_model_when_the_dialog_is_declined(ctx, monkeypatch):
+    from cowork_local.ui.cowork_tab import CoworkTab
+
+    _install(ctx, "manual")
+    tab = CoworkTab(ctx)
+    monkeypatch.setattr("cowork_local.ui.routing_toggle.confirm_switch",
+                         lambda parent, decision, timeout: False)
+    turn: dict = {"bubbles": []}
+
+    tab._apply_routing("write a function", turn)
+
+    assert (tab._routed_provider, tab._routed_model) == (None, None)
+    assert turn["bubbles"] == []
+
+
+def test_a_pinned_admin_agent_still_wins_over_routing(ctx):
+    """An explicitly chosen Admin agent pins its own provider/model; routing must
+    not override a deliberate user choice."""
+    from cowork_local.ui.cowork_tab import CoworkTab
+
+    router = _install(ctx, "auto")
+    tab = CoworkTab(ctx)
+    tab._admin_agent = object()
+    turn: dict = {"bubbles": []}
+
+    tab._apply_routing("write a function", turn)
+
+    assert router.surfaces == []
+    assert (tab._routed_provider, tab._routed_model) == (None, None)
+
+
+# --------------------------------------------------------------------------- #
+# Co4E
+# --------------------------------------------------------------------------- #
+def test_co4e_routes_on_its_own_surface_key_and_returns_the_model(ctx):
+    from cowork_local.ui.co4e_tab import Co4ETab
+
+    router = _install(ctx, "auto")
+    tab = Co4ETab(ctx)
+
+    model = tab._apply_co4e_routing("build me a flow")
+
+    assert router.surfaces == ["co4e"]
+    assert model == "claude-sonnet-4-6"
+    assert tab._co4e_routed_provider == "anthropic"
+
+
+def test_co4e_returns_an_empty_model_when_routing_is_off(ctx):
+    """'' means "use the provider default" - the contract _run_chat_turn expects."""
+    from cowork_local.ui.co4e_tab import Co4ETab
+
+    _install(ctx, "off")
+    tab = Co4ETab(ctx)
+
+    assert tab._apply_co4e_routing("build me a flow") == ""
+    assert tab._co4e_routed_provider is None
+
+
+# --------------------------------------------------------------------------- #
+# AI-Edit
+# --------------------------------------------------------------------------- #
+def test_ai_edit_routes_on_its_own_surface_key(ctx):
+    """R08-T12: the routing call this test pins moved from
+    ``ui/folder_tab.py::FolderTab._ai_apply_routing`` to
+    ``presentation/folder/ai_edit_model_resolver.py::AiEditModelResolver.
+    apply_routing`` - same RoutingApplicationService call, same surface key,
+    now independently testable without the whole FolderTab widget tree."""
+    from cowork_local.presentation.folder.folder_tab import FolderTab
+
+    router = _install(ctx, "auto")
+    tab = FolderTab(ctx)
+
+    tab.ai_panel.resolver.apply_routing("rename this variable")
+
+    assert router.surfaces == ["ai_edit"]
+    assert (tab.ai_panel.resolver.routed_provider, tab.ai_panel.resolver.routed_model) == (
+        "anthropic", "claude-sonnet-4-6")
+
+
+def test_ai_edit_pins_the_coding_task_type(ctx):
+    """An edit instruction is never a QA question, so AI-Edit skips
+    classification entirely - the constraint has to survive the move into the
+    shared service or it is silently dropped."""
+    from cowork_local.core.routing.models import TaskType
+    from cowork_local.presentation.folder.folder_tab import FolderTab
+
+    seen: List[Any] = []
+
+    class _Recorder(_FakeDecisionPort):
+        def evaluate(self, request, mode):
+            seen.append(request.task_type)
+            return super().evaluate(request, mode)
+
+    ctx._routing_app_service = RoutingApplicationService(
+        _Recorder(), mode_resolver=_FixedModeResolver("auto"))
+    tab = FolderTab(ctx)
+
+    tab.ai_panel.resolver.apply_routing("rename this variable")
+
+    assert seen == [TaskType.CODING]

tests/integration/test_routing_unification.py

@@ -0,0 +1,249 @@
+"""R03-T03/T04/T05 — the unified routing path over the REAL routing engine.
+
+The unit tests drive ``RoutingApplicationService`` against fakes; this suite
+proves the same service produces correct outcomes on top of the actual
+``core/routing`` stack (classifier → assessment store → scorer → selector →
+switch controller), which is what the three chat surfaces now call.
+
+Offline by construction: a fake probe client answers benchmarks and judging, and
+the assessment store is a temp file — no network, no Qt, no ``$HOME`` writes.
+"""
+
+from __future__ import annotations
+
+import copy
+
+import pytest
+from cowork_local.application.model_routing import (
+    AppContextModeResolver,
+    CoreRoutingEngine,
+    RoutingApplicationService,
+    RoutingMode,
+    RoutingRequest,
+)
+from cowork_local.config import DEFAULT_CONFIG, AppConfig
+from cowork_local.core import projects as projects_mod
+from cowork_local.core.routing.clients import CompletionResult
+from cowork_local.core.routing.service import RoutingService
+from cowork_local.core.routing.store import AssessmentStore
+from cowork_local.state import AppContext
+
+STRONG_ANSWER = "STRONG-DETAILED-CORRECT-ANSWER"
+WEAK_ANSWER = "weak"
+
+
+class FakeProbeClient:
+    """Deterministic stand-in for the provider layer used during assessment.
+
+    Mirrors ``tests/routing/test_service.py``'s client: benchmark prompts get a
+    per-model canned answer, and judge prompts are graded by looking up that
+    answer, so scores are stable and no model is ever really called.
+    """
+
+    def __init__(self, answers, quality) -> None:
+        self.answers = answers
+        self.quality = quality
+
+    def complete(self, provider, model_id, messages) -> CompletionResult:
+        text = messages[0]["content"]
+        if "grading an AI assistant" in text:      # the judge rubric prompt
+            score = 0.0
+            for answer, value in self.quality.items():
+                if answer and answer in text:
+                    score = value
+                    break
+            return CompletionResult(text='{"score": %s}' % score)
+        answer = self.answers.get((provider, model_id))
+        if answer is None:
+            return CompletionResult(error="unavailable")
+        return CompletionResult(text=answer, tokens_out=len(answer) // 4)
+
+
+@pytest.fixture()
+def ctx(tmp_path, monkeypatch):
+    """An AppContext with two assessable models and temp-only persistence."""
+    # Keep workspace load/save off the developer's real ~/.cowork_local.
+    monkeypatch.setattr(projects_mod, "PROJECTS_DIR", tmp_path / "projects")
+    data = copy.deepcopy(DEFAULT_CONFIG)
+    data["providers"] = {
+        "anthropic": {"base_url": "x", "api_key": "x", "model": "strong-model"},
+    }
+    data["routing"]["candidates"] = [
+        {"provider": "anthropic", "model_id": "strong-model", "tier": "powerful"},
+        {"provider": "anthropic", "model_id": "weak-model", "tier": "fast"},
+    ]
+    data["routing"]["judge_provider"] = "anthropic"
+    data["routing"]["judge_model"] = "judge-model"
+    data["routing"]["policy"] = "quality"
+    data["routing"]["min_score_gain"] = 0.05
+    return AppContext(AppConfig(data=data, path=tmp_path / "config.json"))
+
+
+@pytest.fixture()
+def routing_service(ctx, tmp_path) -> RoutingService:
+    """A real RoutingService with a populated assessment store."""
+    client = FakeProbeClient(
+        answers={
+            ("anthropic", "strong-model"): STRONG_ANSWER,
+            ("anthropic", "weak-model"): WEAK_ANSWER,
+        },
+        quality={STRONG_ANSWER: 0.95, WEAK_ANSWER: 0.35},
+    )
+    store = AssessmentStore(store_path=tmp_path / "assess.json",
+                            history_dir=tmp_path / "history")
+    service = RoutingService(ctx, store=store, client=client)
+    service.reassess()          # populate real probe results + fit scores
+    return service
+
+
+@pytest.fixture()
+def app_service(ctx, routing_service) -> RoutingApplicationService:
+    """The application service wired exactly the way the UI wires it."""
+    return RoutingApplicationService(
+        CoreRoutingEngine(routing_service),
+        AppContextModeResolver(ctx),
+        confirm_timeout_sec=lambda: float(ctx.config.routing["confirm_timeout_sec"]),
+    )
+
+
+def coding_request(**overrides) -> RoutingRequest:
+    """A coding turn currently pinned to the weaker model."""
+    fields = dict(
+        surface="cowork",
+        prompt="Write a Python function to reverse a linked list",
+        current_provider="anthropic",
+        current_model="weak-model",
+    )
+    fields.update(overrides)
+    return RoutingRequest(**fields)
+
+
+# --------------------------------------------------------------------------- #
+# Auto / Off / Manual over the real engine
+# --------------------------------------------------------------------------- #
+def test_auto_switches_to_the_better_assessed_model(app_service) -> None:
+    """The real scorer must rank the strong model first and the service must
+    hand that model back as this turn's override."""
+    outcome = app_service.resolve(coding_request(mode=RoutingMode.AUTO))
+
+    assert outcome.switched is True
+    assert outcome.provider == "anthropic"
+    assert outcome.model == "strong-model"
+    assert outcome.task_type == "coding"     # classified from the prompt
+    assert outcome.score_gain > 0
+
+
+def test_off_keeps_the_pinned_model(app_service) -> None:
+    """Off must not switch even when a clearly better model is assessed."""
+    outcome = app_service.resolve(coding_request(mode=RoutingMode.OFF))
+
+    assert outcome.switched is False
+    assert outcome.provider is None
+
+
+def test_manual_asks_before_switching(app_service) -> None:
+    """The confirm callback receives the engine's own decision object, which is
+    what ``ui/routing_toggle.py::confirm_switch`` renders."""
+    seen: list = []
+
+    outcome = app_service.resolve(
+        coding_request(mode=RoutingMode.MANUAL),
+        confirm=lambda decision, timeout: seen.append((decision, timeout)) or True,
+    )
+
+    assert outcome.switched is True
+    decision, timeout = seen[0]
+    assert decision.to_model == "anthropic/strong-model"
+    assert decision.reason                       # human-readable explanation
+    assert timeout == pytest.approx(60.0)        # from DEFAULT_CONFIG
+
+
+def test_manual_decline_keeps_the_pinned_model(app_service) -> None:
+    outcome = app_service.resolve(
+        coding_request(mode=RoutingMode.MANUAL),
+        confirm=lambda decision, timeout: False,
+    )
+
+    assert outcome.switched is False
+    assert outcome.declined is True
+
+
+def test_already_best_model_is_left_alone(app_service) -> None:
+    """No pointless churn: being on the best model is not a switch."""
+    outcome = app_service.resolve(
+        coding_request(mode=RoutingMode.AUTO, current_model="strong-model"))
+
+    assert outcome.switched is False
+
+
+# --------------------------------------------------------------------------- #
+# Fallback over the real engine
+# --------------------------------------------------------------------------- #
+def test_fallback_keeps_an_assessed_model_even_though_a_better_one_exists(app_service) -> None:
+    """weak-model IS usable (it has a real probe score), so Fallback stays put
+    where Auto would switch — the behavioural difference between the modes."""
+    outcome = app_service.resolve(coding_request(mode=RoutingMode.FALLBACK))
+
+    assert outcome.switched is False
+
+
+def test_fallback_rescues_a_model_the_engine_cannot_serve(app_service) -> None:
+    """A model absent from the ranking (never assessed / unavailable) is exactly
+    the situation Fallback exists for."""
+    outcome = app_service.resolve(
+        coding_request(mode=RoutingMode.FALLBACK, current_model="ghost-model"))
+
+    assert outcome.switched is True
+    assert outcome.model == "strong-model"
+
+
+# --------------------------------------------------------------------------- #
+# Surface parity — the point of R03-T04/T05
+# --------------------------------------------------------------------------- #
+@pytest.mark.parametrize("surface", ["cowork", "co4e", "ai_edit"])
+def test_every_surface_gets_the_same_decision(app_service, surface) -> None:
+    """Chat, Co4E and AI-Edit used to hold three copies of this logic. Given the
+    same inputs they must now be indistinguishable."""
+    outcome = app_service.resolve(coding_request(surface=surface, mode=RoutingMode.AUTO))
+
+    assert outcome.switched is True
+    assert outcome.model == "strong-model"
+
+
+def test_ai_edit_pinned_task_type_reaches_the_engine(app_service) -> None:
+    """AI-Edit pins "coding" instead of classifying; the engine must honour it
+    even when the instruction text reads like something else entirely."""
+    outcome = app_service.resolve(coding_request(
+        surface="ai_edit",
+        prompt="Write a poem about the ocean",   # classifier would say "creative"
+        task_type="coding",
+        mode=RoutingMode.AUTO,
+    ))
+
+    assert outcome.task_type == "coding"
+
+
+def test_mode_comes_from_the_workspace_when_not_pinned(ctx, app_service) -> None:
+    """With no explicit mode, the service reads the per-workspace setting — the
+    lookup the widgets used to do themselves."""
+    ctx.config.data["routing"]["switch_mode"] = "auto"
+
+    outcome = app_service.resolve(coding_request())
+
+    assert outcome.mode is RoutingMode.AUTO
+    assert outcome.switched is True
+
+
+def test_fallback_mode_survives_a_round_trip_through_config(ctx) -> None:
+    """The new mode must be persistable, or the toggle could never select it."""
+    ctx.config.set_routing_mode_for("cowork", "fallback")
+
+    assert ctx.config.routing_mode_for("cowork") == "fallback"
+    assert ctx.project_routing_mode("cowork") == "fallback"
+
+
+def test_unknown_persisted_mode_degrades_to_off(ctx) -> None:
+    """A hand-edited config must not enable routing by accident."""
+    ctx.config.routing["surface_modes"]["cowork"] = "turbo"
+
+    assert ctx.config.routing_mode_for("cowork") == "off"

tests/integration/test_schedule_task_tab.py

@@ -0,0 +1,125 @@
+"""EPIC R08-T11: ScheduleTaskTab shell + KanbanBoardWidget, real Qt offscreen.
+
+Drives the real widgets end to end (build -> refresh -> drag-drop rule via
+TaskApplicationService -> refresh) against a tmp_path task repository, the
+way ``test_history_dir_race.py`` proves R06-T04 against real Qt rather than
+a double. ``TaskApplicationService``'s own business rules are already unit
+tested (R07-T04); this file exists to prove the WIDGET is actually wired to
+that service, not to re-test the rules themselves.
+"""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import pytest
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+
+from cowork_local.config import AppConfig  # noqa: E402
+from cowork_local.infrastructure.persistence.json.task_repository_impl import (  # noqa: E402
+    TaskRepository,
+)
+from cowork_local.state import AppContext  # noqa: E402
+
+pytest.importorskip("PySide6", reason="Qt is required for the integration suite")
+
+
+@pytest.fixture(scope="module")
+def qt_app():
+    from PySide6.QtWidgets import QApplication
+
+    return QApplication.instance() or QApplication([])
+
+
+@pytest.fixture
+def ctx(qt_app, tmp_path: Path):
+    return AppContext(AppConfig.load(tmp_path / "config.json"))
+
+
+@pytest.fixture
+def tasks_dir(tmp_path: Path) -> Path:
+    d = tmp_path / "tasks"
+    d.mkdir()
+    return d
+
+
+def test_schedule_task_tab_builds_and_refreshes_with_no_tasks(ctx, tasks_dir):
+    from cowork_local.presentation.scheduling.schedule_task_tab import ScheduleTaskTab
+
+    tab = ScheduleTaskTab(ctx, scheduler=None, tasks_dir=tasks_dir)
+    tab.refresh()   # must not raise against an empty repo
+
+    assert tab.kanban.columns.keys()   # 7 lanes were built
+
+
+def test_kanban_renders_a_task_into_its_status_lane(ctx, tasks_dir):
+    from cowork_local.presentation.scheduling.kanban_board_widget import KanbanBoardWidget
+
+    repo = TaskRepository(tasks_dir)
+    task = repo.create("My Task", task_type="cowork")
+    task["status"] = "backlog"
+    repo.save(task)
+
+    board = KanbanBoardWidget(ctx, tasks_dir=tasks_dir)
+    board.refresh()
+
+    from PySide6.QtCore import Qt
+
+    backlog_ids = [board.columns["backlog"].item(i).data(Qt.UserRole)
+                   for i in range(board.columns["backlog"].count())]
+    assert task["task_id"] in backlog_ids
+
+
+def test_dropping_a_card_on_done_disables_its_schedule_through_the_real_widget(ctx, tasks_dir):
+    """Same rule TaskApplicationService.move_to_status covers at the unit
+    level (R07-T04) — this proves the Kanban widget's drop handler actually
+    calls it, end to end, with a real TaskRepository on disk."""
+    from cowork_local.presentation.scheduling.kanban_board_widget import KanbanBoardWidget
+
+    repo = TaskRepository(tasks_dir)
+    task = repo.create("Recurring", task_type="cowork")
+    task["schedule"]["enabled"] = True
+    task["schedule"]["run_at"] = "2026-08-28 09:00"
+    task["schedule"]["repeat_type"] = "daily"
+    task["status"] = "scheduled"
+    repo.save(task)
+
+    board = KanbanBoardWidget(ctx, tasks_dir=tasks_dir)
+    board.refresh()
+
+    board._on_task_dropped(task["task_id"], "done")
+
+    on_disk = repo.get(task["task_id"])
+    assert on_disk["status"] == "done"
+    assert on_disk["schedule"]["enabled"] is False
+
+
+def test_kanban_edit_requested_is_wired_to_the_shells_edit_task(ctx, tasks_dir, monkeypatch):
+    """Proves ScheduleTaskTab actually connects
+    ``kanban.edit_requested -> self._edit_task`` (not just that the Kanban
+    widget emits the signal in isolation) by monkeypatching the dialog class
+    ``_edit_task`` opens and checking it was constructed for the right task."""
+    import cowork_local.ui.task_editor_dialog as task_editor_dialog_module
+    from cowork_local.presentation.scheduling.schedule_task_tab import ScheduleTaskTab
+
+    repo = TaskRepository(tasks_dir)
+    task = repo.create("Editable")
+    repo.save(task)
+
+    seen_task_ids = []
+
+    class _FakeDialog:
+        def __init__(self, task, all_tasks, parent, ctx):
+            seen_task_ids.append(task["task_id"] if task else None)
+            self.edited_task = None
+
+        def exec(self):
+            return False   # Cancel — nothing further should happen
+
+    monkeypatch.setattr(task_editor_dialog_module, "TaskEditorDialog", _FakeDialog)
+
+    tab = ScheduleTaskTab(ctx, scheduler=None, tasks_dir=tasks_dir)
+    tab.kanban.edit_requested.emit(task["task_id"])
+
+    assert seen_task_ids == [task["task_id"]]

tests/integration/test_structure_graph_view.py

@@ -0,0 +1,162 @@
+"""EPIC R08-T14: GraphRenderer / GraphQaWidget / StructureGraphView shell,
+real Qt offscreen.
+
+Scope note: a real directory SCAN (``GraphRenderer._scan``) runs on a
+``core.worker.AgentWorker`` QThread and had no existing test before this
+task either (grep confirms nothing under tests/ exercised
+``ui/structure_graph_view.py``). These tests drive ``_render()`` directly
+with a hand-built ``StructureGraph`` instead of a live scan — enough to
+prove the renderer <-> Q&A wiring (the actual R08-T14 deliverable) without
+needing a real codebase to walk.
+"""
+from __future__ import annotations
+
+import os
+
+import pytest
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+
+from cowork_local.config import AppConfig  # noqa: E402
+from cowork_local.core.structure_graph import GEdge, GNode, StructureGraph  # noqa: E402
+from cowork_local.state import AppContext  # noqa: E402
+
+pytest.importorskip("PySide6", reason="Qt is required for the integration suite")
+
+
+@pytest.fixture(scope="module")
+def qt_app():
+    from PySide6.QtWidgets import QApplication
+
+    return QApplication.instance() or QApplication([])
+
+
+@pytest.fixture
+def ctx(qt_app, tmp_path):
+    return AppContext(AppConfig.load(tmp_path / "config.json"))
+
+
+def _fake_graph(tmp_path):
+    f = tmp_path / "mod.py"
+    f.write_text("def hello():\n    pass\n", encoding="utf-8")
+    nodes = [
+        GNode(id="n1", label="mod.py", kind="file", detail="a module", path=str(f)),
+        GNode(id="n2", label="hello", kind="function", detail="says hi", path=str(f)),
+    ]
+    edges = [GEdge(source="n1", target="n2", type="defines")]
+    return StructureGraph(nodes=nodes, edges=edges)
+
+
+def test_structure_graph_view_builds(ctx):
+    from cowork_local.presentation.graph.structure_graph_view import StructureGraphView
+
+    view = StructureGraphView(ctx)
+    assert view.renderer is not None
+    assert view.qa is not None
+
+
+def test_render_populates_the_scene_and_emits_graph_rendered(ctx, tmp_path):
+    from cowork_local.presentation.graph.graph_renderer import GraphRenderer
+
+    renderer = GraphRenderer(ctx)
+    graph = _fake_graph(tmp_path)
+    seen = []
+    renderer.graph_rendered.connect(lambda: seen.append(1))
+
+    renderer._render({"graph": graph, "pos": {"n1": (0, 0), "n2": (100, 0)}, "seq": renderer._scan_seq})
+
+    assert renderer.graph is graph
+    assert len(renderer._node_items) == 2
+    assert seen == [1]
+
+
+def test_render_ignores_a_stale_scan_result(ctx, tmp_path):
+    """Only the LATEST scan's result is ever rendered (no stale overwrite)."""
+    from cowork_local.presentation.graph.graph_renderer import GraphRenderer
+
+    renderer = GraphRenderer(ctx)
+    first = _fake_graph(tmp_path)
+    renderer._render({"graph": first, "pos": {}, "seq": renderer._scan_seq})
+    renderer._scan_seq += 1   # a second scan started
+
+    stale = StructureGraph(nodes=[], edges=[])
+    renderer._render({"graph": stale, "pos": {}, "seq": renderer._scan_seq - 1})
+
+    assert renderer.graph is first   # stale result was dropped
+
+
+def test_node_selection_updates_the_qa_detail_panel(ctx, tmp_path):
+    from cowork_local.presentation.graph.graph_qa_widget import GraphQaWidget
+    from cowork_local.presentation.graph.graph_renderer import GraphRenderer
+
+    renderer = GraphRenderer(ctx)
+    graph = _fake_graph(tmp_path)
+    renderer._render({"graph": graph, "pos": {"n1": (0, 0), "n2": (100, 0)}, "seq": renderer._scan_seq})
+    qa = GraphQaWidget(ctx, renderer)
+
+    node = graph.nodes[1]
+    renderer.node_selected.emit(node)
+
+    assert "hello" in qa.detail.toPlainText()
+    assert "says hi" in qa.detail.toPlainText()
+
+
+def test_candidate_file_paths_uses_selected_nodes_when_present(ctx, tmp_path):
+    from cowork_local.presentation.graph.graph_qa_widget import GraphQaWidget
+    from cowork_local.presentation.graph.graph_renderer import GraphRenderer
+
+    renderer = GraphRenderer(ctx)
+    graph = _fake_graph(tmp_path)
+    renderer._render({"graph": graph, "pos": {"n1": (0, 0), "n2": (100, 0)}, "seq": renderer._scan_seq})
+    qa = GraphQaWidget(ctx, renderer)
+
+    # No selection -> every file node in the graph (both nodes share one
+    # file here, so this also proves the path-dedup in _candidate_file_paths).
+    assert qa._candidate_file_paths() == [graph.nodes[0].path]
+
+    renderer._node_items[0].setSelected(True)
+    assert qa._candidate_file_paths() == [graph.nodes[0].path]
+
+
+def test_project_change_clears_the_qa_extraction_cache(ctx, tmp_path):
+    from cowork_local.presentation.graph.graph_qa_widget import GraphQaWidget
+    from cowork_local.presentation.graph.graph_renderer import GraphRenderer
+
+    renderer = GraphRenderer(ctx)
+    qa = GraphQaWidget(ctx, renderer)
+    qa._extract_cache = {"some/path.py": "cached text"}
+
+    renderer.project_changed.emit()
+
+    assert qa._extract_cache == {}
+
+
+def test_qa_collapse_resizes_the_shells_splitter(ctx):
+    """Exact pixel width is Qt's splitter-layout arithmetic, not this code's
+    concern - what matters is that collapsing narrows the QA pane a lot
+    (down near the strip's width) while the strip itself becomes visible and
+    the total splitter width is conserved."""
+    from cowork_local.presentation.graph.structure_graph_view import StructureGraphView
+    from cowork_local.ui.widgets import CollapseStrip
+
+    view = StructureGraphView(ctx)
+    before = view._split.sizes()
+
+    view.qa._set_collapsed(True)
+
+    after = view._split.sizes()
+    assert after[1] <= CollapseStrip.WIDTH + 2
+    assert view.qa.maximumWidth() == CollapseStrip.WIDTH + 2
+    assert sum(after) == sum(before)   # total width conserved, just redistributed
+
+
+def test_hide_event_clears_extracts(ctx):
+    from cowork_local.presentation.graph.structure_graph_view import StructureGraphView
+
+    view = StructureGraphView(ctx)
+    view.qa._extract_cache = {"x": "y"}
+
+    from PySide6.QtGui import QHideEvent
+    view.hideEvent(QHideEvent())
+
+    assert view.qa._extract_cache == {}

tests/integration/test_task_executor_turn.py

@@ -0,0 +1,191 @@
+"""R04-T05 — the Schedule Task runner's cowork branch, pinned before and after.
+
+Written against the CURRENT ``_run_agent`` first, as the safety net for moving it
+onto ``ConversationApplicationService``: an unattended run has five behaviours the
+interactive path does not have (the plan reminder prefixed to the prompt, the
+session registered in History before the model starts, a re-save after every
+assistant message, the timeout notice, and the "did the agent's own checklist
+finish?" report), and none of them was covered by a test.
+
+Everything is isolated from the user's real config: history goes to ``tmp_path``
+via ``history.custom_dir`` and the AI guardrails are off, so no run touches
+``~/.cowork_local`` or calls a model to review a prompt.
+"""
+
+from __future__ import annotations
+
+import copy
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from cowork_local.config import DEFAULT_CONFIG, AppConfig
+from cowork_local.core import task_executors
+from cowork_local.tests.fakes.fake_provider import FakeProvider
+
+
+class _FakeCtx:
+    """The ``AppContext`` surface ``_run_agent`` touches."""
+
+    def __init__(self, config: AppConfig, provider: FakeProvider) -> None:
+        self.config = config
+        self._provider = provider
+
+    def build_active_provider(self) -> FakeProvider:
+        return self._provider
+
+    def build_provider_for(self, name=None, model=None) -> FakeProvider:
+        return self._provider
+
+
+def _config(tmp_path: Path) -> AppConfig:
+    data = copy.deepcopy(DEFAULT_CONFIG)
+    # Keep the run entirely offline and off the real config dir.
+    data["agent_security"]["enabled"] = False
+    data["history"]["custom_dir"] = str(tmp_path / "history")
+    return AppConfig(data)
+
+
+def _run(tmp_path: Path, provider: FakeProvider, *, prompt: str = "write the report",
+         timeout_sec: Optional[int] = None, admin_agent: Any = None):
+    """Run one cowork task and return ``(result_tuple, events, config)``."""
+    out_dir = tmp_path / "run"
+    out_dir.mkdir(parents=True, exist_ok=True)
+    config = _config(tmp_path)
+    events: List[Dict[str, Any]] = []
+
+    result = task_executors._run_agent(
+        _FakeCtx(config, provider), "cowork", prompt, out_dir,
+        events.append, lambda: False, title="Weekly report",
+        timeout_sec=timeout_sec, admin_agent=admin_agent,
+    )
+    return result, events, config
+
+
+def _saved_conversation(config: AppConfig) -> Dict[str, Any]:
+    """The single conversation the run wrote into the isolated history folder."""
+    files = list(Path(config.history_dir()).rglob("*.json"))
+    assert len(files) == 1, f"expected one saved conversation, found {files}"
+    return json.loads(files[0].read_text(encoding="utf-8"))
+
+
+# --------------------------------------------------------------------------- #
+def test_a_cowork_task_returns_the_final_answer(tmp_path: Path) -> None:
+    provider = FakeProvider()
+    provider.queue_response(content="Report is ready.")
+
+    (answer, timed_out, incomplete), _events, _config = _run(tmp_path, provider)
+
+    assert answer == "Report is ready."
+    assert timed_out is False
+    assert incomplete == ""
+
+
+def test_the_plan_reminder_is_prefixed_to_the_prompt(tmp_path: Path) -> None:
+    # An unattended run has nobody watching, so the agent is pushed to keep its
+    # own checklist honest. The reminder must lead the message.
+    provider = FakeProvider()
+    provider.queue_response(content="ok")
+
+    _run(tmp_path, provider, prompt="write the report")
+
+    sent = provider.call_history[0][-1]["content"]
+    assert sent.startswith("This runs unattended (Schedule Task)")
+    assert sent.endswith("write the report")
+
+
+def test_an_admin_agent_persona_sits_between_the_reminder_and_the_prompt(
+        tmp_path: Path) -> None:
+    class _Agent:
+        # An admin agent may pin its own provider/model; blank means "use the
+        # machine's Settings default", which is what build_agent_provider reads.
+        provider = ""
+        model = ""
+
+        def effective_prompt(self) -> str:
+            return "You are the reporting agent."
+
+    provider = FakeProvider()
+    provider.queue_response(content="ok")
+
+    _run(tmp_path, provider, prompt="write the report", admin_agent=_Agent())
+
+    sent = provider.call_history[0][-1]["content"]
+    assert sent.index("This runs unattended") < sent.index("You are the reporting agent.")
+    assert sent.index("You are the reporting agent.") < sent.index("write the report")
+
+
+def test_the_session_is_announced_once_it_exists_on_disk(tmp_path: Path) -> None:
+    # The scheduler refreshes History on this event, so it must not fire before
+    # the conversation is really there.
+    provider = FakeProvider()
+    provider.queue_response(content="ok")
+
+    _result, events, config = _run(tmp_path, provider)
+
+    ready = [e for e in events if e["type"] == "history_ready"]
+    assert len(ready) == 1
+    assert ready[0]["session_id"]
+    assert _saved_conversation(config)["session_id"] == ready[0]["session_id"]
+
+
+def test_the_saved_conversation_carries_the_answer_and_the_task_title(
+        tmp_path: Path) -> None:
+    provider = FakeProvider()
+    provider.queue_response(content="Report is ready.")
+
+    _result, _events, config = _run(tmp_path, provider)
+
+    saved = _saved_conversation(config)
+    assert saved["title"] == "[Task] Weekly report"
+    assert saved["messages"][-1] == {"role": "assistant", "content": "Report is ready."}
+
+
+def test_an_unfinished_checklist_is_reported_back_to_the_scheduler(
+        tmp_path: Path) -> None:
+    # The agent ticked no step to done, so the task must not be called finished
+    # just because no exception was raised.
+    provider = FakeProvider()
+    provider.queue_response(
+        content="Working on it.",
+        tool_calls=[{"id": "c1", "name": "update_plan",
+                     "arguments": {"steps": [{"title": "Draft", "status": "running"}]}}],
+    )
+    provider.queue_response(content="Stopping here.")
+
+    (_answer, _timed_out, incomplete), _events, _config = _run(tmp_path, provider)
+
+    assert incomplete
+    assert "Draft" in incomplete
+
+
+def test_a_finished_checklist_reports_nothing_outstanding(tmp_path: Path) -> None:
+    provider = FakeProvider()
+    provider.queue_response(
+        content="Done.",
+        tool_calls=[{"id": "c1", "name": "update_plan",
+                     "arguments": {"steps": [{"title": "Draft", "status": "done"}]}}],
+    )
+    provider.queue_response(content="All done.")
+
+    (_answer, _timed_out, incomplete), _events, _config = _run(tmp_path, provider)
+
+    assert incomplete == ""
+
+
+def test_running_out_of_time_appends_the_timeout_notice_to_the_conversation(
+        tmp_path: Path) -> None:
+    # A negative timeout puts the deadline in the past, which is the only
+    # deterministic way to exercise a wall-clock branch in a unit test.
+    provider = FakeProvider()
+    provider.queue_response(content="never gets there")
+
+    (answer, timed_out, incomplete), events, config = _run(
+        tmp_path, provider, timeout_sec=-1)
+
+    assert timed_out is True
+    assert incomplete == ""          # a timeout is not an unfinished checklist
+    assert "quá thời gian chờ" in answer
+    assert any(e["type"] == "assistant_done" and "quá thời gian chờ" in e["content"]
+               for e in events)
+    assert "quá thời gian chờ" in _saved_conversation(config)["messages"][-1]["content"]