diff --git a/services/studio/src/nmp/studio/coding_agent_artifacts.py b/services/studio/src/nmp/studio/coding_agent_artifacts.py
index 83d407360d..1a64852223 100644
--- a/services/studio/src/nmp/studio/coding_agent_artifacts.py
+++ b/services/studio/src/nmp/studio/coding_agent_artifacts.py
@@ -165,16 +165,23 @@ def _decode_answer_pair_value(value: str) -> str:
     return decoded if isinstance(decoded, str) else value
 
 
+def answer_selection_pairs(text: str) -> list[tuple[str, str]]:
+    """Return the question and answer pairs persisted by AskUserQuestion."""
+    pairs: list[tuple[str, str]] = []
+    for match in _ANSWER_PAIR_RE.finditer(text):
+        question = _decode_answer_pair_value(match.group(1)).strip()
+        answer = _decode_answer_pair_value(match.group(2)).strip()
+        if question and answer:
+            pairs.append((question, answer))
+    return pairs
+
+
 def record_answer_selections(
     artifacts: ChatArtifactsResponse,
     text: str,
     question_labels: dict[str, str] | None = None,
 ) -> None:
-    for match in _ANSWER_PAIR_RE.finditer(text):
-        question = _decode_answer_pair_value(match.group(1)).strip()
-        answer = _decode_answer_pair_value(match.group(2)).strip()
-        if not question or not answer:
-            continue
+    for question, answer in answer_selection_pairs(text):
         label = question_labels.get(question) if question_labels else None
         _set_selection_artifact(artifacts, label or _selection_label(question), answer)
 
diff --git a/services/studio/src/nmp/studio/coding_agent_mcp_tools.py b/services/studio/src/nmp/studio/coding_agent_mcp_tools.py
index d6d41be457..634f79795f 100644
--- a/services/studio/src/nmp/studio/coding_agent_mcp_tools.py
+++ b/services/studio/src/nmp/studio/coding_agent_mcp_tools.py
@@ -226,12 +226,14 @@
         ),
         (
             "For clarification, multiple-choice, yes/no, or freeform questions that do NOT map to one of "
-            "the select_* tools, use Claude Code's AskUserQuestion tool rather than writing a "
-            "questionnaire in markdown."
+            "the select_* tools, use Claude Code's AskUserQuestion tool rather than a questionnaire "
+            "in markdown."
         ),
         (
-            "Only fall back to plain chat questions when no suitable UI tool is available, the user "
-            "already provided the value, or the UI tool returns skipped or error."
+            "Only fall back to plain chat questions when no suitable UI tool exists, the user already "
+            "provided the value, or the user explicitly skips the UI tool. A timeout, disconnect, or "
+            "other UI-tool error is not permission to continue or repeat the question in plain text; "
+            "leave the input unresolved and tell the user the interactive request must be retried."
         ),
         (
             "Set UI tool titles, descriptions, display labels, and output_key values to match the "
diff --git a/services/studio/src/nmp/studio/coding_agents.py b/services/studio/src/nmp/studio/coding_agents.py
index b9693902cd..bf58cdc1bd 100644
--- a/services/studio/src/nmp/studio/coding_agents.py
+++ b/services/studio/src/nmp/studio/coding_agents.py
@@ -9,7 +9,7 @@
 import os
 import shutil
 import uuid
-from collections.abc import AsyncIterator, Mapping
+from collections.abc import AsyncIterator, Awaitable, Mapping
 from dataclasses import dataclass
 from dataclasses import field as dataclass_field
 from pathlib import Path
@@ -21,6 +21,7 @@
 from nmp.studio import studio_links
 from nmp.studio.coding_agent_artifacts import (
     ChatArtifactsResponse,
+    answer_selection_pairs,
     record_answer_selections,
     record_coding_agent_model,
     record_spec_text_artifacts,
@@ -54,13 +55,18 @@
 
 MCP_ROUTE_NAME = "studio_coding_agent_mcp"
 PUBLIC_MCP_ROUTE_NAME = "studio_coding_agent_public_mcp"
+PUBLIC_MCP_UNSUPPORTED_METHOD_ROUTE_NAME = "studio_coding_agent_public_mcp_unsupported_method"
 PUBLIC_MCP_PATH = "/studio/api/coding-agents/mcp/{session_id}"
+CLAUDE_MCP_TOOL_TIMEOUT_MS = 2_147_483_647
+MCP_KEEPALIVE_INTERVAL_SECONDS = 15
 
 CLAUDE_PROJECTS_DIR = Path.home() / ".claude" / "projects"
 SERVER_CWD = Path(os.getcwd()).resolve()
 STUDIO_CONTEXT_START = "<nemo_studio_context>"
 STUDIO_CONTEXT_END = "</nemo_studio_context>"
 STUDIO_CONTEXT_USER_REQUEST_PREFIX = "User request:"
+STUDIO_MESSAGE_SUMMARY_START = "<<<NEMO_STUDIO_MESSAGE_SUMMARY_V1>>>"
+STUDIO_MESSAGE_SUMMARY_END = "<<<END_NEMO_STUDIO_MESSAGE_SUMMARY_V1>>>"
 
 
 class NewSessionResponse(BaseModel):
@@ -133,6 +139,14 @@ class HistorySummary:
     chat_artifacts: ChatArtifactsResponse = dataclass_field(default_factory=ChatArtifactsResponse)
 
 
+@dataclass(frozen=True)
+class HistoryToolUse:
+    """Tool metadata needed to restore user interactions during history replay."""
+
+    name: str
+    input: dict[str, Any]
+
+
 def _mcp_tools_for_destinations(
     destinations: Mapping[str, studio_links.StudioLinkDestination],
 ) -> list[dict[str, Any]]:
@@ -148,6 +162,13 @@ def mount_public_mcp_route(app: FastAPI) -> None:
         name=PUBLIC_MCP_ROUTE_NAME,
         include_in_schema=False,
     )
+    app.add_api_route(
+        PUBLIC_MCP_PATH,
+        mcp_unsupported_method,
+        methods=["GET", "DELETE"],
+        name=PUBLIC_MCP_UNSUPPORTED_METHOD_ROUTE_NAME,
+        include_in_schema=False,
+    )
 
 
 def _validate_session_id(session_id: str) -> str:
@@ -290,10 +311,31 @@ def _build_studio_system_prompt(
         "Whenever you need a fileset, fileset reference, dataset, or input/source data file (including an anonymizer or evaluation input, or a CSV/Parquet file), you MUST call mcp__nemo_studio__select_dataset_file instead of asking for a fileset reference or '<workspace>/<fileset>#<file>' path in plain text; for an evaluation config file, you MUST call mcp__nemo_studio__select_eval_config.",
         "Treat 'which agent', 'pick an agent', 'choose a model', 'which fileset', and 'what is your fileset reference' as mandatory tool-use requests for the matching select_* tool, exactly like Studio link requests are mandatory studio_link requests.",
         "Set the picker title and description to match the current workflow, for example title='Select agent to audit'.",
-        "Only skip a picker when the user already gave the value, the value is already unambiguous from the conversation, or a previous picker call returned skipped or error.",
+        "Only skip a picker when the user already gave the value, the value is already unambiguous from the conversation, or the user explicitly skipped a previous picker.",
+        "A timeout, disconnect, or other interactive-tool error is not permission to continue or repeat the question in plain text. Leave the input unresolved and tell the user the interactive request must be retried.",
+        "A message that needs user input is not complete until you call the matching Studio input tool. Never end a message with only a plain-text question when an interactive tool applies.",
+        "In particular, if you need an agent, model, dataset file, or evaluation config, call the matching select_* tool before completing the message; mentioning the needed selection in prose is not a substitute for the tool call.",
         "For finite choices that have no dedicated Studio picker (for example deployments, jobs, or next actions) and for yes/no or multiple-choice clarifications, use Claude Code's AskUserQuestion tool so Studio can render clickable options instead of asking the user to type.",
         "For AskUserQuestion, provide input shaped as {'questions': [{'header': '<short title>', 'question': '<what should the user choose?>', 'options': [{'label': '<option>', 'description': '<short impact/details>'}]}]}.",
         "If you need both a finite choice and free-form text, ask multiple AskUserQuestion questions: first the finite options, then a text question without options.",
+        "Required message-summary behavior:",
+        "At the end of every assistant message to the user, include a short Studio summary block after your normal detailed work.",
+        f"Start the summary block on its own line with {STUDIO_MESSAGE_SUMMARY_START} and end it on its own line with {STUDIO_MESSAGE_SUMMARY_END}.",
+        "Inside the summary block, use exactly these fields on separate lines:",
+        f"{STUDIO_MESSAGE_SUMMARY_START}",
+        "worked_for: <elapsed time if you know it, otherwise unknown>",
+        "summary: <concise Markdown, at most 60 words, describing the user-visible result and current state>",
+        "details_label: worked for <same elapsed time or unknown>",
+        f"{STUDIO_MESSAGE_SUMMARY_END}",
+        "Keep detailed explanation, command output, tool logs, diffs, and step-by-step work outside the summary block and before it.",
+        "Do not put raw command output, code diffs, tool logs, or long reasoning inside the summary block.",
+        "Format the summary as valid Markdown. When it contains multiple suggestions, results, or steps, put a blank line after 'summary:' and use a numbered or bulleted list rather than flattening the items into prose.",
+        "If the detailed message body contains any Markdown links, repeat those links at the bottom of the summary so they remain visible when the details are collapsed.",
+        "Put repeated links on separate lines without a heading and without formatting them as a bulleted or numbered list.",
+        "Studio will use this block to collapse everything before it behind a 'worked for <time>' accordion and show only the short summary by default.",
+        "When you are interrupted by a permission request, input request, or need to ask the user something, still include the summary block describing what happened so far and what you need next.",
+        "When user input is still required, the summary's final sentence MUST state the exact unresolved selection or action, for example 'Select an agent to continue.' Never show only the investigation result while hiding the request for input in the collapsed details.",
+        "Do not omit the summary block because the message is short.",
         "Prefer NeMo Studio MCP tools and Studio views over CLI commands for user-facing follow-up actions, navigation, inspection, and status/result review.",
         "Do not tell the user to run nemo CLI commands, shell commands, curl commands, or status commands to inspect agents, jobs, evaluations, filesets, models, traces, logs, or results when a Studio view, Studio link, or Studio progress card is available for the same purpose.",
         "Use CLI commands only to perform work that has no Studio UI equivalent, when the user explicitly asks for CLI/debugging, or when you must gather data that Studio tools cannot provide.",
@@ -565,6 +607,80 @@ def list_history_sessions() -> list[HistorySessionResponse]:
     return sessions
 
 
+def _history_tool_result_text(content: Any) -> str | None:
+    if isinstance(content, str):
+        return _trimmed_string(content)
+    if not isinstance(content, list):
+        return None
+    text_parts = [
+        text for part in content if isinstance(part, dict) and (text := _trimmed_string(part.get("text"))) is not None
+    ]
+    return "\n".join(text_parts) or None
+
+
+def _history_interaction_text(tool_use: HistoryToolUse, result_text: str) -> str | None:
+    short_name = tool_use.name.rsplit("__", maxsplit=1)[-1]
+    if tool_use.name == "AskUserQuestion" or short_name == "ask_user_question":
+        try:
+            result_value = json.loads(result_text)
+        except json.JSONDecodeError:
+            result_value = None
+        if isinstance(result_value, dict):
+            result_text = _trimmed_string(result_value.get("response")) or result_text
+        pairs = answer_selection_pairs(result_text)
+        return "\n\n".join(f"{question}\n{answer}" for question, answer in pairs) or None
+
+    try:
+        result = json.loads(result_text)
+    except json.JSONDecodeError:
+        return None
+    if not isinstance(result, dict) or result.get("status") != "submitted":
+        return None
+
+    if short_name == SELECT_AGENT_TOOL_NAME:
+        agent = _trimmed_string(result.get("agent"))
+        return f"Selected agent: {agent}" if agent else None
+    if short_name == SELECT_MODEL_TOOL_NAME:
+        output_key = _trimmed_string(tool_use.input.get("output_key")) or "model"
+        model = _trimmed_string(result.get(output_key))
+        display_label = _trimmed_string(tool_use.input.get("display_label")) or "Selected model"
+        return f"{display_label}: {model}" if model else None
+    if short_name == SELECT_DATASET_FILE_TOOL_NAME:
+        fileset = _trimmed_string(result.get("dataset_fileset"))
+        path = _trimmed_string(result.get("dataset_path"))
+        return f"Selected dataset: {fileset}/{path}" if fileset and path else None
+    if short_name == SELECT_EVAL_CONFIG_TOOL_NAME:
+        if result.get("needs_eval_config") is True:
+            return "I don't have an evaluation config yet"
+        if result.get("use_sample_eval_config") is True:
+            return "Use sample evaluation config"
+        fileset = _trimmed_string(result.get("eval_config_fileset"))
+        path = _trimmed_string(result.get("eval_config"))
+        return f"Selected eval config: {fileset}/{path}" if fileset and path else None
+    return None
+
+
+def _history_user_interaction_texts(
+    content: Any,
+    tool_uses: dict[str, HistoryToolUse],
+) -> list[str]:
+    if not isinstance(content, list):
+        return []
+    texts: list[str] = []
+    for part in content:
+        if not isinstance(part, dict) or part.get("type") != "tool_result":
+            continue
+        tool_use_id = _trimmed_string(part.get("tool_use_id"))
+        tool_use = tool_uses.get(tool_use_id) if tool_use_id else None
+        result_text = _history_tool_result_text(part.get("content"))
+        if tool_use is None or result_text is None:
+            continue
+        display_text = _history_interaction_text(tool_use, result_text)
+        if display_text:
+            texts.append(display_text)
+    return texts
+
+
 @router.get("/history/sessions/{session_id}", response_model=SessionHistoryResponse)
 def get_session_history(session_id: str) -> SessionHistoryResponse:
     """Load Claude session history for chat replay."""
@@ -575,6 +691,7 @@ def get_session_history(session_id: str) -> SessionHistoryResponse:
 
     items: list[dict[str, Any]] = []
     summary = _summarize_history_session(path)
+    tool_uses: dict[str, HistoryToolUse] = {}
     try:
         with path.open("r", encoding="utf-8", errors="replace") as fh:
             for line in fh:
@@ -595,10 +712,24 @@ def get_session_history(session_id: str) -> SessionHistoryResponse:
                     if isinstance(content, str) and content:
                         content = _strip_studio_context_from_prompt(content)
                         items.append({"kind": "user", "text": content})
+                    else:
+                        items.extend(
+                            {"kind": "user", "text": text}
+                            for text in _history_user_interaction_texts(content, tool_uses)
+                        )
                 elif entry_type == "assistant" and isinstance(message, dict):
                     parts = _extract_assistant_parts(message.get("content"))
                     if parts:
                         items.append({"kind": "assistant", "parts": parts})
+                    for part in parts:
+                        tool_use_id = _trimmed_string(part.get("id"))
+                        tool_name = _trimmed_string(part.get("name"))
+                        tool_input = part.get("input")
+                        if tool_use_id and tool_name:
+                            tool_uses[tool_use_id] = HistoryToolUse(
+                                name=tool_name,
+                                input=tool_input if isinstance(tool_input, dict) else {},
+                            )
     except OSError as exc:
         raise HTTPException(status_code=500, detail=str(exc)) from exc
 
@@ -647,6 +778,10 @@ def _build_claude_argv(
                 CLAUDE_MCP_SERVER_NAME: {
                     "type": "http",
                     "url": mcp_url,
+                    # Studio input tools intentionally stay open until the user responds. Use the
+                    # largest safe JavaScript timer value so Claude Code does not apply its
+                    # otherwise-observed 60-second per-server tool timeout.
+                    "timeout": CLAUDE_MCP_TOOL_TIMEOUT_MS,
                 }
             }
         }
@@ -688,6 +823,60 @@ def _sse(data: str, event: str | None = None) -> str:
     return f"{prefix}data: {data}\n\n"
 
 
+def _mcp_tool_result_payload(request_id: Any, result: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "jsonrpc": "2.0",
+        "id": request_id,
+        "result": {
+            "content": [{"type": "text", "text": json.dumps(result)}],
+        },
+    }
+
+
+async def _stream_mcp_tool_result(
+    request_id: Any,
+    result: Awaitable[dict[str, Any]],
+) -> AsyncIterator[str]:
+    """Keep a blocking MCP HTTP call alive until Studio receives user input."""
+    task = asyncio.ensure_future(result)
+    try:
+        # Flush the SSE response headers immediately, then send comments often enough to keep
+        # reverse proxies from treating the user-driven request as an idle connection.
+        yield ": keepalive\n\n"
+        while not task.done():
+            done, _ = await asyncio.wait({task}, timeout=MCP_KEEPALIVE_INTERVAL_SECONDS)
+            if not done:
+                yield ": keepalive\n\n"
+
+        payload = _mcp_tool_result_payload(request_id, await task)
+        yield _sse(json.dumps(payload, separators=(",", ":")), event="message")
+    finally:
+        if not task.done():
+            task.cancel()
+            try:
+                await task
+            except asyncio.CancelledError:
+                pass
+
+
+async def _blocking_mcp_tool_response(
+    session_id: str,
+    request_id: Any,
+    result: Awaitable[dict[str, Any]],
+) -> Response:
+    if session_id not in _session_streams:
+        return JSONResponse(_mcp_tool_result_payload(request_id, await result))
+
+    return StreamingResponse(
+        _stream_mcp_tool_result(request_id, result),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache, no-transform",
+            "X-Accel-Buffering": "no",
+        },
+    )
+
+
 async def _request_permission(session_id: str, args: dict[str, Any]) -> dict[str, Any]:
     queue = _session_streams.get(session_id)
     if queue is None:
