diff --git a/services/core/models/tests/integration/conftest.py b/services/core/models/tests/integration/conftest.py
index 9837d52d1c..0328a8158d 100644
--- a/services/core/models/tests/integration/conftest.py
+++ b/services/core/models/tests/integration/conftest.py
@@ -15,6 +15,7 @@
 from nemo_platform.types.inference.model_deployment_config import ModelDeploymentConfig
 from nemo_platform.types.models.model_entity import ModelEntity
 from nmp.common.secrets.encryption import get_base64_encoded_random_bytes
+from nmp.core.files.app.backends.base import FileInfo
 from nmp.core.files.app.backends.huggingface import HuggingfaceStorageImpl
 from nmp.core.models.controllers.backends.backends import DeploymentStatusUpdate, ServiceBackend
 from nmp.core.models.controllers.backends.registry import BackendRegistry
@@ -49,8 +50,12 @@ async def _validate_noop(self):
     async def _resolve_passthrough(self):
         return self.config
 
+    async def _list_files_stub(_self: HuggingfaceStorageImpl, _path: str | None = None) -> list[FileInfo]:
+        return [FileInfo(path="config.json", size=2)]
+
     monkeypatch.setattr(HuggingfaceStorageImpl, "validate_storage", _validate_noop)
     monkeypatch.setattr(HuggingfaceStorageImpl, "resolve_config", _resolve_passthrough)
+    monkeypatch.setattr(HuggingfaceStorageImpl, "list_files", _list_files_stub)
 
 
 # =============================================================================
diff --git a/services/studio/src/nmp/studio/coding_agent_artifacts.py b/services/studio/src/nmp/studio/coding_agent_artifacts.py
new file mode 100644
index 0000000000..f1815c2bd8
--- /dev/null
+++ b/services/studio/src/nmp/studio/coding_agent_artifacts.py
@@ -0,0 +1,349 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Artifact extraction for Studio coding-agent chat history."""
+
+import json
+import re
+from typing import Any
+
+from nmp.studio import studio_links
+from pydantic import BaseModel, Field
+
+
+class ChatSelectionArtifactResponse(BaseModel):
+    """A user selection captured during the chat."""
+
+    label: str
+    value: str
+
+
+class ChatFileArtifactResponse(BaseModel):
+    """A file touched by the local coding agent."""
+
+    action: str
+    path: str
+
+
+class ChatLinkArtifactResponse(BaseModel):
+    """A Studio link requested by the local coding agent."""
+
+    label: str
+    destination: str | None = None
+    href: str | None = None
+
+
+class ChatArtifactsResponse(BaseModel):
+    """Structured chat metadata shown in Studio's artifacts pane."""
+
+    agent: str | None = None
+    model: str | None = None
+    model_source: str | None = None
+    coding_agent_model: str | None = None
+    workspace: str | None = None
+    selections: list[ChatSelectionArtifactResponse] = Field(default_factory=list)
+    files: list[ChatFileArtifactResponse] = Field(default_factory=list)
+    links: list[ChatLinkArtifactResponse] = Field(default_factory=list)
+    tools: list[str] = Field(default_factory=list)
+
+
+_ANSWER_PAIR_RE = re.compile(r'"((?:\\.|[^"\\])*)"\s*=\s*"((?:\\.|[^"\\])*)"')
+_INLINE_CODE_VALUE_RE = re.compile(r"(`+)(?P<value>.*?)\1", re.DOTALL)
+_MARKDOWN_LINK_RE = re.compile(r"\[(?P<label>[^\]]+)\]\((?P<href>[^)]+)\)")
+_FILE_CHANGE_TOOL_ACTIONS = {
+    "Edit": "Edited",
+    "MultiEdit": "Edited",
+    "Write": "Wrote",
+}
+_STUDIO_CONTEXT_WORKSPACE_RE = re.compile(r"^Current Studio workspace:\s*(?P<workspace>.+)$", re.MULTILINE)
+_SPEC_HEADINGS = {
+    "behavior",
+    "change scope",
+    "evaluation setup",
+    "framework",
+    "harness",
+    "model",
+    "name",
+    "open questions",
+    "purpose",
+    "role",
+    "scope",
+    "signals",
+    "success criteria",
+    "tools",
+}
+
+
+def string_value(value: Any) -> str | None:
+    if not isinstance(value, str):
+        return None
+    stripped = value.strip()
+    return stripped or None
+
+
+def _append_unique_string(items: list[str], value: str) -> None:
+    if value not in items:
+        items.append(value)
+
+
+def _clean_artifact_value(value: str) -> str:
+    stripped = value.strip()
+    match = _INLINE_CODE_VALUE_RE.search(stripped)
+    if not match:
+        return stripped
+    unwrapped = match.group("value").strip()
+    return unwrapped or stripped
+
+
+def record_tool_name(artifacts: ChatArtifactsResponse, tool_name: str) -> None:
+    _append_unique_string(artifacts.tools, tool_name)
+
+
+def record_coding_agent_model(artifacts: ChatArtifactsResponse, model: str | None) -> None:
+    if not model:
+        return
+    artifacts.coding_agent_model = model
+
+
+def _set_spec_model(artifacts: ChatArtifactsResponse, model: str) -> None:
+    artifacts.model = _clean_artifact_value(model)
+    artifacts.model_source = "spec"
+
+
+def _set_selection_artifact(artifacts: ChatArtifactsResponse, label: str, value: str) -> None:
+    cleaned_value = _clean_artifact_value(value)
+    if label == "Agent":
+        artifacts.agent = cleaned_value
+    elif label == "Model":
+        artifacts.model = cleaned_value
+        artifacts.model_source = "selection"
+
+    for index, selection in enumerate(artifacts.selections):
+        if selection.label == label:
+            artifacts.selections[index] = ChatSelectionArtifactResponse(
+                label=label,
+                value=cleaned_value,
+            )
+            return
+    artifacts.selections.append(ChatSelectionArtifactResponse(label=label, value=cleaned_value))
+
+
+def _selection_label(question: str, header: str | None = None) -> str:
+    combined = f"{header or ''} {question}".lower()
+    if "agent" in combined:
+        return "Agent"
+    if "model" in combined:
+        return "Model"
+    if "deployment" in combined:
+        return "Deployment"
+    if "fileset" in combined:
+        return "Fileset"
+    if "dataset" in combined:
+        return "Dataset"
+    if "provider" in combined:
+        return "Provider"
+
+    label = header or question.strip().rstrip("?")
+    return label[:40] if len(label) > 40 else label
+
+
+def _decode_answer_pair_value(value: str) -> str:
+    try:
+        decoded = json.loads(f'"{value}"')
+    except json.JSONDecodeError:
+        return value.replace('\\"', '"').replace("\\\\", "\\")
+    return decoded if isinstance(decoded, str) else value
+
+
+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
+        label = question_labels.get(question) if question_labels else None
+        _set_selection_artifact(artifacts, label or _selection_label(question), answer)
+
+
+def _ask_user_question_labels(input_value: Any) -> dict[str, str]:
+    if not isinstance(input_value, dict):
+        return {}
+
+    questions = input_value.get("questions")
+    if not isinstance(questions, list):
+        question = string_value(input_value.get("question"))
+        if not question:
+            return {}
+        return {question: _selection_label(question, string_value(input_value.get("header")))}
+
+    labels: dict[str, str] = {}
+    for question_value in questions:
+        if not isinstance(question_value, dict):
+            continue
+        question = string_value(question_value.get("question"))
+        if not question:
+            continue
+        labels[question] = _selection_label(question, string_value(question_value.get("header")))
+    return labels
+
+
+def _upsert_file_artifact(artifacts: ChatArtifactsResponse, action: str, path: str) -> None:
+    for index, file_artifact in enumerate(artifacts.files):
+        if file_artifact.path == path:
+            artifacts.files[index] = ChatFileArtifactResponse(action=action, path=path)
+            return
+    artifacts.files.append(ChatFileArtifactResponse(action=action, path=path))
+
+
+def _markdown_link_parts(value: str) -> tuple[str | None, str | None]:
+    match = _MARKDOWN_LINK_RE.search(value)
+    if not match:
+        return None, None
+    return match.group("label").strip() or None, match.group("href").strip() or None
+
+
+def _studio_link_artifact_from_input(
+    input_value: dict[str, Any],
+    workspace: str | None,
+) -> ChatLinkArtifactResponse | None:
+    destination = (
+        string_value(input_value.get("destination"))
+        or string_value(input_value.get("page"))
+        or string_value(input_value.get("resource_type"))
+    )
+    label = string_value(input_value.get("label")) or destination
+    href = string_value(input_value.get("href")) or string_value(input_value.get("url"))
+
+    if workspace:
+        result = studio_links.build_studio_link_result(workspace, None, input_value)
+        if "markdown" in result:
+            markdown_label, markdown_href = _markdown_link_parts(str(result["markdown"]))
+            label = string_value(input_value.get("label")) or markdown_label or label
+            href = string_value(result.get("url")) or string_value(result.get("path")) or markdown_href or href
+            destination = string_value(result.get("destination")) or destination
+
+    if not label:
+        return None
+
+    return ChatLinkArtifactResponse(label=label, destination=destination, href=href)
+
+
+def _append_link_artifact(artifacts: ChatArtifactsResponse, input_value: Any) -> None:
+    if not isinstance(input_value, dict):
+        return
+    artifact = _studio_link_artifact_from_input(input_value, artifacts.workspace)
+    if artifact is None:
+        return
+
+    for link in artifacts.links:
+        if link.label == artifact.label and link.destination == artifact.destination:
+            if artifact.href and not link.href:
+                link.href = artifact.href
+            return
+    artifacts.links.append(artifact)
+
+
+def _normalize_spec_line(line: str) -> str:
+    normalized = line.strip()
+    normalized = re.sub(r"^#{1,6}\s+", "", normalized)
+    normalized = re.sub(r"^\s*[-*]\s+", "", normalized)
+    return normalized.replace("**", "").strip()
+
+
+def _normalize_heading(line: str) -> str:
+    return _normalize_spec_line(line).removesuffix(":").strip().lower()
+
+
+def _inline_spec_value(text: str, label: str) -> str | None:
+    prefix = f"{label.lower()}:"
+    for line in text.splitlines():
+        normalized = _normalize_spec_line(line)
+        if not normalized.lower().startswith(prefix):
+            continue
+        return string_value(normalized[len(prefix) :])
+    return None
+
+
+def _clean_spec_value(value: str) -> str:
+    normalized = _normalize_spec_line(value)
+    without_parenthetical = re.sub(r"\s+\([^)]*\)\s*$", "", normalized).strip()
+    return _clean_artifact_value(without_parenthetical or normalized)
+
+
+def _section_spec_value(text: str, heading: str) -> str | None:
+    lines = text.splitlines()
+    target_heading = heading.lower()
+    for index, line in enumerate(lines):
+        if _normalize_heading(line) != target_heading:
+            continue
+        for value_line in lines[index + 1 :]:
+            normalized = _normalize_spec_line(value_line)
+            if not normalized:
+                continue
+            if _normalize_heading(normalized) in _SPEC_HEADINGS:
+                return None
+            return _clean_spec_value(normalized)
+    return None
+
+
+def record_spec_text_artifacts(artifacts: ChatArtifactsResponse, text: str) -> None:
+    agent_name = _inline_spec_value(text, "Name") or _inline_spec_value(text, "Draft Spec")
+    if agent_name:
+        artifacts.agent = _clean_spec_value(agent_name)
+
+    model = _section_spec_value(text, "Model") or _inline_spec_value(text, "Model")
+    if model:
+        _set_spec_model(artifacts, _clean_spec_value(model))
+
+
+def record_tool_artifacts(
+    artifacts: ChatArtifactsResponse,
+    tool_name: str,
+    input_value: Any,
+    tool_use_id: str | None,
+    question_labels_by_tool_use_id: dict[str, dict[str, str]],
+) -> None:
+    if tool_name == "AskUserQuestion" and tool_use_id:
+        labels = _ask_user_question_labels(input_value)
+        if labels:
+            question_labels_by_tool_use_id[tool_use_id] = labels
+
+    action = _FILE_CHANGE_TOOL_ACTIONS.get(tool_name)
+    if action and isinstance(input_value, dict):
+        path = string_value(input_value.get("file_path")) or string_value(input_value.get("path"))
+        if path:
+            _upsert_file_artifact(artifacts, action, path)
+
+    if tool_name == "studio_link" or tool_name.endswith("__studio_link"):
+        _append_link_artifact(artifacts, input_value)
+
+
+def record_workspace_artifact(artifacts: ChatArtifactsResponse, content: str) -> None:
+    if artifacts.workspace:
+        return
+    match = _STUDIO_CONTEXT_WORKSPACE_RE.search(content)
+    if match:
+        artifacts.workspace = match.group("workspace").strip()
+
+
+def record_user_tool_result_artifacts(
+    artifacts: ChatArtifactsResponse,
+    content: Any,
+    question_labels_by_tool_use_id: dict[str, dict[str, str]],
+) -> None:
+    if not isinstance(content, list):
+        return
+
+    for part in content:
+        if not isinstance(part, dict) or part.get("type") != "tool_result":
+            continue
+        result_text = string_value(part.get("content"))
+        if not result_text:
+            continue
+        tool_use_id = string_value(part.get("tool_use_id"))
+        labels = question_labels_by_tool_use_id.get(tool_use_id or "")
+        record_answer_selections(artifacts, result_text, labels)
diff --git a/services/studio/src/nmp/studio/coding_agents.py b/services/studio/src/nmp/studio/coding_agents.py
index 5140c57b4e..04984d75e1 100644
--- a/services/studio/src/nmp/studio/coding_agents.py
+++ b/services/studio/src/nmp/studio/coding_agents.py
@@ -19,6 +19,17 @@
 from fastapi import APIRouter, FastAPI, HTTPException, Request
 from fastapi.responses import JSONResponse, Response, StreamingResponse
 from nmp.studio import studio_links
