flowent 0.1.3 → 0.1.5

package/backend/tests/test_workspace_chat.py

@@ -1,4 +1,5 @@
 import asyncio
+import json
 import time
 
 import httpx
@@ -13,6 +14,7 @@ from flowent.sandbox import CommandResult, SandboxRunner
 def configure_provider(
     client,
     *,
+    agent_prompt: str = "",
     base_url: str = "",
     model: str = "gpt-5.1",
     name: str = "OpenAI",
@@ -34,6 +36,7 @@ def configure_provider(
     client.put(
         "/api/settings",
         json={
+            "agent_prompt": agent_prompt,
             "reasoning_effort": reasoning_effort,
             "selected_model": model,
             "selected_provider_id": provider_id,
@@ -44,6 +47,7 @@ def configure_provider(
 async def configure_provider_async(
     client: httpx.AsyncClient,
     *,
+    agent_prompt: str = "",
     base_url: str = "",
     model: str = "gpt-5.1",
     name: str = "OpenAI",
@@ -65,6 +69,7 @@ async def configure_provider_async(
     await client.put(
         "/api/settings",
         json={
+            "agent_prompt": agent_prompt,
             "reasoning_effort": reasoning_effort,
             "selected_model": model,
             "selected_provider_id": provider_id,
@@ -314,11 +319,14 @@ def test_workspace_compact_persists_compacted_context(tmp_path, monkeypatch) ->
     assert captured_request["model"] == "openai/gpt-5.1"
     assert captured_request["messages"][0] == {
         "role": "system",
-        "content": "You are compacting Flowent workspace context.",
+        "content": "You are performing a context checkpoint compaction for Flowent.",
     }
     assert "AGENTS.md instructions" not in captured_request["messages"][-1]["content"]
     assert "<environment_context>" in captured_request["messages"][-1]["content"]
     assert captured_request["messages"][-1]["role"] == "user"
+    assert (
+        "CONTEXT CHECKPOINT COMPACTION" in captured_request["messages"][-1]["content"]
+    )
     assert "Draft a launch checklist." in captured_request["messages"][-1]["content"]
     assert "Use provider setup first." in captured_request["messages"][-1]["content"]
 
@@ -389,27 +397,46 @@ def test_workspace_response_uses_compacted_context_after_compact(
     }
     assert project_context_message(captured_requests[1]) is None
     assert environment_context_message(captured_requests[1])["role"] == "user"
-    assert response_messages[-3:] == [
-        {"role": "user", "content": "Context compacted"},
-        {"role": "assistant", "content": "Keep the provider setup decision."},
-        {"role": "user", "content": "Continue from there."},
+    compacted_messages = [
+        message
+        for message in response_messages
+        if str(message["content"]).startswith(
+            "Another language model started working on this Flowent workspace session"
+        )
     ]
+    assert len(compacted_messages) == 1
+    assert "Keep the provider setup decision." in compacted_messages[0]["content"]
+    assert response_messages[-1] == {
+        "role": "user",
+        "content": "Continue from there.",
+    }
+    assert {"role": "user", "content": "Context compacted"} not in response_messages
 
 
-def test_workspace_response_includes_project_and_environment_context(
+def test_workspace_response_auto_compacts_before_next_message(
     tmp_path, monkeypatch
 ) -> None:
     monkeypatch.chdir(tmp_path)
     monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
-    (tmp_path / ".git").mkdir()
-    (tmp_path / "AGENTS.md").write_text("Use concise replies.")
-    captured_request: dict[str, object] = {}
+    monkeypatch.setenv("FLOWENT_AUTO_COMPACT_TOKEN_LIMIT", "120")
+    captured_requests: list[dict[str, object]] = []
 
     async def fake_completion(**request: object) -> object:
-        captured_request.update(request)
+        captured_requests.append(request)
+        if not request.get("stream"):
+            return {
+                "choices": [
+                    {
+                        "message": {
+                            "content": "Keep the launch plan summary.",
+                            "role": "assistant",
+                        }
+                    }
+                ]
+            }
 
         async def chunks() -> object:
-            yield {"choices": [{"delta": {"content": "Done."}}]}
+            yield {"choices": [{"delta": {"content": "Continuing."}}]}
 
         return chunks()
 
@@ -417,45 +444,84 @@ def test_workspace_response_includes_project_and_environment_context(
         create_app(serve_frontend=False, chat_completion=fake_completion)
     )
     configure_provider(client)
+    client.put(
+        "/api/workspace/messages",
+        json={
+            "messages": [
+                {
+                    "author": "user",
+                    "content": "Original request. " * 80,
+                    "id": "message-1",
+                },
+                {
+                    "author": "assistant",
+                    "content": "Detailed work log. " * 80,
+                    "id": "message-2",
+                },
+            ]
+        },
+    )
 
-    response = client.post("/api/workspace/respond", json={"content": "Hello."})
+    response = client.post(
+        "/api/workspace/respond",
+        json={"content": "Continue from there."},
+    )
 
     assert response.status_code == 200
-    assert captured_request["messages"][0] == {
-        "role": "system",
-        "content": FLOWENT_AGENT_SYSTEM_PROMPT,
-    }
-    project_message = project_context_message(captured_request)
-    assert project_message == {
-        "role": "user",
-        "content": (
-            f"# AGENTS.md instructions for {tmp_path}\n\n"
-            "<INSTRUCTIONS>\nUse concise replies.\n</INSTRUCTIONS>"
-        ),
-    }
-    environment_message = environment_context_message(captured_request)
-    assert environment_message["role"] == "user"
-    assert f"<cwd>{tmp_path}</cwd>" in environment_message["content"]
-    assert "<filesystem>workspace-write</filesystem>" in environment_message["content"]
-    assert "<network>enabled</network>" in environment_message["content"]
-    assert "<tool>read_file</tool>" in environment_message["content"]
-    assert captured_request["messages"][-1] == {
-        "role": "user",
-        "content": "Hello.",
-    }
+    events = stream_events(response.text)
+    assert events[0]["event"] == "context_optimized"
+    assert json.loads(events[0]["data"])["message"]["content"] == ("Context optimized")
+    assert len(captured_requests) == 2
+    assert (
+        "CONTEXT CHECKPOINT COMPACTION"
+        in captured_requests[0]["messages"][-1]["content"]
+    )
+    response_messages = captured_requests[1]["messages"]
+    compacted_messages = [
+        message
+        for message in response_messages
+        if str(message["content"]).startswith(
+            "Another language model started working on this Flowent workspace session"
+        )
+    ]
+    assert len(compacted_messages) == 1
+    assert "Keep the launch plan summary." in compacted_messages[0]["content"]
+    assert {"role": "user", "content": "Context optimized"} not in response_messages
+    state = client.get("/api/state").json()
+    assert [message["content"] for message in state["messages"]][-3:] == [
+        "Context optimized",
+        "Continue from there.",
+        "Continuing.",
+    ]
 
 
-def test_workspace_response_uses_selected_reasoning_effort(
+def test_workspace_response_auto_compacts_after_tool_result(
     tmp_path, monkeypatch
 ) -> None:
     monkeypatch.chdir(tmp_path)
     monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
-    captured_request: dict[str, object] = {}
+    monkeypatch.setenv("FLOWENT_AUTO_COMPACT_TOKEN_LIMIT", "1200")
+    (tmp_path / "notes.txt").write_text("Launch notes. " * 600)
+    captured_requests: list[dict[str, object]] = []
 
     async def fake_completion(**request: object) -> object:
-        captured_request.update(request)
+        captured_requests.append(request)
+        if not request.get("stream"):
+            return {
+                "choices": [
+                    {
+                        "message": {
+                            "content": "Keep the file findings from notes.txt.",
+                            "role": "assistant",
+                        }
+                    }
+                ]
+            }
 
         async def chunks() -> object:
+            if len(captured_requests) == 1:
+                yield tool_call_chunk("read_file", '{"path": "notes.txt"}')
+                return
             yield {"choices": [{"delta": {"content": "Done."}}]}
 
         return chunks()
@@ -463,27 +529,59 @@ def test_workspace_response_uses_selected_reasoning_effort(
     client = TestClient(
         create_app(serve_frontend=False, chat_completion=fake_completion)
     )
-    configure_provider(client, reasoning_effort="xhigh")
+    configure_provider(client)
 
-    response = client.post("/api/workspace/respond", json={"content": "Hello."})
+    response = client.post(
+        "/api/workspace/respond",
+        json={"content": "Read the launch notes."},
+    )
 
     assert response.status_code == 200
-    assert captured_request["reasoning_effort"] == "xhigh"
+    events = stream_events(response.text)
+    assert [event["event"] for event in events] == [
+        "start",
+        "output_start",
+        "tool_start",
+        "tool_done",
+        "context_optimized",
+        "output_start",
+        "delta",
+        "done",
+    ]
+    assert json.loads(events[4]["data"])["message"]["content"] == ("Context optimized")
+    assert len(captured_requests) == 3
+    assert "Launch notes." in captured_requests[1]["messages"][-1]["content"]
+    response_messages = captured_requests[2]["messages"]
+    compacted_messages = [
+        message
+        for message in response_messages
+        if str(message["content"]).startswith(
+            "Another language model started working on this Flowent workspace session"
+        )
+    ]
+    assert len(compacted_messages) == 1
+    assert "Keep the file findings from notes.txt." in compacted_messages[0]["content"]
+    state = client.get("/api/state").json()
+    assert [message["content"] for message in state["messages"]] == [
+        "Read the launch notes.",
+        "Context optimized",
+        "Done.",
+    ]
 
 
-def test_workspace_response_prefers_agents_override(tmp_path, monkeypatch) -> None:
+def test_workspace_auto_compact_failure_keeps_existing_checkpoint(
+    tmp_path, monkeypatch
+) -> None:
     monkeypatch.chdir(tmp_path)
     monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
-    (tmp_path / ".git").mkdir()
-    (tmp_path / "AGENTS.md").write_text("Versioned instructions.")
-    (tmp_path / "AGENTS.override.md").write_text("Local override instructions.")
-    captured_request: dict[str, object] = {}
+    monkeypatch.setenv("FLOWENT_AUTO_COMPACT_TOKEN_LIMIT", "120")
 
     async def fake_completion(**request: object) -> object:
-        captured_request.update(request)
+        if not request.get("stream"):
+            raise RuntimeError("summary failed")
 
         async def chunks() -> object:
-            yield {"choices": [{"delta": {"content": "Done."}}]}
+            yield {"choices": [{"delta": {"content": "Should not run."}}]}
 
         return chunks()
 
@@ -491,34 +589,60 @@ def test_workspace_response_prefers_agents_override(tmp_path, monkeypatch) -> No
         create_app(serve_frontend=False, chat_completion=fake_completion)
     )
     configure_provider(client)
+    client.put(
+        "/api/workspace/messages",
+        json={
+            "messages": [
+                {
+                    "author": "user",
+                    "content": "Original request. " * 80,
+                    "id": "message-1",
+                }
+            ]
+        },
+    )
 
-    response = client.post("/api/workspace/respond", json={"content": "Hello."})
+    response = client.post(
+        "/api/workspace/respond",
+        json={"content": "Continue from there."},
+    )
 
     assert response.status_code == 200
-    project_message = project_context_message(captured_request)
-    assert project_message is not None
-    assert "Local override instructions." in project_message["content"]
-    assert "Versioned instructions." not in project_message["content"]
+    events = stream_events(response.text)
+    assert events[-1]["event"] == "error"
+    assert json.loads(events[-1]["data"])["message"] == (
+        "Context could not be optimized."
+    )
+    state = client.get("/api/state").json()
+    assert "Context optimized" not in [
+        message["content"] for message in state["messages"]
+    ]
 
 
-def test_workspace_response_merges_project_instructions_from_root_to_cwd(
+def test_workspace_response_uses_auto_compaction_checkpoint_after_restart(
     tmp_path, monkeypatch
 ) -> None:
-    repo = tmp_path / "repo"
-    nested = repo / "packages" / "agent"
-    nested.mkdir(parents=True)
-    (repo / ".git").mkdir()
-    (repo / "AGENTS.md").write_text("Root instructions.")
-    (nested / "AGENTS.md").write_text("Nested instructions.")
-    monkeypatch.chdir(nested)
+    monkeypatch.chdir(tmp_path)
     monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
-    captured_request: dict[str, object] = {}
+    monkeypatch.setenv("FLOWENT_AUTO_COMPACT_TOKEN_LIMIT", "120")
+    captured_requests: list[dict[str, object]] = []
 
     async def fake_completion(**request: object) -> object:
-        captured_request.update(request)
+        captured_requests.append(request)
+        if not request.get("stream"):
+            return {
+                "choices": [
+                    {
+                        "message": {
+                            "content": "Auto checkpoint survives restarts.",
+                            "role": "assistant",
+                        }
+                    }
+                ]
+            }
 
         async def chunks() -> object:
-            yield {"choices": [{"delta": {"content": "Done."}}]}
+            yield {"choices": [{"delta": {"content": "Continuing."}}]}
 
         return chunks()
 
@@ -526,29 +650,62 @@ def test_workspace_response_merges_project_instructions_from_root_to_cwd(
         create_app(serve_frontend=False, chat_completion=fake_completion)
     )
     configure_provider(client)
+    client.put(
+        "/api/workspace/messages",
+        json={
+            "messages": [
+                {
+                    "author": "user",
+                    "content": "Original request. " * 80,
+                    "id": "message-1",
+                }
+            ]
+        },
+    )
 
-    response = client.post("/api/workspace/respond", json={"content": "Hello."})
+    first_response = client.post(
+        "/api/workspace/respond",
+        json={"content": "Continue from there."},
+    )
+    monkeypatch.setenv("FLOWENT_AUTO_COMPACT_TOKEN_LIMIT", "100000")
+    restarted_client = TestClient(
+        create_app(serve_frontend=False, chat_completion=fake_completion)
+    )
+    second_response = restarted_client.post(
+        "/api/workspace/respond",
+        json={"content": "Continue after restart."},
+    )
 
-    assert response.status_code == 200
-    project_message = project_context_message(captured_request)
-    assert project_message is not None
-    assert project_message["content"].index("Root instructions.") < project_message[
-        "content"
-    ].index("Nested instructions.")
+    assert first_response.status_code == 200
+    assert second_response.status_code == 200
+    response_messages = captured_requests[2]["messages"]
+    compacted_messages = [
+        message
+        for message in response_messages
+        if str(message["content"]).startswith(
+            "Another language model started working on this Flowent workspace session"
+        )
+    ]
+    assert len(compacted_messages) == 1
+    assert "Auto checkpoint survives restarts." in compacted_messages[0]["content"]
+    assert {"role": "user", "content": "Context optimized"} not in response_messages
+    assert response_messages[-1] == {
+        "role": "user",
+        "content": "Continue after restart.",
+    }
 
 
-def test_workspace_response_uses_updated_project_instructions(
+def test_workspace_response_includes_project_and_environment_context(
     tmp_path, monkeypatch
 ) -> None:
     monkeypatch.chdir(tmp_path)
     monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
     (tmp_path / ".git").mkdir()
-    agents_file = tmp_path / "AGENTS.md"
-    agents_file.write_text("Old instructions.")
-    captured_requests: list[dict[str, object]] = []
+    (tmp_path / "AGENTS.md").write_text("Use concise replies.")
+    captured_request: dict[str, object] = {}
 
     async def fake_completion(**request: object) -> object:
-        captured_requests.append(request)
+        captured_request.update(request)
 
         async def chunks() -> object:
             yield {"choices": [{"delta": {"content": "Done."}}]}
@@ -560,28 +717,49 @@ def test_workspace_response_uses_updated_project_instructions(
     )
     configure_provider(client)
 
-    first_response = client.post("/api/workspace/respond", json={"content": "First."})
-    agents_file.write_text("Updated instructions.")
-    second_response = client.post("/api/workspace/respond", json={"content": "Second."})
+    response = client.post("/api/workspace/respond", json={"content": "Hello."})
 
-    assert first_response.status_code == 200
-    assert second_response.status_code == 200
-    first_project_message = project_context_message(captured_requests[0])
-    second_project_message = project_context_message(captured_requests[1])
-    assert first_project_message is not None
-    assert second_project_message is not None
-    assert "Old instructions." in first_project_message["content"]
-    assert "Updated instructions." in second_project_message["content"]
-    assert "Old instructions." not in second_project_message["content"]
+    assert response.status_code == 200
+    assert captured_request["messages"][0] == {
+        "role": "system",
+        "content": FLOWENT_AGENT_SYSTEM_PROMPT,
+    }
+    project_message = project_context_message(captured_request)
+    assert project_message == {
+        "role": "user",
+        "content": (
+            f"# AGENTS.md instructions for {tmp_path}\n\n"
+            "<INSTRUCTIONS>\nUse concise replies.\n</INSTRUCTIONS>"
+        ),
+    }
+    environment_message = environment_context_message(captured_request)
+    assert environment_message["role"] == "user"
+    assert f"<cwd>{tmp_path}</cwd>" in environment_message["content"]
+    assert "<filesystem>workspace-write</filesystem>" in environment_message["content"]
+    assert "<network>enabled</network>" in environment_message["content"]
+    assert "<tool>read_file</tool>" in environment_message["content"]
+    assert captured_request["messages"][-1] == {
+        "role": "user",
+        "content": "Hello.",
+    }
 
 
-def test_workspace_context_is_not_persisted_in_state(tmp_path, monkeypatch) -> None:
-    monkeypatch.chdir(tmp_path)
-    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
-    (tmp_path / ".git").mkdir()
-    (tmp_path / "AGENTS.md").write_text("Hidden instructions.")
+def test_workspace_response_uses_flowent_workdir(tmp_path, monkeypatch) -> None:
+    launch_dir = tmp_path / "launch"
+    workdir = tmp_path / "workspace"
+    data_dir = tmp_path / "data"
+    launch_dir.mkdir()
+    workdir.mkdir()
+    monkeypatch.chdir(launch_dir)
+    monkeypatch.setenv("FLOWENT_WORKDIR", str(workdir))
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(data_dir))
+    (workdir / ".git").mkdir()
+    (workdir / "AGENTS.md").write_text("Use workspace instructions.")
+    captured_request: dict[str, object] = {}
 
     async def fake_completion(**request: object) -> object:
+        captured_request.update(request)
+
         async def chunks() -> object:
             yield {"choices": [{"delta": {"content": "Done."}}]}
 
@@ -593,13 +771,244 @@ def test_workspace_context_is_not_persisted_in_state(tmp_path, monkeypatch) -> N
     configure_provider(client)
 
     response = client.post("/api/workspace/respond", json={"content": "Hello."})
-    state = client.get("/api/state").json()
 
     assert response.status_code == 200
-    persisted_content = "\n".join(message["content"] for message in state["messages"])
-    assert "Hidden instructions." not in persisted_content
-    assert "<environment_context>" not in persisted_content
-
+    project_message = project_context_message(captured_request)
+    assert project_message == {
+        "role": "user",
+        "content": (
+            f"# AGENTS.md instructions for {workdir}\n\n"
+            "<INSTRUCTIONS>\nUse workspace instructions.\n</INSTRUCTIONS>"
+        ),
+    }
+    environment_message = environment_context_message(captured_request)
+    assert f"<cwd>{workdir}</cwd>" in environment_message["content"]
+
+
+def test_create_app_workdir_overrides_flowent_workdir(tmp_path, monkeypatch) -> None:
+    env_workdir = tmp_path / "env-workspace"
+    app_workdir = tmp_path / "app-workspace"
+    data_dir = tmp_path / "data"
+    env_workdir.mkdir()
+    app_workdir.mkdir()
+    monkeypatch.setenv("FLOWENT_WORKDIR", str(env_workdir))
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(data_dir))
+    (env_workdir / ".git").mkdir()
+    (app_workdir / ".git").mkdir()
+    (env_workdir / "AGENTS.md").write_text("Use env instructions.")
+    (app_workdir / "AGENTS.md").write_text("Use app instructions.")
+    captured_request: dict[str, object] = {}
+
+    async def fake_completion(**request: object) -> object:
+        captured_request.update(request)
+
+        async def chunks() -> object:
+            yield {"choices": [{"delta": {"content": "Done."}}]}
+
+        return chunks()
+
+    client = TestClient(
+        create_app(
+            serve_frontend=False,
+            chat_completion=fake_completion,
+            workdir=app_workdir,
+        )
+    )
+    configure_provider(client)
+
+    response = client.post("/api/workspace/respond", json={"content": "Hello."})
+
+    assert response.status_code == 200
+    project_message = project_context_message(captured_request)
+    assert project_message is not None
+    assert "Use app instructions." in project_message["content"]
+    assert "Use env instructions." not in project_message["content"]
+    environment_message = environment_context_message(captured_request)
+    assert f"<cwd>{app_workdir}</cwd>" in environment_message["content"]
+
+
+def test_workspace_workdir_does_not_change_data_directory(
+    tmp_path, monkeypatch
+) -> None:
+    workdir = tmp_path / "workspace"
+    data_dir = tmp_path / "data"
+    workdir.mkdir()
+    monkeypatch.setenv("FLOWENT_WORKDIR", str(workdir))
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(data_dir))
+
+    client = TestClient(create_app(serve_frontend=False))
+    response = client.post(
+        "/api/providers",
+        json={
+            "api_key": "sk-local",
+            "base_url": "",
+            "id": "provider-openai",
+            "models": ["gpt-5.1"],
+            "name": "OpenAI",
+            "type": "openai",
+        },
+    )
+
+    assert response.status_code == 200
+    assert (data_dir / "flowent.db").is_file()
+    assert not (workdir / "flowent.db").exists()
+
+
+def test_workspace_response_uses_selected_reasoning_effort(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+    captured_request: dict[str, object] = {}
+
+    async def fake_completion(**request: object) -> object:
+        captured_request.update(request)
+
+        async def chunks() -> object:
+            yield {"choices": [{"delta": {"content": "Done."}}]}
+
+        return chunks()
+
+    client = TestClient(
+        create_app(serve_frontend=False, chat_completion=fake_completion)
+    )
+    configure_provider(client, reasoning_effort="xhigh")
+
+    response = client.post("/api/workspace/respond", json={"content": "Hello."})
+
+    assert response.status_code == 200
+    assert captured_request["reasoning_effort"] == "xhigh"
+
+
+def test_workspace_response_prefers_agents_override(tmp_path, monkeypatch) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+    (tmp_path / ".git").mkdir()
+    (tmp_path / "AGENTS.md").write_text("Versioned instructions.")
+    (tmp_path / "AGENTS.override.md").write_text("Local override instructions.")
+    captured_request: dict[str, object] = {}
+
+    async def fake_completion(**request: object) -> object:
+        captured_request.update(request)
+
+        async def chunks() -> object:
+            yield {"choices": [{"delta": {"content": "Done."}}]}
+
+        return chunks()
+
+    client = TestClient(
+        create_app(serve_frontend=False, chat_completion=fake_completion)
+    )
+    configure_provider(client)
+
+    response = client.post("/api/workspace/respond", json={"content": "Hello."})
+
+    assert response.status_code == 200
+    project_message = project_context_message(captured_request)
+    assert project_message is not None
+    assert "Local override instructions." in project_message["content"]
+    assert "Versioned instructions." not in project_message["content"]
+
+
+def test_workspace_response_merges_project_instructions_from_root_to_cwd(
+    tmp_path, monkeypatch
+) -> None:
+    repo = tmp_path / "repo"
+    nested = repo / "packages" / "agent"
+    nested.mkdir(parents=True)
+    (repo / ".git").mkdir()
+    (repo / "AGENTS.md").write_text("Root instructions.")
+    (nested / "AGENTS.md").write_text("Nested instructions.")
+    monkeypatch.chdir(nested)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+    captured_request: dict[str, object] = {}
+
+    async def fake_completion(**request: object) -> object:
+        captured_request.update(request)
+
+        async def chunks() -> object:
+            yield {"choices": [{"delta": {"content": "Done."}}]}
+
+        return chunks()
+
+    client = TestClient(
+        create_app(serve_frontend=False, chat_completion=fake_completion)
+    )
+    configure_provider(client)
+
+    response = client.post("/api/workspace/respond", json={"content": "Hello."})
+
+    assert response.status_code == 200
+    project_message = project_context_message(captured_request)
+    assert project_message is not None
+    assert project_message["content"].index("Root instructions.") < project_message[
+        "content"
+    ].index("Nested instructions.")
+
+
+def test_workspace_response_uses_updated_project_instructions(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+    (tmp_path / ".git").mkdir()
+    agents_file = tmp_path / "AGENTS.md"
+    agents_file.write_text("Old instructions.")
+    captured_requests: list[dict[str, object]] = []
+
+    async def fake_completion(**request: object) -> object:
+        captured_requests.append(request)
+
+        async def chunks() -> object:
+            yield {"choices": [{"delta": {"content": "Done."}}]}
+
+        return chunks()
+
+    client = TestClient(
+        create_app(serve_frontend=False, chat_completion=fake_completion)
+    )
+    configure_provider(client)
+
+    first_response = client.post("/api/workspace/respond", json={"content": "First."})
+    agents_file.write_text("Updated instructions.")
+    second_response = client.post("/api/workspace/respond", json={"content": "Second."})
+
+    assert first_response.status_code == 200
+    assert second_response.status_code == 200
+    first_project_message = project_context_message(captured_requests[0])
+    second_project_message = project_context_message(captured_requests[1])
+    assert first_project_message is not None
+    assert second_project_message is not None
+    assert "Old instructions." in first_project_message["content"]
+    assert "Updated instructions." in second_project_message["content"]
+    assert "Old instructions." not in second_project_message["content"]
+
+
+def test_workspace_context_is_not_persisted_in_state(tmp_path, monkeypatch) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+    (tmp_path / ".git").mkdir()
+    (tmp_path / "AGENTS.md").write_text("Hidden instructions.")
+
+    async def fake_completion(**request: object) -> object:
+        async def chunks() -> object:
+            yield {"choices": [{"delta": {"content": "Done."}}]}
+
+        return chunks()
+
+    client = TestClient(
+        create_app(serve_frontend=False, chat_completion=fake_completion)
+    )
+    configure_provider(client)
+
+    response = client.post("/api/workspace/respond", json={"content": "Hello."})
+    state = client.get("/api/state").json()
+
+    assert response.status_code == 200
+    persisted_content = "\n".join(message["content"] for message in state["messages"])
+    assert "Hidden instructions." not in persisted_content
+    assert "<environment_context>" not in persisted_content
+
 
 def test_workspace_clear_keeps_runtime_context_available(tmp_path, monkeypatch) -> None:
     monkeypatch.chdir(tmp_path)
@@ -687,10 +1096,15 @@ def test_workspace_compacted_response_includes_latest_runtime_context(
     assert project_message is not None
     assert "Instructions after compact." in project_message["content"]
     assert environment_context_message(captured_requests[1])["role"] == "user"
-    assert {
-        "role": "assistant",
-        "content": "Keep compacted state.",
-    } in response_messages
+    compacted_messages = [
+        message
+        for message in response_messages
+        if str(message["content"]).startswith(
+            "Another language model started working on this Flowent workspace session"
+        )
+    ]
+    assert len(compacted_messages) == 1
+    assert "Keep compacted state." in compacted_messages[0]["content"]
 
 
 def test_project_instructions_are_truncated_to_size_limit(
@@ -845,19 +1259,28 @@ def test_workspace_persists_failed_draft_when_stream_errors(
     assert assistant["author"] == "assistant"
     assert assistant["content"] == "Partial answer."
     assert assistant["status"] == "failed"
+    assert assistant["groups"][-1] == {
+        "id": f"{assistant['id']}-errors",
+        "items": [
+            {
+                "detail": "provider stopped",
+                "id": f"{assistant['id']}-error-1",
+                "message": "Check the model connection settings and try again.",
+                "title": "Request failed",
+                "type": "error",
+            }
+        ],
+    }
 
 
-def test_workspace_marks_draft_complete_when_stream_finishes(
+def test_workspace_persists_error_block_when_model_fails_before_output(
     tmp_path, monkeypatch
 ) -> None:
     monkeypatch.chdir(tmp_path)
     monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
 
     async def fake_completion(**request: object) -> object:
-        async def chunks() -> object:
-            yield {"choices": [{"delta": {"content": "Done."}}]}
-
-        return chunks()
+        raise RuntimeError("provider unavailable")
 
     client = TestClient(
         create_app(serve_frontend=False, chat_completion=fake_completion)
@@ -867,61 +1290,309 @@ def test_workspace_marks_draft_complete_when_stream_finishes(
     response = client.post("/api/workspace/respond", json={"content": "Hello."})
 
     assert response.status_code == 200
+    events = stream_events(response.text)
+    assert events[-1]["event"] == "error"
+    assistant_id = json.loads(events[0]["data"])["id"]
+    assert json.loads(events[-1]["data"]) == {
+        "error": {
+            "detail": "provider unavailable",
+            "id": f"{assistant_id}-error-1",
+            "message": "Check the model connection settings and try again.",
+            "title": "Request failed",
+            "type": "error",
+        },
+        "message": "Check the model connection settings and try again.",
+    }
     state = client.get("/api/state").json()
     assistant = state["messages"][-1]
     assert assistant["author"] == "assistant"
-    assert assistant["content"] == "Done."
-    assert assistant.get("status", "completed") == "completed"
+    assert assistant["content"] == ""
+    assert assistant["status"] == "failed"
+    assert assistant["groups"] == [
+        {
+            "id": f"{assistant['id']}-group-1",
+            "items": [],
+        },
+        {
+            "id": f"{assistant['id']}-errors",
+            "items": [
+                {
+                    "detail": "provider unavailable",
+                    "id": f"{assistant['id']}-error-1",
+                    "message": "Check the model connection settings and try again.",
+                    "title": "Request failed",
+                    "type": "error",
+                }
+            ],
+        },
+    ]
 
 
-@pytest.mark.anyio
-async def test_workspace_run_continues_without_stream_consumer(
+def test_workspace_treats_empty_model_result_as_failed_error_block(
     tmp_path, monkeypatch
 ) -> None:
     monkeypatch.chdir(tmp_path)
     monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
-    first_chunk_sent = asyncio.Event()
-    finish_response = asyncio.Event()
 
     async def fake_completion(**request: object) -> object:
         async def chunks() -> object:
-            yield {"choices": [{"delta": {"content": "Partial "}}]}
-            first_chunk_sent.set()
-            await asyncio.wait_for(finish_response.wait(), timeout=2)
-            yield {"choices": [{"delta": {"content": "answer."}}]}
+            if False:
+                yield {}
 
         return chunks()
 
-    app = create_app(serve_frontend=False, chat_completion=fake_completion)
-    async with httpx.AsyncClient(
-        transport=httpx.ASGITransport(app=app), base_url="http://testserver"
-    ) as client:
-        await configure_provider_async(client)
-        response = await client.post(
-            "/api/workspace/runs",
-            json={"content": "Keep working."},
-        )
-        assert response.status_code == 200
-        await asyncio.wait_for(first_chunk_sent.wait(), timeout=2)
-        finish_response.set()
-
-        for _ in range(20):
-            state = (await client.get("/api/state")).json()
-            assistant = state["messages"][-1]
-            if (
-                assistant["author"] == "assistant"
-                and assistant.get("status", "completed") == "completed"
-            ):
-                break
-            await asyncio.sleep(0.05)
-        else:
-            raise AssertionError("Workspace run did not complete.")
-
-    assert assistant["content"] == "Partial answer."
+    client = TestClient(
+        create_app(serve_frontend=False, chat_completion=fake_completion)
+    )
+    configure_provider(client)
 
+    response = client.post("/api/workspace/respond", json={"content": "Hello."})
 
-@pytest.mark.anyio
-async def test_workspace_state_exposes_active_run_for_reconnect(
+    assert response.status_code == 200
+    events = stream_events(response.text)
+    assert events[-1]["event"] == "error"
+    state = client.get("/api/state").json()
+    assistant = state["messages"][-1]
+    assert assistant["status"] == "failed"
+    assert assistant["groups"][-1]["items"] == [
+        {
+            "detail": "The model did not return a response.",
+            "id": f"{assistant['id']}-error-1",
+            "message": "Check the model connection settings and try again.",
+            "title": "Request failed",
+            "type": "error",
+        }
+    ]
+
+
+def test_workspace_includes_previous_error_summary_in_next_request(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+    captured_requests: list[dict[str, object]] = []
+
+    async def fake_completion(**request: object) -> object:
+        captured_requests.append(request)
+
+        async def chunks() -> object:
+            yield {"choices": [{"delta": {"content": "Recovered."}}]}
+
+        return chunks()
+
+    client = TestClient(
+        create_app(serve_frontend=False, chat_completion=fake_completion)
+    )
+    configure_provider(client)
+    client.put(
+        "/api/workspace/messages",
+        json={
+            "messages": [
+                {
+                    "author": "user",
+                    "content": "Try once.",
+                    "id": "message-user-1",
+                },
+                {
+                    "author": "assistant",
+                    "content": "",
+                    "groups": [
+                        {
+                            "id": "message-assistant-1-errors",
+                            "items": [
+                                {
+                                    "detail": "HTML response returned.",
+                                    "id": "message-assistant-1-error-1",
+                                    "message": "Check the model connection settings and try again.",
+                                    "title": "Request failed",
+                                    "type": "error",
+                                }
+                            ],
+                        }
+                    ],
+                    "id": "message-assistant-1",
+                    "status": "failed",
+                },
+            ]
+        },
+    )
+
+    response = client.post("/api/workspace/respond", json={"content": "Try again."})
+
+    assert response.status_code == 200
+    request_messages = captured_requests[0]["messages"]
+    assert {
+        "role": "assistant",
+        "content": "Previous response failed: Request failed. Check the model connection settings and try again. Detail: HTML response returned.",
+    } in request_messages
+
+
+def test_workspace_marks_running_tool_failed_when_stream_errors(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+
+    async def fake_run_async(self, command, **kwargs):
+        raise RuntimeError("sandbox failed")
+
+    monkeypatch.setattr(SandboxRunner, "run_async", fake_run_async)
+
+    async def fake_completion(**request: object) -> object:
+        async def chunks() -> object:
+            yield tool_call_chunk("shell_command", '{"command": "boom"}')
+
+        return chunks()
+
+    client = TestClient(
+        create_app(serve_frontend=False, chat_completion=fake_completion)
+    )
+    configure_provider(client)
+
+    response = client.post("/api/workspace/respond", json={"content": "Run it."})
+
+    assert response.status_code == 200
+    events = stream_events(response.text)
+    assert events[-1]["event"] == "error"
+    state = client.get("/api/state").json()
+    assistant = state["messages"][-1]
+    assert assistant["status"] == "failed"
+    assert assistant["tools"][0]["name"] == "shell_command"
+    assert assistant["tools"][0]["status"] == "failed"
+    assert "sandbox failed" in assistant["tools"][0]["content"]
+
+
+def test_workspace_marks_draft_complete_when_stream_finishes(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+
+    async def fake_completion(**request: object) -> object:
+        async def chunks() -> object:
+            yield {"choices": [{"delta": {"content": "Done."}}]}
+
+        return chunks()
+
+    client = TestClient(
+        create_app(serve_frontend=False, chat_completion=fake_completion)
+    )
+    configure_provider(client)
+
+    response = client.post("/api/workspace/respond", json={"content": "Hello."})
+
+    assert response.status_code == 200
+    state = client.get("/api/state").json()
+    assistant = state["messages"][-1]
+    assert assistant["author"] == "assistant"
+    assert assistant["content"] == "Done."
+    assert assistant.get("status", "completed") == "completed"
+
+
+def test_workspace_persists_assistant_output_groups_after_tool_round(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+    (tmp_path / "notes.txt").write_text("Launch notes")
+    completion_calls = 0
+
+    async def fake_completion(**request: object) -> object:
+        nonlocal completion_calls
+        completion_calls += 1
+
+        async def chunks() -> object:
+            if completion_calls == 1:
+                yield tool_call_chunk("read_file", '{"path": "notes.txt"}')
+                return
+            yield {"choices": [{"delta": {"content": "The notes are ready."}}]}
+
+        return chunks()
+
+    client = TestClient(
+        create_app(serve_frontend=False, chat_completion=fake_completion)
+    )
+    configure_provider(client)
+
+    response = client.post("/api/workspace/respond", json={"content": "Read notes."})
+    state = client.get("/api/state").json()
+    assistant = state["messages"][-1]
+    tool_id = assistant["tools"][0]["id"]
+
+    assert response.status_code == 200
+    assert assistant["content"] == "The notes are ready."
+    assert assistant["groups"] == [
+        {
+            "id": f"{assistant['id']}-group-1",
+            "items": [
+                {
+                    "id": f"tool-{tool_id}",
+                    "tool": assistant["tools"][0],
+                    "type": "tool",
+                }
+            ],
+        },
+        {
+            "id": f"{assistant['id']}-group-2",
+            "items": [
+                {
+                    "content": "The notes are ready.",
+                    "id": f"{assistant['id']}-text-1",
+                    "type": "text",
+                }
+            ],
+        },
+    ]
+
+
+@pytest.mark.anyio
+async def test_workspace_run_continues_without_stream_consumer(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+    first_chunk_sent = asyncio.Event()
+    finish_response = asyncio.Event()
+
+    async def fake_completion(**request: object) -> object:
+        async def chunks() -> object:
+            yield {"choices": [{"delta": {"content": "Partial "}}]}
+            first_chunk_sent.set()
+            await asyncio.wait_for(finish_response.wait(), timeout=2)
+            yield {"choices": [{"delta": {"content": "answer."}}]}
+
+        return chunks()
+
+    app = create_app(serve_frontend=False, chat_completion=fake_completion)
+    async with httpx.AsyncClient(
+        transport=httpx.ASGITransport(app=app), base_url="http://testserver"
+    ) as client:
+        await configure_provider_async(client)
+        response = await client.post(
+            "/api/workspace/runs",
+            json={"content": "Keep working."},
+        )
+        assert response.status_code == 200
+        await asyncio.wait_for(first_chunk_sent.wait(), timeout=2)
+        finish_response.set()
+
+        for _ in range(20):
+            state = (await client.get("/api/state")).json()
+            assistant = state["messages"][-1]
+            if (
+                assistant["author"] == "assistant"
+                and assistant.get("status", "completed") == "completed"
+            ):
+                break
+            await asyncio.sleep(0.05)
+        else:
+            raise AssertionError("Workspace run did not complete.")
+
+    assert assistant["content"] == "Partial answer."
+
+
+@pytest.mark.anyio
+async def test_workspace_state_exposes_active_run_for_reconnect(
     tmp_path, monkeypatch
 ) -> None:
     monkeypatch.chdir(tmp_path)
@@ -963,6 +1634,215 @@ async def test_workspace_state_exposes_active_run_for_reconnect(
     assert {"event": "delta", "data": '{"content": "second."}'} in events
 
 
+@pytest.mark.anyio
+async def test_workspace_persists_automatic_review_result_during_stream(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+    work_dir = tmp_path / "work"
+    outside_dir = tmp_path / "outside"
+    work_dir.mkdir()
+    outside_dir.mkdir()
+    target = outside_dir / "notes.txt"
+    target.write_text("alpha\n")
+    patch = f"""*** Begin Patch
+*** Update File: {target}
+@@
+-alpha
++beta
+*** End Patch"""
+
+    review_started = asyncio.Event()
+    finish_review = asyncio.Event()
+    review_payload: dict[str, object] = {}
+
+    async def fake_completion(**request: object) -> object:
+        messages = request["messages"]
+        if messages[0]["content"].startswith("You are Flowent Approval Reviewer"):
+            review_payload.update(json.loads(messages[-1]["content"]))
+            review_started.set()
+            await asyncio.wait_for(finish_review.wait(), timeout=2)
+            return {
+                "choices": [
+                    {
+                        "message": {
+                            "content": json.dumps(
+                                {
+                                    "risk_level": "high",
+                                    "risk_score": 85,
+                                    "rationale": "Outside the task scope.",
+                                    "evidence": [],
+                                }
+                            ),
+                            "role": "assistant",
+                        }
+                    }
+                ]
+            }
+
+        async def chunks() -> object:
+            if request["messages"][-1]["role"] == "user":
+                yield tool_call_chunk(
+                    "apply_patch",
+                    json.dumps({"patch": patch}),
+                )
+                return
+            yield {"choices": [{"delta": {"content": "Done."}}]}
+
+        return chunks()
+
+    app = create_app(
+        workdir=work_dir,
+        serve_frontend=False,
+        chat_completion=fake_completion,
+    )
+    async with httpx.AsyncClient(
+        transport=httpx.ASGITransport(app=app), base_url="http://testserver"
+    ) as client:
+        await configure_provider_async(client)
+        response = await client.post(
+            "/api/workspace/runs",
+            json={"content": "Edit notes."},
+        )
+        run_id = response.json()["run_id"]
+        await asyncio.wait_for(review_started.wait(), timeout=2)
+        state = (await client.get("/api/state")).json()
+        finish_review.set()
+        stream_response = await client.get(
+            f"/api/workspace/runs/{run_id}/stream?after={state['active_run_event_index']}"
+        )
+
+    assistant = state["messages"][-1]
+    assert state["active_run_id"] == run_id
+    assert assistant["tools"][0]["name"] == "apply_patch"
+    assert assistant["tools"][0]["status"] == "running"
+    events = stream_events(stream_response.text)
+    tool_error = next(event for event in events if event["event"] == "tool_error")
+    tool_error_data = json.loads(str(tool_error["data"]))
+    assert tool_error_data["data"]["approval"]["decision"] == "denied"
+    assert tool_error_data["data"]["approval"]["reason"] == "Outside the task scope."
+    assert review_payload["user_request"] == "Edit notes."
+    assert target.read_text() == "alpha\n"
+
+
+@pytest.mark.anyio
+async def test_workspace_review_request_includes_recent_transcript(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+    work_dir = tmp_path / "work"
+    work_dir.mkdir()
+    review_payload: dict[str, object] = {}
+
+    async def fake_completion(**request: object) -> object:
+        messages = request["messages"]
+        if messages[0]["content"].startswith("You are Flowent Approval Reviewer"):
+            review_payload.update(json.loads(messages[-1]["content"]))
+            return {
+                "choices": [
+                    {
+                        "message": {
+                            "content": json.dumps(
+                                {
+                                    "risk_level": "high",
+                                    "risk_score": 85,
+                                    "rationale": "No run is needed for this test.",
+                                    "evidence": [],
+                                }
+                            ),
+                            "role": "assistant",
+                        }
+                    }
+                ]
+            }
+
+        async def chunks() -> object:
+            if request["messages"][-1]["role"] == "user":
+                yield tool_call_chunk(
+                    "shell_command",
+                    json.dumps(
+                        {
+                            "additional_permissions": {
+                                "file_system": {"write": ["/var/run/docker.sock"]}
+                            },
+                            "command": (
+                                "docker compose up -d --force-recreate flowent"
+                            ),
+                            "sandbox_permissions": "with_additional_permissions",
+                        }
+                    ),
+                )
+                return
+            yield {"choices": [{"delta": {"content": "Stopped."}}]}
+
+        return chunks()
+
+    app = create_app(
+        workdir=work_dir,
+        serve_frontend=False,
+        chat_completion=fake_completion,
+    )
+    async with httpx.AsyncClient(
+        transport=httpx.ASGITransport(app=app), base_url="http://testserver"
+    ) as client:
+        await configure_provider_async(client)
+        await client.put(
+            "/api/workspace/messages",
+            json={
+                "messages": [
+                    {
+                        "author": "user",
+                        "content": "Can you recreate the dev container?",
+                        "id": "user-1",
+                    },
+                    {
+                        "author": "assistant",
+                        "content": (
+                            "This will recreate the Flowent dev container through "
+                            "Docker and may briefly interrupt the running service."
+                        ),
+                        "id": "assistant-1",
+                        "tools": [
+                            {
+                                "arguments": {"command": "docker compose ps"},
+                                "content": "flowent-dev-preview-flowent-1 running",
+                                "data": {},
+                                "id": "tool-1",
+                                "name": "shell_command",
+                                "status": "success",
+                                "title": "Ran docker compose ps",
+                            }
+                        ],
+                    },
+                ]
+            },
+        )
+        response = await client.post(
+            "/api/workspace/runs",
+            json={"content": "确认"},
+        )
+        run_id = response.json()["run_id"]
+        stream_response = await client.get(f"/api/workspace/runs/{run_id}/stream")
+
+    events = stream_events(stream_response.text)
+    assert "tool_error" in [event["event"] for event in events]
+    assert review_payload["user_request"] == "确认"
+    transcript = review_payload["transcript"]
+    assert {"role": "user", "content": "确认"} in transcript
+    assert any(
+        entry["role"] == "assistant" and "briefly interrupt" in entry["content"]
+        for entry in transcript
+    )
+    assert any(
+        entry["role"] == "tool"
+        and entry["name"] == "shell_command"
+        and "flowent-dev-preview-flowent-1" in entry["content"]
+        for entry in transcript
+    )
+
+
 @pytest.mark.anyio
 async def test_workspace_clear_removes_running_run_draft(tmp_path, monkeypatch) -> None:
     monkeypatch.chdir(tmp_path)
@@ -999,3 +1879,244 @@ async def test_workspace_clear_removes_running_run_draft(tmp_path, monkeypatch)
     assert clear_response.status_code == 200
     assert state["messages"] == []
     assert state["active_run_id"] is None
+
+
+def test_workspace_response_uses_compaction_checkpoint_after_restart(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+    captured_requests: list[dict[str, object]] = []
+
+    async def fake_completion(**request: object) -> object:
+        captured_requests.append(request)
+        if len(captured_requests) == 1:
+            return {
+                "choices": [
+                    {
+                        "message": {
+                            "content": "Checkpoint summary survives restarts.",
+                            "role": "assistant",
+                        }
+                    }
+                ]
+            }
+
+        async def chunks() -> object:
+            yield {"choices": [{"delta": {"content": "Continuing."}}]}
+
+        return chunks()
+
+    client = TestClient(
+        create_app(serve_frontend=False, chat_completion=fake_completion)
+    )
+    configure_provider(client)
+    client.put(
+        "/api/workspace/messages",
+        json={
+            "messages": [
+                {"author": "user", "content": "Original request.", "id": "message-1"},
+                {
+                    "author": "assistant",
+                    "content": "Original reply.",
+                    "id": "message-2",
+                },
+            ]
+        },
+    )
+
+    compact_response = client.post("/api/workspace/compact")
+    restarted_client = TestClient(
+        create_app(serve_frontend=False, chat_completion=fake_completion)
+    )
+    response = restarted_client.post(
+        "/api/workspace/respond",
+        json={"content": "Continue after restart."},
+    )
+
+    assert compact_response.status_code == 200
+    assert response.status_code == 200
+    response_messages = captured_requests[1]["messages"]
+    compacted_messages = [
+        message
+        for message in response_messages
+        if str(message["content"]).startswith(
+            "Another language model started working on this Flowent workspace session"
+        )
+    ]
+    assert len(compacted_messages) == 1
+    assert "Checkpoint summary survives restarts." in compacted_messages[0]["content"]
+    assert {"role": "user", "content": "Context compacted"} not in response_messages
+    assert response_messages[-1] == {
+        "role": "user",
+        "content": "Continue after restart.",
+    }
+
+
+def test_workspace_compact_is_unavailable_while_response_is_running(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+    continue_stream = asyncio.Event()
+
+    async def fake_completion(**request: object) -> object:
+        async def chunks() -> object:
+            yield {"choices": [{"delta": {"content": "Partial."}}]}
+            await asyncio.wait_for(continue_stream.wait(), timeout=2)
+            yield {"choices": [{"delta": {"content": " Done."}}]}
+
+        return chunks()
+
+    async def run_test() -> None:
+        app = create_app(serve_frontend=False, chat_completion=fake_completion)
+        async with httpx.AsyncClient(
+            transport=httpx.ASGITransport(app=app), base_url="http://testserver"
+        ) as client:
+            await configure_provider_async(client)
+            response_task = asyncio.create_task(
+                client.post("/api/workspace/respond", json={"content": "Start."})
+            )
+            await asyncio.sleep(0)
+            compact_response = await client.post("/api/workspace/compact")
+            continue_stream.set()
+            response = await response_task
+
+        assert compact_response.status_code == 409
+        assert compact_response.json()["detail"] == (
+            "Compact is unavailable while Flowent is responding."
+        )
+        assert response.status_code == 200
+
+    asyncio.run(run_test())
+
+
+def configured_agent_prompt_message(
+    request: dict[str, object],
+) -> dict[str, object] | None:
+    for message in request["messages"]:
+        if str(message["content"]).startswith("# Flowent configured agent prompt"):
+            return message
+    return None
+
+
+def test_workspace_response_includes_configured_agent_prompt_before_agents_md(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+    (tmp_path / ".git").mkdir()
+    (tmp_path / "AGENTS.md").write_text("Use project instructions.")
+    captured_request: dict[str, object] = {}
+
+    async def fake_completion(**request: object) -> object:
+        captured_request.update(request)
+
+        async def chunks() -> object:
+            yield {"choices": [{"delta": {"content": "Done."}}]}
+
+        return chunks()
+
+    client = TestClient(
+        create_app(serve_frontend=False, chat_completion=fake_completion)
+    )
+    configure_provider(client, agent_prompt="Use UI configured instructions first.")
+
+    response = client.post("/api/workspace/respond", json={"content": "Hello."})
+
+    assert response.status_code == 200
+    configured_message = configured_agent_prompt_message(captured_request)
+    project_message = project_context_message(captured_request)
+    assert configured_message is not None
+    assert project_message is not None
+    assert configured_message["role"] == "system"
+    assert "Use UI configured instructions first." in configured_message["content"]
+    assert "Use project instructions." in project_message["content"]
+    assert captured_request["messages"].index(configured_message) < captured_request[
+        "messages"
+    ].index(project_message)
+
+
+def test_workspace_compacted_response_includes_latest_configured_agent_prompt(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+    captured_requests: list[dict[str, object]] = []
+
+    async def fake_completion(**request: object) -> object:
+        captured_requests.append(request)
+        if len(captured_requests) == 1:
+            return {
+                "choices": [
+                    {
+                        "message": {
+                            "content": "Keep compacted state.",
+                            "role": "assistant",
+                        }
+                    }
+                ]
+            }
+
+        async def chunks() -> object:
+            yield {"choices": [{"delta": {"content": "Done."}}]}
+
+        return chunks()
+
+    client = TestClient(
+        create_app(serve_frontend=False, chat_completion=fake_completion)
+    )
+    configure_provider(client, agent_prompt="Prompt before compact.")
+    client.put(
+        "/api/workspace/messages",
+        json={
+            "messages": [
+                {"author": "user", "content": "Original request.", "id": "message-1"}
+            ]
+        },
+    )
+
+    compact_response = client.post("/api/workspace/compact")
+    client.put(
+        "/api/settings",
+        json={
+            "agent_prompt": "Prompt after compact.",
+            "reasoning_effort": "default",
+            "selected_model": "gpt-5.1",
+            "selected_provider_id": "provider-openai",
+        },
+    )
+    response = client.post("/api/workspace/respond", json={"content": "Continue."})
+
+    assert compact_response.status_code == 200
+    assert response.status_code == 200
+    configured_message = configured_agent_prompt_message(captured_requests[1])
+    assert configured_message is not None
+    assert "Prompt after compact." in configured_message["content"]
+    assert "Prompt before compact." not in configured_message["content"]
+
+
+def test_workspace_response_trims_blank_configured_agent_prompt(
+    tmp_path, monkeypatch
+) -> None:
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("FLOWENT_DATA_DIR", str(tmp_path / "data"))
+    captured_request: dict[str, object] = {}
+
+    async def fake_completion(**request: object) -> object:
+        captured_request.update(request)
+
+        async def chunks() -> object:
+            yield {"choices": [{"delta": {"content": "Done."}}]}
+
+        return chunks()
+
+    client = TestClient(
+        create_app(serve_frontend=False, chat_completion=fake_completion)
+    )
+    configure_provider(client, agent_prompt="\n\n")
+
+    response = client.post("/api/workspace/respond", json={"content": "Hello."})
+
+    assert response.status_code == 200
+    assert configured_agent_prompt_message(captured_request) is None