@@ -709,10 +898,7 @@ async def _request_permission(session_id: str, args: dict[str, Any]) -> dict[str
     await queue.put(("permission_request", payload))
 
     try:
-        decision = await asyncio.wait_for(future, timeout=300)
-    except asyncio.TimeoutError:
-        await queue.put(("permission_expired", json.dumps({"request_id": request_id})))
-        return {"behavior": "deny", "message": "permission request timed out"}
+        decision = await future
     finally:
         _pending_permissions.pop(request_id, None)
 
@@ -744,10 +930,7 @@ async def _request_agent_input(session_id: str, kind: str, args: dict[str, Any])
     await queue.put(("input_request", payload))
 
     try:
-        decision = await asyncio.wait_for(future, timeout=300)
-    except asyncio.TimeoutError:
-        await queue.put(("input_expired", json.dumps({"request_id": request_id})))
-        return {"status": "error", "message": "input request timed out"}
+        decision = await future
     finally:
         _pending_agent_inputs.pop(request_id, None)
 
@@ -990,51 +1173,31 @@ async def mcp_endpoint(session_id: str, request: Request) -> Response:
             return JSONResponse(status_code=400, content={"detail": "tool arguments must be an object"})
 
         if name == SELECT_AGENT_TOOL_NAME:
-            result = await _request_agent_input(sid, "agent", args)
-            return JSONResponse(
-                {
-                    "jsonrpc": "2.0",
-                    "id": request_id,
-                    "result": {
-                        "content": [{"type": "text", "text": json.dumps(result)}],
-                    },
-                }
+            return await _blocking_mcp_tool_response(
+                sid,
+                request_id,
+                _request_agent_input(sid, "agent", args),
             )
 
         if name == SELECT_EVAL_CONFIG_TOOL_NAME:
-            result = await _request_agent_input(sid, "eval_config", args)
-            return JSONResponse(
-                {
-                    "jsonrpc": "2.0",
-                    "id": request_id,
-                    "result": {
-                        "content": [{"type": "text", "text": json.dumps(result)}],
-                    },
-                }
+            return await _blocking_mcp_tool_response(
+                sid,
+                request_id,
+                _request_agent_input(sid, "eval_config", args),
             )
 
         if name == SELECT_DATASET_FILE_TOOL_NAME:
-            result = await _request_agent_input(sid, "dataset_file", args)
-            return JSONResponse(
-                {
-                    "jsonrpc": "2.0",
-                    "id": request_id,
-                    "result": {
-                        "content": [{"type": "text", "text": json.dumps(result)}],
-                    },
-                }
+            return await _blocking_mcp_tool_response(
+                sid,
+                request_id,
+                _request_agent_input(sid, "dataset_file", args),
             )
 
         if name == SELECT_MODEL_TOOL_NAME:
-            result = await _request_agent_input(sid, "model", args)
-            return JSONResponse(
-                {
-                    "jsonrpc": "2.0",
-                    "id": request_id,
-                    "result": {
-                        "content": [{"type": "text", "text": json.dumps(result)}],
-                    },
-                }
+            return await _blocking_mcp_tool_response(
+                sid,
+                request_id,
+                _request_agent_input(sid, "model", args),
             )
 
         if name == JOB_PROGRESS_TOOL_NAME:
@@ -1049,15 +1212,10 @@ async def mcp_endpoint(session_id: str, request: Request) -> Response:
             )
 
         if name == APPROVAL_TOOL_NAME:
-            result = await _request_permission(sid, args)
-            return JSONResponse(
-                {
-                    "jsonrpc": "2.0",
-                    "id": request_id,
-                    "result": {
-                        "content": [{"type": "text", "text": json.dumps(result)}],
-                    },
-                }
+            return await _blocking_mcp_tool_response(
+                sid,
+                request_id,
+                _request_permission(sid, args),
             )
 
         if name == STUDIO_LINK_TOOL_NAME:
@@ -1090,3 +1248,10 @@ async def mcp_endpoint(session_id: str, request: Request) -> Response:
             "error": {"code": -32601, "message": f"method not found: {method}"},
         }
     )
+
+
+@router.api_route("/mcp/{session_id}", methods=["GET", "DELETE"], include_in_schema=False)
+async def mcp_unsupported_method(session_id: str) -> Response:
+    """Decline optional MCP SSE/session methods without falling through to Studio HTML."""
+    _validate_session_id(session_id)
+    return Response(status_code=405, headers={"Allow": "POST"})
diff --git a/services/studio/tests/unit/test_coding_agents.py b/services/studio/tests/unit/test_coding_agents.py
index 975ecd8209..a497693204 100644
--- a/services/studio/tests/unit/test_coding_agents.py
+++ b/services/studio/tests/unit/test_coding_agents.py
@@ -119,6 +119,12 @@ def test_build_claude_argv_uses_new_session_then_resume_flag():
     assert argv[:3] == ["claude", "-p", "hello"]
     assert "--output-format" in argv
     assert "stream-json" in argv
+    mcp_config = json.loads(argv[argv.index("--mcp-config") + 1])
+    assert mcp_config["mcpServers"][coding_agents.CLAUDE_MCP_SERVER_NAME] == {
+        "type": "http",
+        "url": "http://test/mcp",
+        "timeout": coding_agents.CLAUDE_MCP_TOOL_TIMEOUT_MS,
+    }
     assert "--allowedTools" in argv
     allowed_tools = argv[argv.index("--allowedTools") + 1].split(",")
     assert f"mcp__{coding_agents.CLAUDE_MCP_SERVER_NAME}__select_agent" in allowed_tools
@@ -127,6 +133,7 @@ def test_build_claude_argv_uses_new_session_then_resume_flag():
     assert f"mcp__{coding_agents.CLAUDE_MCP_SERVER_NAME}__select_model" in allowed_tools
     assert f"mcp__{coding_agents.CLAUDE_MCP_SERVER_NAME}__job_progress" in allowed_tools
     assert f"mcp__{coding_agents.CLAUDE_MCP_SERVER_NAME}__studio_link" in allowed_tools
+    assert "--disallowedTools" not in argv
     assert "--append-system-prompt" in argv
     assert argv[argv.index("--append-system-prompt") + 1] == coding_agents.STUDIO_CODING_AGENT_CONTEXT
     assert "--permission-prompt-tool" in argv
@@ -408,6 +415,7 @@ def test_list_and_get_history_sessions(
                     },
                 ],
             },
+            {"kind": "user", "text": "Which agent should be used?\nbeach-finder"},
             {
                 "kind": "assistant",
                 "parts": [
@@ -478,6 +486,50 @@ def test_list_claude_skills_returns_claude_install_metadata(
     assert response.json() == [_expected_inference_skill_response(installed=True)]
 
 
+@pytest.mark.parametrize(
+    ("tool_name", "tool_input", "result", "expected"),
+    [
+        (
+            "mcp__nemo_studio__select_agent",
+            {},
+            '{"status":"submitted","agent":"beach-finder"}',
+            "Selected agent: beach-finder",
+        ),
+        (
+            "mcp__nemo_studio__select_model",
+            {"display_label": "Fallback model", "output_key": "fallback_model"},
+            '{"status":"submitted","fallback_model":"nemotron"}',
+            "Fallback model: nemotron",
+        ),
+        (
+            "mcp__nemo_studio__select_dataset_file",
+            {},
+            '{"status":"submitted","dataset_fileset":"eval-data","dataset_path":"input.jsonl"}',
+            "Selected dataset: eval-data/input.jsonl",
+        ),
+        (
+            "mcp__nemo_studio__select_eval_config",
+            {},
+            '{"status":"submitted","needs_eval_config":true}',
+            "I don't have an evaluation config yet",
+        ),
+    ],
+)
+def test_history_interaction_text_restores_studio_picker_submissions(
+    tool_name: str,
+    tool_input: dict[str, Any],
+    result: str,
+    expected: str,
+):
+    assert (
+        coding_agents._history_interaction_text(
+            coding_agents.HistoryToolUse(name=tool_name, input=tool_input),
+            result,
+        )
+        == expected
+    )
+
+
 def test_load_claude_skills_falls_back_on_duplicate_skill_error(
     tmp_path: Path,
     monkeypatch: pytest.MonkeyPatch,
@@ -632,6 +684,34 @@ def test_build_studio_system_prompt_preserves_empty_enabled_destinations():
     assert destinations_line == "Enabled Studio link destinations for this Studio instance: ."
 
 
+def test_build_studio_system_prompt_includes_message_summary_contract():
+    prompt = coding_agents._build_studio_system_prompt(
+        "default",
+        "https://studio.test",
+        "/workspaces/default/dashboard/code-agent",
+        {},
+    )
+
+    assert "Required message-summary behavior:" in prompt
+    assert coding_agents.STUDIO_MESSAGE_SUMMARY_START in prompt
+    assert coding_agents.STUDIO_MESSAGE_SUMMARY_END in prompt
+    assert "worked_for: <elapsed time if you know it, otherwise unknown>" in prompt
+    assert "summary: <concise Markdown" in prompt
+    assert "details_label: worked for <same elapsed time or unknown>" in prompt
+    assert "behind a 'worked for <time>' accordion" in prompt
+    assert "Never end a message with only a plain-text question" in prompt
+    assert "call the matching select_* tool before completing the message" in prompt
+    assert "use Claude Code's AskUserQuestion tool" in prompt
+    assert "For AskUserQuestion, provide input shaped as" in prompt
+    assert "A timeout, disconnect, or other interactive-tool error is not permission to continue" in prompt
+    assert "summary's final sentence MUST state the exact unresolved selection or action" in prompt
+    assert "Never show only the investigation result" in prompt
+    assert "use a numbered or bulleted list" in prompt
+    assert "repeat those links at the bottom of the summary" in prompt
+    assert "Put repeated links on separate lines without a heading" in prompt
+    assert "Do not omit the summary block because the message is short." in prompt
+
+
 def test_studio_link_destinations_cover_registered_workspace_routes():
     repo_root = Path(__file__).resolve().parents[4]
     routes_index = (repo_root / "web/packages/studio/src/routes/index.tsx").read_text()
@@ -1282,6 +1362,81 @@ async def test_request_agent_input_rejects_reserved_response_keys():
     }
 
 
+async def test_permission_request_waits_until_user_resolves_it():
+    session_id = str(uuid.uuid4())
+    coding_agents._session_streams[session_id] = asyncio.Queue()
+
+    request_task = asyncio.create_task(
+        coding_agents._request_permission(
+            session_id,
+            {"tool_name": "AskUserQuestion", "input": {"question": "Continue?"}},
+        )
+    )
+    _, payload = await coding_agents._session_streams[session_id].get()
+    request_id = json.loads(payload)["request_id"]
+
+    await asyncio.sleep(0)
+    assert not request_task.done()
+
+    await coding_agents.resolve_permission(
+        session_id,
+        request_id,
+        coding_agents.PermissionDecision(approved=True),
+    )
+
+    assert await request_task == {"behavior": "allow", "updatedInput": {"question": "Continue?"}}
+
+
+async def test_agent_input_request_cleans_up_when_wait_is_cancelled():
+    session_id = str(uuid.uuid4())
+    coding_agents._session_streams[session_id] = asyncio.Queue()
+
+    request_task = asyncio.create_task(coding_agents._request_agent_input(session_id, "agent", {}))
+    _, payload = await coding_agents._session_streams[session_id].get()
+    request_id = json.loads(payload)["request_id"]
+
+    assert request_id in coding_agents._pending_agent_inputs
+    request_task.cancel()
+    with pytest.raises(asyncio.CancelledError):
+        await request_task
+    assert request_id not in coding_agents._pending_agent_inputs
+
+
+async def test_blocking_mcp_tool_response_streams_keepalives_until_user_responds():
+    session_id = str(uuid.uuid4())
+    coding_agents._session_streams[session_id] = asyncio.Queue()
+    result = asyncio.get_running_loop().create_future()
+
+    response = await coding_agents._blocking_mcp_tool_response(session_id, 7, result)
+
+    assert response.media_type == "text/event-stream"
+    assert response.headers["cache-control"] == "no-cache, no-transform"
+    assert response.headers["x-accel-buffering"] == "no"
+
+    iterator = response.body_iterator
+    assert await anext(iterator) == ": keepalive\n\n"
+
+    result.set_result({"status": "answered", "response": "A detailed answer"})
+    final_event = await anext(iterator)
+    assert final_event.startswith("event: message\ndata: ")
+    payload = json.loads(final_event.removeprefix("event: message\ndata: ").removesuffix("\n\n"))
+    assert payload == {
+        "jsonrpc": "2.0",
+        "id": 7,
+        "result": {
+            "content": [
+                {
+                    "type": "text",
+                    "text": json.dumps({"status": "answered", "response": "A detailed answer"}),
+                }
+            ]
+        },
+    }
+
+    with pytest.raises(StopAsyncIteration):
+        await anext(iterator)
+
+
 def test_platform_route_stream_uses_public_mcp_callback(monkeypatch: pytest.MonkeyPatch):
     service = StudioService()
     app = FastAPI()
@@ -1423,6 +1578,8 @@ def test_public_mcp_route_is_mounted_before_static_fallback():
         f"/studio/api/coding-agents/mcp/{session_id}",
         json={"jsonrpc": "2.0", "id": 1, "method": "tools/list"},
     )
+    get_response = client.get(f"/studio/api/coding-agents/mcp/{session_id}")
+    delete_response = client.delete(f"/studio/api/coding-agents/mcp/{session_id}")
 
     assert response.status_code == 200
     assert [tool["name"] for tool in response.json()["result"]["tools"]] == [
@@ -1434,6 +1591,10 @@ def test_public_mcp_route_is_mounted_before_static_fallback():
         "job_progress",
         "studio_link",
     ]
+    assert get_response.status_code == 405
+    assert get_response.headers["allow"] == "POST"
+    assert delete_response.status_code == 405
+    assert delete_response.headers["allow"] == "POST"
 
 
 def test_coding_agent_routes_are_available_by_default():
diff --git a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/ClaudeCodeHistoryPanel.test.tsx b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/ClaudeCodeHistoryPanel.test.tsx
index ddacfe15bd..92bf90fce6 100644
--- a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/ClaudeCodeHistoryPanel.test.tsx
+++ b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/ClaudeCodeHistoryPanel.test.tsx
@@ -107,12 +107,34 @@ describe('ClaudeCodeHistoryPanel', () => {
     );
 
     expect(screen.getByText('Jobs')).toBeInTheDocument();
+    expect(screen.queryByText('Workspace')).not.toBeInTheDocument();
     expect(screen.getByRole('link', { name: /agent-eval-1/ })).toHaveAttribute(
       'href',
       '/workspaces/default/agents/evaluations/agent-eval-1'
     );
   });
 
+  it('does not treat workspace metadata as a visible chat artifact', () => {
+    render(
+      <ClaudeCodeHistoryPanel
+        activeSessionId="session-1"
+        artifacts={{
+          workspace: 'default',
+          selections: [],
+          files: [],
+          links: [],
+          jobs: [],
+          tools: [],
+        }}
+        onNewChat={vi.fn()}
+        onSelectSession={vi.fn()}
+      />
+    );
+
+    expect(screen.queryByText('Workspace')).not.toBeInTheDocument();
+    expect(screen.getByText('No artifacts yet')).toBeInTheDocument();
+  });
+
   it('lists Claude Code skills in the skills tab', async () => {
     const user = userEvent.setup();
     render(
diff --git a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/ClaudeCodeToolCallPart.test.tsx b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/ClaudeCodeToolCallPart.test.tsx
index e0b5a21fe0..4100bf73ce 100644
--- a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/ClaudeCodeToolCallPart.test.tsx
+++ b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/ClaudeCodeToolCallPart.test.tsx
@@ -7,6 +7,7 @@ import {
   CLAUDE_CODE_JOB_PROGRESS_TOOL_NAME,
 } from '@studio/routes/agents/ClaudeCodeChatRoute/jobProgressConsts';
 import {
+  CLAUDE_CODE_COLLAPSED_STUDIO_DETAILS_TOOL_NAME,
   CLAUDE_CODE_COLLAPSED_THINKING_TOOL_NAME,
   CLAUDE_CODE_SUBTLE_TOOL_GROUP_NAME,
 } from '@studio/routes/agents/ClaudeCodeChatRoute/toolParts';
@@ -111,6 +112,63 @@ const expectFileChangeBlockFullWidth = () => {
 };
 
 describe('ClaudeCodeToolCallPart', () => {
+  it('renders Studio summary details behind a worked-for disclosure', async () => {
+    const user = userEvent.setup();
+
+    render(
+      <ClaudeCodeToolCallPart
+        addResult={vi.fn()}
+        args={{
+          label: 'worked for 42s',
+          parts: [
+            {
+              type: 'text',
+              text: [
+                '## Optimization report',
+                '',
+                '**Current config:** `meta-llama-3-1-70b-instruct`',
+                '',
+                '- Preserved first suggestion',
+                '- Preserved second suggestion',
+              ].join('\n'),
+            },
+            {
+              type: 'tool-call',
+              args: { command: 'pwd' },
+              argsText: '{"command":"pwd"}',
+              toolCallId: 'toolu_bash',
+              toolName: 'Bash',
+            },
+          ],
+        }}
+        argsText=""
+        resume={vi.fn()}
+        status={{ type: 'complete' }}
+        toolCallId="claude-code-collapsed-studio-details"
+        toolName={CLAUDE_CODE_COLLAPSED_STUDIO_DETAILS_TOOL_NAME}
+        type="tool-call"
+      />
+    );
+
+    const disclosure = screen.getByTestId('claude-code-collapsed-studio-details');
+    expect(disclosure).toHaveTextContent('worked for 42s');
+    expect(disclosure).not.toHaveAttribute('open');
+    expect(screen.getByTestId('claude-code-collapsed-studio-details-content')).toHaveTextContent(
+      'Optimization report'
+    );
+    expect(screen.getByTestId('claude-code-collapsed-studio-details-content')).toHaveTextContent(
+      'Ran pwd'
+    );
+
+    await user.click(screen.getByText('worked for 42s'));
+
+    expect(disclosure).toHaveAttribute('open');
+    expect(screen.getByRole('heading', { level: 2, name: 'Optimization report' })).toBeVisible();
+    expect(screen.getByText('Current config:')).toHaveProperty('tagName', 'STRONG');
+    expect(screen.getByText('meta-llama-3-1-70b-instruct')).toHaveProperty('tagName', 'CODE');
+    expect(screen.getAllByRole('listitem')[0]).toHaveTextContent('Preserved first suggestion');
+  });
+
   it('renders collapsed thinking as an expandable subtle disclosure', async () => {
     const user = userEvent.setup();
 
@@ -144,6 +202,27 @@ describe('ClaudeCodeToolCallPart', () => {
     );
   });
 
+  it('replaces a persisted unknown work time with a neutral label', () => {
+    render(
+      <ClaudeCodeToolCallPart
+        addResult={vi.fn()}
+        args={{
+          label: 'worked for unknown',
+          parts: [{ type: 'text', text: 'Completed work.' }],
+        }}
+        argsText=""
+        resume={vi.fn()}
+        status={{ type: 'complete' }}
+        toolCallId="claude-code-collapsed-studio-details"
+        toolName={CLAUDE_CODE_COLLAPSED_STUDIO_DETAILS_TOOL_NAME}
+        type="tool-call"
+      />
+    );
+
+    expect(screen.getByText('Work details')).toBeVisible();
+    expect(screen.queryByText('worked for unknown')).not.toBeInTheDocument();
+  });
+
   it.each(subtleToolCases)(
     'renders $toolName as subtle text',
     ({ args, expectedText, toolName }) => {
diff --git a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/ClaudeCodeToolCallPart.tsx b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/ClaudeCodeToolCallPart.tsx
index 50370bcaad..7de7360ee5 100644
--- a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/ClaudeCodeToolCallPart.tsx
+++ b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/ClaudeCodeToolCallPart.tsx
@@ -2,6 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type { ToolCallMessagePartComponent } from '@assistant-ui/react';
+import { MessageContent } from '@nemo/common/src/components/Chat/MessageContent';
+import { Text } from '@nvidia/foundations-react-core';
+import { ClaudeCodeStudioLink } from '@studio/routes/agents/ClaudeCodeChatRoute/ClaudeCodeStudioLink';
 import { JobProgressToolCall } from '@studio/routes/agents/ClaudeCodeChatRoute/JobProgressToolCall';
 import { CollapsedThinkingToolCall } from '@studio/routes/agents/ClaudeCodeChatRoute/toolCall/CollapsedThinkingToolCall';
 import { TOOL_LABELS } from '@studio/routes/agents/ClaudeCodeChatRoute/toolCall/constants';
@@ -18,11 +21,15 @@ import {
 } from '@studio/routes/agents/ClaudeCodeChatRoute/toolCall/helpers';
 import { SubtleToolCallRow } from '@studio/routes/agents/ClaudeCodeChatRoute/toolCall/SubtleToolCallRow';
 import {
+  CLAUDE_CODE_COLLAPSED_STUDIO_DETAILS_TOOL_NAME,
   CLAUDE_CODE_COLLAPSED_THINKING_TOOL_NAME,
   CLAUDE_CODE_SUBTLE_TOOL_GROUP_NAME,
+  CLAUDE_CODE_WORK_DETAILS_LABEL,
   isClaudeCodeJobProgressToolName,
+  toClaudeCodeToolArgs,
   type ClaudeCodeToolArgs,
 } from '@studio/routes/agents/ClaudeCodeChatRoute/toolParts';
+import { ChevronRight, ClipboardList } from 'lucide-react';
 
 interface ClaudeCodeToolCallPartContentProps {
   readonly args: ClaudeCodeToolArgs;
@@ -31,12 +38,128 @@ interface ClaudeCodeToolCallPartContentProps {
   readonly toolName: string;
 }
 
+interface CollapsedStudioDetailsTextPart {
+  readonly text: string;
+  readonly type: 'text';
+}
+
+interface CollapsedStudioDetailsToolPart {
+  readonly args: ClaudeCodeToolArgs;
+  readonly argsText: string;
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly type: 'tool-call';
+}
+
+type CollapsedStudioDetailsPart = CollapsedStudioDetailsTextPart | CollapsedStudioDetailsToolPart;
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value);
+
+const getCollapsedStudioDetailsParts = (
+  args: ClaudeCodeToolArgs
+): readonly CollapsedStudioDetailsPart[] => {
+  const parts = args.parts;
+  if (!Array.isArray(parts)) return [];
+
+  return parts
+    .map((part): CollapsedStudioDetailsPart | undefined => {
+      if (!isRecord(part)) return undefined;
+
+      if (part.type === 'text' && typeof part.text === 'string' && part.text.trim()) {
+        return { type: 'text', text: part.text };
+      }
+
+      if (
+        part.type === 'tool-call' &&
+        typeof part.toolName === 'string' &&
+        typeof part.toolCallId === 'string'
+      ) {
+        const toolArgs = isRecord(part.args) ? toClaudeCodeToolArgs(part.args) : {};
+        return {
+          type: 'tool-call',
+          args: toolArgs,
+          argsText: typeof part.argsText === 'string' ? part.argsText : JSON.stringify(toolArgs),
+          toolCallId: part.toolCallId,
+          toolName: part.toolName,
+        };
+      }
+
+      return undefined;
+    })
+    .filter((part): part is CollapsedStudioDetailsPart => part !== undefined);
+};
+
+const CollapsedStudioDetailsText = ({ text }: { readonly text: string }) => (
+  <MessageContent content={text} markdownLinkComponent={ClaudeCodeStudioLink} />
+);
+
+const CollapsedStudioDetailsPartContent = ({
+  part,
+}: {
+  readonly part: CollapsedStudioDetailsPart;
+}) => {
+  if (part.type === 'text') return <CollapsedStudioDetailsText text={part.text} />;
+
+  return (
+    <ClaudeCodeToolCallPartContent
+      args={part.args}
+      argsText={part.argsText}
+      isRunning={false}
+      toolName={part.toolName}
+    />
+  );
+};
+
+const CollapsedStudioDetailsToolCall = ({ args }: { readonly args: ClaudeCodeToolArgs }) => {
+  const storedLabel = getStringArg(args, ['label']);
+  const label =
+    !storedLabel || storedLabel.toLowerCase() === 'worked for unknown'
+      ? CLAUDE_CODE_WORK_DETAILS_LABEL
+      : storedLabel;
+  const parts = getCollapsedStudioDetailsParts(args);
+  if (!parts.length) return null;
+
+  return (
+    <Text asChild kind="body/regular/sm">
+      <details
+        className="group/studio-details my-density-xs max-w-full text-gray-500 dark:text-gray-400"
+        data-testid="claude-code-collapsed-studio-details"
+      >
+        <summary className="inline-flex cursor-pointer list-none items-center gap-density-xs marker:hidden">
+          <ChevronRight
+            aria-hidden
+            className="size-3 shrink-0 transition-transform group-open/studio-details:rotate-90"
+          />
+          <ClipboardList aria-hidden className="size-3.5 shrink-0" />
+          <span>{label}</span>
+        </summary>
+        <div
+          className="mt-density-xs space-y-density-xs border-l border-base pl-density-md text-secondary"
+          data-testid="claude-code-collapsed-studio-details-content"
+        >
+          {parts.map((part, index) => (
+            <CollapsedStudioDetailsPartContent
+              key={`${part.type}-${part.type === 'text' ? part.text.slice(0, 24) : part.toolCallId}-${index}`}
+              part={part}
+            />
+          ))}
+        </div>
+      </details>
+    </Text>
+  );
+};
+
 const ClaudeCodeToolCallPartContent = ({
   args,
   argsText,
   toolName,
   isRunning = false,
 }: ClaudeCodeToolCallPartContentProps) => {
+  if (toolName === CLAUDE_CODE_COLLAPSED_STUDIO_DETAILS_TOOL_NAME) {
+    return <CollapsedStudioDetailsToolCall args={args} />;
+  }
+
   if (toolName === CLAUDE_CODE_COLLAPSED_THINKING_TOOL_NAME) {
     const text = getStringArg(args, ['text']);
     return text ? <CollapsedThinkingToolCall text={text} /> : null;
diff --git a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/historyPanel/ClaudeCodeArtifactsPane.tsx b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/historyPanel/ClaudeCodeArtifactsPane.tsx
index 10892cd9f2..983afb88c1 100644
--- a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/historyPanel/ClaudeCodeArtifactsPane.tsx
+++ b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/historyPanel/ClaudeCodeArtifactsPane.tsx
@@ -16,7 +16,7 @@ import {
   hasArtifacts,
 } from '@studio/routes/agents/ClaudeCodeChatRoute/historyPanel/helpers';
 import type { ClaudeCodeChatArtifacts } from '@studio/routes/agents/ClaudeCodeChatRoute/types';
-import { Bot, Boxes, Cpu, PanelRightClose, Sparkles } from 'lucide-react';
+import { Bot, Cpu, PanelRightClose, Sparkles } from 'lucide-react';
 
 export const ClaudeCodeArtifactsPane = ({
   artifacts,
@@ -60,7 +60,6 @@ export const ClaudeCodeArtifactsPane = ({
           <Stack gap="density-sm" className="min-w-0">
             <ArtifactRow icon={<Bot size={14} />} label="Agent" value={artifacts.agent} />
             <ArtifactRow icon={<Cpu size={14} />} label="Model" value={selectedModel} />
-            <ArtifactRow icon={<Boxes size={14} />} label="Workspace" value={artifacts.workspace} />
           </Stack>
           <SelectionArtifacts selections={artifacts.selections} />
           <JobArtifacts jobs={artifacts.jobs} workspace={artifacts.workspace} />
diff --git a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/historyPanel/helpers.ts b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/historyPanel/helpers.ts
index 2eacc717aa..6d7d1d87bb 100644
--- a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/historyPanel/helpers.ts
+++ b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/historyPanel/helpers.ts
@@ -46,7 +46,6 @@ export const hasArtifacts = (
   !!(
     artifacts.agent ||
     getSelectedArtifactModel(artifacts) ||
-    artifacts.workspace ||
     artifacts.selections.length ||
     artifacts.files.length ||
     artifacts.links.length ||
diff --git a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/toolParts.test.ts b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/toolParts.test.ts
new file mode 100644
index 0000000000..b1d64d225d
--- /dev/null
+++ b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/toolParts.test.ts
@@ -0,0 +1,331 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ThreadAssistantMessagePart } from '@assistant-ui/react';
+import {
+  CLAUDE_CODE_COLLAPSED_STUDIO_DETAILS_TOOL_NAME,
+  getClaudeCodeCompletedMessageParts,
+  STUDIO_MESSAGE_SUMMARY_END,
+  STUDIO_MESSAGE_SUMMARY_START,
+} from '@studio/routes/agents/ClaudeCodeChatRoute/toolParts';
+
+describe('Claude Code tool parts', () => {
+  it('collapses details before a Studio summary block and shows only the summary text', () => {
+    const bashPart: ThreadAssistantMessagePart = {
+      type: 'tool-call',
+      toolCallId: 'toolu_bash',
+      toolName: 'Bash',
+      args: { command: 'pwd' },
+      argsText: '{"command":"pwd"}',
+    };
+    const parts: readonly ThreadAssistantMessagePart[] = [
+      { type: 'text', text: 'I inspected the repo first.' },
+      bashPart,
+      {
+        type: 'text',
+        text: [
+          'I found the prompt builder and updated it.',
+          '',
+          STUDIO_MESSAGE_SUMMARY_START,
+          'worked_for: unknown',
+          'summary: Updated Studio so completed coding-agent messages collapse to a short summary.',
+          'details_label: worked for unknown',
+          STUDIO_MESSAGE_SUMMARY_END,
+        ].join('\n'),
+      },
+    ];
+
+    const completedParts = getClaudeCodeCompletedMessageParts(parts, { elapsedMs: 123_000 });
+
+    expect(completedParts).toMatchObject([
+      {
+        type: 'tool-call',
+        toolName: CLAUDE_CODE_COLLAPSED_STUDIO_DETAILS_TOOL_NAME,
+        args: {
+          label: 'worked for 2m 3s',
+          parts: [
+            { type: 'text', text: 'I inspected the repo first.' },
+            { type: 'tool-call', toolName: 'Bash', args: { command: 'pwd' } },
+            { type: 'text', text: 'I found the prompt builder and updated it.' },
+          ],
+        },
+      },
+      {
+        type: 'text',
+        text: 'Updated Studio so completed coding-agent messages collapse to a short summary.',
+      },
+    ]);
+  });
+
+  it('preserves non-text parts interleaved across a streamed Studio summary block', () => {
+    const interleavedToolPart: ThreadAssistantMessagePart = {
+      type: 'tool-call',
+      toolCallId: 'toolu_interleaved',
+      toolName: 'Bash',
+      args: { command: 'pwd' },
+      argsText: '{"command":"pwd"}',
+    };
+    const parts: readonly ThreadAssistantMessagePart[] = [
+      { type: 'text', text: 'Detailed work that should be collapsed.' },
+      {
+        type: 'text',
+        text: [
+          STUDIO_MESSAGE_SUMMARY_START,
+          'worked_for: 8s',
+          'summary: Finished the streamed work.',
+        ].join('\n'),
+      },
+      interleavedToolPart,
+      {
+        type: 'text',
+        text: ['details_label: worked for 8s', STUDIO_MESSAGE_SUMMARY_END].join('\n'),
+      },
+    ];
+
+    expect(getClaudeCodeCompletedMessageParts(parts)).toMatchObject([
+      {
+        type: 'tool-call',
+        toolName: CLAUDE_CODE_COLLAPSED_STUDIO_DETAILS_TOOL_NAME,
+        args: {
+          parts: [
+            { type: 'text', text: 'Detailed work that should be collapsed.' },
+            { type: 'tool-call', toolCallId: 'toolu_interleaved', toolName: 'Bash' },
+          ],
+        },
+      },
+      { type: 'text', text: 'Finished the streamed work.' },
+    ]);
+  });
+
+  it('hides a raw Studio summary marker when the streamed block is truncated', () => {
+    const parts: readonly ThreadAssistantMessagePart[] = [
+      { type: 'text', text: 'I finished the available repository analysis.' },
+      {
+        type: 'text',
+        text: [
+          STUDIO_MESSAGE_SUMMARY_START,
+          'worked_for: 8s',
+          'summary: This partial field must not expose its sentinel.',
+        ].join('\n'),
+      },
+    ];
+
+    const completedParts = getClaudeCodeCompletedMessageParts(parts, { elapsedMs: 8_000 });
+
+    expect(completedParts).toMatchObject([
+      {
+        type: 'tool-call',
+        toolName: CLAUDE_CODE_COLLAPSED_STUDIO_DETAILS_TOOL_NAME,
+        args: {
+          label: 'worked for 8s',
+          parts: [{ type: 'text', text: 'I finished the available repository analysis.' }],
+        },
+      },
+      { type: 'text', text: 'I finished the available repository analysis.' },
+    ]);
+    expect(JSON.stringify(completedParts)).not.toContain(STUDIO_MESSAGE_SUMMARY_START);
+  });
+
+  it('removes the Studio summary markers when there are no details to collapse', () => {
+    const parts: readonly ThreadAssistantMessagePart[] = [
+      {
+        type: 'text',
+        text: [
+          STUDIO_MESSAGE_SUMMARY_START,
+          'worked_for: 4s',
+          'summary: Ready for the next step.',
+          'details_label: worked for 4s',
+          STUDIO_MESSAGE_SUMMARY_END,
+        ].join('\n'),
+      },
+    ];
+
+    expect(getClaudeCodeCompletedMessageParts(parts)).toEqual([
+      { type: 'text', text: 'Ready for the next step.' },
+    ]);
+  });
+
+  it('uses a neutral details label when the work time is unknown', () => {
+    const parts: readonly ThreadAssistantMessagePart[] = [
+      { type: 'text', text: 'Detailed work that should be collapsed.' },
+      {
+        type: 'text',
+        text: [
+          STUDIO_MESSAGE_SUMMARY_START,
+          'worked_for: unknown',
+          'summary: Ready for the next step.',
+          'details_label: worked for unknown',
+          STUDIO_MESSAGE_SUMMARY_END,
+        ].join('\n'),
+      },
+    ];
+
+    expect(getClaudeCodeCompletedMessageParts(parts)).toMatchObject([
+      {
+        type: 'tool-call',
+        toolName: CLAUDE_CODE_COLLAPSED_STUDIO_DETAILS_TOOL_NAME,
+        args: { label: 'Work details' },
+      },
+      { type: 'text', text: 'Ready for the next step.' },
+    ]);
+  });
+
+  it('keeps an unanswered trailing question visible when the model omits it from the summary', () => {
+    const parts: readonly ThreadAssistantMessagePart[] = [
+      {
+        type: 'text',
+        text: [
+          'I found three deployed agents.',
+          '',
+          'Which agent do you want to optimize?',
+          STUDIO_MESSAGE_SUMMARY_START,
+          'worked_for: 20s',
+          'summary: I investigated the available optimization targets.',
+          'details_label: worked for 20s',
+          STUDIO_MESSAGE_SUMMARY_END,
+        ].join('\n'),
+      },
+    ];
+
+    expect(getClaudeCodeCompletedMessageParts(parts)).toMatchObject([
+      {
+        type: 'tool-call',
+        toolName: CLAUDE_CODE_COLLAPSED_STUDIO_DETAILS_TOOL_NAME,
+        args: {
+          parts: [{ type: 'text', text: 'I found three deployed agents.' }],
+        },
+      },
+      {
+        type: 'text',
+        text: [
+          'I investigated the available optimization targets.',
+          '',
+          'Which agent do you want to optimize?',
+        ].join('\n'),
+      },
+    ]);
+  });
+
+  it('accepts an inline Studio summary block from the model', () => {
+    const parts: readonly ThreadAssistantMessagePart[] = [
+      { type: 'text', text: 'Detailed work that should be collapsed.' },
+      {
+        type: 'text',
+        text: `${STUDIO_MESSAGE_SUMMARY_START} worked_for: ~3 minutes summary: Analyzed calculator-agent and generated 3 optimization suggestions. Snapshot and suggestions persisted. details_label: worked for ~3 minutes ${STUDIO_MESSAGE_SUMMARY_END}`,
+      },
+    ];
+
+    expect(getClaudeCodeCompletedMessageParts(parts)).toMatchObject([
+      {
+        type: 'tool-call',
+        toolName: CLAUDE_CODE_COLLAPSED_STUDIO_DETAILS_TOOL_NAME,
+        args: {
+          label: 'worked for ~3 minutes',
+          parts: [{ type: 'text', text: 'Detailed work that should be collapsed.' }],
+        },
+      },
+      {
+        type: 'text',
+        text: 'Analyzed calculator-agent and generated 3 optimization suggestions. Snapshot and suggestions persisted.',
+      },
+    ]);
+  });
+
+  it('preserves markdown formatting in a Studio summary block', () => {
+    const markdownSummary = [
+      '## Completed',
+      '',
+      '1. Preserved **emphasis**',
+      '2. Preserved `inline code`',
+      '',
+      '```ts',
+      'const formatted = true;',
+      '```',
+    ].join('\n');
+    const parts: readonly ThreadAssistantMessagePart[] = [
+      { type: 'text', text: 'Detailed work that should be collapsed.' },
+      {
+        type: 'text',
+        text: [
+          STUDIO_MESSAGE_SUMMARY_START,
+          'worked_for: 12s',
+          'summary:',
+          markdownSummary,
+          'details_label: worked for 12s',
+          STUDIO_MESSAGE_SUMMARY_END,
+        ].join('\n'),
+      },
+    ];
+
+    expect(getClaudeCodeCompletedMessageParts(parts)).toMatchObject([
+      {
+        type: 'tool-call',
+        toolName: CLAUDE_CODE_COLLAPSED_STUDIO_DETAILS_TOOL_NAME,
+      },
+      { type: 'text', text: markdownSummary },
+    ]);
+  });
+
+  it('includes links from collapsed details at the bottom of the summary', () => {
+    const parts: readonly ThreadAssistantMessagePart[] = [
+      {
+        type: 'text',
+        text: [
+          'I generated the report.',
+          '',
+          '[Agent optimizations](/workspaces/default/agents/suggestions)',
+        ].join('\n'),
+      },
+      {
+        type: 'text',
+        text: [
+          STUDIO_MESSAGE_SUMMARY_START,
+          'worked_for: 12s',
+          'summary: Generated three optimization suggestions.',
+          'details_label: worked for 12s',
+          STUDIO_MESSAGE_SUMMARY_END,
+        ].join('\n'),
+      },
+    ];
+
+    expect(getClaudeCodeCompletedMessageParts(parts)).toMatchObject([
+      {
+        type: 'tool-call',
+        toolName: CLAUDE_CODE_COLLAPSED_STUDIO_DETAILS_TOOL_NAME,
+      },
+      {
+        type: 'text',
+        text: [
+          'Generated three optimization suggestions.',
+          '',
+          '[Agent optimizations](/workspaces/default/agents/suggestions)',
+        ].join('\n'),
+      },
+    ]);
+  });
+
+  it('does not duplicate a detail link already included in the summary', () => {
+    const link = '[Agent optimizations](/workspaces/default/agents/suggestions)';
+    const parts: readonly ThreadAssistantMessagePart[] = [
+      { type: 'text', text: `I generated the report.\n\n${link}` },
+      {
+        type: 'text',
+        text: [
+          STUDIO_MESSAGE_SUMMARY_START,
+          'worked_for: 12s',
+          `summary: Generated three optimization suggestions.\n\n${link}`,
+          'details_label: worked for 12s',
+          STUDIO_MESSAGE_SUMMARY_END,
+        ].join('\n'),
+      },
+    ];
+
+    const completedParts = getClaudeCodeCompletedMessageParts(parts);
+    const summaryPart = completedParts.at(-1);
+
+    expect(summaryPart).toEqual({
+      type: 'text',
+      text: `Generated three optimization suggestions.\n\n${link}`,
+    });
+  });
+});
diff --git a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/toolParts.ts b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/toolParts.ts
index 50302bc33e..e7ae4721f7 100644
--- a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/toolParts.ts
+++ b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/toolParts.ts
@@ -12,7 +12,11 @@ export type ClaudeCodeToolArgs = ClaudeCodeToolCallPart['args'];
 type ClaudeCodeToolArgValue = ClaudeCodeToolArgs[string];
 
 export const CLAUDE_CODE_COLLAPSED_THINKING_TOOL_NAME = 'ClaudeCodeCollapsedThinking';
+export const CLAUDE_CODE_COLLAPSED_STUDIO_DETAILS_TOOL_NAME = 'ClaudeCodeCollapsedStudioDetails';
 export const CLAUDE_CODE_SUBTLE_TOOL_GROUP_NAME = 'ClaudeCodeSubtleToolGroup';
+export const CLAUDE_CODE_WORK_DETAILS_LABEL = 'Work details';
+export const STUDIO_MESSAGE_SUMMARY_START = '<<<NEMO_STUDIO_MESSAGE_SUMMARY_V1>>>';
+export const STUDIO_MESSAGE_SUMMARY_END = '<<<END_NEMO_STUDIO_MESSAGE_SUMMARY_V1>>>';
 
 const FILE_CHANGE_TOOL_CALL_NAMES = new Set(['Edit', 'MultiEdit', 'Write']);
 
@@ -22,6 +26,7 @@ export const isClaudeCodeJobProgressToolName = (toolName: string): boolean =>
 
 export const isClaudeCodeSubtleToolCallName = (toolName: string): boolean =>
   toolName !== CLAUDE_CODE_COLLAPSED_THINKING_TOOL_NAME &&
+  toolName !== CLAUDE_CODE_COLLAPSED_STUDIO_DETAILS_TOOL_NAME &&
   toolName !== CLAUDE_CODE_SUBTLE_TOOL_GROUP_NAME &&
   !FILE_CHANGE_TOOL_CALL_NAMES.has(toolName) &&
   !isClaudeCodeJobProgressToolName(toolName);
@@ -88,6 +93,197 @@ const createClaudeCodeCollapsedThinkingPart = (text: string): ThreadAssistantMes
   };
 };
 
+interface ClaudeCodeCompletedMessageOptions {
+  readonly elapsedMs?: number;
+}
+
+interface StudioSummaryBlock {
+  readonly detailsLabel: string;
+  readonly detailParts: readonly ThreadAssistantMessagePart[];
+  readonly summaryText: string;
+}
+
+interface MarkdownLink {
+  readonly href: string;
+  readonly markdown: string;
+}
+
+interface SerializedClaudeCodeTextPart {
+  readonly text: string;
+  readonly type: 'text';
+}
+
+interface SerializedClaudeCodeToolPart {
+  readonly args: ClaudeCodeToolArgs;
+  readonly argsText: string;
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly type: 'tool-call';
+}
+
+type SerializedClaudeCodePart = SerializedClaudeCodeTextPart | SerializedClaudeCodeToolPart;
+
+const formatElapsedDuration = (elapsedMs: number | undefined): string | undefined => {
+  if (elapsedMs === undefined || !Number.isFinite(elapsedMs)) return undefined;
+
+  const totalSeconds = Math.max(1, Math.round(elapsedMs / 1000));
+  if (totalSeconds < 60) return `${totalSeconds}s`;
+
+  const totalMinutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  if (totalMinutes < 60) return seconds ? `${totalMinutes}m ${seconds}s` : `${totalMinutes}m`;
+
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+  return minutes ? `${hours}h ${minutes}m` : `${hours}h`;
+};
+
+const normalizeSummaryField = (value: string | undefined): string | undefined => {
+  const trimmed = value?.replace(/\s+/g, ' ').trim();
+  return trimmed || undefined;
+};
+
+const normalizeMarkdownSummary = (value: string | undefined): string | undefined => {
+  const trimmed = value?.replace(/\r\n?/g, '\n').trim();
+  return trimmed || undefined;
+};
+
+const getMarkdownLinks = (text: string): readonly MarkdownLink[] => {
+  const links: MarkdownLink[] = [];
+  const seenHrefs = new Set<string>();
+  const markdownLinkPattern = /(?<!!)\[([^\]\n]+)\]\(([^)\s]+)(?:\s+["'][^"']*["'])?\)/g;
+
+  for (const match of text.matchAll(markdownLinkPattern)) {
+    const label = match[1]?.trim();
+    const href = match[2]?.trim();
+    if (!label || !href || seenHrefs.has(href)) continue;
+    seenHrefs.add(href);
+    links.push({ href, markdown: `[${label}](${href})` });
+  }
+
+  for (const match of text.matchAll(/https?:\/\/[^\s<>()\]]+/g)) {
+    const href = match[0].replace(/[.,;:!?]+$/, '');
+    if (!href || seenHrefs.has(href)) continue;
+    seenHrefs.add(href);
+    links.push({ href, markdown: `[${href}](${href})` });
+  }
+
+  return links;
+};
+
+const appendDetailLinksToSummary = (
+  summaryText: string,
+  detailParts: readonly ThreadAssistantMessagePart[]
+): string => {
+  const summaryHrefs = new Set(getMarkdownLinks(summaryText).map((link) => link.href));
+  const detailText = detailParts
+    .filter(
+      (part): part is Extract<ThreadAssistantMessagePart, { type: 'text' }> => part.type === 'text'
+    )
+    .map((part) => part.text)
+    .join('\n');
+  const missingLinks = getMarkdownLinks(detailText).filter((link) => !summaryHrefs.has(link.href));
+  if (!missingLinks.length) return summaryText;
+
+  return `${summaryText}\n\n${missingLinks.map((link) => link.markdown).join('\n\n')}`;
+};
+
+const getStudioSummaryFields = (
+  blockText: string
+): {
+  readonly detailsLabel?: string;
+  readonly summaryText?: string;
+  readonly workedFor?: string;
+} => {
+  const fields: Partial<Record<'details_label' | 'summary' | 'worked_for', string[]>> = {};
+
+  const fieldMatches = Array.from(
+    blockText.matchAll(/(?:^|\s)(worked_for|summary|details_label):\s*/gi)
+  );
+
+  for (const [index, match] of fieldMatches.entries()) {
+    const field = match[1]!.toLowerCase() as 'details_label' | 'summary' | 'worked_for';
+    const valueStart = (match.index ?? 0) + match[0].length;
+    const valueEnd = fieldMatches[index + 1]?.index ?? blockText.length;
+    fields[field] = [blockText.slice(valueStart, valueEnd)];
+  }
+
+  return {
+    detailsLabel: normalizeSummaryField(fields.details_label?.join(' ')),
+    summaryText: normalizeMarkdownSummary(fields.summary?.join('\n')),
+    workedFor: normalizeSummaryField(fields.worked_for?.join(' ')),
+  };
+};
+
+const getStudioDetailsLabel = ({
+  elapsedMs,
+  summaryFields,
+}: {
+  readonly elapsedMs?: number;
+  readonly summaryFields: ReturnType<typeof getStudioSummaryFields>;
+}): string => {
+  const elapsedDuration = formatElapsedDuration(elapsedMs);
+  if (elapsedDuration) return `worked for ${elapsedDuration}`;
+
+  if (summaryFields.detailsLabel?.toLowerCase().startsWith('worked for ')) {
+    return summaryFields.detailsLabel.toLowerCase() === 'worked for unknown'
+      ? CLAUDE_CODE_WORK_DETAILS_LABEL
+      : summaryFields.detailsLabel;
+  }
+
+  if (!summaryFields.workedFor || summaryFields.workedFor.toLowerCase() === 'unknown') {
+    return CLAUDE_CODE_WORK_DETAILS_LABEL;
+  }
+
+  return `worked for ${summaryFields.workedFor}`;
+};
+
+const serializeClaudeCodePart = (
+  part: ThreadAssistantMessagePart
+): SerializedClaudeCodePart | undefined => {
+  if (part.type === 'text') {
+    const text = part.text.trim();
+    return text ? { type: 'text', text } : undefined;
+  }
+
+  if (
+    part.type !== 'tool-call' ||
+    part.toolName === CLAUDE_CODE_COLLAPSED_STUDIO_DETAILS_TOOL_NAME
+  ) {
+    return undefined;
+  }
+
+  return {
+    type: 'tool-call',
+    args: toClaudeCodeToolArgs(part.args),
+    argsText: part.argsText,
+    toolCallId: part.toolCallId,
+    toolName: part.toolName,
+  };
+};
+
+const createClaudeCodeCollapsedStudioDetailsPart = ({
+  label,
+  parts,
+}: {
+  readonly label: string;
+  readonly parts: readonly ThreadAssistantMessagePart[];
+}): ThreadAssistantMessagePart | undefined => {
+  const serializedParts = groupConsecutiveClaudeCodeSubtleToolCalls(parts)
+    .map(serializeClaudeCodePart)
+    .filter((part): part is SerializedClaudeCodePart => part !== undefined);
+  if (!serializedParts.length) return undefined;
+
+  const args = toClaudeCodeToolArgs({ label, parts: serializedParts });
+  return {
+    type: 'tool-call',
+    toolCallId: 'claude-code-collapsed-studio-details',
+    toolName: CLAUDE_CODE_COLLAPSED_STUDIO_DETAILS_TOOL_NAME,
+    args,
+    argsText: JSON.stringify(args),
+  };
+};
+
 interface ClaudeCodeSubtleToolAction {
   readonly args: ClaudeCodeToolArgs;
   readonly toolCallId: string;
@@ -177,6 +373,111 @@ const splitTextParagraphs = (text: string): readonly string[] =>
     .map((paragraph) => paragraph.trim())
     .filter(Boolean);
 
+const splitTrailingQuestion = (
+  text: string
+): { readonly detailText: string; readonly question?: string } => {
+  const lines = text.trim().split('\n');
+  const lastLine = lines.at(-1)?.trim();
+  if (!lastLine?.endsWith('?')) return { detailText: text.trim() };
+
+  return {
+    detailText: lines.slice(0, -1).join('\n').trim(),
+    question: lastLine,
+  };
+};
+
+const getTruncatedStudioSummaryText = (
+  detailParts: readonly ThreadAssistantMessagePart[],
+  question: string | undefined
+): string => {
+  const detailText = detailParts
+    .filter(
+      (part): part is Extract<ThreadAssistantMessagePart, { type: 'text' }> => part.type === 'text'
+    )
+    .map((part) => part.text)
+    .join('\n\n');
+  const detailSummary = splitTextParagraphs(detailText).at(-1);
+  const baseSummary = detailSummary ?? 'The response ended before its summary was complete.';
+  return question && !baseSummary.includes(question)
+    ? `${baseSummary}\n\n${question}`
+    : baseSummary;
+};
+
+const getStudioSummaryBlock = (
+  parts: readonly ThreadAssistantMessagePart[],
+  options: ClaudeCodeCompletedMessageOptions
+): StudioSummaryBlock | undefined => {
+  const detailParts: ThreadAssistantMessagePart[] = [];
+
+  for (let index = 0; index < parts.length; index += 1) {
+    const part = parts[index]!;
+    if (part.type !== 'text') {
+      detailParts.push(part);
+      continue;
+    }
+
+    const summaryStartIndex = part.text.indexOf(STUDIO_MESSAGE_SUMMARY_START);
+    if (summaryStartIndex < 0) {
+      detailParts.push(part);
+      continue;
+    }
+
+    const textBeforeSummary = part.text.slice(0, summaryStartIndex).trim();
+    const { detailText, question } = splitTrailingQuestion(textBeforeSummary);
+    if (detailText) {
+      detailParts.push({ type: 'text', text: detailText });
+    }
+
+    const summarySourceParts = [part.text.slice(summaryStartIndex)];
+    for (const remainingPart of parts.slice(index + 1)) {
+      if (remainingPart.type === 'text') {
+        summarySourceParts.push(remainingPart.text);
+      } else {
+        detailParts.push(remainingPart);
+      }
+    }
+    const summarySource = summarySourceParts.join('\n');
+    const summaryEndIndex = summarySource.indexOf(STUDIO_MESSAGE_SUMMARY_END);
+    if (summaryEndIndex < 0) {
+      return {
+        detailsLabel: getStudioDetailsLabel({
+          elapsedMs: options.elapsedMs,
+          summaryFields: getStudioSummaryFields(''),
+        }),
+        detailParts,
+        summaryText: getTruncatedStudioSummaryText(detailParts, question),
+      };
+    }
+
+    const summaryBlockText = summarySource
+      .slice(STUDIO_MESSAGE_SUMMARY_START.length, summaryEndIndex)
+      .trim();
+    const trailingSummaryText = summarySource
+      .slice(summaryEndIndex + STUDIO_MESSAGE_SUMMARY_END.length)
+      .trim();
+    const summaryFields = getStudioSummaryFields(summaryBlockText);
+    const baseSummaryText =
+      summaryFields.summaryText ?? normalizeMarkdownSummary(trailingSummaryText);
+    if (!baseSummaryText) return undefined;
+    const summaryTextWithQuestion =
+      question && !baseSummaryText.includes(question)
+        ? `${baseSummaryText}\n\n${question}`
+        : baseSummaryText;
+    const summaryText = appendDetailLinksToSummary(summaryTextWithQuestion, detailParts);
+
+    return {
+      detailsLabel: getStudioDetailsLabel({
+        elapsedMs: options.elapsedMs,
+        summaryFields,
+      }),
+      detailParts,
+      summaryText,
+    };
+  }
+
+  return undefined;
+};
+
 const getCollapsedTextParts = (
   parts: readonly ThreadAssistantMessagePart[],
   lastToolIndex: number
@@ -214,8 +515,21 @@ const getCollapsedTextParts = (
 };
 
 export const getClaudeCodeCompletedMessageParts = (
-  parts: readonly ThreadAssistantMessagePart[]
+  parts: readonly ThreadAssistantMessagePart[],
+  options: ClaudeCodeCompletedMessageOptions = {}
 ): readonly ThreadAssistantMessagePart[] => {
+  const studioSummaryBlock = getStudioSummaryBlock(parts, options);
+  if (studioSummaryBlock) {
+    const completedParts: ThreadAssistantMessagePart[] = [];
+    const collapsedDetailsPart = createClaudeCodeCollapsedStudioDetailsPart({
+      label: studioSummaryBlock.detailsLabel,
+      parts: studioSummaryBlock.detailParts,
+    });
+    if (collapsedDetailsPart) completedParts.push(collapsedDetailsPart);
+    completedParts.push({ type: 'text', text: studioSummaryBlock.summaryText });
+    return completedParts;
+  }
+
   const completedParts: ThreadAssistantMessagePart[] = [];
   let lastToolIndex = -1;
 
diff --git a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/useCustomAssistantChatRuntime.test.ts b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/useCustomAssistantChatRuntime.test.ts
index 8fca78c9a6..041818db44 100644
--- a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/useCustomAssistantChatRuntime.test.ts
+++ b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/useCustomAssistantChatRuntime.test.ts
@@ -4,8 +4,11 @@
 import type { ThreadAssistantMessagePart, ThreadMessageLike } from '@assistant-ui/react';
 import { getMessageText } from '@nemo/common/src/components/AssistantChat/messageUtils';
 import {
+  CLAUDE_CODE_COLLAPSED_STUDIO_DETAILS_TOOL_NAME,
   CLAUDE_CODE_COLLAPSED_THINKING_TOOL_NAME,
   CLAUDE_CODE_SUBTLE_TOOL_GROUP_NAME,
+  STUDIO_MESSAGE_SUMMARY_END,
+  STUDIO_MESSAGE_SUMMARY_START,
 } from '@studio/routes/agents/ClaudeCodeChatRoute/toolParts';
 import {
   type CustomAssistantBeforeRunContext,
@@ -188,6 +191,61 @@ describe('useCustomAssistantChatRuntime', () => {
     });
   });
 
+  it('excludes time waiting for user input from the completed work duration', async () => {
+    let now = 1_000;
+    const dateNow = vi.spyOn(Date, 'now').mockImplementation(() => now);
+    let resumeRun!: () => void;
+    const onRun = vi.fn(async (context: CustomAssistantRunContext) => {
+      now = 2_000;
+      context.appendAssistantParts([{ type: 'text', text: 'I inspected the repository.' }]);
+      now = 3_000;
+      context.prepareForUserInput();
+      await new Promise<void>((resolve) => {
+        resumeRun = resolve;
+      });
+      now = 303_000;
+      context.appendAssistantParts([
+        {
+          type: 'text',
+          text: [
+            STUDIO_MESSAGE_SUMMARY_START,
+            'worked_for: unknown',
+            'summary: Finished after receiving the answer.',
+            'details_label: worked for unknown',
+            STUDIO_MESSAGE_SUMMARY_END,
+          ].join('\n'),
+        },
+      ]);
+      now = 305_000;
+    });
+    const { result } = renderHook(() => useCustomAssistantChatRuntime({ onRun }));
+
+    act(() => {
+      void result.current.submitPrompt('Inspect the repository');
+    });
+
+    await waitFor(() => {
+      expect(resumeRun).toBeDefined();
+    });
+
+    await act(async () => {
+      resumeRun();
+    });
+
+    await waitFor(() => {
+      expect(getAssistantContent(getMockRuntime(result.current.runtime).messages)).toMatchObject([
+        {
+          type: 'tool-call',
+          toolName: CLAUDE_CODE_COLLAPSED_STUDIO_DETAILS_TOOL_NAME,
+          args: { label: 'worked for 4s' },
+        },
+        { type: 'text', text: 'Finished after receiving the answer.' },
+      ]);
+    });
+
+    dateNow.mockRestore();
+  });
+
   it('preserves resumed assistant parts when setting assistant text', async () => {
     const bashPart: ThreadAssistantMessagePart = {
       type: 'tool-call',
diff --git a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/useCustomAssistantChatRuntime.ts b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/useCustomAssistantChatRuntime.ts
index 70e8346b90..f42e908cac 100644
--- a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/useCustomAssistantChatRuntime.ts
+++ b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/useCustomAssistantChatRuntime.ts
@@ -118,10 +118,11 @@ const hasVisibleAssistantContent = (content: ThreadMessageLike['content']): bool
 
 const completeClaudeCodeAssistantContent = (
   content: ThreadMessageLike['content'],
-  status: MessageStatus
+  status: MessageStatus,
+  elapsedMs?: number
 ): ThreadMessageLike['content'] => {
   if (status.type !== 'complete' || !Array.isArray(content)) return content;
-  return getClaudeCodeCompletedMessageParts(content);
+  return getClaudeCodeCompletedMessageParts(content, { elapsedMs });
 };
 
 export const useCustomAssistantChatRuntime = ({
@@ -192,8 +193,17 @@ export const useCustomAssistantChatRuntime = ({
       let assistantMessageId: string | null = null;
       let responseText = '';
       let responseContent: readonly ThreadAssistantMessagePart[] | undefined;
+      let runStartedAt = Date.now();
+      let runPausedAt: number | undefined;
+
+      const resumeRunTimer = () => {
+        if (runPausedAt === undefined) return;
+        runStartedAt += Date.now() - runPausedAt;
+        runPausedAt = undefined;
+      };
 
       const createAssistantMessage = () => {
+        resumeRunTimer();
         const assistantMessage = createTextMessage('assistant', '', RUNNING_STATUS);
         assistantMessageId = assistantMessage.id!;
         responseText = '';
@@ -211,6 +221,7 @@ export const useCustomAssistantChatRuntime = ({
           return false;
         }
 
+        resumeRunTimer();
         assistantMessageId = lastMessage.id;
         responseContent = getAssistantMessageParts(lastMessage);
         responseText = getAssistantPartsText(responseContent);
@@ -242,7 +253,7 @@ export const useCustomAssistantChatRuntime = ({
           currentAssistantMessageId,
           options.collapseClaudeCodeContent === false
             ? content
-            : completeClaudeCodeAssistantContent(content, status),
+            : completeClaudeCodeAssistantContent(content, status, Date.now() - runStartedAt),
           status
         );
       };
@@ -293,6 +304,7 @@ export const useCustomAssistantChatRuntime = ({
         completeActiveAssistantMessage(COMPLETE_STATUS, getCurrentResponseContent(), {
           collapseClaudeCodeContent: false,
         });
+        runPausedAt ??= Date.now();
       };
 
       try {
diff --git a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/util.test.ts b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/util.test.ts
index 682e66c0dd..022efbfcb4 100644
--- a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/util.test.ts
+++ b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/util.test.ts
@@ -3,8 +3,11 @@
 
 import { CLAUDE_CODE_JOB_PROGRESS_MCP_TOOL_NAME } from '@studio/routes/agents/ClaudeCodeChatRoute/jobProgressConsts';
 import {
+  CLAUDE_CODE_COLLAPSED_STUDIO_DETAILS_TOOL_NAME,
   CLAUDE_CODE_COLLAPSED_THINKING_TOOL_NAME,
   CLAUDE_CODE_SUBTLE_TOOL_GROUP_NAME,
+  STUDIO_MESSAGE_SUMMARY_END,
+  STUDIO_MESSAGE_SUMMARY_START,
 } from '@studio/routes/agents/ClaudeCodeChatRoute/toolParts';
 import type { ClaudeCodeSessionHistory } from '@studio/routes/agents/ClaudeCodeChatRoute/types';
 import {
@@ -219,6 +222,163 @@ describe('Claude Code utilities', () => {
     });
   });
 
+  it('collapses all assistant history before a Studio summary block on refresh', () => {
+    const history: ClaudeCodeSessionHistory = {
+      session_id: 'session-1',
+      chat_artifacts: { selections: [], files: [], links: [], jobs: [], tools: [] },
+      items: [
+        { kind: 'user', text: 'optimize calculator-agent' },
+        {
+          kind: 'assistant',
+          parts: [
+            {
+              type: 'text',
+              text: "I'll start by invoking the nemo-agents-optimize skill.",
+            },
+            { type: 'tool_use', name: 'ToolSearch', input: { query: 'select_agent' } },
+            { type: 'tool_use', name: 'mcp__nemo_studio__select_agent', input: {} },
+          ],
+        },
+        {
+          kind: 'assistant',
+          parts: [
+            {
+              type: 'text',
+              text: "The user selected calculator-agent. Now I'll run the workflow.",
+            },
+            { type: 'tool_use', name: 'Skill', input: { name: 'nemo-agents-optimize' } },
+          ],
+        },
+        {
+          kind: 'assistant',
+          parts: [
+            { type: 'text', text: 'Starting parallel data fetches.' },
+            { type: 'tool_use', name: 'Bash', input: { description: 'List deployed agents' } },
+            { type: 'tool_use', name: 'Bash', input: { description: 'Read model catalog' } },
+          ],
+        },
+        {
+          kind: 'assistant',
+          parts: [
+            { type: 'text', text: 'Both files uploaded. Let me get the Studio link.' },
+            { type: 'tool_use', name: 'mcp__nemo_studio__studio_link', input: {} },
+            {
+              type: 'text',
+              text: `${STUDIO_MESSAGE_SUMMARY_START} worked_for: ~3 minutes summary: Analyzed calculator-agent and generated 3 optimization suggestions. Snapshot and suggestions persisted. details_label: worked for ~3 minutes ${STUDIO_MESSAGE_SUMMARY_END}`,
+            },
+          ],
+        },
+      ],
+    };
+
+    const messages = getClaudeCodeHistoryMessages(history);
+
+    expect(messages).toHaveLength(2);
+    expect(messages[0]).toEqual({
+      id: 'session-1-0',
+      role: 'user',
+      content: [{ type: 'text', text: 'optimize calculator-agent' }],
+    });
+    expect(messages[1]).toMatchObject({
+      role: 'assistant',
+      content: [
+        {
+          type: 'tool-call',
+          toolName: CLAUDE_CODE_COLLAPSED_STUDIO_DETAILS_TOOL_NAME,
+          args: {
+            label: 'worked for ~3 minutes',
+            parts: [
+              {
+                type: 'text',
+                text: "I'll start by invoking the nemo-agents-optimize skill.",
+              },
+              {
+                type: 'tool-call',
+                toolName: CLAUDE_CODE_SUBTLE_TOOL_GROUP_NAME,
+              },
+              {
+                type: 'text',
+                text: "The user selected calculator-agent. Now I'll run the workflow.",
+              },
+              {
+                type: 'tool-call',
+                toolName: 'Skill',
+              },
+              {
+                type: 'text',
+                text: 'Starting parallel data fetches.',
+              },
+              {
+                type: 'tool-call',
+                toolName: CLAUDE_CODE_SUBTLE_TOOL_GROUP_NAME,
+              },
+              {
+                type: 'text',
+                text: 'Both files uploaded. Let me get the Studio link.',
+              },
+              {
+                type: 'tool-call',
+                toolName: 'mcp__nemo_studio__studio_link',
+              },
+            ],
+          },
+        },
+        {
+          type: 'text',
+          text: 'Analyzed calculator-agent and generated 3 optimization suggestions. Snapshot and suggestions persisted.',
+        },
+      ],
+    });
+  });
+
+  it('preserves interactive user answers as message boundaries on refresh', () => {
+    const history: ClaudeCodeSessionHistory = {
+      session_id: 'session-1',
+      chat_artifacts: { selections: [], files: [], links: [], jobs: [], tools: [] },
+      items: [
+        { kind: 'user', text: 'optimize an agent' },
+        {
+          kind: 'assistant',
+          parts: [
+            { type: 'text', text: 'Which agent should I optimize?' },
+            { type: 'tool_use', name: 'mcp__nemo_studio__select_agent', input: {} },
+          ],
+        },
+        { kind: 'user', text: 'Selected agent: calculator-agent' },
+        {
+          kind: 'assistant',
+          parts: [
+            { type: 'text', text: 'I analyzed calculator-agent.' },
+            {
+              type: 'text',
+              text: `${STUDIO_MESSAGE_SUMMARY_START} summary: Generated optimization suggestions. details_label: worked briefly ${STUDIO_MESSAGE_SUMMARY_END}`,
+            },
+          ],
+        },
+      ],
+    };
+
+    const messages = getClaudeCodeHistoryMessages(history);
+
+    expect(messages).toHaveLength(4);
+    expect(messages[1]).toMatchObject({ role: 'assistant' });
+    expect(messages[2]).toEqual({
+      id: 'session-1-2',
+      role: 'user',
+      content: [{ type: 'text', text: 'Selected agent: calculator-agent' }],
+    });
+    expect(messages[3]).toMatchObject({
+      role: 'assistant',
+      content: [
+        {
+          type: 'tool-call',
+          toolName: CLAUDE_CODE_COLLAPSED_STUDIO_DETAILS_TOOL_NAME,
+        },
+        { type: 'text', text: 'Generated optimization suggestions.' },
+      ],
+    });
+  });
+
   it('keeps stored job progress tool calls visible in history', () => {
     const history: ClaudeCodeSessionHistory = {
       session_id: 'session-1',
diff --git a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/util.ts b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/util.ts
index c33b603b70..2d024b3a96 100644
--- a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/util.ts
+++ b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/util.ts
@@ -8,6 +8,7 @@ import {
   getClaudeCodeCompletedMessageParts,
   groupConsecutiveClaudeCodeSubtleToolCalls,
   mergeConsecutiveClaudeCodeSubtleToolMessages,
+  STUDIO_MESSAGE_SUMMARY_START,
 } from '@studio/routes/agents/ClaudeCodeChatRoute/toolParts';
 import type {
   ClaudeCodeAssistantHistoryPart,
@@ -50,6 +51,56 @@ const getAssistantMessagePart = (
   return undefined;
 };
 
+const getAssistantContent = (
+  message: ThreadMessageLike
+): readonly ThreadAssistantMessagePart[] | undefined =>
+  message.role === 'assistant' && Array.isArray(message.content) ? message.content : undefined;
+
+const hasStudioSummaryMarker = (message: ThreadMessageLike): boolean =>
+  getAssistantContent(message)?.some(
+    (part) => part.type === 'text' && part.text.includes(STUDIO_MESSAGE_SUMMARY_START)
+  ) ?? false;
+
+const combineAssistantRunMessages = (
+  messages: readonly ThreadMessageLike[]
+): readonly ThreadMessageLike[] => {
+  const combinedMessages: ThreadMessageLike[] = [];
+  let pendingAssistantMessages: ThreadMessageLike[] = [];
+
+  const flushPendingAssistantMessages = () => {
+    if (!pendingAssistantMessages.length) return;
+
+    if (!pendingAssistantMessages.some(hasStudioSummaryMarker)) {
+      combinedMessages.push(...pendingAssistantMessages);
+      pendingAssistantMessages = [];
+      return;
+    }
+
+    const firstMessage = pendingAssistantMessages[0]!;
+    const lastMessage = pendingAssistantMessages[pendingAssistantMessages.length - 1]!;
+    combinedMessages.push({
+      ...lastMessage,
+      id: firstMessage.id ?? lastMessage.id,
+      content: pendingAssistantMessages.flatMap((message) => getAssistantContent(message) ?? []),
+      status: COMPLETE_STATUS,
+    });
+    pendingAssistantMessages = [];
+  };
+
+  for (const message of messages) {
+    if (message.role === 'assistant') {
+      pendingAssistantMessages.push(message);
+      continue;
+    }
+
+    flushPendingAssistantMessages();
+    combinedMessages.push(message);
+  }
+
+  flushPendingAssistantMessages();
+  return combinedMessages;
+};
+
 export const getClaudeCodeHistoryMessages = (
   history: ClaudeCodeSessionHistory | undefined
 ): readonly ThreadMessageLike[] => {
@@ -81,9 +132,10 @@ export const getClaudeCodeHistoryMessages = (
     })
     .filter((message): message is ThreadMessageLike => message !== undefined);
 
-  return mergeConsecutiveClaudeCodeSubtleToolMessages(messages).map((message) =>
-    message.role === 'assistant' && Array.isArray(message.content)
-      ? { ...message, content: getClaudeCodeCompletedMessageParts(message.content) }
-      : message
+  return mergeConsecutiveClaudeCodeSubtleToolMessages(combineAssistantRunMessages(messages)).map(
+    (message) =>
+      message.role === 'assistant' && Array.isArray(message.content)
+        ? { ...message, content: getClaudeCodeCompletedMessageParts(message.content) }
+        : message
   );
 };