+from nmp.studio.coding_agent_artifacts import (
+    ChatArtifactsResponse,
+    record_answer_selections,
+    record_coding_agent_model,
+    record_spec_text_artifacts,
+    record_tool_artifacts,
+    record_tool_name,
+    record_user_tool_result_artifacts,
+    record_workspace_artifact,
+    string_value,
+)
 from nmp.studio.coding_agent_mcp_tools import (
     APPROVAL_TOOL_NAME,
     CLAUDE_MCP_SERVER_NAME,
@@ -92,6 +103,7 @@ class HistorySessionResponse(BaseModel):
     token_count: int
     tool_call_count: int
     tool_calls: list[str]
+    chat_artifacts: ChatArtifactsResponse
 
 
 class SessionHistoryResponse(BaseModel):
@@ -99,6 +111,7 @@ class SessionHistoryResponse(BaseModel):
 
     session_id: str
     items: list[dict[str, Any]]
+    chat_artifacts: ChatArtifactsResponse
 
 
 _initialized_sessions: set[str] = set()
@@ -117,6 +130,7 @@ class HistorySummary:
     token_count: int = 0
     tool_call_count: int = 0
     tool_calls: list[str] = dataclass_field(default_factory=list)
+    chat_artifacts: ChatArtifactsResponse = dataclass_field(default_factory=ChatArtifactsResponse)
 
 
 def _mcp_tools_for_destinations(
@@ -347,6 +361,11 @@ def _int_metric(value: Any) -> int:
     return value if isinstance(value, int) and not isinstance(value, bool) else 0
 
 
+def _append_unique_string(items: list[str], value: str) -> None:
+    if value not in items:
+        items.append(value)
+
+
 def _usage_token_count(usage: Any) -> int:
     if not isinstance(usage, dict):
         return 0
@@ -372,17 +391,25 @@ def _usage_identity(entry: dict[str, Any], message: dict[str, Any]) -> tuple[str
 
 def _append_tool_call(summary: HistorySummary, tool_name: str) -> None:
     summary.tool_call_count += 1
-    if tool_name not in summary.tool_calls:
-        summary.tool_calls.append(tool_name)
+    _append_unique_string(summary.tool_calls, tool_name)
+    record_tool_name(summary.chat_artifacts, tool_name)
 
 
 def _record_assistant_tool_calls(
     summary: HistorySummary,
     message: dict[str, Any],
     seen_tool_use_ids: set[str],
+    question_labels_by_tool_use_id: dict[str, dict[str, str]],
 ) -> None:
     for part in message.get("content") or []:
-        if not isinstance(part, dict) or part.get("type") != "tool_use":
+        if not isinstance(part, dict):
+            continue
+        if part.get("type") == "text":
+            text = string_value(part.get("text"))
+            if text:
+                record_spec_text_artifacts(summary.chat_artifacts, text)
+            continue
+        if part.get("type") != "tool_use":
             continue
         tool_use_id = part.get("id")
         if isinstance(tool_use_id, str):
@@ -390,13 +417,22 @@ def _record_assistant_tool_calls(
                 continue
             seen_tool_use_ids.add(tool_use_id)
         tool_name = part.get("name")
-        _append_tool_call(summary, tool_name if isinstance(tool_name, str) and tool_name else "tool")
+        tool_name = tool_name if isinstance(tool_name, str) and tool_name else "tool"
+        _append_tool_call(summary, tool_name)
+        record_tool_artifacts(
+            summary.chat_artifacts,
+            tool_name,
+            part.get("input") or {},
+            tool_use_id if isinstance(tool_use_id, str) else None,
+            question_labels_by_tool_use_id,
+        )
 
 
 def _summarize_history_session(path: Path) -> HistorySummary:
     summary = HistorySummary()
     seen_usage_events: set[tuple[str, str]] = set()
     seen_tool_use_ids: set[str] = set()
+    question_labels_by_tool_use_id: dict[str, dict[str, str]] = {}
     try:
         with path.open("r", encoding="utf-8", errors="replace") as fh:
             for line in fh:
@@ -414,6 +450,7 @@ def _summarize_history_session(path: Path) -> HistorySummary:
 
                 message = entry.get("message")
                 if isinstance(message, dict):
+                    record_coding_agent_model(summary.chat_artifacts, string_value(message.get("model")))
                     usage_identity = _usage_identity(entry, message)
                     if usage_identity is None or usage_identity not in seen_usage_events:
                         summary.token_count += _usage_token_count(message.get("usage"))
@@ -424,15 +461,27 @@ def _summarize_history_session(path: Path) -> HistorySummary:
 
                 entry_type = entry.get("type")
                 if entry_type == "assistant" and isinstance(message, dict):
-                    _record_assistant_tool_calls(summary, message, seen_tool_use_ids)
+                    _record_assistant_tool_calls(
+                        summary,
+                        message,
+                        seen_tool_use_ids,
+                        question_labels_by_tool_use_id,
+                    )
                 elif entry_type == "user" and isinstance(message, dict):
                     content = message.get("content")
-                    if not isinstance(content, str):
-                        continue
-                    content = _strip_studio_context_from_prompt(content)
-                    summary.message_count += 1
-                    if summary.first_prompt is None:
-                        summary.first_prompt = content
+                    if isinstance(content, str):
+                        record_workspace_artifact(summary.chat_artifacts, content)
+                        record_answer_selections(summary.chat_artifacts, content)
+                        content = _strip_studio_context_from_prompt(content)
+                        summary.message_count += 1
+                        if summary.first_prompt is None:
+                            summary.first_prompt = content
+                    else:
+                        record_user_tool_result_artifacts(
+                            summary.chat_artifacts,
+                            content,
+                            question_labels_by_tool_use_id,
+                        )
     except OSError:
         return HistorySummary()
     return summary
@@ -506,6 +555,7 @@ def list_history_sessions() -> list[HistorySessionResponse]:
                 token_count=summary.token_count,
                 tool_call_count=summary.tool_call_count,
                 tool_calls=summary.tool_calls,
+                chat_artifacts=summary.chat_artifacts,
             )
         )
     sessions.sort(key=lambda session: session.mtime, reverse=True)
@@ -521,6 +571,7 @@ def get_session_history(session_id: str) -> SessionHistoryResponse:
         raise HTTPException(status_code=404, detail="no such session history")
 
     items: list[dict[str, Any]] = []
+    summary = _summarize_history_session(path)
     try:
         with path.open("r", encoding="utf-8", errors="replace") as fh:
             for line in fh:
@@ -549,7 +600,7 @@ def get_session_history(session_id: str) -> SessionHistoryResponse:
         raise HTTPException(status_code=500, detail=str(exc)) from exc
 
     _initialized_sessions.add(sid)
-    return SessionHistoryResponse(session_id=sid, items=items)
+    return SessionHistoryResponse(session_id=sid, items=items, chat_artifacts=summary.chat_artifacts)
 
 
 @router.get("/skills", response_model=list[ClaudeSkillResponse])
diff --git a/services/studio/src/nmp/studio/studio_links.py b/services/studio/src/nmp/studio/studio_links.py
index 85e36174f7..45779ec224 100644
--- a/services/studio/src/nmp/studio/studio_links.py
+++ b/services/studio/src/nmp/studio/studio_links.py
@@ -302,6 +302,12 @@ class StudioLinkDestination:
         aliases=("experiment_group_detail",),
         requires_name=True,
     ),
+    "experiment_detail": StudioLinkDestination(
+        "Experiment {experiment_name}",
+        "/workspaces/{workspace}/experiment/{name}/{experiment_name}",
+        aliases=("experiment_run",),
+        required_args=("name", "experiment_name"),
+    ),
 }
 
 _STUDIO_LINK_DESTINATION_ALIASES = {
@@ -332,6 +338,7 @@ class StudioLinkDestination:
         "experiment_group_id",
         "experimentGroupId",
     ),
+    "experiment_name": ("experimentName", "experiment_id", "experimentId"),
     "file_path": ("file", "filePath", "file_path_encoded", "filePathEncoded", "path"),
 }
 
@@ -392,6 +399,7 @@ class StudioLinkDestination:
     "members": ("members_enabled",),
     "experiment": ("experiment",),
     "experiment_group": ("experiment",),
+    "experiment_detail": ("experiment",),
 }
 
 _STUDIO_LINK_DESTINATION_ANY_FEATURE_FLAGS: dict[str, tuple[str, ...]] = {
diff --git a/services/studio/tests/unit/test_coding_agents.py b/services/studio/tests/unit/test_coding_agents.py
index 87f983d64c..052c898937 100644
--- a/services/studio/tests/unit/test_coding_agents.py
+++ b/services/studio/tests/unit/test_coding_agents.py
@@ -169,6 +169,7 @@ def test_list_and_get_history_sessions(
                         "type": "assistant",
                         "message": {
                             "id": "msg_1",
+                            "model": "claude-sonnet-4-5",
                             "content": [
                                 {"type": "thinking", "thinking": "checking"},
                                 {"type": "text", "text": "done"},
@@ -189,6 +190,88 @@ def test_list_and_get_history_sessions(
                         "requestId": "req_1",
                     }
                 ),
+                json.dumps(
+                    {
+                        "type": "assistant",
+                        "message": {
+                            "id": "msg_2",
+                            "model": "claude-sonnet-4-6",
+                            "content": [
+                                {
+                                    "type": "tool_use",
+                                    "id": "toolu_write",
+                                    "name": "Write",
+                                    "input": {"file_path": "agents/beach-finder.yml", "content": "name: beach-finder"},
+                                },
+                                {
+                                    "type": "tool_use",
+                                    "id": "toolu_link",
+                                    "name": "mcp__nemo_studio__studio_link",
+                                    "input": {"destination": "agents", "label": "Agents"},
+                                },
+                                {
+                                    "type": "tool_use",
+                                    "id": "toolu_question",
+                                    "name": "AskUserQuestion",
+                                    "input": {
+                                        "questions": [
+                                            {
+                                                "question": "Which agent should be used?",
+                                                "header": "Agent",
+                                                "options": [{"label": "beach-finder"}],
+                                            }
+                                        ]
+                                    },
+                                },
+                            ],
+                        },
+                        "requestId": "req_2",
+                    }
+                ),
+                json.dumps(
+                    {
+                        "type": "user",
+                        "message": {
+                            "content": [
+                                {
+                                    "type": "tool_result",
+                                    "tool_use_id": "toolu_question",
+                                    "content": (
+                                        'Your question has been answered: "Which agent should be used?"='
+                                        '"beach-finder". You can now continue with this answer in mind.'
+                                    ),
+                                }
+                            ]
+                        },
+                    }
+                ),
+                json.dumps(
+                    {
+                        "type": "assistant",
+                        "message": {
+                            "id": "msg_3",
+                            "model": "claude-sonnet-4-6",
+                            "content": [
+                                {
+                                    "type": "text",
+                                    "text": "\n".join(
+                                        [
+                                            "Draft Spec: `cat-identifier`",
+                                            "Name: `cat-identifier`",
+                                            "",
+                                            "Model",
+                                            "`cloud, nvidia/llama-3.3-nemotron-super-49b-v1` - default, good reasoning",
+                                            "",
+                                            "Framework",
+                                            "langgraph-nat",
+                                        ]
+                                    ),
+                                }
+                            ],
+                        },
+                        "requestId": "req_3",
+                    }
+                ),
                 json.dumps(
                     {
                         "type": "user",
@@ -223,8 +306,19 @@ def test_list_and_get_history_sessions(
             "first_prompt": "first prompt",
             "message_count": 1,
             "token_count": 30,
-            "tool_call_count": 1,
-            "tool_calls": ["Bash"],
+            "tool_call_count": 4,
+            "tool_calls": ["Bash", "Write", "mcp__nemo_studio__studio_link", "AskUserQuestion"],
+            "chat_artifacts": {
+                "agent": "cat-identifier",
+                "model": "cloud, nvidia/llama-3.3-nemotron-super-49b-v1",
+                "model_source": "spec",
+                "coding_agent_model": "claude-sonnet-4-6",
+                "workspace": "default",
+                "selections": [{"label": "Agent", "value": "beach-finder"}],
+                "files": [{"action": "Wrote", "path": "agents/beach-finder.yml"}],
+                "links": [{"label": "Agents", "destination": "agents", "href": "/workspaces/default/agents"}],
+                "tools": ["Bash", "Write", "mcp__nemo_studio__studio_link", "AskUserQuestion"],
+            },
         }
     ]
 
@@ -243,7 +337,69 @@ def test_list_and_get_history_sessions(
                     {"type": "tool_use", "id": "toolu_1", "name": "Bash", "input": {"command": "pwd"}},
                 ],
             },
+            {
+                "kind": "assistant",
+                "parts": [
+                    {
+                        "type": "tool_use",
+                        "id": "toolu_write",
+                        "name": "Write",
+                        "input": {"file_path": "agents/beach-finder.yml", "content": "name: beach-finder"},
+                    },
+                    {
+                        "type": "tool_use",
+                        "id": "toolu_link",
+                        "name": "mcp__nemo_studio__studio_link",
+                        "input": {"destination": "agents", "label": "Agents"},
+                    },
+                    {
+                        "type": "tool_use",
+                        "id": "toolu_question",
+                        "name": "AskUserQuestion",
+                        "input": {
+                            "questions": [
+                                {
+                                    "question": "Which agent should be used?",
+                                    "header": "Agent",
+                                    "options": [{"label": "beach-finder"}],
+                                }
+                            ]
+                        },
+                    },
+                ],
+            },
+            {
+                "kind": "assistant",
+                "parts": [
+                    {
+                        "type": "text",
+                        "text": "\n".join(
+                            [
+                                "Draft Spec: `cat-identifier`",
+                                "Name: `cat-identifier`",
+                                "",
+                                "Model",
+                                "`cloud, nvidia/llama-3.3-nemotron-super-49b-v1` - default, good reasoning",
+                                "",
+                                "Framework",
+                                "langgraph-nat",
+                            ]
+                        ),
+                    }
+                ],
+            },
         ],
+        "chat_artifacts": {
+            "agent": "cat-identifier",
+            "model": "cloud, nvidia/llama-3.3-nemotron-super-49b-v1",
+            "model_source": "spec",
+            "coding_agent_model": "claude-sonnet-4-6",
+            "workspace": "default",
+            "selections": [{"label": "Agent", "value": "beach-finder"}],
+            "files": [{"action": "Wrote", "path": "agents/beach-finder.yml"}],
+            "links": [{"label": "Agents", "destination": "agents", "href": "/workspaces/default/agents"}],
+            "tools": ["Bash", "Write", "mcp__nemo_studio__studio_link", "AskUserQuestion"],
+        },
     }
     assert session_id in coding_agents._initialized_sessions
 
@@ -454,6 +610,7 @@ def test_studio_link_destinations_cover_registered_workspace_routes():
         "evaluationResultDetails": "evaluation_result",
         "evaluationResults": "evaluation_results",
         "experiment": "experiment",
+        "experimentDetail": "experiment_detail",
         "experimentGroupDetail": "experiment_group",
         "filesetDetail": "fileset",
         "filesetDetails": "fileset_panel",
diff --git a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/ClaudeCodeHistoryPanel.tsx b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/ClaudeCodeHistoryPanel.tsx
index 0ef6597935..d8bbfe2f70 100644
--- a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/ClaudeCodeHistoryPanel.tsx
+++ b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/ClaudeCodeHistoryPanel.tsx
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import {
+  Anchor,
   Banner,
   Button,
   Card,
@@ -13,13 +14,21 @@ import {
   Tooltip,
 } from '@nvidia/foundations-react-core';
 import { Empty } from '@studio/components/Empty';
+import { useWorkspaceFromPathIfExists } from '@studio/hooks/useWorkspaceFromPath';
 import {
   CLAUDE_CODE_HISTORY_SESSIONS_QUERY_KEY,
   CLAUDE_CODE_SKILLS_QUERY_KEY,
   listClaudeCodeHistorySessions,
   listClaudeCodeSkills,
 } from '@studio/routes/agents/ClaudeCodeChatRoute/api';
+import { cleanClaudeCodeArtifactText } from '@studio/routes/agents/ClaudeCodeChatRoute/artifacts';
+import { CLAUDE_CODE_STUDIO_LINK_CLASS } from '@studio/routes/agents/ClaudeCodeChatRoute/ClaudeCodeStudioLink';
+import { getStudioInternalLinkTarget } from '@studio/routes/agents/ClaudeCodeChatRoute/ClaudeCodeStudioLinkTarget';
 import type {
+  ClaudeCodeChatArtifacts,
+  ClaudeCodeChatFileArtifact,
+  ClaudeCodeChatLinkArtifact,
+  ClaudeCodeChatSelectionArtifact,
   ClaudeCodeHistorySession,
   ClaudeCodeSkill,
 } from '@studio/routes/agents/ClaudeCodeChatRoute/types';
@@ -29,19 +38,28 @@ import { CLAUDE_CODE_HISTORY_OPEN_KEY, CLAUDE_CODE_PANEL_TAB_KEY } from '@studio
 import { useQuery } from '@tanstack/react-query';
 import cn from 'classnames';
 import {
+  ArrowRight,
+  Bot,
   BookOpen,
+  Boxes,
+  Cpu,
+  FileCode2,
   History,
+  Link2,
   MessageSquare,
   MessageSquarePlus,
   PanelRightClose,
   PanelRightOpen,
   RefreshCw,
+  Sparkles,
   Wrench,
 } from 'lucide-react';
-import { type FC } from 'react';
+import { type FC, type ReactNode } from 'react';
+import { Link } from 'react-router-dom';
 
 interface ClaudeCodeHistoryPanelProps {
   activeSessionId?: string;
+  artifacts?: ClaudeCodeChatArtifacts;
   onNewChat: () => void;
   onSelectSession: (sessionId: string) => void;
 }
@@ -120,6 +138,245 @@ const ToolCallSummary = ({ toolCalls }: { toolCalls: string[] }) => {
   );
 };
 
+const ArtifactChip = ({ children }: { children: ReactNode }) => {
+  const content = typeof children === 'string' ? cleanClaudeCodeArtifactText(children) : children;
+
+  return (
+    <span className="inline-flex min-w-0 max-w-full items-center rounded-full border border-accent/30 bg-accent/10 px-2 py-0.5 text-accent">
+      <Text kind="label/bold/sm" className="truncate">
+        {content}
+      </Text>
+    </span>
+  );
+};
+
+const ArtifactRow = ({
+  icon,
+  label,
+  value,
+}: {
+  icon: ReactNode;
+  label: string;
+  value?: string;
+}) => {
+  if (!value) return null;
+
+  return (
+    <Flex align="start" gap="density-sm" className="min-w-0">
+      <span className="mt-1 flex size-5 shrink-0 items-center justify-center text-secondary">
+        {icon}
+      </span>
+      <Flex align="center" gap="density-xs" className="min-w-0 flex-1 flex-wrap">
+        <Text kind="label/bold/sm" color="secondary" className="shrink-0">
+          {label}:
+        </Text>
+        <ArtifactChip>{value}</ArtifactChip>
+      </Flex>
+    </Flex>
+  );
+};
+
+const ArtifactSection = ({
+  background,
+  children,
+  icon,
+  title,
+}: {
+  background?: boolean;
+  children: ReactNode;
+  icon: ReactNode;
+  title: string;
+}) => (
+  <Stack
+    gap="density-xs"
+    className={cn(
+      'min-w-0',
+      background && 'rounded border border-base bg-surface-sunken px-density-sm py-density-sm'
+    )}
+  >
+    <Flex align="center" gap="density-xs" className="text-secondary">
+      {icon}
+      <Text kind="label/bold/sm" color="secondary">
+        {title}
+      </Text>
+    </Flex>
+    {children}
+  </Stack>
+);
+
+const getFileLabel = (file: ClaudeCodeChatFileArtifact): string => {
+  const parts = file.path.split('/');
+  return parts[parts.length - 1] || file.path;
+};
+
+const FileArtifacts = ({ files }: { files: ClaudeCodeChatFileArtifact[] }) => {
+  if (!files.length) return null;
+
+  return (
+    <ArtifactSection icon={<FileCode2 size={14} />} title="Files">
+      <Stack gap="density-xs">
+        {files.slice(0, 6).map((file) => (
+          <Flex
+            key={`${file.action}-${file.path}`}
+            align="center"
+            gap="density-xs"
+            className="min-w-0 rounded border border-base bg-surface-sunken px-density-sm py-density-xs"
+            title={file.path}
+          >
+            <Text kind="label/bold/sm" className="shrink-0">
+              {file.action}
+            </Text>
+            <Text kind="body/regular/sm" className="min-w-0 flex-1 truncate font-mono">
+              {getFileLabel(file)}
+            </Text>
+          </Flex>
+        ))}
+      </Stack>
+    </ArtifactSection>
+  );
+};
+
+const LinkArtifacts = ({ links }: { links: ClaudeCodeChatLinkArtifact[] }) => {
+  const workspace = useWorkspaceFromPathIfExists();
+
+  if (!links.length) return null;
+
+  return (
+    <ArtifactSection icon={<Link2 size={14} />} title="Studio links">
+      <Flex gap="density-xs" className="min-w-0 flex-wrap">
+        {links.slice(0, 6).map((link) => {
+          const target = getStudioInternalLinkTarget(
+            link.href ?? link.destination,
+            window.location.origin,
+            workspace
+          );
+          const label = cleanClaudeCodeArtifactText(link.label);
+          const key = `${link.label}-${link.destination ?? link.href ?? 'link'}`;
+
+          return target ? (
+            <Anchor asChild key={key}>
+              <Link className={CLAUDE_CODE_STUDIO_LINK_CLASS} to={target}>
+                <span className="truncate">{label}</span>
+                <ArrowRight aria-hidden="true" className="h-3.5 w-3.5 shrink-0" />
+              </Link>
+            </Anchor>
+          ) : (
+            <ArtifactChip key={key}>{label}</ArtifactChip>
+          );
+        })}
+      </Flex>
+    </ArtifactSection>
+  );
+};
+
+const SelectionArtifacts = ({ selections }: { selections: ClaudeCodeChatSelectionArtifact[] }) => {
+  if (!selections.length) return null;
+
+  return (
+    <ArtifactSection background icon={<Boxes size={14} />} title="Selections">
+      <Stack gap="density-xs">
+        {selections.slice(0, 6).map((selection) => (
+          <ArtifactRow
+            key={selection.label}
+            icon={<Sparkles size={14} />}
+            label={selection.label}
+            value={selection.value}
+          />
+        ))}
+      </Stack>
+    </ArtifactSection>
+  );
+};
+
+const ToolArtifacts = ({ tools }: { tools: string[] }) => {
+  if (!tools.length) return null;
+
+  return (
+    <ArtifactSection background icon={<Wrench size={14} />} title="Tools">
+      <Flex gap="density-xs" className="min-w-0 flex-wrap">
+        {tools.slice(0, 8).map((tool) => (
+          <ArtifactChip key={tool}>{tool}</ArtifactChip>
+        ))}
+      </Flex>
+    </ArtifactSection>
+  );
+};
+
+const getSelectedArtifactModel = (artifacts: ClaudeCodeChatArtifacts): string | undefined =>
+  artifacts.model_source === 'selection' || artifacts.model_source === 'spec'
+    ? artifacts.model
+    : undefined;
+
+const hasArtifacts = (artifacts?: ClaudeCodeChatArtifacts): artifacts is ClaudeCodeChatArtifacts =>
+  !!artifacts &&
+  !!(
+    artifacts.agent ||
+    getSelectedArtifactModel(artifacts) ||
+    artifacts.workspace ||
+    artifacts.selections.length ||
+    artifacts.files.length ||
+    artifacts.links.length ||
+    artifacts.tools.length
+  );
+
+const ClaudeCodeArtifactsPane = ({
+  artifacts,
+  collapseLabel,
+  onCollapse,
+}: {
+  artifacts?: ClaudeCodeChatArtifacts;
+  collapseLabel: string;
+  onCollapse: () => void;
+}) => {
+  const selectedModel = artifacts ? getSelectedArtifactModel(artifacts) : undefined;
+
+  return (
+    <section className="flex min-h-0 basis-1/2 flex-col border-b border-base">
+      <Flex
+        align="center"
+        justify="between"
+        gap="density-sm"
+        className="border-b border-base px-density-md py-density-sm"
+      >
+        <Flex align="center" gap="density-sm" className="min-w-0">
+          <Sparkles size={18} className="shrink-0 text-secondary" />
+          <Text kind="label/bold/md" className="truncate">
+            Chat artifacts
+          </Text>
+        </Flex>
+        <Tooltip slotContent={collapseLabel} side="left">
+          <Button
+            aria-label={collapseLabel}
+            kind="tertiary"
+            size="small"
+            type="button"
+            onClick={onCollapse}
+          >
+            <PanelRightClose size={18} />
+          </Button>
+        </Tooltip>
+      </Flex>
+      {hasArtifacts(artifacts) ? (
+        <Stack gap="density-md" padding="density-md" className="min-h-0 flex-1 overflow-y-auto">
+          <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} />
+          <FileArtifacts files={artifacts.files} />
+          <LinkArtifacts links={artifacts.links} />
+          <ToolArtifacts tools={artifacts.tools} />
+        </Stack>
+      ) : (
+        <Flex className="min-h-0 flex-1 px-density-md" align="center" justify="center">
+          <Empty title="No artifacts yet" description="Selections and outputs will appear here." />
+        </Flex>
+      )}
+    </section>
+  );
+};
+
 const HistorySessionButton = ({
   active,
   onSelect,
@@ -206,6 +463,7 @@ const HistoryPanelContents = ({
   } = useQuery({
     queryKey: CLAUDE_CODE_HISTORY_SESSIONS_QUERY_KEY,
     queryFn: listClaudeCodeHistorySessions,
+    refetchOnMount: 'always',
   });
 
   return (
@@ -357,35 +615,35 @@ export const ClaudeCodeHistoryPanel: FC<ClaudeCodeHistoryPanelProps> = (props) =
   }
 
   return (
-    <aside className="flex min-h-80 w-full shrink-0 flex-col border-t border-base bg-surface-base lg:w-84 lg:border-l lg:border-t-0">
-      <Flex
-        align="center"
-        justify="between"
-        gap="density-sm"
-        className="border-b border-base px-density-md py-density-sm"
-      >
-        <SegmentedControl
-          size="tiny"
-          value={selectedTab}
-          onValueChange={handleTabChange}
-          items={PANEL_TAB_ITEMS}
-          className="min-w-0 flex-1"
-        />
-        <Tooltip slotContent={toggleLabel} side="left">
-          <Button
-            aria-label={toggleLabel}
-            kind="tertiary"
-            size="small"
-            type="button"
-            onClick={() => setHistoryOpen('false')}
-          >
-            <PanelRightClose size={18} />
-          </Button>
-        </Tooltip>
-      </Flex>
-      <div className="flex min-h-0 flex-1 flex-col">
-        {selectedTab === 'history' ? <HistoryPanelContents {...props} /> : <SkillsPanelContents />}
-      </div>
+    <aside className="flex min-h-80 w-full shrink-0 flex-col border-t border-base bg-surface-base lg:w-[30rem] lg:border-l lg:border-t-0 xl:w-[32rem]">
+      <ClaudeCodeArtifactsPane
+        artifacts={props.artifacts}
+        collapseLabel={toggleLabel}
+        onCollapse={() => setHistoryOpen('false')}
+      />
+      <section className="flex min-h-0 basis-1/2 flex-col">
+        <Flex
+          align="center"
+          justify="between"
+          gap="density-sm"
+          className="border-b border-base px-density-md py-density-sm"
+        >
+          <SegmentedControl
+            size="tiny"
+            value={selectedTab}
+            onValueChange={handleTabChange}
+            items={PANEL_TAB_ITEMS}
+            className="min-w-0 flex-1"
+          />
+        </Flex>
+        <div className="flex min-h-0 flex-1 flex-col">
+          {selectedTab === 'history' ? (
+            <HistoryPanelContents {...props} />
+          ) : (
+            <SkillsPanelContents />
+          )}
+        </div>
+      </section>
     </aside>
   );
 };
diff --git a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/ClaudeCodeLayout.tsx b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/ClaudeCodeLayout.tsx
index c773e079ce..295b5aa402 100644
--- a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/ClaudeCodeLayout.tsx
+++ b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/ClaudeCodeLayout.tsx
@@ -4,6 +4,7 @@
 import { Flex } from '@nvidia/foundations-react-core';
 import { useWorkspaceFromPath } from '@studio/hooks/useWorkspaceFromPath';
 import { ClaudeCodeHistoryPanel } from '@studio/routes/agents/ClaudeCodeChatRoute/ClaudeCodeHistoryPanel';
+import type { ClaudeCodeChatArtifacts } from '@studio/routes/agents/ClaudeCodeChatRoute/types';
 import { getClaudeCodeChatRouteForSession } from '@studio/routes/agents/ClaudeCodeChatRoute/util';
 import { getWorkspaceDashboardRoute } from '@studio/routes/utils';
 import { type FC, type ReactNode, useCallback } from 'react';
@@ -11,10 +12,15 @@ import { useNavigate } from 'react-router-dom';
 
 interface ClaudeCodeLayoutProps {
   activeSessionId?: string;
+  artifacts?: ClaudeCodeChatArtifacts;
   children: ReactNode;
 }
 
-export const ClaudeCodeLayout: FC<ClaudeCodeLayoutProps> = ({ activeSessionId, children }) => {
+export const ClaudeCodeLayout: FC<ClaudeCodeLayoutProps> = ({
+  activeSessionId,
+  artifacts,
+  children,
+}) => {
   const workspace = useWorkspaceFromPath();
   const navigate = useNavigate();
 
@@ -34,6 +40,7 @@ export const ClaudeCodeLayout: FC<ClaudeCodeLayoutProps> = ({ activeSessionId, c
       <Flex className="h-full min-h-0 min-w-0 flex-1">{children}</Flex>
       <ClaudeCodeHistoryPanel
         activeSessionId={activeSessionId}
+        artifacts={artifacts}
         onNewChat={handleNewChat}
         onSelectSession={handleSelectSession}
       />
diff --git a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/ClaudeCodeStudioLink.tsx b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/ClaudeCodeStudioLink.tsx
index 46438dac6d..ff14a04ee0 100644
--- a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/ClaudeCodeStudioLink.tsx
+++ b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/ClaudeCodeStudioLink.tsx
@@ -13,6 +13,9 @@ interface ClaudeCodeStudioLinkProps {
   href?: string;
 }
 
+export const CLAUDE_CODE_STUDIO_LINK_CLASS =
+  'inline-flex min-h-7 max-w-full items-center gap-density-xs rounded border border-base bg-[linear-gradient(135deg,var(--background-color-accent-green-subtle),var(--background-color-accent-teal-subtle)_58%,var(--background-color-interaction-base))] px-density-sm py-density-xs align-baseline text-sm font-medium leading-none no-underline shadow-sm transition-[background,box-shadow] hover:bg-[linear-gradient(135deg,var(--background-color-accent-green-subtle-hover),var(--background-color-accent-teal-subtle-hover)_58%,var(--background-color-interaction-hover))] hover:shadow';
+
 export const ClaudeCodeStudioLink = ({ href, children }: ClaudeCodeStudioLinkProps) => {
   const workspace = useWorkspaceFromPathIfExists();
   const target = getStudioInternalLinkTarget(href, window.location.origin, workspace);
@@ -23,10 +26,7 @@ export const ClaudeCodeStudioLink = ({ href, children }: ClaudeCodeStudioLinkPro
 
   return (
     <Anchor asChild>
-      <Link
-        className="inline-flex min-h-7 max-w-full items-center gap-density-xs rounded border border-base bg-[linear-gradient(135deg,var(--background-color-accent-green-subtle),var(--background-color-accent-teal-subtle)_58%,var(--background-color-interaction-base))] px-density-sm py-density-xs align-baseline text-sm font-medium leading-none no-underline shadow-sm transition-[background,box-shadow] hover:bg-[linear-gradient(135deg,var(--background-color-accent-green-subtle-hover),var(--background-color-accent-teal-subtle-hover)_58%,var(--background-color-interaction-hover))] hover:shadow"
-        to={target}
-      >
+      <Link className={CLAUDE_CODE_STUDIO_LINK_CLASS} to={target}>
         <span className="truncate">{children}</span>
         <ArrowRight aria-hidden="true" className="h-3.5 w-3.5 shrink-0" />
       </Link>
diff --git a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/ClaudeCodeToolCallPart.spec.tsx b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/ClaudeCodeToolCallPart.spec.tsx
index 47d5ba4ec8..e2c631b7c2 100644
--- a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/ClaudeCodeToolCallPart.spec.tsx
+++ b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/ClaudeCodeToolCallPart.spec.tsx
@@ -6,7 +6,10 @@ import {
   CLAUDE_CODE_JOB_PROGRESS_MCP_TOOL_NAME,
   CLAUDE_CODE_JOB_PROGRESS_TOOL_NAME,
 } from '@studio/routes/agents/ClaudeCodeChatRoute/jobProgressConsts';
-import { CLAUDE_CODE_SUBTLE_TOOL_GROUP_NAME } from '@studio/routes/agents/ClaudeCodeChatRoute/toolParts';
+import {
+  CLAUDE_CODE_COLLAPSED_THINKING_TOOL_NAME,
+  CLAUDE_CODE_SUBTLE_TOOL_GROUP_NAME,
+} from '@studio/routes/agents/ClaudeCodeChatRoute/toolParts';
 import { render, screen, within } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 
@@ -94,6 +97,39 @@ const expectLineChangeColors = ({
 };
 
 describe('ClaudeCodeToolCallPart', () => {
+  it('renders collapsed thinking as an expandable subtle disclosure', async () => {
+    const user = userEvent.setup();
+
+    render(
+      <ClaudeCodeToolCallPart
+        addResult={vi.fn()}
+        args={{
+          text: 'I will inspect the repo first.\n\nI found the files that matter.',
+        }}
+        argsText='{"text":"I will inspect the repo first.\\n\\nI found the files that matter."}'
+        resume={vi.fn()}
+        status={{ type: 'complete' }}
+        toolCallId="claude-code-collapsed-thinking"
+        toolName={CLAUDE_CODE_COLLAPSED_THINKING_TOOL_NAME}
+        type="tool-call"
+      />
+    );
+
+    const disclosure = screen.getByTestId('claude-code-collapsed-thinking');
+    expect(disclosure).toHaveTextContent('Earlier thinking');
+    expect(disclosure).not.toHaveAttribute('open');
+
+    await user.click(screen.getByText('Earlier thinking'));
+
+    expect(disclosure).toHaveAttribute('open');
+    expect(screen.getByTestId('claude-code-collapsed-thinking-content')).toHaveTextContent(
+      'I will inspect the repo first.'
+    );
+    expect(screen.getByTestId('claude-code-collapsed-thinking-content')).toHaveTextContent(
+      'I found the files that matter.'
+    );
+  });
+
   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 8ea9eba4a0..ddbbbd1634 100644
--- a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/ClaudeCodeToolCallPart.tsx
+++ b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/ClaudeCodeToolCallPart.tsx
@@ -5,6 +5,7 @@ import type { ToolCallMessagePartComponent } from '@assistant-ui/react';
 import { Text } from '@nvidia/foundations-react-core';
 import { JobProgressToolCall } from '@studio/routes/agents/ClaudeCodeChatRoute/JobProgressToolCall';
 import {
+  CLAUDE_CODE_COLLAPSED_THINKING_TOOL_NAME,
   CLAUDE_CODE_SUBTLE_TOOL_GROUP_NAME,
   isClaudeCodeJobProgressToolName,
   isClaudeCodeSubtleToolCallName,
@@ -206,6 +207,13 @@ const getEditStats = (args: Record<string, unknown>): { additions: number; delet
 const isToolArgsRecord = (value: unknown): value is Record<string, unknown> =>
   typeof value === 'object' && value !== null && !Array.isArray(value);
 
+const splitCollapsedThinkingParagraphs = (text: string): readonly string[] =>
+  text
+    .trim()
+    .split(/\n\s*\n/)
+    .map((paragraph) => paragraph.trim())
+    .filter(Boolean);
+
 const getAskUserQuestionSummary = (args: ClaudeCodeToolArgs): string | undefined => {
   const questions = args.questions;
   const firstQuestion = Array.isArray(questions) ? questions.find(isToolArgsRecord) : undefined;
@@ -550,6 +558,39 @@ const SubtleToolCallRow = ({ actions, isRunning = false }: SubtleToolCallRowProp
   </Text>
 );
 
+const CollapsedThinkingToolCall = ({ text }: { readonly text: string }) => {
+  const paragraphs = splitCollapsedThinkingParagraphs(text);
+  if (!paragraphs.length) return null;
+
+  return (
+    <Text asChild kind="body/regular/sm">
+      <details
+        className="group/thinking my-density-xs max-w-full text-gray-500 dark:text-gray-400"
+        data-testid="claude-code-collapsed-thinking"
+      >
+        <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/thinking:rotate-90"
+          />
+          <ClipboardList aria-hidden className="size-3.5 shrink-0" />
+          <span>Earlier thinking</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-thinking-content"
+        >
+          {paragraphs.map((paragraph, index) => (
+            <p key={`${paragraph.slice(0, 24)}-${index}`} className="whitespace-pre-wrap">
+              {paragraph}
+            </p>
+          ))}
+        </div>
+      </details>
+    </Text>
+  );
+};
+
 interface FileChangeToolCallCardProps {
   readonly isRunning?: boolean;
   readonly summary: {
@@ -617,13 +658,23 @@ const FileChangeToolCallCard = ({ isRunning = false, summary }: FileChangeToolCa
   );
 };
 
-export const ClaudeCodeToolCallPart: ToolCallMessagePartComponent<ClaudeCodeToolArgs, unknown> = ({
+interface ClaudeCodeToolCallPartContentProps {
+  readonly args: ClaudeCodeToolArgs;
+  readonly argsText: string;
+  readonly isRunning?: boolean;
+  readonly toolName: string;
+}
+
+const ClaudeCodeToolCallPartContent = ({
   args,
   argsText,
-  status,
   toolName,
-}) => {
-  const isRunning = status.type === 'running';
+  isRunning = false,
+}: ClaudeCodeToolCallPartContentProps) => {
+  if (toolName === CLAUDE_CODE_COLLAPSED_THINKING_TOOL_NAME) {
+    const text = getStringArg(args, ['text']);
+    return text ? <CollapsedThinkingToolCall text={text} /> : null;
+  }
 
   if (isClaudeCodeJobProgressToolName(toolName)) {
     return <JobProgressToolCall args={args} />;
@@ -682,3 +733,17 @@ export const ClaudeCodeToolCallPart: ToolCallMessagePartComponent<ClaudeCodeTool
     />
   );
 };
+
+export const ClaudeCodeToolCallPart: ToolCallMessagePartComponent<ClaudeCodeToolArgs, unknown> = ({
+  args,
+  argsText,
+  status,
+  toolName,
+}) => (
+  <ClaudeCodeToolCallPartContent
+    args={args}
+    argsText={argsText}
+    isRunning={status.type === 'running'}
+    toolName={toolName}
+  />
+);
diff --git a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/api.spec.ts b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/api.spec.ts
index 1c20a0ede9..133ea63628 100644
--- a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/api.spec.ts
+++ b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/api.spec.ts
@@ -55,6 +55,38 @@ describe('Claude Code API helpers', () => {
     );
   });
 
+  it('keeps historical chat artifact selections when loading a session', async () => {
+    const fetchMock = vi.fn().mockResolvedValue(
+      new Response(
+        JSON.stringify({
+          session_id: 'session-1',
+          items: [],
+          chat_artifacts: {
+            selections: [
+              { label: 'Agent', value: 'cat-identifier' },
+              { label: 'Model', value: '`cloud, nvidia/example` - good for this agent' },
+            ],
+            files: [],
+            links: [{ label: 'Agents', destination: 'agents', href: '/workspaces/default/agents' }],
+            tools: [],
+          },
+        }),
+        { status: 200 }
+      )
+    );
+    vi.stubGlobal('fetch', fetchMock);
+
+    const history = await getClaudeCodeSessionHistory('session-1');
+
+    expect(history.chat_artifacts.selections).toEqual([
+      { label: 'Agent', value: 'cat-identifier' },
+      { label: 'Model', value: 'cloud, nvidia/example' },
+    ]);
+    expect(history.chat_artifacts.links).toEqual([
+      { label: 'Agents', destination: 'agents', href: '/workspaces/default/agents' },
+    ]);
+  });
+
   it('emits structured permission requests from SSE events', async () => {
     const fetchMock = vi
       .fn()
@@ -388,6 +420,17 @@ describe('Claude Code API helpers', () => {
 
     await expect(getClaudeCodeSessionHistory('session-1')).resolves.toEqual({
       session_id: 'session-1',
+      chat_artifacts: {
+        agent: undefined,
+        coding_agent_model: undefined,
+        files: [],
+        links: [],
+        model: undefined,
+        model_source: undefined,
+        selections: [],
+        tools: ['job_progress'],
+        workspace: undefined,
+      },
       items: [
         {
           kind: 'assistant',
diff --git a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/api.ts b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/api.ts
index 234e6d2f75..705243e337 100644
--- a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/api.ts
+++ b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/api.ts
@@ -2,9 +2,19 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { BASE_URL, PLATFORM_BASE_URL } from '@studio/constants/environment';
+import {
+  cleanClaudeCodeArtifactText,
+  createEmptyClaudeCodeChatArtifacts,
+  updateClaudeCodeChatArtifactsFromHistoryItems,
+} from '@studio/routes/agents/ClaudeCodeChatRoute/artifacts';
 import { parseJsonObject, parseSseChunk } from '@studio/routes/agents/ClaudeCodeChatRoute/stream';
 import type {
   ClaudeCodeAssistantHistoryPart,
+  ClaudeCodeChatArtifacts,
+  ClaudeCodeChatFileArtifact,
+  ClaudeCodeChatLinkArtifact,
+  ClaudeCodeChatModelSource,
+  ClaudeCodeChatSelectionArtifact,
   ClaudeCodeHistorySession,
   ClaudeCodeInputDecision,
   ClaudeCodeInputRequest,
@@ -89,6 +99,73 @@ const getNumber = (value: unknown): number =>
 const getStringArray = (value: unknown): string[] =>
   Array.isArray(value) ? value.filter((item): item is string => typeof item === 'string') : [];
 
+const getOptionalString = (value: unknown): string | undefined => {
+  const text = getString(value).trim();
+  return text || undefined;
+};
+
+const getOptionalArtifactString = (value: unknown): string | undefined => {
+  const text = getOptionalString(value);
+  return text ? cleanClaudeCodeArtifactText(text) : undefined;
+};
+
+const parseModelSource = (value: unknown): ClaudeCodeChatModelSource | undefined => {
+  if (value === 'coding_agent' || value === 'selection' || value === 'spec') return value;
+  return undefined;
+};
+
+const parseSelectionArtifact = (value: unknown): ClaudeCodeChatSelectionArtifact | undefined => {
+  if (!isRecord(value)) return undefined;
+  const label = getOptionalString(value.label);
+  const artifactValue = getOptionalArtifactString(value.value);
+  if (!label || !artifactValue) return undefined;
+  return { label, value: artifactValue };
+};
+
+const parseFileArtifact = (value: unknown): ClaudeCodeChatFileArtifact | undefined => {
+  if (!isRecord(value)) return undefined;
+  const action = getOptionalString(value.action);
+  const path = getOptionalString(value.path);
+  if (!action || !path) return undefined;
+  return { action, path };
+};
+
+const parseLinkArtifact = (value: unknown): ClaudeCodeChatLinkArtifact | undefined => {
+  if (!isRecord(value)) return undefined;
+  const label = getOptionalString(value.label);
+  if (!label) return undefined;
+  return {
+    label,
+    destination: getOptionalString(value.destination),
+    href: getOptionalString(value.href),
+  };
+};
+
+const parseArray = <T>(value: unknown, parseItem: (item: unknown) => T | undefined): T[] =>
+  Array.isArray(value) ? value.map(parseItem).filter((item): item is T => item !== undefined) : [];
+
+const parseChatArtifacts = (value: unknown): ClaudeCodeChatArtifacts => {
+  if (!isRecord(value)) return createEmptyClaudeCodeChatArtifacts();
+
+  const modelSource = parseModelSource(value.model_source);
+  const model = getOptionalArtifactString(value.model);
+  const codingAgentModel =
+    getOptionalArtifactString(value.coding_agent_model) ||
+    (modelSource === 'coding_agent' ? model : undefined);
+
+  return {
+    agent: getOptionalArtifactString(value.agent),
+    model: modelSource === 'coding_agent' ? undefined : model,
+    model_source: modelSource === 'coding_agent' ? undefined : modelSource,
+    coding_agent_model: codingAgentModel,
+    workspace: getOptionalArtifactString(value.workspace),
+    selections: parseArray(value.selections, parseSelectionArtifact),
+    files: parseArray(value.files, parseFileArtifact),
+    links: parseArray(value.links, parseLinkArtifact),
+    tools: getStringArray(value.tools).map(cleanClaudeCodeArtifactText),
+  };
+};
+
 const parseHistorySession = (value: unknown): ClaudeCodeHistorySession | undefined => {
   if (!isRecord(value)) return undefined;
   const sessionId = getString(value.session_id);
@@ -102,6 +179,7 @@ const parseHistorySession = (value: unknown): ClaudeCodeHistorySession | undefin
     token_count: getNumber(value.token_count),
     tool_call_count: getNumber(value.tool_call_count),
     tool_calls: getStringArray(value.tool_calls),
+    chat_artifacts: parseChatArtifacts(value.chat_artifacts),
   };
 };
 
@@ -207,13 +285,19 @@ export const getClaudeCodeSessionHistory = async (
     throw new Error('Claude Code session history response was not an object');
   }
 
+  const items = Array.isArray(body.items)
+    ? body.items
+        .map(parseSessionHistoryItem)
+        .filter((item): item is ClaudeCodeSessionHistoryItem => item !== undefined)
+    : [];
+
   return {
     session_id: getString(body.session_id) || sessionId,
-    items: Array.isArray(body.items)
-      ? body.items
-          .map(parseSessionHistoryItem)
-          .filter((item): item is ClaudeCodeSessionHistoryItem => item !== undefined)
-      : [],
+    items,
+    chat_artifacts: updateClaudeCodeChatArtifactsFromHistoryItems(
+      parseChatArtifacts(body.chat_artifacts),
+      items
+    ),
   };
 };
 
diff --git a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/artifacts.spec.ts b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/artifacts.spec.ts
new file mode 100644
index 0000000000..a8f629ff94
--- /dev/null
+++ b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/artifacts.spec.ts
@@ -0,0 +1,189 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import {
+  createEmptyClaudeCodeChatArtifacts,
+  updateClaudeCodeChatArtifactsFromEvent,
+  updateClaudeCodeChatArtifactsFromHistoryItems,
+  updateClaudeCodeChatArtifactsFromSelections,
+} from '@studio/routes/agents/ClaudeCodeChatRoute/artifacts';
+
+describe('Claude Code chat artifacts', () => {
+  it('keeps the latest streamed coding-agent model', () => {
+    const initial = createEmptyClaudeCodeChatArtifacts();
+    const first = updateClaudeCodeChatArtifactsFromEvent(initial, {
+      type: 'assistant',
+      message: { model: 'claude-sonnet-4-5', content: [] },
+    });
+    const updated = updateClaudeCodeChatArtifactsFromEvent(first, {
+      type: 'assistant',
+      message: { model: 'claude-sonnet-4-6', content: [] },
+    });
+
+    expect(updated.model).toBeUndefined();
+    expect(updated.model_source).toBeUndefined();
+    expect(updated.coding_agent_model).toBe('claude-sonnet-4-6');
+  });
+
+  it('promotes agent and selected model answers while preserving coding-agent model', () => {
+    const withCodingModel = updateClaudeCodeChatArtifactsFromEvent(
+      createEmptyClaudeCodeChatArtifacts(),
+      {
+        type: 'assistant',
+        message: { model: 'claude-sonnet-4-6', content: [] },
+      }
+    );
+
+    const withSelections = updateClaudeCodeChatArtifactsFromSelections(
+      withCodingModel,
+      [
+        { header: 'Agent', question: 'Which agent should be used?' },
+        { header: 'Model', question: 'Which inference provider and model should be used?' },
+        { header: 'Dataset type', question: 'What kind of dataset do you want to generate?' },
+      ],
+      {
+        'Which agent should be used?': 'beach-finder',
+        'Which inference provider and model should be used?':
+          'nvidia-build - meta/llama-3.3-70b-instruct',
+        'What kind of dataset do you want to generate?': 'Text classification',
+      }
+    );
+
+    expect(withSelections.agent).toBe('beach-finder');
+    expect(withSelections.model).toBe('nvidia-build - meta/llama-3.3-70b-instruct');
+    expect(withSelections.model_source).toBe('selection');
+    expect(withSelections.coding_agent_model).toBe('claude-sonnet-4-6');
+    expect(withSelections.selections).toEqual([
+      { label: 'Agent', value: 'beach-finder' },
+      { label: 'Model', value: 'nvidia-build - meta/llama-3.3-70b-instruct' },
+      { label: 'Dataset', value: 'Text classification' },
+    ]);
+  });
+
+  it('collects relevant tool artifacts from streamed events', () => {
+    const artifacts = updateClaudeCodeChatArtifactsFromEvent(
+      { ...createEmptyClaudeCodeChatArtifacts(), workspace: 'default' },
+      {
+        type: 'assistant',
+        message: {
+          content: [
+            {
+              type: 'tool_use',
+              name: 'Write',
+              input: { file_path: 'agents/beach-finder.yml' },
+            },
+            {
+              type: 'tool_use',
+              name: 'mcp__nemo_studio__studio_link',
+              input: { destination: 'agents', label: 'Agents' },
+            },
+          ],
+        },
+      }
+    );
+
+    expect(artifacts.files).toEqual([{ action: 'Wrote', path: 'agents/beach-finder.yml' }]);
+    expect(artifacts.links).toEqual([
+      { label: 'Agents', destination: 'agents', href: '/workspaces/default/agents' },
+    ]);
+    expect(artifacts.tools).toEqual(['Write', 'mcp__nemo_studio__studio_link']);
+  });
+
+  it('does not double encode encoded file paths in studio link artifacts', () => {
+    const artifacts = updateClaudeCodeChatArtifactsFromEvent(
+      { ...createEmptyClaudeCodeChatArtifacts(), workspace: 'default' },
+      {
+        type: 'assistant',
+        message: {
+          content: [
+            {
+              type: 'tool_use',
+              name: 'mcp__nemo_studio__studio_link',
+              input: {
+                destination: 'fileset_file',
+                name: 'training data',
+                file_path_encoded: 'nested%2Fexamples.jsonl',
+                label: 'Dataset file',
+              },
+            },
+          ],
+        },
+      }
+    );
+
+    expect(artifacts.links).toEqual([
+      {
+        label: 'Dataset file',
+        destination: 'fileset_file',
+        href: '/workspaces/default/filesets/training%20data/file/nested%2Fexamples.jsonl',
+      },
+    ]);
+  });
+
+  it('promotes draft spec name and model over the coding-agent model', () => {
+    const withCodingModel = updateClaudeCodeChatArtifactsFromEvent(
+      createEmptyClaudeCodeChatArtifacts(),
+      {
+        type: 'assistant',
+        message: { model: 'claude-sonnet-4-6', content: [] },
+      }
+    );
+
+    const withSpecModel = updateClaudeCodeChatArtifactsFromEvent(withCodingModel, {
+      type: 'assistant',
+      message: {
+        content: [
+          {
+            type: 'text',
+            text: [
+              'Draft Spec: `cat-identifier`',
+              'Name: `cat-identifier`',
+              '',
+              'Model',
+              '`cloud, nvidia/llama-3.3-nemotron-super-49b-v1` - default, good reasoning',
+              '',
+              'Framework',
+              'langgraph-nat',
+            ].join('\n'),
+          },
+        ],
+      },
+    });
+    const afterCodeModelUpdate = updateClaudeCodeChatArtifactsFromEvent(withSpecModel, {
+      type: 'assistant',
+      message: { model: 'claude-opus-4-6', content: [] },
+    });
+
+    expect(afterCodeModelUpdate.agent).toBe('cat-identifier');
+    expect(afterCodeModelUpdate.model).toBe('cloud, nvidia/llama-3.3-nemotron-super-49b-v1');
+    expect(afterCodeModelUpdate.model_source).toBe('spec');
+    expect(afterCodeModelUpdate.coding_agent_model).toBe('claude-opus-4-6');
+  });
+
+  it('derives spec artifacts from loaded transcript items', () => {
+    const artifacts = updateClaudeCodeChatArtifactsFromHistoryItems(
+      createEmptyClaudeCodeChatArtifacts(),
+      [
+        { kind: 'user', text: 'draft a cat identifier' },
+        {
+          kind: 'assistant',
+          parts: [
+            {
+              type: 'text',
+              text: [
+                'Name: `cat-identifier`',
+                '',
+                'Model',
+                '`cloud, nvidia/llama-3.3-nemotron-super-49b-v1`',
+              ].join('\n'),
+            },
+          ],
+        },
+      ]
+    );
+
+    expect(artifacts.agent).toBe('cat-identifier');
+    expect(artifacts.model).toBe('cloud, nvidia/llama-3.3-nemotron-super-49b-v1');
+    expect(artifacts.model_source).toBe('spec');
+  });
+});
diff --git a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/artifacts.ts b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/artifacts.ts
new file mode 100644
index 0000000000..d9c3de1bed
--- /dev/null
+++ b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/artifacts.ts
@@ -0,0 +1,461 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import type {
+  ClaudeCodeChatArtifacts,
+  ClaudeCodeChatFileArtifact,
+  ClaudeCodeChatLinkArtifact,
+  ClaudeCodeChatSelectionArtifact,
+  ClaudeCodeSessionHistoryItem,
+} from '@studio/routes/agents/ClaudeCodeChatRoute/types';
+
+interface ClaudeCodeArtifactQuestion {
+  header?: string;
+  question: string;
+}
+
+const FILE_CHANGE_TOOL_ACTIONS = new Map([
+  ['Edit', 'Edited'],
+  ['MultiEdit', 'Edited'],
+  ['Write', 'Wrote'],
+]);
+
+const STUDIO_CONTEXT_WORKSPACE_RE = /^Current Studio workspace:\s*(?<workspace>.+)$/m;
+const SPEC_HEADINGS = new Set([
+  'behavior',
+  'change scope',
+  'evaluation setup',
+  'framework',
+  'harness',
+  'model',
+  'name',
+  'open questions',
+  'purpose',
+  'role',
+  'scope',
+  'signals',
+  'success criteria',
+  'tools',
+]);
+const STUDIO_LINK_PATH_TEMPLATES: Record<string, string> = {
+  workspace: '/workspaces/{workspace}',
+  dashboard: '/workspaces/{workspace}/dashboard',
+  code_agent: '/workspaces/{workspace}/dashboard/code-agent',
+  agents: '/workspaces/{workspace}/agents',
+  agent: '/workspaces/{workspace}/agents/{name}',
+  agent_chat: '/workspaces/{workspace}/agents/{name}?tab=chat-playground',
+  agent_deployments: '/workspaces/{workspace}/agents',
+  agent_deployment: '/workspaces/{workspace}/agents/{name}',
+  agent_evaluations: '/workspaces/{workspace}/agents/evaluations',
+  agent_evaluation: '/workspaces/{workspace}/agents/evaluations/{name}',
+  agent_monitor: '/workspaces/{workspace}/agents/monitor',
+  agent_optimizations: '/workspaces/{workspace}/agents/suggestions',
+  base_models: '/workspaces/{workspace}/base-models',
+  base_model: '/workspaces/{workspace}/base-models/{name}',
+  base_model_chat: '/workspaces/{workspace}/base-models/{name}?tab=chat-playground',
+  evaluation: '/workspaces/{workspace}/evaluation',
+  evaluation_metrics: '/workspaces/{workspace}/evaluation/metrics',
+  evaluation_metric_new: '/workspaces/{workspace}/evaluation/metrics/new',
+  evaluation_run: '/workspaces/{workspace}/evaluation/metrics/run',
+  evaluation_metric: '/workspaces/{workspace}/evaluation/metrics/{name}',
+  evaluation_metric_run: '/workspaces/{workspace}/evaluation/metrics/{name}/run',
+  evaluation_benchmarks: '/workspaces/{workspace}/evaluation/benchmarks',
+  evaluation_benchmark: '/workspaces/{workspace}/evaluation/benchmarks/{name}',
+  evaluation_results: '/workspaces/{workspace}/evaluation/results',
+  evaluation_result: '/workspaces/{workspace}/evaluation/results/{name}',
+  customizations: '/workspaces/{workspace}/customizations',
+  customization_new: '/workspaces/{workspace}/customizations/fine-tuned/new',
+  customization: '/workspaces/{workspace}/customizations/{name}',
+  prompt_tuning: '/workspaces/{workspace}/customizations/prompt-tuned/new',
+  model_chat: '/workspaces/{workspace}/model-compare',
+  jobs: '/workspaces/{workspace}/jobs',
+  job: '/workspaces/{workspace}/jobs/{name}',
+  filesets: '/workspaces/{workspace}/filesets',
+  fileset_new: '/workspaces/{workspace}/filesets/new',
+  fileset_panel: '/workspaces/{workspace}/filesets/{name}',
+  fileset: '/workspaces/{workspace}/filesets/{name}/detail',
+  fileset_file: '/workspaces/{workspace}/filesets/{name}/file/{file_path}',
+  deployments: '/workspaces/{workspace}/deployments',
+  deployment: '/workspaces/{workspace}/deployments/{name}/details',
+  inference_providers: '/workspaces/{workspace}/inference-providers',
+  guardrails: '/workspaces/{workspace}/guardrails',
+  secrets: '/workspaces/{workspace}/secrets',
+  intake: '/workspaces/{workspace}/intake',
+  intake_traces: '/workspaces/{workspace}/intake/traces',
+  intake_spans: '/workspaces/{workspace}/intake/spans',
+  intake_trace: '/workspaces/{workspace}/intake/traces/{name}',
+  intake_span: '/workspaces/{workspace}/intake/spans/{name}',
+  data_designer: '/workspaces/{workspace}/data-designer',
+  data_designer_new: '/workspaces/{workspace}/data-designer/new',
+  data_designer_job: '/workspaces/{workspace}/data-designer/{name}',
+  safe_synthesizer: '/workspaces/{workspace}/safe-synthesizer',
+  safe_synthesizer_new: '/workspaces/{workspace}/safe-synthesizer/new',
+  safe_synthesizer_job: '/workspaces/{workspace}/safe-synthesizer/job/{name}',
+  safe_synthesizer_report: '/workspaces/{workspace}/safe-synthesizer/job/{name}/report',
+  settings: '/workspaces/{workspace}/settings',
+  members: '/workspaces/{workspace}/members',
+  experiment: '/workspaces/{workspace}/experiment',
+  experiment_group: '/workspaces/{workspace}/experiment/{name}',
+  experiment_detail: '/workspaces/{workspace}/experiment/{name}/{experiment_name}',
+};
+const STUDIO_LINK_ARGUMENT_ALIASES = {
+  name: [
+    'resource_name',
+    'resourceName',
+    'id',
+    'job_name',
+    'jobName',
+    'agent_name',
+    'agentName',
+    'model_name',
+    'modelName',
+    'fileset_id',
+    'filesetId',
+    'fileset_name',
+    'filesetName',
+    'deployment_name',
+    'deploymentName',
+    'trace_id',
+    'traceId',
+    'span_id',
+    'spanId',
+    'experiment_group_id',
+    'experimentGroupId',
+  ],
+  experiment_name: ['experimentName', 'experiment_id', 'experimentId'],
+  file_path: ['file', 'filePath', 'file_path_encoded', 'filePathEncoded', 'path'],
+} satisfies Record<'name' | 'experiment_name' | 'file_path', readonly string[]>;
+
+export const createEmptyClaudeCodeChatArtifacts = (): ClaudeCodeChatArtifacts => ({
+  selections: [],
+  files: [],
+  links: [],
+  tools: [],
+});
+
+export const cleanClaudeCodeArtifactText = (value: string): string => {
+  const trimmed = value.trim();
+  const inlineCodeMatch = trimmed.match(/(`+)([\s\S]*?)\1/);
+  if (!inlineCodeMatch) return trimmed;
+
+  const unwrapped = inlineCodeMatch[2]?.trim();
+  return unwrapped || trimmed;
+};
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value);
+
+const getString = (value: unknown): string | undefined => {
+  if (typeof value !== 'string') return undefined;
+  const trimmed = value.trim();
+  return trimmed || undefined;
+};
+
+const decodeEncodedFilePath = (value: string): string => {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+};
+
+const normalizeStudioLinkDestination = (value: string | undefined): string | undefined => {
+  const normalized = value
+    ?.trim()
+    .toLowerCase()
+    .replace(/[-\s]+/g, '_');
+  return normalized && STUDIO_LINK_PATH_TEMPLATES[normalized] ? normalized : undefined;
+};
+
+const getStudioLinkArgument = (
+  input: Record<string, unknown>,
+  argumentName: keyof typeof STUDIO_LINK_ARGUMENT_ALIASES
+): string | undefined => {
+  for (const key of [argumentName, ...STUDIO_LINK_ARGUMENT_ALIASES[argumentName]]) {
+    const value = getString(input[key]);
+    if (!value) continue;
+    if (
+      argumentName === 'file_path' &&
+      (key === 'file_path_encoded' || key === 'filePathEncoded')
+    ) {
+      return decodeEncodedFilePath(value);
+    }
+    return value;
+  }
+
+  return undefined;
+};
+
+const buildStudioLinkHrefFromInput = (
+  input: Record<string, unknown>,
+  workspace: string | undefined
+): string | undefined => {
+  const explicitHref = getString(input.href) ?? getString(input.url);
+  if (explicitHref) return explicitHref;
+
+  const destination = normalizeStudioLinkDestination(
+    getString(input.destination) ?? getString(input.page) ?? getString(input.resource_type)
+  );
+  const template = destination ? STUDIO_LINK_PATH_TEMPLATES[destination] : undefined;
+  const workspaceValue = getString(input.workspace) ?? workspace;
+  if (!template || !workspaceValue) return undefined;
+
+  const values: Record<string, string> = {
+    workspace: encodeURIComponent(workspaceValue),
+  };
+
+  for (const argumentName of ['name', 'experiment_name', 'file_path'] as const) {
+    if (!template.includes(`{${argumentName}}`)) continue;
+
+    const value = getStudioLinkArgument(input, argumentName);
+    if (!value) return undefined;
+
+    values[argumentName] = encodeURIComponent(value);
+  }
+
+  return template.replace(
+    /\{(workspace|name|experiment_name|file_path)\}/g,
+    (_match, key: string) => values[key] ?? ''
+  );
+};
+
+const cloneArtifacts = (artifacts: ClaudeCodeChatArtifacts): ClaudeCodeChatArtifacts => ({
+  agent: artifacts.agent,
+  model: artifacts.model,
+  model_source: artifacts.model_source,
+  coding_agent_model: artifacts.coding_agent_model,
+  workspace: artifacts.workspace,
+  selections: [...artifacts.selections],
+  files: [...artifacts.files],
+  links: [...artifacts.links],
+  tools: [...artifacts.tools],
+});
+
+const pushUnique = (items: string[], value: string) => {
+  if (!items.includes(value)) items.push(value);
+};
+
+const inferSelectionLabel = (question: string, header?: string): string => {
+  const combined = `${header ?? ''} ${question}`.toLowerCase();
+  if (combined.includes('agent')) return 'Agent';
+  if (combined.includes('model')) return 'Model';
+  if (combined.includes('deployment')) return 'Deployment';
+  if (combined.includes('fileset')) return 'Fileset';
+  if (combined.includes('dataset')) return 'Dataset';
+  if (combined.includes('provider')) return 'Provider';
+
+  const label = header?.trim() || question.trim().replace(/\?$/, '');
+  return label.length > 40 ? label.slice(0, 40) : label;
+};
+
+const setCodingAgentModel = (artifacts: ClaudeCodeChatArtifacts, model: string) => {
+  artifacts.coding_agent_model = model;
+};
+
+const setSpecModel = (artifacts: ClaudeCodeChatArtifacts, model: string) => {
+  artifacts.model = model;
+  artifacts.model_source = 'spec';
+};
+
+const setSelection = (
+  artifacts: ClaudeCodeChatArtifacts,
+  selection: ClaudeCodeChatSelectionArtifact
+) => {
+  const cleanedSelection: ClaudeCodeChatSelectionArtifact = {
+    ...selection,
+    value: cleanClaudeCodeArtifactText(selection.value),
+  };
+
+  if (cleanedSelection.label === 'Agent') {
+    artifacts.agent = cleanedSelection.value;
+  } else if (cleanedSelection.label === 'Model') {
+    artifacts.model = cleanedSelection.value;
+    artifacts.model_source = 'selection';
+  }
+
+  const existingIndex = artifacts.selections.findIndex(
+    (item) => item.label === cleanedSelection.label
+  );
+  if (existingIndex >= 0) {
+    artifacts.selections[existingIndex] = cleanedSelection;
+    return;
+  }
+  artifacts.selections.push(cleanedSelection);
+};
+
+const upsertFile = (artifacts: ClaudeCodeChatArtifacts, file: ClaudeCodeChatFileArtifact) => {
+  const existingIndex = artifacts.files.findIndex((item) => item.path === file.path);
+  if (existingIndex >= 0) {
+    artifacts.files[existingIndex] = file;
+    return;
+  }
+  artifacts.files.push(file);
+};
+
+const appendLink = (artifacts: ClaudeCodeChatArtifacts, link: ClaudeCodeChatLinkArtifact) => {
+  const existingIndex = artifacts.links.findIndex(
+    (item) => item.label === link.label && item.destination === link.destination
+  );
+  if (existingIndex >= 0) {
+    artifacts.links[existingIndex] = {
+      ...artifacts.links[existingIndex],
+      href: link.href ?? artifacts.links[existingIndex]?.href,
+    };
+    return;
+  }
+  artifacts.links.push(link);
+};
+
+const normalizeSpecLine = (line: string): string =>
+  line
+    .trim()
+    .replace(/^#{1,6}\s+/, '')
+    .replace(/^\s*[-*]\s+/, '')
+    .replace(/\*\*/g, '')
+    .trim();
+
+const normalizeHeading = (line: string): string =>
+  normalizeSpecLine(line).replace(/:$/, '').trim().toLowerCase();
+
+const getInlineSpecValue = (text: string, label: string): string | undefined => {
+  const prefix = `${label.toLowerCase()}:`;
+
+  for (const line of text.split('\n')) {
+    const normalized = normalizeSpecLine(line);
+    if (!normalized.toLowerCase().startsWith(prefix)) continue;
+
+    return getString(normalized.slice(prefix.length));
+  }
+
+  return undefined;
+};
+
+const cleanSpecValue = (value: string): string => {
+  const normalized = normalizeSpecLine(value);
+  const withoutParenthetical = normalized.replace(/\s+\([^)]*\)\s*$/, '').trim();
+  return cleanClaudeCodeArtifactText(withoutParenthetical || normalized);
+};
+
+const getSectionSpecValue = (text: string, heading: string): string | undefined => {
+  const lines = text.split('\n');
+  const targetHeading = heading.toLowerCase();
+
+  for (let index = 0; index < lines.length; index += 1) {
+    if (normalizeHeading(lines[index] ?? '') !== targetHeading) continue;
+
+    for (let valueIndex = index + 1; valueIndex < lines.length; valueIndex += 1) {
+      const normalized = normalizeSpecLine(lines[valueIndex] ?? '');
+      if (!normalized) continue;
+      if (SPEC_HEADINGS.has(normalizeHeading(normalized))) return undefined;
+      return cleanSpecValue(normalized);
+    }
+  }
+
+  return undefined;
+};
+
+const recordSpecTextArtifacts = (artifacts: ClaudeCodeChatArtifacts, text: string) => {
+  const agentName = getInlineSpecValue(text, 'Name') ?? getInlineSpecValue(text, 'Draft Spec');
+  if (agentName) artifacts.agent = cleanSpecValue(agentName);
+
+  const specModel = getSectionSpecValue(text, 'Model') ?? getInlineSpecValue(text, 'Model');
+  if (specModel) setSpecModel(artifacts, cleanSpecValue(specModel));
+};
+
+const recordToolArtifacts = (
+  artifacts: ClaudeCodeChatArtifacts,
+  toolName: string,
+  input: unknown
+) => {
+  pushUnique(artifacts.tools, toolName);
+
+  const action = FILE_CHANGE_TOOL_ACTIONS.get(toolName);
+  if (action && isRecord(input)) {
+    const path = getString(input.file_path) ?? getString(input.path);
+    if (path) upsertFile(artifacts, { action, path });
+  }
+
+  if ((toolName === 'studio_link' || toolName.endsWith('__studio_link')) && isRecord(input)) {
+    const destination = getString(input.destination);
+    const label = getString(input.label) ?? destination;
+    const href = buildStudioLinkHrefFromInput(input, artifacts.workspace);
+    if (label) appendLink(artifacts, { label, destination, href });
+  }
+};
+
+export const updateClaudeCodeChatArtifactsFromEvent = (
+  current: ClaudeCodeChatArtifacts,
+  event: unknown
+): ClaudeCodeChatArtifacts => {
+  if (!isRecord(event)) return current;
+
+  const next = cloneArtifacts(current);
+  const message = isRecord(event.message) ? event.message : undefined;
+  const model = getString(message?.model);
+  if (model) setCodingAgentModel(next, model);
+
+  const content = message?.content;
+  if (!Array.isArray(content)) return next;
+
+  for (const part of content) {
+    if (!isRecord(part)) continue;
+
+    if (part.type === 'text') {
+      const text = getString(part.text);
+      if (text) recordSpecTextArtifacts(next, text);
+      continue;
+    }
+
+    if (part.type !== 'tool_use') continue;
+    const toolName = getString(part.name) ?? 'tool';
+    recordToolArtifacts(next, toolName, part.input);
+  }
+
+  return next;
+};
+
+export const updateClaudeCodeChatArtifactsFromSelections = (
+  current: ClaudeCodeChatArtifacts,
+  questions: readonly ClaudeCodeArtifactQuestion[],
+  answers: Record<string, string>
+): ClaudeCodeChatArtifacts => {
+  const next = cloneArtifacts(current);
+
+  for (const question of questions) {
+    const answer = getString(answers[question.question]);
+    if (!answer) continue;
+    setSelection(next, {
+      label: inferSelectionLabel(question.question, question.header),
+      value: answer,
+    });
+  }
+
+  return next;
+};
+
+export const updateClaudeCodeChatArtifactsFromUserText = (
+  current: ClaudeCodeChatArtifacts,
+  text: string
+): ClaudeCodeChatArtifacts => {
+  const next = cloneArtifacts(current);
+  const workspace = text.match(STUDIO_CONTEXT_WORKSPACE_RE)?.groups?.workspace?.trim();
+  if (workspace && !next.workspace) next.workspace = workspace;
+  return next;
+};
+
+export const updateClaudeCodeChatArtifactsFromHistoryItems = (
+  current: ClaudeCodeChatArtifacts,
+  items: readonly ClaudeCodeSessionHistoryItem[]
+): ClaudeCodeChatArtifacts =>
+  items.reduce((artifacts, item) => {
+    if (item.kind === 'user') {
+      return updateClaudeCodeChatArtifactsFromUserText(artifacts, item.text);
+    }
+
+    return updateClaudeCodeChatArtifactsFromEvent(artifacts, {
+      type: 'assistant',
+      message: {
+        content: item.parts,
+      },
+    });
+  }, current);
diff --git a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/index.tsx b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/index.tsx
index bae5cb197b..c19c930666 100644
--- a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/index.tsx
+++ b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/index.tsx
@@ -18,7 +18,10 @@ import { BlockingInputComposer } from '@studio/routes/agents/ClaudeCodeChatRoute
 import { ClaudeCodeLayout } from '@studio/routes/agents/ClaudeCodeChatRoute/ClaudeCodeLayout';
 import { ClaudeCodeStudioLink } from '@studio/routes/agents/ClaudeCodeChatRoute/ClaudeCodeStudioLink';
 import { ClaudeCodeToolCallPart } from '@studio/routes/agents/ClaudeCodeChatRoute/ClaudeCodeToolCallPart';
-import type { ClaudeCodeChatRouteState } from '@studio/routes/agents/ClaudeCodeChatRoute/types';
+import type {
+  ClaudeCodeChatArtifacts,
+  ClaudeCodeChatRouteState,
+} from '@studio/routes/agents/ClaudeCodeChatRoute/types';
 import { useClaudeCodeChatRuntime } from '@studio/routes/agents/ClaudeCodeChatRoute/useClaudeCodeChatRuntime';
 import {
   getClaudeCodeHistoryMessages,
@@ -40,6 +43,7 @@ const getInitialPrompt = (state: unknown): string | undefined => {
 };
 
 interface ClaudeCodeChatSurfaceProps {
+  initialArtifacts?: ClaudeCodeChatArtifacts;
   initialMessages?: ReturnType<typeof getClaudeCodeHistoryMessages>;
   initialPrompt?: string;
   initialSessionId?: string;
@@ -81,6 +85,7 @@ const ClaudeCodeChatErrorState = ({ selectedSessionId }: { selectedSessionId?: s
 );
 
 const ClaudeCodeChatSurface: FC<ClaudeCodeChatSurfaceProps> = ({
+  initialArtifacts,
   initialMessages = [],
   initialPrompt,
   initialSessionId,
@@ -92,6 +97,7 @@ const ClaudeCodeChatSurface: FC<ClaudeCodeChatSurfaceProps> = ({
   const consumedInitialPromptRef = useRef<string | undefined>(undefined);
   const chatViewportRef = useRef<HTMLDivElement>(null);
   const {
+    artifacts,
     decisionChoices,
     decisionRequest,
     decisionStatus,
@@ -106,6 +112,7 @@ const ClaudeCodeChatSurface: FC<ClaudeCodeChatSurfaceProps> = ({
     skipDecisionRequest,
     submitPrompt,
   } = useClaudeCodeChatRuntime({
+    initialArtifacts,
     initialMessages,
     initialSessionId,
     onError: (error) => toast.error(error.message),
@@ -159,7 +166,7 @@ const ClaudeCodeChatSurface: FC<ClaudeCodeChatSurfaceProps> = ({
   }, [decisionRequest, inputRequest]);
 
   return (
-    <ClaudeCodeLayout activeSessionId={activeSessionId}>
+    <ClaudeCodeLayout activeSessionId={activeSessionId} artifacts={artifacts}>
       <AccessibleTitle title={`Code Agent chat for ${workspace}`}>
         <Stack className="h-full w-full py-density-lg">
           <Stack className="min-h-0 w-full flex-1">
@@ -220,6 +227,7 @@ export const ClaudeCodeChatRoute: FC = () => {
     queryKey: getClaudeCodeSessionHistoryQueryKey(selectedSessionId ?? ''),
     queryFn: () => getClaudeCodeSessionHistory(selectedSessionId ?? ''),
     enabled: !!selectedSessionId,
+    refetchOnMount: 'always',
   });
   const initialMessages = useMemo(
     () => getClaudeCodeHistoryMessages(sessionHistoryQuery.data),
@@ -237,6 +245,7 @@ export const ClaudeCodeChatRoute: FC = () => {
   return (
     <ClaudeCodeChatSurface
       key={selectedSessionId ?? 'new'}
+      initialArtifacts={sessionHistoryQuery.data?.chat_artifacts}
       initialMessages={initialMessages}
       initialPrompt={selectedSessionId ? undefined : initialPrompt}
       initialSessionId={selectedSessionId}
diff --git a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/toolParts.ts b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/toolParts.ts
index 813221f525..50302bc33e 100644
--- a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/toolParts.ts
+++ b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/toolParts.ts
@@ -11,6 +11,7 @@ type ClaudeCodeToolCallPart = Extract<ThreadAssistantMessagePart, { type: 'tool-
 export type ClaudeCodeToolArgs = ClaudeCodeToolCallPart['args'];
 type ClaudeCodeToolArgValue = ClaudeCodeToolArgs[string];
 
+export const CLAUDE_CODE_COLLAPSED_THINKING_TOOL_NAME = 'ClaudeCodeCollapsedThinking';
 export const CLAUDE_CODE_SUBTLE_TOOL_GROUP_NAME = 'ClaudeCodeSubtleToolGroup';
 
 const FILE_CHANGE_TOOL_CALL_NAMES = new Set(['Edit', 'MultiEdit', 'Write']);
@@ -20,6 +21,7 @@ export const isClaudeCodeJobProgressToolName = (toolName: string): boolean =>
   toolName === CLAUDE_CODE_JOB_PROGRESS_MCP_TOOL_NAME;
 
 export const isClaudeCodeSubtleToolCallName = (toolName: string): boolean =>
+  toolName !== CLAUDE_CODE_COLLAPSED_THINKING_TOOL_NAME &&
   toolName !== CLAUDE_CODE_SUBTLE_TOOL_GROUP_NAME &&
   !FILE_CHANGE_TOOL_CALL_NAMES.has(toolName) &&
   !isClaudeCodeJobProgressToolName(toolName);
@@ -74,6 +76,18 @@ export const createClaudeCodeToolCallPart = ({
   };
 };
 
+const createClaudeCodeCollapsedThinkingPart = (text: string): ThreadAssistantMessagePart => {
+  const args = toClaudeCodeToolArgs({ text });
+
+  return {
+    type: 'tool-call',
+    toolCallId: 'claude-code-collapsed-thinking',
+    toolName: CLAUDE_CODE_COLLAPSED_THINKING_TOOL_NAME,
+    args,
+    argsText: JSON.stringify(args),
+  };
+};
+
 interface ClaudeCodeSubtleToolAction {
   readonly args: ClaudeCodeToolArgs;
   readonly toolCallId: string;
@@ -156,6 +170,75 @@ const createClaudeCodeSubtleToolGroupPart = (
   };
 };
 
+const splitTextParagraphs = (text: string): readonly string[] =>
+  text
+    .trim()
+    .split(/\n\s*\n/)
+    .map((paragraph) => paragraph.trim())
+    .filter(Boolean);
+
+const getCollapsedTextParts = (
+  parts: readonly ThreadAssistantMessagePart[],
+  lastToolIndex: number
+): {
+  readonly collapsedText: string | undefined;
+  readonly summaryText: string | undefined;
+} => {
+  const thinkingTextParts: string[] = [];
+  const trailingTextParts: string[] = [];
+
+  parts.forEach((part, index) => {
+    if (part.type !== 'text') return;
+
+    const text = part.text.trim();
+    if (!text) return;
+
+    if (index > lastToolIndex) {
+      trailingTextParts.push(text);
+    } else {
+      thinkingTextParts.push(text);
+    }
+  });
+
+  const trailingParagraphs = splitTextParagraphs(trailingTextParts.join('\n\n'));
+  const summaryParagraphs = trailingParagraphs.slice(-2);
+  const collapsedTrailingParagraphs = trailingParagraphs.slice(0, -2);
+  const collapsedParagraphs = splitTextParagraphs(
+    [...thinkingTextParts, collapsedTrailingParagraphs.join('\n\n')].filter(Boolean).join('\n\n')
+  );
+
+  return {
+    collapsedText: collapsedParagraphs.length ? collapsedParagraphs.join('\n\n') : undefined,
+    summaryText: summaryParagraphs.length ? summaryParagraphs.join('\n\n') : undefined,
+  };
+};
+
+export const getClaudeCodeCompletedMessageParts = (
+  parts: readonly ThreadAssistantMessagePart[]
+): readonly ThreadAssistantMessagePart[] => {
+  const completedParts: ThreadAssistantMessagePart[] = [];
+  let lastToolIndex = -1;
+
+  parts.forEach((part, index) => {
+    if (part.type === 'tool-call') {
+      completedParts.push(part);
+      lastToolIndex = index;
+    }
+  });
+
+  if (lastToolIndex < 0) return parts;
+
+  const { collapsedText, summaryText } = getCollapsedTextParts(parts, lastToolIndex);
+  if (collapsedText) completedParts.unshift(createClaudeCodeCollapsedThinkingPart(collapsedText));
+  for (const part of parts.slice(lastToolIndex + 1)) {
+    if (part.type === 'text') continue;
+    completedParts.push(part);
+  }
+  if (summaryText) completedParts.push({ type: 'text', text: summaryText });
+
+  return completedParts;
+};
+
 export const groupConsecutiveClaudeCodeSubtleToolCalls = (
   parts: readonly ThreadAssistantMessagePart[]
 ): readonly ThreadAssistantMessagePart[] => {
diff --git a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/types.ts b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/types.ts
index bf52d80f5a..34d79d475d 100644
--- a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/types.ts
+++ b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/types.ts
@@ -39,6 +39,36 @@ export interface ClaudeCodeChatRouteState {
   initialPrompt?: string;
 }
 
+export interface ClaudeCodeChatSelectionArtifact {
+  label: string;
+  value: string;
+}
+
+export interface ClaudeCodeChatFileArtifact {
+  action: string;
+  path: string;
+}
+
+export interface ClaudeCodeChatLinkArtifact {
+  label: string;
+  destination?: string;
+  href?: string;
+}
+
+export type ClaudeCodeChatModelSource = 'coding_agent' | 'selection' | 'spec';
+
+export interface ClaudeCodeChatArtifacts {
+  agent?: string;
+  model?: string;
+  model_source?: ClaudeCodeChatModelSource;
+  coding_agent_model?: string;
+  workspace?: string;
+  selections: ClaudeCodeChatSelectionArtifact[];
+  files: ClaudeCodeChatFileArtifact[];
+  links: ClaudeCodeChatLinkArtifact[];
+  tools: string[];
+}
+
 export interface ClaudeCodeHistorySession {
   session_id: string;
   mtime: number;
@@ -47,6 +77,7 @@ export interface ClaudeCodeHistorySession {
   token_count: number;
   tool_call_count: number;
   tool_calls: string[];
+  chat_artifacts: ClaudeCodeChatArtifacts;
 }
 
 export interface ClaudeCodeSkill {
@@ -92,4 +123,5 @@ export type ClaudeCodeSessionHistoryItem =
 export interface ClaudeCodeSessionHistory {
   session_id: string;
   items: ClaudeCodeSessionHistoryItem[];
+  chat_artifacts: ClaudeCodeChatArtifacts;
 }
diff --git a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/useClaudeCodeChatRuntime.spec.ts b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/useClaudeCodeChatRuntime.spec.ts
index 786a268f62..5da9f16684 100644
--- a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/useClaudeCodeChatRuntime.spec.ts
+++ b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/useClaudeCodeChatRuntime.spec.ts
@@ -68,6 +68,65 @@ describe('useClaudeCodeChatRuntime', () => {
     vi.clearAllMocks();
   });
 
+  it('exposes the latest streamed coding-agent model without promoting it to selected model', async () => {
+    mocks.createClaudeCodeSession.mockResolvedValue('session-1');
+    mocks.streamClaudeCodeMessage.mockImplementation(
+      async ({ handlers }: { handlers: { onClaudeEvent: (event: unknown) => void } }) => {
+        handlers.onClaudeEvent({
+          type: 'assistant',
+          message: { model: 'claude-sonnet-4-5', content: [] },
+        });
+        handlers.onClaudeEvent({
+          type: 'assistant',
+          message: { model: 'claude-sonnet-4-6', content: [] },
+        });
+      }
+    );
+
+    const { result } = renderUseClaudeCodeChatRuntime();
+
+    await act(async () => {
+      await result.current.submitPrompt('List files');
+    });
+
+    await waitFor(() =>
+      expect(result.current.artifacts.coding_agent_model).toBe('claude-sonnet-4-6')
+    );
+    expect(result.current.artifacts.model).toBeUndefined();
+    expect(result.current.artifacts.model_source).toBeUndefined();
+  });
+
+  it('syncs artifacts when historical session metadata arrives after mount', async () => {
+    const { rerender, result } = renderHook(
+      ({ model }: { model?: string }) =>
+        useClaudeCodeChatRuntime({
+          initialArtifacts: model
+            ? {
+                coding_agent_model: model,
+                selections: [],
+                files: [],
+                links: [],
+                tools: [],
+              }
+            : undefined,
+        }),
+      { initialProps: {} }
+    );
+
+    expect(result.current.artifacts.model).toBeUndefined();
+
+    rerender({ model: 'claude-sonnet-4-6' });
+
+    await waitFor(() =>
+      expect(result.current.artifacts.coding_agent_model).toBe('claude-sonnet-4-6')
+    );
+    expect(result.current.artifacts.model).toBeUndefined();
+
+    rerender({ model: undefined });
+
+    await waitFor(() => expect(result.current.artifacts.coding_agent_model).toBeUndefined());
+  });
+
   it('does not append denial text when permission resolution fails', async () => {
     const onError = vi.fn();
     let finishStream!: () => void;
diff --git a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/useClaudeCodeChatRuntime.ts b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/useClaudeCodeChatRuntime.ts
index 3205b73992..b5bc9a6ff2 100644
--- a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/useClaudeCodeChatRuntime.ts
+++ b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/useClaudeCodeChatRuntime.ts
@@ -19,15 +19,21 @@ import {
   resolveClaudeCodePermission,
   streamClaudeCodeMessage,
 } from '@studio/routes/agents/ClaudeCodeChatRoute/api';
+import {
+  createEmptyClaudeCodeChatArtifacts,
+  updateClaudeCodeChatArtifactsFromEvent,
+  updateClaudeCodeChatArtifactsFromSelections,
+} from '@studio/routes/agents/ClaudeCodeChatRoute/artifacts';
 import { getAssistantPartsFromClaudeEvent } from '@studio/routes/agents/ClaudeCodeChatRoute/stream';
 import type {
+  ClaudeCodeChatArtifacts,
   ClaudeCodeInputDecision,
   ClaudeCodeInputRequest,
   ClaudeCodePermissionRequest,
 } from '@studio/routes/agents/ClaudeCodeChatRoute/types';
 import { useCustomAssistantChatRuntime } from '@studio/routes/agents/ClaudeCodeChatRoute/useCustomAssistantChatRuntime';
 import { useQueryClient } from '@tanstack/react-query';
-import { useCallback, useRef, useState } from 'react';
+import { useCallback, useEffect, useRef, useState } from 'react';
 
 const ASK_USER_QUESTION_TOOL_NAME = 'AskUserQuestion';
 const CUSTOM_INSTRUCTION_LABEL = 'No, and tell the Agent what to do';
@@ -187,7 +193,24 @@ const formatAskUserQuestionDisplayText = (
     .filter(isDefined)
     .join('\n\n');
 
+const getArtifactsSignature = (artifacts: ClaudeCodeChatArtifacts | undefined): string =>
+  artifacts ? JSON.stringify(artifacts) : '';
+
+const createWorkspaceArtifacts = (
+  artifacts: ClaudeCodeChatArtifacts | undefined,
+  workspace: string | undefined
+): ClaudeCodeChatArtifacts => {
+  const nextArtifacts = artifacts ?? createEmptyClaudeCodeChatArtifacts();
+  return nextArtifacts.workspace || !workspace
+    ? nextArtifacts
+    : {
+        ...nextArtifacts,
+        workspace,
+      };
+};
+
 interface UseClaudeCodeChatRuntimeOptions {
+  initialArtifacts?: ClaudeCodeChatArtifacts;
   initialMessages?: readonly ThreadMessageLike[];
   initialSessionId?: string;
   onError?: (error: Error) => void;
@@ -196,7 +219,11 @@ interface UseClaudeCodeChatRuntimeOptions {
 
 export const useClaudeCodeChatRuntime = (options?: UseClaudeCodeChatRuntimeOptions) => {
   const queryClient = useQueryClient();
+  const workspace = options?.workspace;
   const [sessionId, setSessionId] = useState<string | null>(options?.initialSessionId ?? null);
+  const [artifacts, setArtifacts] = useState<ClaudeCodeChatArtifacts>(
+    createWorkspaceArtifacts(options?.initialArtifacts, workspace)
+  );
   const [decisionRequest, setDecisionRequest] = useState<AgentDecisionRequest | null>(null);
   const [decisionChoices, setDecisionChoices] = useState<readonly AgentDecisionChoice[]>([]);
   const [decisionStatus, setDecisionStatus] = useState<AgentDecisionInputStatus>('pending');
@@ -206,8 +233,18 @@ export const useClaudeCodeChatRuntime = (options?: UseClaudeCodeChatRuntimeOptio
   const permissionRequestRef = useRef<ClaudeCodePermissionRequest | null>(null);
   const inputRequestRef = useRef<ClaudeCodeInputRequest | null>(null);
   const activeDecisionRef = useRef<ActiveDecisionState | null>(null);
+  const initialArtifactsRef = useRef<ClaudeCodeChatArtifacts | undefined>(
+    options?.initialArtifacts
+  );
+  const initialArtifactsSignature = getArtifactsSignature(options?.initialArtifacts);
   const onError = options?.onError;
 
+  initialArtifactsRef.current = options?.initialArtifacts;
+
+  useEffect(() => {
+    setArtifacts(createWorkspaceArtifacts(initialArtifactsRef.current, workspace));
+  }, [initialArtifactsSignature, workspace]);
+
   const ensureSessionId = useCallback(async (): Promise<string> => {
     if (sessionIdRef.current) return sessionIdRef.current;
 
@@ -321,6 +358,7 @@ export const useClaudeCodeChatRuntime = (options?: UseClaudeCodeChatRuntimeOptio
             onClaudeEvent: (event) => {
               if (signal.aborted || !isCurrentRun()) return;
 
+              setArtifacts((current) => updateClaudeCodeChatArtifactsFromEvent(current, event));
               appendAssistantParts(getAssistantPartsFromClaudeEvent(event));
             },
             onPermissionRequest: (request) => {
@@ -399,10 +437,10 @@ export const useClaudeCodeChatRuntime = (options?: UseClaudeCodeChatRuntimeOptio
       approved: boolean;
       displayText?: string;
       reason?: string;
-    }) => {
+    }): Promise<boolean> => {
       const activeSessionId = sessionIdRef.current;
       const activeRequest = permissionRequestRef.current;
-      if (!activeSessionId || !activeRequest) return;
+      if (!activeSessionId || !activeRequest) return false;
 
       const trimmedReason = reason?.trim();
       const trimmedDisplayText = displayText?.trim();
@@ -421,6 +459,7 @@ export const useClaudeCodeChatRuntime = (options?: UseClaudeCodeChatRuntimeOptio
           appendUserMessage(trimmedDisplayText);
         }
         clearPermissionRequest(activeRequest.requestId);
+        return true;
       } catch (error: unknown) {
         if (permissionRequestRef.current?.requestId === activeRequest.requestId) {
           setDecisionStatus('pending');
@@ -428,6 +467,7 @@ export const useClaudeCodeChatRuntime = (options?: UseClaudeCodeChatRuntimeOptio
         const errorMessage =
           error instanceof Error ? error.message : 'Failed to resolve Claude Code permission';
         onError?.(new Error(errorMessage));
+        return false;
       }
     },
     [appendUserMessage, clearPermissionRequest, onError]
@@ -457,11 +497,16 @@ export const useClaudeCodeChatRuntime = (options?: UseClaudeCodeChatRuntimeOptio
         return;
       }
 
-      await submitActiveDecision({
+      const submitted = await submitActiveDecision({
         approved: false,
         reason: formatAskUserQuestionReason(state.questions, answers),
         displayText: formatAskUserQuestionDisplayText(state.questions, answers),
       });
+      if (submitted) {
+        setArtifacts((current) =>
+          updateClaudeCodeChatArtifactsFromSelections(current, state.questions, answers)
+        );
+      }
     },
     [setAskUserQuestionDecision, submitActiveDecision]
   );
@@ -497,12 +542,14 @@ export const useClaudeCodeChatRuntime = (options?: UseClaudeCodeChatRuntimeOptio
   const handleReset = useCallback(() => {
     sessionIdRef.current = null;
     setSessionId(null);
+    setArtifacts(createWorkspaceArtifacts(undefined, workspace));
     clearPermissionRequest();
     clearInputRequest();
     resetThread();
-  }, [clearInputRequest, clearPermissionRequest, resetThread]);
+  }, [clearInputRequest, clearPermissionRequest, resetThread, workspace]);
 
   return {
+    artifacts,
     decisionChoices,
     decisionRequest,
     decisionStatus,
diff --git a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/useCustomAssistantChatRuntime.spec.ts b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/useCustomAssistantChatRuntime.spec.ts
index ab137fb678..5c412397c4 100644
--- a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/useCustomAssistantChatRuntime.spec.ts
+++ b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/useCustomAssistantChatRuntime.spec.ts
@@ -3,7 +3,10 @@
 
 import type { ThreadAssistantMessagePart, ThreadMessageLike } from '@assistant-ui/react';
 import { getMessageText } from '@nemo/common/src/components/AssistantChat/messageUtils';
-import { CLAUDE_CODE_SUBTLE_TOOL_GROUP_NAME } from '@studio/routes/agents/ClaudeCodeChatRoute/toolParts';
+import {
+  CLAUDE_CODE_COLLAPSED_THINKING_TOOL_NAME,
+  CLAUDE_CODE_SUBTLE_TOOL_GROUP_NAME,
+} from '@studio/routes/agents/ClaudeCodeChatRoute/toolParts';
 import {
   type CustomAssistantRunContext,
   useCustomAssistantChatRuntime,
@@ -167,4 +170,122 @@ describe('useCustomAssistantChatRuntime', () => {
       await getMockRuntime(result.current.runtime).onCancel();
     });
   });
+
+  it('does not collapse agent thinking while waiting for user input', async () => {
+    const bashPart: ThreadAssistantMessagePart = {
+      type: 'tool-call',
+      toolCallId: 'toolu_bash',
+      toolName: 'Bash',
+      args: { command: 'pwd' },
+      argsText: '{"command":"pwd"}',
+    };
+    let runContext: CustomAssistantRunContext | undefined;
+    const onRun = vi.fn(async (context: CustomAssistantRunContext) => {
+      runContext = context;
+      context.appendAssistantParts([{ type: 'text', text: 'I will inspect the repo first.' }]);
+      context.appendAssistantParts([bashPart]);
+      context.prepareForUserInput();
+      await new Promise<void>((resolve) => {
+        context.signal.addEventListener('abort', () => resolve(), { once: true });
+      });
+    });
+    const { result } = renderHook(() => useCustomAssistantChatRuntime({ onRun }));
+
+    act(() => {
+      void result.current.submitPrompt('Check files');
+    });
+
+    await waitFor(() => {
+      expect(runContext).toBeDefined();
+      const content = getAssistantContent(getMockRuntime(result.current.runtime).messages);
+      expect(content).toEqual([{ type: 'text', text: 'I will inspect the repo first.' }, bashPart]);
+      expect(getMockRuntime(result.current.runtime).messages[1]?.status).toEqual({
+        type: 'complete',
+        reason: 'stop',
+      });
+    });
+
+    await act(async () => {
+      await getMockRuntime(result.current.runtime).onCancel();
+    });
+  });
+
+  it('keeps completed tool activity before the final summary', async () => {
+    const bashPart: ThreadAssistantMessagePart = {
+      type: 'tool-call',
+      toolCallId: 'toolu_bash',
+      toolName: 'Bash',
+      args: { command: 'pwd' },
+      argsText: '{"command":"pwd"}',
+    };
+    const readPart: ThreadAssistantMessagePart = {
+      type: 'tool-call',
+      toolCallId: 'toolu_read',
+      toolName: 'Read',
+      args: { file_path: 'README.md' },
+      argsText: '{"file_path":"README.md"}',
+    };
+    let runContext: CustomAssistantRunContext | undefined;
+    let finishRun!: () => void;
+    const onRun = vi.fn(async (context: CustomAssistantRunContext) => {
+      runContext = context;
+      context.appendAssistantParts([
+        { type: 'text', text: 'I will inspect the repo first.' },
+        bashPart,
+      ]);
+      await new Promise<void>((resolve) => {
+        finishRun = resolve;
+      });
+      context.appendAssistantParts([
+        readPart,
+        {
+          type: 'text',
+          text: 'I found the relevant files.\n\nI checked the repo.\n\nTests passed.',
+        },
+      ]);
+    });
+    const { result } = renderHook(() => useCustomAssistantChatRuntime({ onRun }));
+
+    act(() => {
+      void result.current.submitPrompt('Check files');
+    });
+
+    await waitFor(() => {
+      expect(runContext).toBeDefined();
+      const content = getAssistantContent(getMockRuntime(result.current.runtime).messages);
+      expect(content).toEqual([{ type: 'text', text: 'I will inspect the repo first.' }, bashPart]);
+    });
+
+    await act(async () => {
+      finishRun();
+    });
+
+    await waitFor(() => {
+      const content = getAssistantContent(getMockRuntime(result.current.runtime).messages);
+      expect(content).toMatchObject([
+        {
+          type: 'tool-call',
+          toolName: CLAUDE_CODE_COLLAPSED_THINKING_TOOL_NAME,
+          args: {
+            text: 'I will inspect the repo first.\n\nI found the relevant files.',
+          },
+        },
+        {
+          type: 'tool-call',
+          toolName: CLAUDE_CODE_SUBTLE_TOOL_GROUP_NAME,
+          args: {
+            actions: [
+              { toolName: 'Bash', args: { command: 'pwd' } },
+              { toolName: 'Read', args: { file_path: 'README.md' } },
+            ],
+          },
+        },
+        { type: 'text', text: 'I checked the repo.\n\nTests passed.' },
+      ]);
+      expect(getMockRuntime(result.current.runtime).messages[1]?.status).toEqual({
+        type: 'complete',
+        reason: 'stop',
+      });
+    });
+  });
 });
diff --git a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/useCustomAssistantChatRuntime.ts b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/useCustomAssistantChatRuntime.ts
index b55ba641ed..3f530e395b 100644
--- a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/useCustomAssistantChatRuntime.ts
+++ b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/useCustomAssistantChatRuntime.ts
@@ -18,7 +18,10 @@ import {
   createTextMessage,
   getMessageText,
 } from '@nemo/common/src/components/AssistantChat/messageUtils';
-import { groupConsecutiveClaudeCodeSubtleToolCalls } from '@studio/routes/agents/ClaudeCodeChatRoute/toolParts';
+import {
+  getClaudeCodeCompletedMessageParts,
+  groupConsecutiveClaudeCodeSubtleToolCalls,
+} from '@studio/routes/agents/ClaudeCodeChatRoute/toolParts';
 import { useCallback, useRef, useState } from 'react';
 
 export interface CustomAssistantRunContext {
@@ -43,6 +46,10 @@ interface UseCustomAssistantChatRuntimeOptions {
   onError?: (error: Error) => void;
 }
 
+interface CompleteAssistantMessageOptions {
+  readonly collapseClaudeCodeContent?: boolean;
+}
+
 const isAbortError = (error: unknown): boolean =>
   error instanceof DOMException && error.name === 'AbortError';
 
@@ -90,6 +97,14 @@ const hasVisibleAssistantContent = (content: ThreadMessageLike['content']): bool
   });
 };
 
+const completeClaudeCodeAssistantContent = (
+  content: ThreadMessageLike['content'],
+  status: MessageStatus
+): ThreadMessageLike['content'] => {
+  if (status.type !== 'complete' || !Array.isArray(content)) return content;
+  return getClaudeCodeCompletedMessageParts(content);
+};
+
 export const useCustomAssistantChatRuntime = ({
   initialMessages = [],
   onRun,
@@ -176,7 +191,8 @@ export const useCustomAssistantChatRuntime = ({
 
       const completeActiveAssistantMessage = (
         status: MessageStatus,
-        content: ThreadMessageLike['content'] = getCurrentResponseContent()
+        content: ThreadMessageLike['content'] = getCurrentResponseContent(),
+        options: CompleteAssistantMessageOptions = {}
       ) => {
         if (!assistantMessageId) return;
 
@@ -184,7 +200,13 @@ export const useCustomAssistantChatRuntime = ({
         assistantMessageId = null;
         responseText = '';
         responseContent = undefined;
-        completeAssistantMessageContent(currentAssistantMessageId, content, status);
+        completeAssistantMessageContent(
+          currentAssistantMessageId,
+          options.collapseClaudeCodeContent === false
+            ? content
+            : completeClaudeCodeAssistantContent(content, status),
+          status
+        );
       };
 
       createAssistantMessage();
@@ -214,7 +236,9 @@ export const useCustomAssistantChatRuntime = ({
       };
 
       const prepareForUserInput = () => {
-        completeActiveAssistantMessage(COMPLETE_STATUS);
+        completeActiveAssistantMessage(COMPLETE_STATUS, getCurrentResponseContent(), {
+          collapseClaudeCodeContent: false,
+        });
       };
 
       try {
diff --git a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/util.spec.ts b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/util.spec.ts
index 6a109fb3fc..79637fc109 100644
--- a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/util.spec.ts
+++ b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/util.spec.ts
@@ -2,7 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { CLAUDE_CODE_JOB_PROGRESS_MCP_TOOL_NAME } from '@studio/routes/agents/ClaudeCodeChatRoute/jobProgressConsts';
-import { CLAUDE_CODE_SUBTLE_TOOL_GROUP_NAME } from '@studio/routes/agents/ClaudeCodeChatRoute/toolParts';
+import {
+  CLAUDE_CODE_COLLAPSED_THINKING_TOOL_NAME,
+  CLAUDE_CODE_SUBTLE_TOOL_GROUP_NAME,
+} from '@studio/routes/agents/ClaudeCodeChatRoute/toolParts';
 import type { ClaudeCodeSessionHistory } from '@studio/routes/agents/ClaudeCodeChatRoute/types';
 import {
   getClaudeCodeChatRouteForSession,
@@ -26,6 +29,7 @@ describe('Claude Code utilities', () => {
   it('converts stored transcript items to assistant-ui messages', () => {
     const history: ClaudeCodeSessionHistory = {
       session_id: '2dc6e5a6-acd7-43bf-b128-c9fd5cf6eb9a',
+      chat_artifacts: { selections: [], files: [], links: [], tools: [] },
       items: [
         { kind: 'user', text: 'check the repo' },
         {
@@ -36,6 +40,7 @@ describe('Claude Code utilities', () => {
             { type: 'tool_use', name: 'Bash', input: { command: 'pwd' } },
             { type: 'tool_use', name: 'Grep', input: { pattern: 'TODO' } },
             { type: 'tool_use', name: 'Read', input: { file_path: 'README.md' } },
+            { type: 'text', text: 'I updated the route.\n\nTests passed.' },
           ],
         },
         {
@@ -74,7 +79,13 @@ describe('Claude Code utilities', () => {
       id: '2dc6e5a6-acd7-43bf-b128-c9fd5cf6eb9a-1',
       role: 'assistant',
       content: [
-        { type: 'text', text: 'I found the route.' },
+        {
+          type: 'tool-call',
+          toolName: CLAUDE_CODE_COLLAPSED_THINKING_TOOL_NAME,
+          args: {
+            text: 'I found the route.',
+          },
+        },
         {
           type: 'tool-call',
           toolName: CLAUDE_CODE_SUBTLE_TOOL_GROUP_NAME,
@@ -87,6 +98,7 @@ describe('Claude Code utilities', () => {
             ],
           },
         },
+        { type: 'text', text: 'I updated the route.\n\nTests passed.' },
       ],
       status: { type: 'complete', reason: 'stop' },
     });
@@ -115,7 +127,13 @@ describe('Claude Code utilities', () => {
       id: '2dc6e5a6-acd7-43bf-b128-c9fd5cf6eb9a-3',
       role: 'assistant',
       content: [
-        { type: 'text', text: 'I found another route.' },
+        {
+          type: 'tool-call',
+          toolName: CLAUDE_CODE_COLLAPSED_THINKING_TOOL_NAME,
+          args: {
+            text: 'I found another route.',
+          },
+        },
         {
           type: 'tool-call',
           toolName: CLAUDE_CODE_SUBTLE_TOOL_GROUP_NAME,
@@ -136,6 +154,7 @@ describe('Claude Code utilities', () => {
   it('combines consecutive tool-only assistant transcript items', () => {
     const history: ClaudeCodeSessionHistory = {
       session_id: 'session-1',
+      chat_artifacts: { selections: [], files: [], links: [], tools: [] },
       items: [
         { kind: 'user', text: 'map the repo' },
         {
@@ -203,6 +222,7 @@ describe('Claude Code utilities', () => {
   it('keeps stored job progress tool calls visible in history', () => {
     const history: ClaudeCodeSessionHistory = {
       session_id: 'session-1',
+      chat_artifacts: { selections: [], files: [], links: [], tools: [] },
       items: [
         { kind: 'user', text: 'evaluate my agent' },
         {
diff --git a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/util.ts b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/util.ts
index 94ed714b63..c33b603b70 100644
--- a/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/util.ts
+++ b/web/packages/studio/src/routes/agents/ClaudeCodeChatRoute/util.ts
@@ -5,6 +5,7 @@ import type { ThreadAssistantMessagePart, ThreadMessageLike } from '@assistant-u
 import { COMPLETE_STATUS } from '@nemo/common/src/components/AssistantChat/constants';
 import {
   createClaudeCodeToolCallPart,
+  getClaudeCodeCompletedMessageParts,
   groupConsecutiveClaudeCodeSubtleToolCalls,
   mergeConsecutiveClaudeCodeSubtleToolMessages,
 } from '@studio/routes/agents/ClaudeCodeChatRoute/toolParts';
@@ -80,5 +81,9 @@ export const getClaudeCodeHistoryMessages = (
     })
     .filter((message): message is ThreadMessageLike => message !== undefined);
 
-  return mergeConsecutiveClaudeCodeSubtleToolMessages(messages);
+  return mergeConsecutiveClaudeCodeSubtleToolMessages(messages).map((message) =>
+    message.role === 'assistant' && Array.isArray(message.content)
+      ? { ...message, content: getClaudeCodeCompletedMessageParts(message.content) }
+      : message
+  );
 };